Merge branch 'avallete/psql-436-feedback-request-postgrest-js-and-postgrest-v13-integration' into avallete/psql-372-postgrest-add-maxaffected-in-client-libraries

Author: avallete

src/PostgrestClient.ts

@@ -2,7 +2,7 @@ import PostgrestQueryBuilder from './PostgrestQueryBuilder'
 import PostgrestFilterBuilder from './PostgrestFilterBuilder'
 import PostgrestBuilder from './PostgrestBuilder'
 import { DEFAULT_HEADERS } from './constants'
-import { Fetch, GenericSchema, ClientServerOptions } from './types'
+import { Fetch, GenericSchema, ClientServerOptions, GetGenericDatabaseWithOptions } from './types'
 
 /**
  * PostgREST client.
@@ -16,12 +16,16 @@ import { Fetch, GenericSchema, ClientServerOptions } from './types'
  */
 export default class PostgrestClient<
   Database = any,
-  ClientOptions extends ClientServerOptions = { postgrestVersion: 12 },
-  SchemaName extends string & keyof Database = 'public' extends keyof Database
+  ClientOptions extends ClientServerOptions = GetGenericDatabaseWithOptions<
+    Database,
+    { postgrestVersion: 12 }
+  >['options'],
+  SchemaName extends string &
+    keyof GetGenericDatabaseWithOptions<Database>['db'] = 'public' extends keyof GetGenericDatabaseWithOptions<Database>['db']
     ? 'public'
