@supabase/supabase-js 2.79.1-canary.1 → 2.80.0

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@supabase/supabase-js",
-  "version": "2.79.1-canary.1",
-  "description": "Isomorphic Javascript client for Supabase",
+  "version": "2.80.0",
+  "description": "Isomorphic Javascript SDK for Supabase",
   "keywords": [
     "javascript",
     "typescript",
@@ -25,53 +25,77 @@
     "directory": "packages/core/supabase-js"
   },
   "scripts": {
-    "clean": "rimraf dist docs/v2",
-    "build": "npm run clean && npx nx build:main supabase-js && npx nx build:module supabase-js && npx nx build:umd supabase-js",
+    "build": "npm run build:main && npm run build:module && npm run build:umd",
     "build:main": "tsc -p tsconfig.json",
     "build:module": "tsc -p tsconfig.module.json",
     "build:umd": "webpack --env mode=production",
-    "test": "npx nx test:types supabase-js && npx nx test:run supabase-js",
-    "test:all": "npx nx test:types supabase-js && npx nx test:run supabase-js && npx nx test:integration supabase-js && npx nx test:integration:browser supabase-js",
+    "test": "npm run test:types && npm run test:run",
+    "test:all": "npm run test:types && npm run test:run && npm run test:integration && npm run test:integration:browser",
     "test:run": "jest --runInBand --detectOpenHandles",
     "test:unit": "jest --runInBand --detectOpenHandles test/unit",
     "test:coverage": "jest --runInBand --coverage --testPathIgnorePatterns=\"test/integration|test/deno\"",
     "test:integration": "jest --runInBand --detectOpenHandles test/integration.test.ts",
     "test:integration:browser": "deno test --allow-all test/integration.browser.test.ts",
-    "test:edge-functions": "deno test --allow-all --no-check --unstable-sloppy-imports --config test/deno/deno.json test/deno/edge-functions-integration.test.ts",
+    "test:edge-functions": "cd test/deno && npm run test:edge-functions",
+    "test:deno": "cd test/deno && npm run test",
     "test:watch": "jest --watch --verbose false --silent false",
     "test:node:playwright": "cd test/integration/node-browser && npm install && cp ../../../dist/umd/supabase.js . && npm run test",
     "test:bun": "cd test/integration/bun && bun install && bun test",
-    "test:types": "npx nx build:module supabase-js && tsd --files test/types/*.test-d.ts && jsr publish --dry-run --allow-dirty",
+    "test:expo": "cd test/integration/expo && npm test",
+    "test:next": "cd test/integration/next && npm test",
+    "test:types": "tsd --files test/types/*.test-d.ts && jsr publish --dry-run --allow-dirty",
     "docs": "typedoc --entryPoints src/index.ts --out docs/v2",
     "docs:json": "typedoc --entryPoints src/index.ts --json docs/v2/spec.json --excludeExternals",
     "serve:coverage": "npx nx test:coverage supabase-js && serve test/coverage",
-    "update:test-deps": "npx nx build supabase-js && npm pack && cp supabase-supabase-js-*.tgz test/integration/expo/supabase-supabase-js-0.0.0-automated.tgz && cp supabase-supabase-js-*.tgz test/integration/next/supabase-supabase-js-0.0.0-automated.tgz && cp supabase-supabase-js-*.tgz test/deno/supabase-supabase-js-0.0.0-automated.tgz && cp supabase-supabase-js-*.tgz test/integration/bun/supabase-supabase-js-0.0.0-automated.tgz && cd test/integration/expo && npm install && cd ../next && npm install --legacy-peer-deps && cd ../../deno && npm install && cd ../integration/bun && bun install",
-    "update:test-deps:expo": "npx nx build supabase-js && npm pack && cp supabase-supabase-js-*.tgz test/integration/expo/supabase-supabase-js-0.0.0-automated.tgz && cd test/integration/expo && npm install",
-    "update:test-deps:next": "npx nx build supabase-js && npm pack && cp supabase-supabase-js-*.tgz test/integration/next/supabase-supabase-js-0.0.0-automated.tgz && cd test/integration/next && npm install --legacy-peer-deps",
-    "update:test-deps:deno": "npx nx build supabase-js && npm pack && cp supabase-supabase-js-*.tgz test/deno/supabase-supabase-js-0.0.0-automated.tgz && cd test/deno && npm install",
-    "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"
+    "update:test-deps": "npm run update:test-deps:expo && npm run update:test-deps:next && npm run update:test-deps:deno && npm run update:test-deps:bun",
+    "update:test-deps:expo": "cd test/integration/expo && npm install",
+    "update:test-deps:next": "cd test/integration/next && npm install --legacy-peer-deps",
+    "update:test-deps:deno": "cd test/deno && npm install",
+    "update:test-deps:bun": "cd test/integration/bun && bun install"
   },
   "dependencies": {
-    "@supabase/auth-js": "2.79.1-canary.1",
-    "@supabase/functions-js": "2.79.1-canary.1",
-    "@supabase/postgrest-js": "2.79.1-canary.1",
-    "@supabase/realtime-js": "2.79.1-canary.1",
-    "@supabase/storage-js": "2.79.1-canary.1",
-    "@supabase/node-fetch": "2.6.15"
+    "@supabase/auth-js": "2.80.0",
+    "@supabase/functions-js": "2.80.0",
+    "@supabase/postgrest-js": "2.80.0",
+    "@supabase/realtime-js": "2.80.0",
+    "@supabase/storage-js": "2.80.0"
   },
   "devDependencies": {
-    "@sebbo2002/semantic-release-jsr": "^1.0.0",
     "jsr": "^0.13.5",
-    "pretty-quick": "^3.1.3",
     "puppeteer": "^24.9.0",
     "serve": "^14.2.1",
-    "ts-jest": "^29.0.5",
     "ts-loader": "^9.5.4",
     "tsd": "^0.30.4",
-    "eslint-formatter-pretty": "^4.1.0",
     "webpack": "^5.69.1",
     "webpack-cli": "^4.9.2"
   },
   "jsdelivr": "dist/umd/supabase.js",
