@supabase/supabase-js 2.74.1-canary.6 → 2.75.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@supabase/supabase-js",
-  "version": "2.74.1-canary.6",
+  "version": "2.75.0",
   "description": "Isomorphic Javascript client for Supabase",
   "keywords": [
     "javascript",
@@ -52,11 +52,11 @@
     "update:test-deps:bun": "npx nx build supabase-js && npm pack && cp supabase-supabase-js-*.tgz test/integration/bun/supabase-supabase-js-0.0.0-automated.tgz && cd test/integration/bun && bun install"
   },
   "dependencies": {
-    "@supabase/auth-js": "2.74.1-canary.6",
-    "@supabase/functions-js": "2.74.1-canary.6",
-    "@supabase/postgrest-js": "2.74.1-canary.6",
-    "@supabase/realtime-js": "2.74.1-canary.6",
-    "@supabase/storage-js": "2.74.1-canary.6",
+    "@supabase/auth-js": "2.75.0",
+    "@supabase/functions-js": "2.75.0",
+    "@supabase/postgrest-js": "2.75.0",
+    "@supabase/realtime-js": "2.75.0",
+    "@supabase/storage-js": "2.75.0",
     "@supabase/node-fetch": "2.6.15"
   },
   "devDependencies": {

package/src/SupabaseClient.ts

@@ -1,27 +1,33 @@
+import type { AuthChangeEvent } from '@supabase/auth-js'
 import { FunctionsClient } from '@supabase/functions-js'
-import { AuthChangeEvent } from '@supabase/auth-js'
 import {
   PostgrestClient,
-  PostgrestFilterBuilder,
-  PostgrestQueryBuilder,
+  type PostgrestFilterBuilder,
+  type PostgrestQueryBuilder,
 } from '@supabase/postgrest-js'
 import {
-  RealtimeChannel,
-  RealtimeChannelOptions,
+  type RealtimeChannel,
+  type RealtimeChannelOptions,
   RealtimeClient,
-  RealtimeClientOptions,
+  type RealtimeClientOptions,
 } from '@supabase/realtime-js'
 import { StorageClient as SupabaseStorageClient } from '@supabase/storage-js'
 import {
-  DEFAULT_GLOBAL_OPTIONS,
-  DEFAULT_DB_OPTIONS,
   DEFAULT_AUTH_OPTIONS,
+  DEFAULT_DB_OPTIONS,
+  DEFAULT_GLOBAL_OPTIONS,
   DEFAULT_REALTIME_OPTIONS,
 } from './lib/constants'
 import { fetchWithAuth } from './lib/fetch'
 import { applySettingDefaults, validateSupabaseUrl } from './lib/helpers'
 import { SupabaseAuthClient } from './lib/SupabaseAuthClient'
-import { Fetch, GenericSchema, SupabaseClientOptions, SupabaseAuthClientOptions } from './lib/types'
+import type {
+  Fetch,
+  GenericSchema,
+  SupabaseAuthClientOptions,
+  SupabaseClientOptions,
+} from './lib/types'
+import { GetRpcFunctionFilterBuilderByArgs } from './lib/rest/types/common/rpc'
 
 /**
  * Supabase Client.
@@ -238,28 +244,44 @@ export default class SupabaseClient<
    * `"estimated"`: Uses exact count for low numbers and planned count for high
    * numbers.
    */
-  rpc<FnName extends string & keyof Schema['Functions'], Fn extends Schema['Functions'][FnName]>(
+  rpc<
+    FnName extends string & keyof Schema['Functions'],
+    Args extends Schema['Functions'][FnName]['Args'] = never,
+    FilterBuilder extends GetRpcFunctionFilterBuilderByArgs<
+      Schema,
+      FnName,
+      Args
+    > = GetRpcFunctionFilterBuilderByArgs<Schema, FnName, Args>,
+  >(
     fn: FnName,
-    args: Fn['Args'] = {},
+    args: Args = {} as Args,
     options: {
       head?: boolean
       get?: boolean
       count?: 'exact' | 'planned' | 'estimated'
-    } = {}
+    } = {
+      head: false,
+      get: false,
+      count: undefined,
+    }
   ): PostgrestFilterBuilder<
     ClientOptions,
     Schema,
-    Fn['Returns'] extends any[]
-      ? Fn['Returns'][number] extends Record<string, unknown>
-        ? Fn['Returns'][number]
-        : never
-      : never,
-    Fn['Returns'],
-    FnName,
-    null,
+    FilterBuilder['Row'],
+    FilterBuilder['Result'],
+    FilterBuilder['RelationName'],
+    FilterBuilder['Relationships'],
     'RPC'
   > {
-    return this.rest.rpc(fn, args, options)
+    return this.rest.rpc(fn, args, options) as unknown as PostgrestFilterBuilder<
+      ClientOptions,
+      Schema,
+      FilterBuilder['Row'],
+      FilterBuilder['Result'],
+      FilterBuilder['RelationName'],
+      FilterBuilder['Relationships'],
+      'RPC'
+    >
   }
 
   /**
@@ -355,7 +377,7 @@ export default class SupabaseClient<
   }
 
   private _listenForAuthEvents() {
-    let data = this.auth.onAuthStateChange((event, session) => {
+    const data = this.auth.onAuthStateChange((event, session) => {
       this._handleTokenChanged(event, 'CLIENT', session?.access_token)
     })
     return data

package/src/lib/rest/types/common/common/common.ts

@@ -0,0 +1,56 @@
+// Types that are shared between supabase-js and postgrest-js
+
+export type Fetch = typeof fetch
+
+export type GenericRelationship = {
+  foreignKeyName: string
+  columns: string[]
+  isOneToOne?: boolean
+  referencedRelation: string
+  referencedColumns: string[]
+}
+
+export type GenericTable = {
+  Row: Record<string, unknown>
+  Insert: Record<string, unknown>
+  Update: Record<string, unknown>
+  Relationships: GenericRelationship[]
+}
+
+export type GenericUpdatableView = {
+  Row: Record<string, unknown>
+  Insert: Record<string, unknown>
+  Update: Record<string, unknown>
+  Relationships: GenericRelationship[]
+}
+
+export type GenericNonUpdatableView = {
+  Row: Record<string, unknown>
+  Relationships: GenericRelationship[]
+}
+
+export type GenericView = GenericUpdatableView | GenericNonUpdatableView
+
+export type GenericSetofOption = {
+  isSetofReturn?: boolean | undefined
+  isOneToOne?: boolean | undefined
+  isNotNullable?: boolean | undefined
+  to: string
+  from: string
+}
+
+export type GenericFunction = {
+  Args: Record<string, unknown> | never
+  Returns: unknown
+  SetofOptions?: GenericSetofOption
+}
+
+export type GenericSchema = {
+  Tables: Record<string, GenericTable>
+  Views: Record<string, GenericView>
+  Functions: Record<string, GenericFunction>
+}
+
+export type ClientServerOptions = {
+  PostgrestVersion?: string
+}

package/src/lib/rest/types/common/common/rpc.ts

@@ -0,0 +1,135 @@
+import type { GenericFunction, GenericSchema, GenericSetofOption } from './common'
+
+// Functions matching utils
+type IsMatchingArgs<
+  FnArgs extends GenericFunction['Args'],
+  PassedArgs extends GenericFunction['Args'],
+> = [FnArgs] extends [Record<PropertyKey, never>]
+  ? PassedArgs extends Record<PropertyKey, never>
+    ? true
+    : false
+  : keyof PassedArgs extends keyof FnArgs
+    ? PassedArgs extends FnArgs
+      ? true
+      : false
+    : false
+
+type MatchingFunctionArgs<
+  Fn extends GenericFunction,
+  Args extends GenericFunction['Args'],
+> = Fn extends { Args: infer A extends GenericFunction['Args'] }
+  ? IsMatchingArgs<A, Args> extends true
+    ? Fn
+    : never
+  : false
+
+type FindMatchingFunctionByArgs<
+  FnUnion,
+  Args extends GenericFunction['Args'],
+> = FnUnion extends infer Fn extends GenericFunction ? MatchingFunctionArgs<Fn, Args> : false
+
+// Types for working with database schemas
+type TablesAndViews<Schema extends GenericSchema> = Schema['Tables'] & Exclude<Schema['Views'], ''>
+
+// Utility types for working with unions
+type UnionToIntersection<U> = (U extends any ? (k: U) => void : never) extends (k: infer I) => void
+  ? I
+  : never
+
+type LastOf<T> =
+  UnionToIntersection<T extends any ? () => T : never> extends () => infer R ? R : never
+
+type IsAny<T> = 0 extends 1 & T ? true : false
+
+type ExactMatch<T, S> = [T] extends [S] ? ([S] extends [T] ? true : false) : false
+
+type ExtractExactFunction<Fns, Args> = Fns extends infer F
+  ? F extends GenericFunction
+    ? ExactMatch<F['Args'], Args> extends true
+      ? F
+      : never
+    : never
+  : never
+
+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'],
+  Args,
+> = {
+  0: Schema['Functions'][FnName]
+  // If the Args is exactly never (function call without any params)
+  1: IsAny<Schema> extends true
+    ? any
+    : IsNever<Args> extends true
+      ? // This is for retro compatibility, if the funcition is defined with an single return and an union of Args
+        // we fallback to the last function definition matched by name
+        IsNever<ExtractExactFunction<Schema['Functions'][FnName], Args>> extends true
+        ? LastOf<Schema['Functions'][FnName]>
+        : ExtractExactFunction<Schema['Functions'][FnName], Args>
+      : Args extends Record<PropertyKey, never>
+        ? LastOf<Schema['Functions'][FnName]>
+        : // Otherwise, we attempt to match with one of the function definition in the union based
+          // on the function arguments provided
+          Args extends GenericFunction['Args']
+          ? // This is for retro compatibility, if the funcition is defined with an single return and an union of Args
+            // we fallback to the last function definition matched by name
+            IsNever<
+              LastOf<FindMatchingFunctionByArgs<Schema['Functions'][FnName], Args>>
+            > extends true
+            ? LastOf<Schema['Functions'][FnName]>
+            : // Otherwise, we use the arguments based function definition narrowing to get the right value
+              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>
+            : any
+}[1] extends infer Fn
+  ? // If we are dealing with an non-typed client everything is any
+    IsAny<Fn> extends true
+    ? { Row: any; Result: any; RelationName: FnName; Relationships: null }
+    : // Otherwise, we use the arguments based function definition narrowing to get the rigt value
+      Fn extends GenericFunction
+      ? {
+          Row: Fn['SetofOptions'] extends GenericSetofOption
+            ? Fn['SetofOptions']['isSetofReturn'] extends true
+              ? TablesAndViews<Schema>[Fn['SetofOptions']['to']]['Row']
+              : TablesAndViews<Schema>[Fn['SetofOptions']['to']]['Row']
+            : Fn['Returns'] extends any[]
+              ? Fn['Returns'][number] extends Record<string, unknown>
+                ? Fn['Returns'][number]
+                : never
+              : Fn['Returns'] extends Record<string, unknown>
+                ? Fn['Returns']
+                : never
+          Result: Fn['SetofOptions'] extends GenericSetofOption
+            ? Fn['SetofOptions']['isSetofReturn'] extends true
+              ? Fn['SetofOptions']['isOneToOne'] extends true
+                ? Fn['Returns'][]
+                : Fn['Returns']
+              : Fn['Returns']
+            : Fn['Returns']
+          RelationName: Fn['SetofOptions'] extends GenericSetofOption
+            ? Fn['SetofOptions']['to']
+            : FnName
+          Relationships: Fn['SetofOptions'] extends GenericSetofOption
+            ? Fn['SetofOptions']['to'] extends keyof Schema['Tables']
+              ? Schema['Tables'][Fn['SetofOptions']['to']]['Relationships']
+              : Schema['Views'][Fn['SetofOptions']['to']]['Relationships']
+            : null
+        }
+      : // If we failed to find the function by argument, we still pass with any but also add an overridable
+        Fn extends false
+        ? RpcFunctionNotFound<FnName>
+        : RpcFunctionNotFound<FnName>
+  : RpcFunctionNotFound<FnName>

package/src/lib/rest/types/common/common.ts

@@ -0,0 +1,56 @@
+// Types that are shared between supabase-js and postgrest-js
+
+export type Fetch = typeof fetch
+
+export type GenericRelationship = {
+  foreignKeyName: string
+  columns: string[]
+  isOneToOne?: boolean
+  referencedRelation: string
+  referencedColumns: string[]
+}
+
+export type GenericTable = {
+  Row: Record<string, unknown>
+  Insert: Record<string, unknown>
+  Update: Record<string, unknown>
+  Relationships: GenericRelationship[]
+}
+
+export type GenericUpdatableView = {
+  Row: Record<string, unknown>
+  Insert: Record<string, unknown>
+  Update: Record<string, unknown>
+  Relationships: GenericRelationship[]
+}
+
+export type GenericNonUpdatableView = {
+  Row: Record<string, unknown>
+  Relationships: GenericRelationship[]
+}
+
+export type GenericView = GenericUpdatableView | GenericNonUpdatableView
+
+export type GenericSetofOption = {
+  isSetofReturn?: boolean | undefined
+  isOneToOne?: boolean | undefined
+  isNotNullable?: boolean | undefined
+  to: string
+  from: string
+}
+
+export type GenericFunction = {
+  Args: Record<string, unknown> | never
+  Returns: unknown
+  SetofOptions?: GenericSetofOption
+}
+
+export type GenericSchema = {
+  Tables: Record<string, GenericTable>
+  Views: Record<string, GenericView>
+  Functions: Record<string, GenericFunction>
+}
+
+export type ClientServerOptions = {
+  PostgrestVersion?: string
+}

package/src/lib/rest/types/common/rpc.ts

@@ -0,0 +1,135 @@
+import type { GenericFunction, GenericSchema, GenericSetofOption } from './common'
+
+// Functions matching utils
+type IsMatchingArgs<
+  FnArgs extends GenericFunction['Args'],
+  PassedArgs extends GenericFunction['Args'],
+> = [FnArgs] extends [Record<PropertyKey, never>]
+  ? PassedArgs extends Record<PropertyKey, never>
+    ? true
+    : false
+  : keyof PassedArgs extends keyof FnArgs
+    ? PassedArgs extends FnArgs
+      ? true
+      : false
+    : false
+
+type MatchingFunctionArgs<
+  Fn extends GenericFunction,
+  Args extends GenericFunction['Args'],
+> = Fn extends { Args: infer A extends GenericFunction['Args'] }
+  ? IsMatchingArgs<A, Args> extends true
+    ? Fn
+    : never
+  : false
+
+type FindMatchingFunctionByArgs<
+  FnUnion,
+  Args extends GenericFunction['Args'],
+> = FnUnion extends infer Fn extends GenericFunction ? MatchingFunctionArgs<Fn, Args> : false
+
+// Types for working with database schemas
+type TablesAndViews<Schema extends GenericSchema> = Schema['Tables'] & Exclude<Schema['Views'], ''>
+
+// Utility types for working with unions
+type UnionToIntersection<U> = (U extends any ? (k: U) => void : never) extends (k: infer I) => void
+  ? I
+  : never
+
+type LastOf<T> =
+  UnionToIntersection<T extends any ? () => T : never> extends () => infer R ? R : never
+
+type IsAny<T> = 0 extends 1 & T ? true : false
+
+type ExactMatch<T, S> = [T] extends [S] ? ([S] extends [T] ? true : false) : false
+
+type ExtractExactFunction<Fns, Args> = Fns extends infer F
+  ? F extends GenericFunction
+    ? ExactMatch<F['Args'], Args> extends true
+      ? F
+      : never
+    : never
+  : never
+
+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'],
+  Args,
+> = {
+  0: Schema['Functions'][FnName]
+  // If the Args is exactly never (function call without any params)
+  1: IsAny<Schema> extends true
+    ? any
+    : IsNever<Args> extends true
+      ? // This is for retro compatibility, if the funcition is defined with an single return and an union of Args
+        // we fallback to the last function definition matched by name
+        IsNever<ExtractExactFunction<Schema['Functions'][FnName], Args>> extends true
+        ? LastOf<Schema['Functions'][FnName]>
+        : ExtractExactFunction<Schema['Functions'][FnName], Args>
+      : Args extends Record<PropertyKey, never>
+        ? LastOf<Schema['Functions'][FnName]>
+        : // Otherwise, we attempt to match with one of the function definition in the union based
+          // on the function arguments provided
+          Args extends GenericFunction['Args']
+          ? // This is for retro compatibility, if the funcition is defined with an single return and an union of Args
+            // we fallback to the last function definition matched by name
+            IsNever<
+              LastOf<FindMatchingFunctionByArgs<Schema['Functions'][FnName], Args>>
+            > extends true
+            ? LastOf<Schema['Functions'][FnName]>
+            : // Otherwise, we use the arguments based function definition narrowing to get the right value
+              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>
+            : any
+}[1] extends infer Fn
+  ? // If we are dealing with an non-typed client everything is any
+    IsAny<Fn> extends true
+    ? { Row: any; Result: any; RelationName: FnName; Relationships: null }
+    : // Otherwise, we use the arguments based function definition narrowing to get the rigt value
+      Fn extends GenericFunction
+      ? {
+          Row: Fn['SetofOptions'] extends GenericSetofOption
+            ? Fn['SetofOptions']['isSetofReturn'] extends true
+              ? TablesAndViews<Schema>[Fn['SetofOptions']['to']]['Row']
+              : TablesAndViews<Schema>[Fn['SetofOptions']['to']]['Row']
+            : Fn['Returns'] extends any[]
+              ? Fn['Returns'][number] extends Record<string, unknown>
+                ? Fn['Returns'][number]
+                : never
+              : Fn['Returns'] extends Record<string, unknown>
+                ? Fn['Returns']
+                : never
+          Result: Fn['SetofOptions'] extends GenericSetofOption
+            ? Fn['SetofOptions']['isSetofReturn'] extends true
+              ? Fn['SetofOptions']['isOneToOne'] extends true
+                ? Fn['Returns'][]
+                : Fn['Returns']
+              : Fn['Returns']
+            : Fn['Returns']
+          RelationName: Fn['SetofOptions'] extends GenericSetofOption
+            ? Fn['SetofOptions']['to']
+            : FnName
+          Relationships: Fn['SetofOptions'] extends GenericSetofOption
+            ? Fn['SetofOptions']['to'] extends keyof Schema['Tables']
+              ? Schema['Tables'][Fn['SetofOptions']['to']]['Relationships']
+              : Schema['Views'][Fn['SetofOptions']['to']]['Relationships']
+            : null
+        }
+      : // If we failed to find the function by argument, we still pass with any but also add an overridable
+        Fn extends false
+        ? RpcFunctionNotFound<FnName>
+        : RpcFunctionNotFound<FnName>
+  : RpcFunctionNotFound<FnName>

package/src/lib/types.ts

@@ -2,6 +2,24 @@ import { AuthClient } from '@supabase/auth-js'
 import { RealtimeClientOptions } from '@supabase/realtime-js'
 import { PostgrestError } from '@supabase/postgrest-js'
 import type { StorageClientOptions } from '@supabase/storage-js'
+import type {
+  GenericSchema,
+  GenericRelationship,
+  GenericTable,
+  GenericUpdatableView,
+  GenericNonUpdatableView,
+  GenericView,
+  GenericFunction,
+} from './rest/types/common/common'
+export type {
+  GenericSchema,
+  GenericRelationship,
+  GenericTable,
+  GenericUpdatableView,
+  GenericNonUpdatableView,
+  GenericView,
+  GenericFunction,
+}
 
 type AuthClientOptions = ConstructorParameters<typeof AuthClient>[0]
 
@@ -90,41 +108,6 @@ export type SupabaseClientOptions<SchemaName> = {
   accessToken?: () => Promise<string | null>
 }
 
-export type GenericRelationship = {
-  foreignKeyName: string
-  columns: string[]
-  isOneToOne?: boolean
-  referencedRelation: string
-  referencedColumns: string[]
-}
-
-export type GenericTable = {
-  Row: Record<string, unknown>
-  Insert: Record<string, unknown>
-  Update: Record<string, unknown>
-  Relationships: GenericRelationship[]
-}
-
-export type GenericUpdatableView = GenericTable
-
-export type GenericNonUpdatableView = {
-  Row: Record<string, unknown>
-  Relationships: GenericRelationship[]
-}
-
-export type GenericView = GenericUpdatableView | GenericNonUpdatableView
-
-export type GenericFunction = {
-  Args: Record<string, unknown>
-  Returns: unknown
-}
-
-export type GenericSchema = {
-  Tables: Record<string, GenericTable>
-  Views: Record<string, GenericView>
-  Functions: Record<string, GenericFunction>
-}
-
 /**
  * Helper types for query results.
  */

package/src/lib/version.ts

@@ -4,4 +4,4 @@
 // - Debugging and support (identifying which version is running)
 // - Telemetry and logging (version reporting in errors/analytics)
 // - Ensuring build artifacts match the published package version
-export const version = '2.74.1-canary.6'
+export const version = '2.75.0'