-    : string & keyof Database,
-  Schema extends GenericSchema = Database[SchemaName] extends GenericSchema
-    ? Database[SchemaName]
+    : string & keyof GetGenericDatabaseWithOptions<Database>['db'],
+  Schema extends GenericSchema = GetGenericDatabaseWithOptions<Database>['db'][SchemaName] extends GenericSchema
+    ? GetGenericDatabaseWithOptions<Database>['db'][SchemaName]
     : any
 > {
   url: string
@@ -85,7 +89,7 @@ export default class PostgrestClient<
    *
    * @param schema - The schema to query
    */
-  schema<DynamicSchema extends string & keyof Database>(
+  schema<DynamicSchema extends string & keyof GetGenericDatabaseWithOptions<Database>['db']>(
     schema: DynamicSchema
   ): PostgrestClient<
     Database,

src/index.ts

@@ -28,6 +28,8 @@ export type {
   PostgrestResponseSuccess,
   PostgrestSingleResponse,
   PostgrestMaybeSingleResponse,
+  ClientServerOptions,
+  PostgRESTVersion,
 } from './types'
 // https://github.com/supabase/postgrest-js/issues/551
 // To be replaced with a helper type that only uses public types

src/select-query-parser/result.ts

@@ -445,7 +445,7 @@ type ProcessSpreadNode<
   ? Result extends SelectQueryError<infer E>
     ? SelectQueryError<E>
     : ExtractFirstProperty<Result> extends unknown[]
-    ? ClientOptions['postgrestVersion'] extends 13 // Spread over an many-to-many relationship, turn all the result fields into arrays
+    ? ClientOptions['postgrestVersion'] extends 13 // Spread over an many-to-many relationship, turn all the result fields into correlated arrays
       ? ProcessManyToManySpreadNodeResult<Result>
       : {
           [K in Spread['target']['name']]: SelectQueryError<`"${RelationName}" and "${Spread['target']['name']}" do not form a many-to-one or one-to-one relationship spread not possible`>

src/types.ts

@@ -1,6 +1,6 @@
 import PostgrestError from './PostgrestError'
 import { ContainsNull } from './select-query-parser/types'
-import { SelectQueryError } from './select-query-parser/utils'
+import { IsAny, SelectQueryError } from './select-query-parser/utils'
 
 export type Fetch = typeof fetch
 
@@ -73,11 +73,33 @@ export type GenericSchema = {
 
 export type PostgRESTVersion = 12 | 13
 export type ClientServerOptions = {
-  postgrestVersion: PostgRESTVersion
+  postgrestVersion?: PostgRESTVersion
 }
 
+export type DatabaseWithOptions<Database, Options extends ClientServerOptions> = {
+  db: Database
+  options: Options
+}
+
+const INTERNAL_SUPABASE_OPTIONS = '__internal_supabase'
+
+export type GetGenericDatabaseWithOptions<
+  Database,
+  Opts extends ClientServerOptions = { postgrestVersion: 12 }
+> = IsAny<Database> extends true
+  ? DatabaseWithOptions<Database, Opts>
+  : typeof INTERNAL_SUPABASE_OPTIONS extends keyof Database
+  ? Database[typeof INTERNAL_SUPABASE_OPTIONS] extends ClientServerOptions
+    ? DatabaseWithOptions<
+        Omit<Database, typeof INTERNAL_SUPABASE_OPTIONS>,
+        Database[typeof INTERNAL_SUPABASE_OPTIONS]
+      >
+    : DatabaseWithOptions<Omit<Database, typeof INTERNAL_SUPABASE_OPTIONS>, Opts>
+  : DatabaseWithOptions<Database, Opts>
+
 // https://twitter.com/mattpocockuk/status/1622730173446557697
 export type Prettify<T> = { [K in keyof T]: T[K] } & {}
+
 // https://github.com/sindresorhus/type-fest
 export type SimplifyDeep<Type, ExcludeType = never> = ConditionalSimplifyDeep<
   Type,

test/index.test-d.ts

@@ -4,9 +4,11 @@ import { PostgrestClient, PostgrestError } from '../src/index'
 import { Prettify } from '../src/types'
 import { Json } from '../src/select-query-parser/types'
 import { Database } from './types.override'
+import { Database as DatabaseWithOptions } from './types.override-with-options-postgrest13'
 
 const REST_URL = 'http://localhost:3000'
 const postgrest = new PostgrestClient<Database>(REST_URL)
+const postgrestWithOptions = new PostgrestClient<DatabaseWithOptions>(REST_URL)
 
 // table invalid type
 {
@@ -295,20 +297,9 @@ const postgrest = new PostgrestClient<Database>(REST_URL)
     }[]
   >(result.data)
 }
-// Json string Accessor with custom types overrides
+// Check that client options __internal_supabase isn't considered like the other schemas
 {
-  const result = await postgrest
-    .schema('personal')
-    .from('users')
-    .select('data->bar->>baz, data->>en, data->>bar')
-  if (result.error) {
-    throw new Error(result.error.message)
-  }
-  expectType<
-    {
-      baz: string
-      en: 'ONE' | 'TWO' | 'THREE'
-      bar: string
-    }[]
-  >(result.data)
+  await postgrestWithOptions
+    // @ts-expect-error supabase internal shouldn't be available as one of the selectable schema
+    .schema('__internal_supabase')
 }

test/relationships.ts

@@ -1,10 +1,12 @@
 import { PostgrestClient } from '../src/index'
 import { Database } from './types.override'
+import { Database as DatabaseWithOptions13 } from './types.override-with-options-postgrest13'
 
 const REST_URL = 'http://localhost:3000'
 export const postgrest = new PostgrestClient<Database>(REST_URL)
 const REST_URL_13 = 'http://localhost:3001'
 const postgrest13 = new PostgrestClient<Database, { postgrestVersion: 13 }>(REST_URL_13)
+const postgrest13FromDatabaseTypes = new PostgrestClient<DatabaseWithOptions13>(REST_URL_13)
 
 const userColumn: 'catchphrase' | 'username' = 'username'
 
@@ -350,6 +352,9 @@ export const selectQueries = {
   selectSpreadOnManyRelation13: postgrest13
     .from(selectParams.selectSpreadOnManyRelation.from)
     .select(selectParams.selectSpreadOnManyRelation.select),
+  selectSpreadOnManyRelation13FromDatabaseType: postgrest13FromDatabaseTypes
+    .from(selectParams.selectSpreadOnManyRelation.from)
+    .select(selectParams.selectSpreadOnManyRelation.select),
   selectWithDuplicatesFields: postgrest
     .from(selectParams.selectWithDuplicatesFields.from)
     .select(selectParams.selectWithDuplicatesFields.select),
@@ -1778,6 +1783,27 @@ test('select spread on many relation postgrest13', async () => {
   `)
 })
 
+test('select spread on many relation postgrest13FromDatabaseTypes', async () => {
+  const res = await selectQueries.selectSpreadOnManyRelation13FromDatabaseType.limit(1).single()
+  expect(res).toMatchInlineSnapshot(`
+    Object {
+      "count": null,
+      "data": Object {
+        "channel_id": 1,
+        "id": Array [
+          1,
+        ],
+        "message": Array [
+          "Hello World 👋",
+        ],
+      },
+      "error": null,
+      "status": 200,
+      "statusText": "OK",
+    }
+  `)
+})
+
 test('multiple times the same column in selection', async () => {
   const res = await selectQueries.selectWithDuplicatesFields.limit(1).single()
   expect(res).toMatchInlineSnapshot(`

test/select-query-parser/select.test-d.ts

@@ -672,6 +672,20 @@ type Schema = Database['public']
   expectType<TypeEqual<typeof result, typeof expected>>(true)
 }
 
+// spread over a many relation with postgrest13 passed within the Database type
+{
+  const { data } = await selectQueries.selectSpreadOnManyRelation13FromDatabaseType
+    .limit(1)
+    .single()
+  let result: Exclude<typeof data, null>
+  let expected: {
+    channel_id: number
+    id: Array<number>
+    message: Array<string | null>
+  }
+  expectType<TypeEqual<typeof result, typeof expected>>(true)
+}
+
 // multiple times the same column in selection
 {
   const { data } = await selectQueries.selectWithDuplicatesFields.limit(1).single()