-  "unpkg": "dist/umd/supabase.js"
+  "unpkg": "dist/umd/supabase.js",
+  "nx": {
+    "targets": {
+      "test:integration:browser": {
+        "dependsOn": [
+          {
+            "projects": [
+              "storage-js"
+            ],
+            "target": "build"
+          }
+        ]
+      },
+      "test:edge-functions": {
+        "dependsOn": [
+          {
+            "projects": [
+              "storage-js"
+            ],
+            "target": "build"
+          }
+        ]
+      }
+    }
+  },
+  "engines": {
+    "node": ">=20.0.0"
+  }
 }

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'
+    >
   }
 
   /**
@@ -318,6 +340,7 @@ export default class SupabaseClient<
       flowType,
       lock,
       debug,
+      throwOnError,
     }: SupabaseAuthClientOptions,
     headers?: Record<string, string>,
     fetch?: Fetch
@@ -338,6 +361,7 @@ export default class SupabaseClient<
       flowType,
       lock,
       debug,
+      throwOnError,
       fetch,
       // auth checks if there is a custom authorizaiton header using this flag
       // so it knows whether to return an error when getUser is called with no session
@@ -355,7 +379,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/fetch.ts

@@ -1,25 +1,13 @@
-// @ts-ignore
-import nodeFetch, { Headers as NodeFetchHeaders } from '@supabase/node-fetch'
-
 type Fetch = typeof fetch
 
 export const resolveFetch = (customFetch?: Fetch): Fetch => {
-  let _fetch: Fetch
   if (customFetch) {
-    _fetch = customFetch
-  } else if (typeof fetch === 'undefined') {
-    _fetch = nodeFetch as unknown as Fetch
-  } else {
-    _fetch = fetch
+    return (...args: Parameters<Fetch>) => customFetch(...args)
   }
-  return (...args: Parameters<Fetch>) => _fetch(...args)
+  return (...args: Parameters<Fetch>) => fetch(...args)
 }
 
 export const resolveHeadersConstructor = () => {
-  if (typeof Headers === 'undefined') {
-    return NodeFetchHeaders
-  }
-
   return Headers
 }
 

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

@@ -0,0 +1,66 @@
+/**
+ * AUTO-GENERATED FILE - DO NOT EDIT
+ *
+ * This file is automatically synchronized from @supabase/postgrest-js
+ * Source: packages/core/postgrest-js/src/types/common/
+ *
+ * To update this file, modify the source in postgrest-js and run:
+ *   npm run codegen
+ */
+
+// 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,145 @@
+/**
+ * AUTO-GENERATED FILE - DO NOT EDIT
+ *
+ * This file is automatically synchronized from @supabase/postgrest-js
+ * Source: packages/core/postgrest-js/src/types/common/
+ *
+ * To update this file, modify the source in postgrest-js and run:
+ *   npm run codegen
+ */
+
+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

@@ -1,11 +1,27 @@
-import { AuthClient } from '@supabase/auth-js'
+import { GoTrueClientOptions } 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]
-
-export interface SupabaseAuthClientOptions extends AuthClientOptions {}
+export interface SupabaseAuthClientOptions extends GoTrueClientOptions {}
 
 export type Fetch = typeof fetch
 
@@ -60,6 +76,11 @@ export type SupabaseClientOptions<SchemaName> = {
      * @experimental
      */
     lock?: SupabaseAuthClientOptions['lock']
+    /**
+     * If there is an error with the query, throwOnError will reject the promise by
+     * throwing the error instead of returning it as part of a successful response.
+     */
+    throwOnError?: SupabaseAuthClientOptions['throwOnError']
   }
   /**
    * Options passed to the realtime-js instance
@@ -79,9 +100,9 @@ export type SupabaseClientOptions<SchemaName> = {
   /**
    * Optional function for using a third-party authentication system with
    * Supabase. The function should return an access token or ID token (JWT) by
-   * obtaining it from the third-party auth client library. Note that this
+   * obtaining it from the third-party auth SDK. Note that this
    * function may be called concurrently and many times. Use memoization and
-   * locking techniques if this is not supported by the client libraries.
+   * locking techniques if this is not supported by the SDKs.
    *
    * When set, the `auth` namespace of the Supabase client cannot be used.
    * Create another client if you wish to use Supabase Auth and third-party
@@ -90,41 +111,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.79.1-canary.1'
+export const version = '2.80.0'