chore: add tests, fix types test

Author: avallete

src/PostgrestClient.ts

@@ -55,10 +55,10 @@ export type GetRpcFunctionFilterBuilderByArgs<
           : null
       }
     : // If we failed to find the function by argument, we still pass with any but also add an overridable
-    Fn extends never
+    Fn extends false
     ? {
         Row: any
-        Result: { error: true } & "Couldn't find function"
+        Result: { error: true } & "Couldn't infer function definition matching provided arguments"
         RelationName: FnName
         Relationships: null
       }

src/select-query-parser/utils.ts

@@ -662,4 +662,4 @@ type FindMatchingFunctionBySetofFrom<
   TableName extends string
 > = FnUnion extends infer Fn extends GenericFunction
   ? MatchingFunctionBySetofFrom<Fn, TableName>
-  : never
+  : false

test/advanced_rpc.test-d.ts

@@ -9,14 +9,14 @@ type Schema = Database['public']
 {
   const { data } = await rpcQueries['function returning a setof embeded table']
   let result: Exclude<typeof data, null>
-  let expected: Array<Schema['Tables']['messages']['Row']>
+  let expected: Array<Omit<Schema['Tables']['messages']['Row'], 'blurb_message'>>
   expectType<TypeEqual<typeof result, typeof expected>>(true)
 }
 
 {
   const { data } = await rpcQueries['function double definition returning a setof embeded table']
   let result: Exclude<typeof data, null>
-  let expected: Array<Schema['Tables']['messages']['Row']>
+  let expected: Array<Omit<Schema['Tables']['messages']['Row'], 'blurb_message'>>
   expectType<TypeEqual<typeof result, typeof expected>>(true)
 }
 
@@ -30,21 +30,21 @@ type Schema = Database['public']
 {
   const { data } = await rpcQueries['function with scalar input']
   let result: Exclude<typeof data, null>
-  let expected: Array<Schema['Tables']['messages']['Row']>
+  let expected: Array<Omit<Schema['Tables']['messages']['Row'], 'blurb_message'>>
   expectType<TypeEqual<typeof result, typeof expected>>(true)
 }
 
 {
   const { data } = await rpcQueries['function with table row input']
   let result: Exclude<typeof data, null>
-  let expected: Array<Schema['Tables']['messages']['Row']>
+  let expected: Array<Omit<Schema['Tables']['messages']['Row'], 'blurb_message'>>
   expectType<TypeEqual<typeof result, typeof expected>>(true)
 }
 
 {
   const { data } = await rpcQueries['function with view row input']
   let result: Exclude<typeof data, null>
-  let expected: Array<Schema['Tables']['messages']['Row']>
+  let expected: Array<Omit<Schema['Tables']['messages']['Row'], 'blurb_message'>>
   expectType<TypeEqual<typeof result, typeof expected>>(true)
 }
 
@@ -146,14 +146,14 @@ type Schema = Database['public']
 {
   const { data } = await rpcQueries['resolvable function with channel_id and search params']
   let result: Exclude<typeof data, null>
-  let expected: Array<Schema['Tables']['messages']['Row']>
+  let expected: Array<Omit<Schema['Tables']['messages']['Row'], 'blurb_message'>>
   expectType<TypeEqual<typeof result, typeof expected>>(true)
 }
 
 {
   const { data } = await rpcQueries['resolvable function with user_row param']
   let result: Exclude<typeof data, null>
-  let expected: Array<Schema['Tables']['messages']['Row']>
+  let expected: Array<Omit<Schema['Tables']['messages']['Row'], 'blurb_message'>>
   expectType<TypeEqual<typeof result, typeof expected>>(true)
 }
 
@@ -287,3 +287,36 @@ type Schema = Database['public']
     | SelectQueryError<'Could not choose the best candidate function between: polymorphic_function_with_unnamed_default_overload( => int4), polymorphic_function_with_unnamed_default_overload(). Try renaming the parameters or the function itself in the database so function overloading can be resolved'>
   expectType<TypeEqual<typeof result, typeof expected>>(true)
 }
+
+{
+  const { data } = await rpcQueries['function with blurb_message']
+  let result: Exclude<typeof data, null>
+  let expected: never
+  expectType<TypeEqual<typeof result, typeof expected>>(true)
+}
+
+{
+  const { data } = await rpcQueries['function returning row']
+  let result: Exclude<typeof data, null>
+  let expected: {
+    age_range: unknown
+    catchphrase: unknown
+    data: unknown
+    status: 'ONLINE' | 'OFFLINE' | null
+    username: string
+  }
+  expectType<TypeEqual<typeof result, typeof expected>>(true)
+}
+
+{
+  const { data } = await rpcQueries['function returning set of rows']
+  let result: Exclude<typeof data, null>
+  let expected: Array<{
+    age_range: unknown
+    catchphrase: unknown
+    data: unknown
+    status: 'ONLINE' | 'OFFLINE' | null
+    username: string
+  }>
+  expectType<TypeEqual<typeof result, typeof expected>>(true)
+}

test/advanced_rpc.ts

@@ -214,6 +214,17 @@ export const rpcQueries = {
       '': true,
     }
   ),
