wip: tests pass with hand fixed database types

Author: avallete

src/PostgrestClient.ts

@@ -9,6 +9,7 @@ import {
   GenericSetofOption,
 } from './types'
 import { FindMatchingFunctionByArgs, IsAny } from './select-query-parser/utils'
+import { LastOf } from './select-query-parser/types'
 
 type ExactMatch<T, S> = [T] extends [S] ? ([S] extends [T] ? true : false) : false
 
@@ -20,20 +21,21 @@ type ExtractExactFunction<Fns, Args> = Fns extends infer F
     : never
   : never
 
+type IsNever<T> = [T] extends [never] ? true : false
+
 export type GetRpcFunctionFilterBuilderByArgs<
   Schema extends GenericSchema,
   FnName extends string & keyof Schema['Functions'],
   Args
 > = {
   0: Schema['Functions'][FnName]
-  // This is here to handle the case where the args is exactly {} and fallback to the empty
-  // args function definition if there is one in such case
-  1: [keyof Args] extends [never]
+  // If the Args is exactly never (function call without any params)
+  1: IsNever<Args> extends true
     ? ExtractExactFunction<Schema['Functions'][FnName], Args>
     : // Otherwise, we attempt to match with one of the function definition in the union based
     // on the function arguments provided
     Args extends GenericFunction['Args']
-    ? FindMatchingFunctionByArgs<Schema['Functions'][FnName], Args>
+    ? LastOf<FindMatchingFunctionByArgs<Schema['Functions'][FnName], Args>>
     : // If we can't find a matching function by args, we try to find one by function name
     ExtractExactFunction<Schema['Functions'][FnName], Args> extends GenericFunction
     ? ExtractExactFunction<Schema['Functions'][FnName], Args>
@@ -197,7 +199,7 @@ export default class PostgrestClient<
    */
   rpc<
     FnName extends string & keyof Schema['Functions'],
-    Args extends Schema['Functions'][FnName]['Args'] = {},
+    Args extends Schema['Functions'][FnName]['Args'] = never,
     FilterBuilder extends GetRpcFunctionFilterBuilderByArgs<
       Schema,
       FnName,

src/types.ts

@@ -68,7 +68,7 @@ export type GenericSetofOption = {
 }
 
 export type GenericFunction = {
-  Args: Record<string, unknown>
+  Args: Record<string, unknown> | never
   Returns: unknown
   SetofOptions?: GenericSetofOption
 }

test/advanced_rpc.test.ts

@@ -154,7 +154,7 @@ describe('advanced rpc', () => {
       },
     })
     let result: Exclude<typeof res.data, null>
-    let expected: z.infer<typeof UserProfileSchema>
+    let expected: z.infer<typeof UserProfileSchema>[]
     expectType<TypeEqual<typeof result, typeof expected>>(true)
     expect(res).toMatchInlineSnapshot(`
       Object {
@@ -170,7 +170,7 @@ describe('advanced rpc', () => {
         "statusText": "OK",
       }
     `)
-    UserProfileSchema.parse(res.data)
+    UserProfileSchema.array().parse(res.data)
   })
 
   test('function with scalar input', async () => {
@@ -440,7 +440,7 @@ describe('advanced rpc', () => {
       })
       .select('channel_id, message, users(username, catchphrase)')
     let result: Exclude<typeof res.data, null>
-    let expected: z.infer<typeof SelectWithUsersSchema>[]
+    let expected: RequiredDeep<z.infer<typeof SelectWithUsersSchema>>[]
     expectType<TypeEqual<typeof result, typeof expected>>(true)
     expect(res).toMatchInlineSnapshot(`
       Object {
@@ -938,24 +938,11 @@ describe('advanced rpc', () => {
     `)
   })
 
