Revert "Merge pull request #1416 from supabase/chore/upgrade-postgrest-js-deps"

This reverts commit a4ec228, reversing
changes made to 62ee92a.

Author: avallete

package-lock.json

@@ -52,7 +52,7 @@
     "@supabase/auth-js": "2.70.0",
     "@supabase/functions-js": "2.4.5",
     "@supabase/node-fetch": "2.6.15",
-    "@supabase/postgrest-js": "1.21.0",
+    "@supabase/postgrest-js": "1.19.4",
     "@supabase/realtime-js": "2.11.15",
     "@supabase/storage-js": "2.7.1"
   },

package.json

@@ -4,8 +4,6 @@ import {
   PostgrestClient,
   PostgrestFilterBuilder,
   PostgrestQueryBuilder,
-  ClientServerOptions as PostgrestClientServerOption,
-  GetGenericDatabaseWithOptions,
 } from '@supabase/postgrest-js'
 import {
   RealtimeChannel,
@@ -30,18 +28,13 @@ import { Fetch, GenericSchema, SupabaseClientOptions, SupabaseAuthClientOptions
  *
  * An isomorphic Javascript client for interacting with Postgres.
  */
-
-export type ServicesOptions = PostgrestClientServerOption & {}
-
 export default class SupabaseClient<
   Database = any,
-  ClientOptions extends ServicesOptions = { PostgrestVersion: '12' },
-  SchemaName extends string &
-    keyof GetGenericDatabaseWithOptions<Database>['db'] = 'public' extends keyof GetGenericDatabaseWithOptions<Database>['db']
+  SchemaName extends string & keyof Database = 'public' extends keyof Database
     ? 'public'
-    : string & keyof GetGenericDatabaseWithOptions<Database>['db'],
-  Schema extends GenericSchema = GetGenericDatabaseWithOptions<Database>['db'][SchemaName] extends GenericSchema
-    ? GetGenericDatabaseWithOptions<Database>['db'][SchemaName]
+    : string & keyof Database,
+  Schema extends GenericSchema = Database[SchemaName] extends GenericSchema
+    ? Database[SchemaName]
     : any
 > {
   /**
@@ -54,7 +47,7 @@ export default class SupabaseClient<
   protected authUrl: URL
   protected storageUrl: URL
   protected functionsUrl: URL
-  protected rest: PostgrestClient<Database, ClientOptions, SchemaName, Schema>
+  protected rest: PostgrestClient<Database, SchemaName, Schema>
   protected storageKey: string
   protected fetch?: Fetch
   protected changedAccessToken?: string
@@ -163,16 +156,16 @@ export default class SupabaseClient<
   from<
     TableName extends string & keyof Schema['Tables'],
     Table extends Schema['Tables'][TableName]
-  >(relation: TableName): PostgrestQueryBuilder<ClientOptions, Schema, Table, TableName>
+  >(relation: TableName): PostgrestQueryBuilder<Schema, Table, TableName>
   from<ViewName extends string & keyof Schema['Views'], View extends Schema['Views'][ViewName]>(
     relation: ViewName
-  ): PostgrestQueryBuilder<ClientOptions, Schema, View, ViewName>
+  ): PostgrestQueryBuilder<Schema, View, ViewName>
   /**
    * Perform a query on a table or a view.
    *
    * @param relation - The table or view name to query
    */
-  from(relation: string): PostgrestQueryBuilder<ClientOptions, Schema, any, any> {
+  from(relation: string): PostgrestQueryBuilder<Schema, any, any> {
     return this.rest.from(relation)
   }
 
@@ -184,11 +177,10 @@ export default class SupabaseClient<
    *
    * @param schema - The schema to query
    */
-  schema<DynamicSchema extends string & keyof GetGenericDatabaseWithOptions<Database>['db']>(
+  schema<DynamicSchema extends string & keyof Database>(
     schema: DynamicSchema
   ): PostgrestClient<
     Database,
-    ClientOptions,
     DynamicSchema,
     Database[DynamicSchema] extends GenericSchema ? Database[DynamicSchema] : any
   > {
@@ -228,7 +220,6 @@ export default class SupabaseClient<
       count?: 'exact' | 'planned' | 'estimated'
     } = {}
   ): PostgrestFilterBuilder<
-    ClientOptions,
     Schema,
     Fn['Returns'] extends any[]
       ? Fn['Returns'][number] extends Record<string, unknown>
@@ -237,8 +228,7 @@ export default class SupabaseClient<
       : never,
     Fn['Returns'],
     FnName,
-    null,
-    'RPC'
+    null
   > {
     return this.rest.rpc(fn, args, options)
   }

src/SupabaseClient.ts

@@ -1,7 +1,5 @@
 import SupabaseClient from './SupabaseClient'
 import type { GenericSchema, SupabaseClientOptions } from './lib/types'
-import type { ServicesOptions } from './SupabaseClient'
-import type { GetGenericDatabaseWithOptions } from '@supabase/postgrest-js'
 
 export * from '@supabase/auth-js'
 export type { User as AuthUser, Session as AuthSession } from '@supabase/auth-js'
@@ -28,28 +26,16 @@ export type { SupabaseClientOptions, QueryResult, QueryData, QueryError } from '
  */
 export const createClient = <
   Database = any,
-  ClientOptions extends ServicesOptions = GetGenericDatabaseWithOptions<Database>['options'],
-  SchemaName extends string &
-    keyof GetGenericDatabaseWithOptions<Database>['db'] = 'public' extends keyof GetGenericDatabaseWithOptions<Database>['db']
+  SchemaName extends string & keyof Database = 'public' extends keyof Database
     ? 'public'
-    : string & keyof GetGenericDatabaseWithOptions<Database>['db'],
-  Schema = GetGenericDatabaseWithOptions<Database>['db'][SchemaName] extends GenericSchema
-    ? GetGenericDatabaseWithOptions<Database>['db'][SchemaName]
+    : string & keyof Database,
+  Schema extends GenericSchema = Database[SchemaName] extends GenericSchema
+    ? Database[SchemaName]
     : any
 >(
   supabaseUrl: string,
   supabaseKey: string,
   options?: SupabaseClientOptions<SchemaName>
-): SupabaseClient<
-  Database,
-  ClientOptions,
-  SchemaName,
-  Schema extends GenericSchema ? Schema : any
-> => {
-  return new SupabaseClient<
-    Database,
-    ClientOptions,
-    SchemaName,
-    Schema extends GenericSchema ? Schema : any
-  >(supabaseUrl, supabaseKey, options)
+): SupabaseClient<Database, SchemaName, Schema> => {
+  return new SupabaseClient<Database, SchemaName, Schema>(supabaseUrl, supabaseKey, options)
 }

src/index.ts

@@ -59,15 +59,15 @@ Deno.test(
         const { error: deleteError } = await supabase
           .from('todos')
           .delete()
-          .eq('id', createdTodo!.id as string)
+          .eq('id', createdTodo!.id)
 
         assertEquals(deleteError, null)
 
         // Verify the todo was deleted
         const { data: fetchedTodo, error: fetchError } = await supabase
           .from('todos')
           .select('*')
-          .eq('id', createdTodo!.id as string)
+          .eq('id', createdTodo!.id)
           .single()
 
         assertExists(fetchError)

test/deno/integration.test.ts

@@ -136,59 +136,3 @@ const supabase = createClient<Database>(URL, KEY)
     }[]
   >(channels)
 }
-// Test Postgrest13
-// should be able to declare specific PostgrestVersion
-{
-  // @ts-expect-error should raise error if provinding invalid version
-  createClient<Database, { PostgrestVersion: 42 }>('HTTP://localhost:3000', KEY)
-}
-//  should be able to infer PostgrestVersion from Database __InternalSupabase
-{
-  type DatabaseWithInternals = {
-    __InternalSupabase: {
-      PostgrestVersion: '13'
-    }
-    public: {
-      Tables: {
-        shops: {
-          Row: {
-            address: string | null
-            id: number
-            shop_geom: unknown | null
-          }
-          Insert: {
-            address?: string | null
-            id: number
-            shop_geom?: unknown | null
-          }
-          Update: {
-            address?: string | null
-            id?: number
-            shop_geom?: unknown | null
-          }
-          Relationships: []
-        }
-      }
-      Views: {
-        [_ in never]: never
-      }
-      Functions: {
-        [_ in never]: never
-      }
-      Enums: {
-        [_ in never]: never
-      }
-      CompositeTypes: {
-        [_ in never]: never
-      }
-    }
-  }
-  // Note: The template argument properties (PostgrestVersion) will not be autocompleted
-  // due to a Typescript bug tracked here: https://github.com/microsoft/TypeScript/issues/56299
-  const pg13Client = createClient<DatabaseWithInternals>('HTTP://localhost:3000', KEY)
-  const pg12Client = createClient<Database>('HTTP://localhost:3000', KEY)
-  const res13 = await pg13Client.from('shops').update({ id: 21 }).maxAffected(1)
-  const res12 = await pg12Client.from('shops').update({ id: 21 }).maxAffected(1)
-  expectType<typeof res13.data>(null)
-  expectType<typeof res12.Error>('maxAffected method only available on postgrest 13+')
-}

test/types/index.test-d.ts

@@ -74,20 +74,18 @@ describe('SupabaseClient', () => {
     test('should have custom header set', () => {
       const customHeader = { 'X-Test-Header': 'value' }
       const request = createClient(URL, KEY, { global: { headers: customHeader } }).rpc('')
-      //@ts-expect-error headers is protected attribute
-      const requestHeader = request.headers.get('X-Test-Header')
-      expect(requestHeader).toBe(customHeader['X-Test-Header'])
+      // @ts-ignore
+      const getHeaders = request.headers
+      expect(getHeaders).toHaveProperty('X-Test-Header', 'value')
     })
 
     test('should merge custom headers with default headers', () => {
       const customHeader = { 'X-Test-Header': 'value' }
-      const request = createClient(URL, KEY, { global: { headers: customHeader } }).rpc('')
-
-      //@ts-expect-error headers is protected attribute
-      const requestHeader = request.headers.get('X-Test-Header')
-      expect(requestHeader).toBe(customHeader['X-Test-Header'])
-      //@ts-expect-error headers is protected attribute
-      expect(request.headers.get('X-Client-Info')).not.toBeNull()
+      const client = createClient(URL, KEY, { global: { headers: customHeader } })
+      // @ts-ignore
+      expect(client.headers).toHaveProperty('X-Test-Header', 'value')
+      // @ts-ignore
+      expect(client.headers).toHaveProperty('X-Client-Info')
     })
   })