fix(postgrest): use latest postgres-meta canary build

Author: avallete

packages/core/postgrest-js/src/select-query-parser/utils.ts

@@ -635,7 +635,7 @@ export type IsStringUnion<T> = string extends T
     : false
 
 // Functions matching utils
-export type IsMatchingArgs<
+type IsMatchingArgs<
   FnArgs extends GenericFunction['Args'],
   PassedArgs extends GenericFunction['Args'],
 > = [FnArgs] extends [Record<PropertyKey, never>]
@@ -648,19 +648,19 @@ export type IsMatchingArgs<
       : false
     : false
 
-export type MatchingFunctionArgs<
+type MatchingFunctionArgs<
   Fn extends GenericFunction,
   Args extends GenericFunction['Args'],
 > = Fn extends { Args: infer A extends GenericFunction['Args'] }
   ? IsMatchingArgs<A, Args> extends true
     ? Fn
     : never
-  : never
+  : false
 
 export type FindMatchingFunctionByArgs<
   FnUnion,
   Args extends GenericFunction['Args'],
-> = FnUnion extends infer Fn extends GenericFunction ? MatchingFunctionArgs<Fn, Args> : never
+> = FnUnion extends infer Fn extends GenericFunction ? MatchingFunctionArgs<Fn, Args> : false
 
 type MatchingFunctionBySetofFrom<
   Fn extends GenericFunction,
@@ -669,7 +669,7 @@ type MatchingFunctionBySetofFrom<
   ? TableName extends Fn['SetofOptions']['from']
     ? Fn
     : never
-  : never
+  : false
 
 type FindMatchingFunctionBySetofFrom<
   FnUnion,

packages/core/postgrest-js/src/types.ts

@@ -17,6 +17,15 @@ type ExtractExactFunction<Fns, Args> = Fns extends infer F
 
 type IsNever<T> = [T] extends [never] ? true : false
 
+type RpcFunctionNotFound<FnName> = {
+  Row: any
+  Result: {
+    error: true
+  } & "Couldn't infer function definition matching provided arguments"
+  RelationName: FnName
+  Relationships: null
+}
+
 export type GetRpcFunctionFilterBuilderByArgs<
   Schema extends GenericSchema,
   FnName extends string & keyof Schema['Functions'],
@@ -72,16 +81,9 @@ export type GetRpcFunctionFilterBuilderByArgs<
         }
       : // If we failed to find the function by argument, we still pass with any but also add an overridable
         Fn extends false