-  test('polymorphic function with unnamed params definition call with bool param', async () => {
+  test('polymorphic function with unnamed params definition call with string param', async () => {
     const res = await postgrest.rpc('polymorphic_function_with_no_params_or_unnamed', {
-      // @ts-expect-error should not have generated a type definition for the boolean
-      '': true,
+      '': '',
     })
     let result: Exclude<typeof res.data, null>
-    // TODO: since this call use an invalid type definition, we can't distinguish between the "no values" or the "empty"
-    // property call:
-    // polymorphic_function_with_no_params_or_unnamed:
-    // | {
-    //     Args: Record<PropertyKey, never>
-    //     Returns: number
-    //   }
-    // | {
-    //     Args: { '': string }
-    //     Returns: string
-    //   }
-    // A type error would be raised at higher level (argument providing) time though
     let expected: string
     expectType<TypeEqual<typeof result, typeof expected>>(true)
     expect(res).toMatchInlineSnapshot(`
@@ -1009,22 +996,22 @@ describe('advanced rpc', () => {
   })
 
   test('polymorphic function with unnamed default int param', async () => {
-    const res = await postgrest.rpc('polymorphic_function_with_unnamed_default', {
-      //@ts-expect-error the type definition for empty params should be text
-      '': 123,
-    })
+    const res = await postgrest.rpc('polymorphic_function_with_unnamed_default', undefined)
     let result: Exclude<typeof res.data, null>
-    // TODO: since this call use an invalid type definition, we can't distinguish between the "no values" or the "empty"
-    // A type error would be raised at higher level (argument providing) time though
     let expected: string
     expectType<TypeEqual<typeof result, typeof expected>>(true)
     expect(res).toMatchInlineSnapshot(`
       Object {
         "count": null,
-        "data": "foo",
-        "error": null,
-        "status": 200,
-        "statusText": "OK",
+        "data": null,
+        "error": Object {
+          "code": "PGRST203",
+          "details": null,
+          "hint": "Try renaming the parameters or the function itself in the database so function overloading can be resolved",
+          "message": "Could not choose the best candidate function between: public.polymorphic_function_with_unnamed_default(), public.polymorphic_function_with_unnamed_default( => text)",
+        },
+        "status": 300,
+        "statusText": "Multiple Choices",
       }
     `)
   })
@@ -1069,22 +1056,22 @@ describe('advanced rpc', () => {
   })
 
   test('polymorphic function with unnamed default overload int param', async () => {
-    const res = await postgrest.rpc('polymorphic_function_with_unnamed_default_overload', {
-      //@ts-expect-error the type definition for empty params should be text
-      '': 123,
-    })
+    const res = await postgrest.rpc('polymorphic_function_with_unnamed_default_overload', undefined)
     let result: Exclude<typeof res.data, null>
-    // TODO: since this call use an invalid type definition, we can't distinguish between the "no values" or the "empty"
-    // A type error would be raised at higher level (argument providing) time though
     let expected: string
     expectType<TypeEqual<typeof result, typeof expected>>(true)
     expect(res).toMatchInlineSnapshot(`
       Object {
         "count": null,
-        "data": "foo",
-        "error": null,
-        "status": 200,
-        "statusText": "OK",
+        "data": null,
+        "error": Object {
+          "code": "PGRST203",
+          "details": null,
+          "hint": "Try renaming the parameters or the function itself in the database so function overloading can be resolved",
+          "message": "Could not choose the best candidate function between: public.polymorphic_function_with_unnamed_default_overload(), public.polymorphic_function_with_unnamed_default_overload( => text)",
+        },
+        "status": 300,
+        "statusText": "Multiple Choices",
       }
     `)
   })
@@ -1130,15 +1117,7 @@ describe('advanced rpc', () => {
   })
 
   test('function with blurb_message', async () => {
-    // @ts-expect-error the function types doesn't exist and should fail to be retrieved by cache
-    // for direct rpc call
-    const res = await postgrest.rpc('blurb_messages', {
-      channel_id: 1,
-      data: null,
-      id: 1,
-      message: 'Hello World 👋',
-      username: 'supabot',
-    })
+    const res = await postgrest.rpc('blurb_message')
     let result: Exclude<typeof res.data, null>
     let expected: never
     expectType<TypeEqual<typeof result, typeof expected>>(true)
@@ -1148,9 +1127,38 @@ describe('advanced rpc', () => {
         "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.",
+          "details": "Searched for the function public.blurb_message without parameters 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_message without parameters in the schema cache",
+        },
+        "status": 404,
+        "statusText": "Not Found",
+      }
+    `)
+  })
+  test('function with blurb_message with params', async () => {
+    const res = await postgrest.rpc('blurb_message', {
+      '': {
+        channel_id: 1,
+        data: null,
+        id: 1,
+        message: null,
+        username: 'test',
+        blurb_message: null,
+      },
+    })
+    let result: Exclude<typeof res.data, null>
+    let expected: SelectQueryError<'the function public.blurb_message with parameter or with a single unnamed json/jsonb parameter, but no matches were found in the schema cache'>
+    expectType<TypeEqual<typeof result, typeof expected>>(true)
+    expect(res).toMatchInlineSnapshot(`
+      Object {
+        "count": null,
+        "data": null,
+        "error": Object {
+          "code": "PGRST202",
+          "details": "Searched for the function public.blurb_message with parameter  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",
+          "message": "Could not find the function public.blurb_message() in the schema cache",
         },
         "status": 404,
         "statusText": "Not Found",

test/types.generated.ts

@@ -545,10 +545,12 @@ export type Database = {
     Functions: {
       blurb_message: {
         Args: { '': Database['public']['Tables']['messages']['Row'] }
-        Returns: string
+        Returns: {
+          error: true
+        } & 'the function public.blurb_message with parameter or with a single unnamed json/jsonb parameter, but no matches were found in the schema cache'
       }
       function_returning_row: {
-        Args: Record<PropertyKey, never>
+        Args: never
         Returns: {
           age_range: unknown | null
           catchphrase: unknown | null
@@ -558,7 +560,7 @@ export type Database = {
         }
       }
       function_returning_set_of_rows: {
-        Args: Record<PropertyKey, never>
+        Args: never
         Returns: {
           age_range: unknown | null
           catchphrase: unknown | null
@@ -659,6 +661,11 @@ export type Database = {
           message: string | null
           username: string | null
         }[]
+        SetofOptions: {
+          from: '*'
+          to: 'recent_messages'
+          isOneToOne: false
+        }
       }
       get_status: {
         Args: { name_param: string }
@@ -701,7 +708,7 @@ export type Database = {
         Returns: {
           id: number
           username: string | null
-        }
+        }[]
         SetofOptions: {
           from: 'users'
           to: 'user_profiles'
@@ -764,27 +771,36 @@ export type Database = {
         Args: { name_param: string }
         Returns: Database['public']['Enums']['user_status']
       }
-      polymorphic_function_with_different_return:
-        | { Args: { '': boolean }; Returns: number }
-        | { Args: { '': number }; Returns: number }
-        | { Args: { '': string }; Returns: string }
+      polymorphic_function_with_different_return: { Args: { '': string }; Returns: string }
       polymorphic_function_with_no_params_or_unnamed:
-        | { Args: Record<PropertyKey, never>; Returns: number }
-        | { Args: { '': boolean }; Returns: number }
+        | { Args: never; Returns: number }
         | { Args: { '': string }; Returns: string }
       polymorphic_function_with_unnamed_default:
-        | { Args: Record<PropertyKey, never>; Returns: number }
-        | { Args: { ''?: number }; Returns: number }
-        | { Args: { ''?: string }; Returns: string }
+        | {
+            Args: { ''?: string }
+            Returns: string
+          }
+        | {
+            Args: never
+            Returns: {
+              error: true
+            } & 'Could not choose the best candidate function between: polymorphic_function_with_unnamed_default( => int4), polymorphic_function_with_unnamed_default(). Try renaming the parameters or the function itself in the database so function overloading can be resolved'
+          }
       polymorphic_function_with_unnamed_default_overload:
-        | { Args: Record<PropertyKey, never>; Returns: number }
-        | { Args: { ''?: number }; Returns: number }
-        | { Args: { ''?: string }; Returns: string }
-        | { Args: { ''?: boolean }; Returns: number }
-      polymorphic_function_with_unnamed_integer: {
-        Args: { '': number }
-        Returns: number
-      }
+        | {
+            Args: never
+            Returns: {
+              error: true
+            } & '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'
+          }
+        | {
+            Args: { ''?: string }
+            Returns: string
+          }
+      // polymorphic_function_with_unnamed_integer: {
+      //   Args:  { ''?: any };
+      //   Returns: number
+      // }
       polymorphic_function_with_unnamed_json: {
         Args: { '': Json }
         Returns: number
@@ -798,7 +814,7 @@ export type Database = {
         Returns: number
       }
       postgrest_resolvable_with_override_function:
-        | { Args: Record<PropertyKey, never>; Returns: undefined }
+        | { Args: never; Returns: undefined }
         | { Args: { a: string }; Returns: number }
         | { Args: { b: number }; Returns: string }
         | {
@@ -834,9 +850,19 @@ export type Database = {
             }
           }
       postgrest_unresolvable_function:
-        | { Args: Record<PropertyKey, never>; Returns: undefined }
-        | { Args: { a: string }; Returns: number }
-        | { Args: { a: number }; Returns: string }
+        | { Args: never; Returns: undefined }
+        | {
+            Args: { a: string }
+            Returns: {
+              error: true
+            } & 'Could not choose the best candidate function between: postgrest_unresolvable_function(a => int4), postgrest_unresolvable_function(a => text). Try renaming the parameters or the function itself in the database so function overloading can be resolved'
+          }
+        | {
+            Args: { a: number }
+            Returns: {
+              error: true
+            } & 'Could not choose the best candidate function between: postgrest_unresolvable_function(a => int4), postgrest_unresolvable_function(a => text). Try renaming the parameters or the function itself in the database so function overloading can be resolved'
+          }
       set_users_offline: {
         Args: { name_param: string }
         Returns: {
@@ -847,7 +873,7 @@ export type Database = {
           username: string
         }[]
       }
-      void_func: { Args: Record<PropertyKey, never>; Returns: undefined }
+      void_func: { Args: never; Returns: undefined }
     }
     Enums: {
       user_status: 'ONLINE' | 'OFFLINE'