+  // @ts-expect-error the function types doesn't exist and should fail to be retrieved by cache
+  // for direct rpc call
+  'function with blurb_message': postgrest.rpc('blurb_messages', {
+    channel_id: 1,
+    data: null,
+    id: 1,
+    message: 'Hello World 👋',
+    username: 'supabot',
+  }),
+  'function returning row': postgrest.rpc('function_returning_row'),
+  'function returning set of rows': postgrest.rpc('function_returning_set_of_rows'),
 } as const
 
 describe('rpc', () => {
@@ -920,4 +931,97 @@ describe('rpc', () => {
         }
       `)
   })
+
+  test('function with blurb_message', async () => {
+    const res = await rpcQueries['function with blurb_message']
+    expect(res).toMatchInlineSnapshot(`
+      Object {
+        "count": null,
+        "data": null,
+        "error": Object {
+          "code": "PGRST202",
+          "details": "Searched for the function public.blurb_messages with parameters channel_id, data, id, message, username or with a single unnamed json/jsonb parameter, but no matches were found in the schema cache.",
+          "hint": "Perhaps you meant to call the function public.get_messages",
+          "message": "Could not find the function public.blurb_messages(channel_id, data, id, message, username) in the schema cache",
+        },
+        "status": 404,
+        "statusText": "Not Found",
+      }
+    `)
+  })
+
+  test('function returning row', async () => {
+    const res = await rpcQueries['function returning row']
+    expect(res).toMatchInlineSnapshot(`
+      Object {
+        "count": null,
+        "data": Object {
+          "age_range": "[1,2)",
+          "catchphrase": "'cat' 'fat'",
+          "data": null,
+          "status": "ONLINE",
+          "username": "supabot",
+        },
+        "error": null,
+        "status": 200,
+        "statusText": "OK",
+      }
+    `)
+  })
+
+  test('function returning set of rows', async () => {
+    const res = await rpcQueries['function returning set of rows']
+    expect(res).toMatchInlineSnapshot(`
+      Object {
+        "count": null,
+        "data": Array [
+          Object {
+            "age_range": "[1,2)",
+            "catchphrase": "'cat' 'fat'",
+            "data": null,
+            "status": "ONLINE",
+            "username": "supabot",
+          },
+          Object {
+            "age_range": "[25,35)",
+            "catchphrase": "'bat' 'cat'",
+            "data": null,
+            "status": "OFFLINE",
+            "username": "kiwicopple",
+          },
+          Object {
+            "age_range": "[25,35)",
+            "catchphrase": "'bat' 'rat'",
+            "data": null,
+            "status": "ONLINE",
+            "username": "awailas",
+          },
+          Object {
+            "age_range": "[20,30)",
+            "catchphrase": "'json' 'test'",
+            "data": Object {
+              "foo": Object {
+                "bar": Object {
+                  "nested": "value",
+                },
+                "baz": "string value",
+              },
+            },
+            "status": "ONLINE",
+            "username": "jsonuser",
+          },
+          Object {
+            "age_range": "[20,30)",
+            "catchphrase": "'fat' 'rat'",
+            "data": null,
+            "status": "ONLINE",
+            "username": "dragarcia",
+          },
+        ],
+        "error": null,
+        "status": 200,
+        "statusText": "OK",
+      }
+    `)
+  })
 })

test/db/00-schema.sql

@@ -307,3 +307,24 @@ create or replace function public.polymorphic_function_with_unnamed_default_over
 create or replace function public.polymorphic_function_with_unnamed_default_overload(text default 'default') returns text language sql as $$ SELECT 'foo' $$;
 create or replace function public.polymorphic_function_with_unnamed_default_overload(bool default true) returns int language sql as 'SELECT 3';
 
+create function public.blurb_message(public.messages) returns character varying as
+$$
+select substring($1.message, 1, 3);
+$$ language sql stable;
+
+
+create or replace function public.function_returning_row()
+returns public.users
+language sql
+stable
+as $$
+  select * from public.users limit 1;
+$$;
+
+create or replace function public.function_returning_set_of_rows()
+returns setof public.users
+language sql
+stable
+as $$
+  select * from public.users;
+$$;

test/embeded_functions_join.test-d.ts

@@ -130,3 +130,30 @@ type Schema = Database['public']
   }>
   expectType<TypeEqual<typeof result, typeof expected>>(true)
 }
+
+{
+  const { data } = await selectQueries.embeded_function_with_blurb_message
+  let result: Exclude<typeof data, null>
+  let expected: Array<{
+    username: string
+    user_messages: Array<
+      Pick<Schema['Tables']['messages']['Row'], 'id' | 'message' | 'blurb_message'>
+    >
+  }>
+  expectType<TypeEqual<typeof result, typeof expected>>(true)
+}
+
+// Cannot embed an function that is not a setofOptions one
+{
+  const { data } = await selectQueries.embeded_function_returning_row
+  let result: Exclude<typeof data, null>
+  let expected: never[]
+  expectType<TypeEqual<typeof result, typeof expected>>(true)
+}
+
+{
+  const { data } = await selectQueries.embeded_function_returning_set_of_rows
+  let result: Exclude<typeof data, null>
+  let expected: never[]
+  expectType<TypeEqual<typeof result, typeof expected>>(true)
+}