-        ? {
-            Row: any
-            Result: {
-              error: true
-            } & "Couldn't infer function definition matching provided arguments"
-            RelationName: FnName
-            Relationships: null
-          }
-        : never
-  : never
+        ? RpcFunctionNotFound<FnName>
+        : RpcFunctionNotFound<FnName>
+  : RpcFunctionNotFound<FnName>
 
 /**
  * Response format

packages/core/postgrest-js/test/db/docker-compose.yml

@@ -41,7 +41,7 @@ services:
       POSTGRES_HOST: /var/run/postgresql
       POSTGRES_PORT: 5432
   pgmeta:
-    image: supabase/postgres-meta:v0.91.5
+    image: supabase/postgres-meta:canary-pr-971-12217b2b59b6eeddbb65949ddb257e17fec56393
     ports:
       - '8080:8080'
     environment:

packages/core/postgrest-js/test/embeded_functions_join.test.ts

@@ -72,6 +72,9 @@ describe('embeded functions select', () => {
       })
     )
     let expected: RequiredDeep<z.infer<typeof ExpectedSchema>>
+    // Assert over the keys of the expected and result objects to ensure consistency between versions of types
+    // should always fallback to a SelectQueryError if the relation cannot be found
+    expectType<TypeEqual<keyof (typeof expected)[number], keyof (typeof result)[number]>>(true)
     expectType<TypeEqual<typeof result, typeof expected>>(true)
     ExpectedSchema.parse(res.data)
   })
@@ -130,6 +133,7 @@ describe('embeded functions select', () => {
       })
     )
     let expected: z.infer<typeof ExpectedSchema>
+    expectType<TypeEqual<keyof (typeof expected)[number], keyof (typeof result)[number]>>(true)
     expectType<TypeEqual<typeof result, typeof expected>>(true)
     ExpectedSchema.parse(res.data)
   })
@@ -204,6 +208,7 @@ describe('embeded functions select', () => {
       })
     )
     let expected: RequiredDeep<z.infer<typeof ExpectedSchema>>
+    expectType<TypeEqual<keyof (typeof expected)[number], keyof (typeof result)[number]>>(true)
     expectType<TypeEqual<typeof result, typeof expected>>(true)
     ExpectedSchema.parse(res.data)
   })
@@ -268,6 +273,7 @@ describe('embeded functions select', () => {
       })
     )
     let expected: z.infer<typeof ExpectedSchema>
+    expectType<TypeEqual<keyof (typeof expected)[number], keyof (typeof result)[number]>>(true)
     expectType<TypeEqual<typeof result, typeof expected>>(true)
     ExpectedSchema.parse(res.data)
   })
@@ -336,6 +342,7 @@ describe('embeded functions select', () => {
       })
     )
     let expected: z.infer<typeof ExpectedSchema>
+    expectType<TypeEqual<keyof (typeof expected)[number], keyof (typeof result)[number]>>(true)
     expectType<TypeEqual<typeof result, typeof expected>>(true)
     ExpectedSchema.parse(res.data)
   })
@@ -390,6 +397,7 @@ describe('embeded functions select', () => {
       })
     )
     let expected: z.infer<typeof ExpectedSchema>
+    expectType<TypeEqual<keyof (typeof expected)[number], keyof (typeof result)[number]>>(true)
     expectType<TypeEqual<typeof result, typeof expected>>(true)
     ExpectedSchema.parse(res.data)
   })
@@ -454,14 +462,17 @@ describe('embeded functions select', () => {
       })
     )
     let expected: z.infer<typeof ExpectedSchema>
+    expectType<TypeEqual<keyof (typeof expected)[number], keyof (typeof result)[number]>>(true)
     expectType<TypeEqual<typeof result, typeof expected>>(true)
     ExpectedSchema.parse(res.data)
   })
 
   test('embeded_setof_row_one_function_not_nullable - function returning a single row embeded table not nullable', async () => {
     const res = await postgrest
       .from('users')
-      .select('username, user_called_profile_not_null:get_user_profile_non_nullable(*)')
+      // Inner join to ensure the join result is not nullable can also be set at relation level
+      // by setting isNotNullable for the function SetofOptions definition to true
+      .select('username, user_called_profile_not_null:get_user_profile_non_nullable!inner(*)')
     expect(res).toMatchInlineSnapshot(`
       Object {
         "count": null,
@@ -473,22 +484,6 @@ describe('embeded functions select', () => {
             },
             "username": "supabot",
           },
-          Object {
-            "user_called_profile_not_null": null,
-            "username": "kiwicopple",
-          },
-          Object {
-            "user_called_profile_not_null": null,
-            "username": "awailas",
-          },
-          Object {
-            "user_called_profile_not_null": null,
-            "username": "jsonuser",
-          },
-          Object {
-            "user_called_profile_not_null": null,
-            "username": "dragarcia",
-          },
         ],
         "error": null,
         "status": 200,
@@ -509,22 +504,10 @@ describe('embeded functions select', () => {
       })
     )
     let expected: z.infer<typeof ExpectedSchema>
+    expectType<TypeEqual<keyof (typeof expected)[number], keyof (typeof result)[number]>>(true)
     expectType<TypeEqual<typeof result, typeof expected>>(true)
-    // Parsing with the non-nullable schema should throw, because there are nulls in the data.
-    expect(() => ExpectedSchema.parse(res.data)).toThrowError()
-    // However, parsing with a nullable schema should succeed.
-    const ExpectedNullable = z.array(
-      z.object({
-        username: z.string(),
-        user_called_profile_not_null: z
-          .object({
-            id: z.number(),
-            username: z.string().nullable(),
-          })
-          .nullable(),
-      })
-    )
-    ExpectedNullable.parse(res.data)
+    // Can parse the data because the !inner ensure the join result from function is not nullable
+    ExpectedSchema.parse(res.data)
   })
 
   test('embeded_setof_row_one_function_with_fields_selection - function returning a single row embeded table with fields selection', async () => {
@@ -581,6 +564,7 @@ describe('embeded functions select', () => {
       })
     )
     let expected: z.infer<typeof ExpectedSchema>
+    expectType<TypeEqual<keyof (typeof expected)[number], keyof (typeof result)[number]>>(true)
     expectType<TypeEqual<typeof result, typeof expected>>(true)
     ExpectedSchema.parse(res.data)
   })
@@ -655,6 +639,7 @@ describe('embeded functions select', () => {
       })
     )
     let expected: z.infer<typeof ExpectedSchema>
+    expectType<TypeEqual<keyof (typeof expected)[number], keyof (typeof result)[number]>>(true)
     expectType<TypeEqual<typeof result, typeof expected>>(true)
     ExpectedSchema.parse(res.data)
   })
@@ -729,6 +714,7 @@ describe('embeded functions select', () => {
       })
     )
     let expected: RequiredDeep<z.infer<typeof ExpectedSchema>>
+    expectType<TypeEqual<keyof (typeof expected)[number], keyof (typeof result)[number]>>(true)
     expectType<TypeEqual<typeof result, typeof expected>>(true)
     ExpectedSchema.parse(res.data)
   })
@@ -801,6 +787,7 @@ describe('embeded functions select', () => {
       })
     )
     let expected: RequiredDeep<z.infer<typeof ExpectedSchema>>
+    expectType<TypeEqual<keyof (typeof expected)[number], keyof (typeof result)[number]>>(true)
     expectType<TypeEqual<typeof result, typeof expected>>(true)
     ExpectedSchema.parse(res.data)
   })
@@ -877,6 +864,7 @@ describe('embeded functions select', () => {
       })
     )
     let expected: RequiredDeep<z.infer<typeof ExpectedSchema>>
+    expectType<TypeEqual<keyof (typeof expected)[number], keyof (typeof result)[number]>>(true)
     expectType<TypeEqual<typeof result, typeof expected>>(true)
     ExpectedSchema.parse(res.data)
   })
@@ -949,6 +937,7 @@ describe('embeded functions select', () => {
       })
     )
     let expected: RequiredDeep<z.infer<typeof ExpectedSchema>>
+    expectType<TypeEqual<keyof (typeof expected)[number], keyof (typeof result)[number]>>(true)
     expectType<TypeEqual<typeof result, typeof expected>>(true)
     ExpectedSchema.parse(res.data)
   })
@@ -1017,6 +1006,7 @@ describe('embeded functions select', () => {
       })
     )
     let expected: z.infer<typeof ExpectedSchema>
+    expectType<TypeEqual<keyof (typeof expected)[number], keyof (typeof result)[number]>>(true)
     expectType<TypeEqual<typeof result, typeof expected>>(true)
     ExpectedSchema.parse(res.data)
   })
@@ -1088,6 +1078,7 @@ describe('embeded functions select', () => {
       })
     )
     let expected: z.infer<typeof ExpectedSchema>
+    expectType<TypeEqual<keyof (typeof expected)[number], keyof (typeof result)[number]>>(true)
     expectType<TypeEqual<typeof result, typeof expected>>(true)
     ExpectedSchema.parse(res.data)
   })
@@ -1175,6 +1166,7 @@ describe('embeded functions select', () => {
       })
     )
     let expected: z.infer<typeof ExpectedSchema>
+    expectType<TypeEqual<keyof (typeof expected)[number], keyof (typeof result)[number]>>(true)
     expectType<TypeEqual<typeof result, typeof expected>>(true)
     ExpectedSchema.parse(res.data)
   })
@@ -1229,6 +1221,7 @@ describe('embeded functions select', () => {
       })
     )
     let expected: z.infer<typeof ExpectedSchema>
+    expectType<TypeEqual<keyof (typeof expected)[number], keyof (typeof result)[number]>>(true)
     expectType<TypeEqual<typeof result, typeof expected>>(true)
     ExpectedSchema.parse(res.data)
   })

packages/core/postgrest-js/test/rpc.test.ts

@@ -4,9 +4,9 @@ import { expectType, TypeEqual } from './types'
 import { z } from 'zod'
 
 const REST_URL = 'http://localhost:3000'
-const postgrest = new PostgrestClient<Database>(REST_URL)
+export const postgrest = new PostgrestClient<Database>(REST_URL)
 
-const RPC_NAME = 'get_username_and_status'
+export const RPC_NAME = 'get_username_and_status'
 
 test('RPC call with no params', async () => {
   const res = await postgrest.rpc(RPC_NAME, { name_param: 'supabot' }).select()
@@ -206,43 +206,3 @@ test('RPC call with field aggregate', async () => {
   expectType<TypeEqual<typeof result, typeof expected>>(true)
   ExpectedSchema.parse(res.data)
 })
-
-test('RPC get_status with no params', async () => {
-  const res = await postgrest.rpc('get_status')
-  expect(res).toMatchInlineSnapshot(`
-    Object {
-      "count": null,
-      "data": null,
-      "error": Object {
-        "code": "PGRST202",
-        "details": "Searched for the function public.get_status without parameters or with a single unnamed json/jsonb parameter, but no matches were found in the schema cache.",
-        "hint": null,
-        "message": "Could not find the function public.get_status without parameters in the schema cache",
-      },
-      "status": 404,
-      "statusText": "Not Found",
-    }
-  `)
-  let result: Exclude<typeof res.data, null>
-  // get_status without name param doesn't exist in the schema so we expect never
-  let expected: never
-  expectType<TypeEqual<typeof result, typeof expected>>(true)
-})
-
-test('RPC get_status with name params', async () => {
-  const res = await postgrest.rpc('get_status', { name_param: 'supabot' })
-  expect(res).toMatchInlineSnapshot(`
-    Object {
-      "count": null,
-      "data": "ONLINE",
-      "error": null,
-      "status": 200,
-      "statusText": "OK",
-    }
-  `)
-  let result: Exclude<typeof res.data, null>
-  const ExpectedSchema = z.enum(['ONLINE', 'OFFLINE'] as const)
-  let expected: z.infer<typeof ExpectedSchema>
-  expectType<TypeEqual<typeof result, typeof expected>>(true)
-  ExpectedSchema.parse(res.data)
-})