@supabase/supabase-js 2.105.5-beta.8 → 2.106.0-canary.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@supabase/supabase-js",
-  "version": "2.105.5-beta.8",
+  "version": "2.106.0-canary.1",
   "description": "Isomorphic Javascript SDK for Supabase",
   "keywords": [
     "javascript",
@@ -49,15 +49,16 @@
     "directory": "packages/core/supabase-js"
   },
   "dependencies": {
-    "@supabase/auth-js": "2.105.5-beta.8",
-    "@supabase/postgrest-js": "2.105.5-beta.8",
-    "@supabase/functions-js": "2.105.5-beta.8",
-    "@supabase/realtime-js": "2.105.5-beta.8",
-    "@supabase/storage-js": "2.105.5-beta.8"
+    "@supabase/auth-js": "2.106.0-canary.1",
+    "@supabase/functions-js": "2.106.0-canary.1",
+    "@supabase/realtime-js": "2.106.0-canary.1",
+    "@supabase/postgrest-js": "2.106.0-canary.1",
+    "@supabase/storage-js": "2.106.0-canary.1"
   },
   "devDependencies": {
     "jsr": "^0.13.5",
-    "puppeteer": "^24.9.0"
+    "puppeteer": "^24.9.0",
+    "@supabase/tracing": "0.0.0-automated"
   },
   "jsdelivr": "dist/umd/supabase.js",
   "unpkg": "dist/umd/supabase.js",

package/src/SupabaseClient.ts

@@ -18,9 +18,14 @@ import {
   DEFAULT_DB_OPTIONS,
   DEFAULT_GLOBAL_OPTIONS,
   DEFAULT_REALTIME_OPTIONS,
+  DEFAULT_TRACE_PROPAGATION_OPTIONS,
 } from './lib/constants'
 import { fetchWithAuth } from './lib/fetch'
-import { applySettingDefaults, validateSupabaseUrl } from './lib/helpers'
+import {
+  applySettingDefaults,
+  validateSupabaseUrl,
+  type ResolvedSupabaseClientOptions,
+} from './lib/helpers'
 import { SupabaseAuthClient } from './lib/SupabaseAuthClient'
 import type {
   Fetch,
@@ -89,6 +94,7 @@ export default class SupabaseClient<
   protected accessToken?: () => Promise<string | null>
 
   protected headers: Record<string, string>
+  protected settings?: ResolvedSupabaseClientOptions<SchemaName>
 
   /**
    * Create a new client for use in the browser.
@@ -298,9 +304,11 @@ export default class SupabaseClient<
       realtime: DEFAULT_REALTIME_OPTIONS,
       auth: { ...DEFAULT_AUTH_OPTIONS, storageKey: defaultStorageKey },
       global: DEFAULT_GLOBAL_OPTIONS,
+      tracePropagation: DEFAULT_TRACE_PROPAGATION_OPTIONS,
     }
 
     const settings = applySettingDefaults(options ?? {}, DEFAULTS)
+    this.settings = settings
 
     this.storageKey = settings.auth.storageKey ?? ''
     this.headers = settings.global.headers ?? {}
@@ -325,7 +333,13 @@ export default class SupabaseClient<
       })
     }
 
-    this.fetch = fetchWithAuth(supabaseKey, this._getAccessToken.bind(this), settings.global.fetch)
+    this.fetch = fetchWithAuth(
+      supabaseKey,
+      supabaseUrl,
+      this._getAccessToken.bind(this),
+      settings.global.fetch,
+      settings.tracePropagation
+    )
     this.realtime = this._initRealtimeClient({
       headers: this.headers,
       accessToken: this._getAccessToken.bind(this),

package/src/lib/constants.ts

@@ -1,6 +1,6 @@
 // constants.ts
 import { RealtimeClientOptions } from '@supabase/realtime-js'
-import { SupabaseAuthClientOptions } from './types'
+import { SupabaseAuthClientOptions, TracePropagationOptions } from './types'
 import { version } from './version'
 
 let JS_ENV = ''
@@ -33,3 +33,8 @@ export const DEFAULT_AUTH_OPTIONS: SupabaseAuthClientOptions = {
 }
 
 export const DEFAULT_REALTIME_OPTIONS: RealtimeClientOptions = {}
+
+export const DEFAULT_TRACE_PROPAGATION_OPTIONS: TracePropagationOptions = {
+  enabled: false,
+  respectSamplingDecision: true,
+}

package/src/lib/fetch.ts

@@ -1,3 +1,13 @@
+import {
+  extractTraceContext,
+  parseTraceParent,
+  shouldPropagateToTarget,
+  getDefaultPropagationTargets,
+  type TraceContext,
+  type TracePropagationTarget,
+} from '@supabase/tracing'
+import type { TracePropagationOptions } from './types'
+
 type Fetch = typeof fetch
 
 export const resolveFetch = (customFetch?: Fetch): Fetch => {
@@ -13,12 +23,22 @@ export const resolveHeadersConstructor = () => {
 
 export const fetchWithAuth = (
   supabaseKey: string,
+  supabaseUrl: string,
   getAccessToken: () => Promise<string | null>,
-  customFetch?: Fetch
+  customFetch?: Fetch,
+  tracePropagationOptions?: TracePropagationOptions
 ): Fetch => {
   const fetch = resolveFetch(customFetch)
   const HeadersConstructor = resolveHeadersConstructor()
 
+  // Pre-compute trace propagation state once. When disabled, the per-request
+  // path skips all tracing work with a single truthy check.
+  const traceEnabled = tracePropagationOptions?.enabled === true
+  const respectSampling = tracePropagationOptions?.respectSamplingDecision !== false
+  const traceTargets: TracePropagationTarget[] | null = traceEnabled
+    ? getDefaultPropagationTargets(supabaseUrl)
+    : null
+
   return async (input, init) => {
     const accessToken = (await getAccessToken()) ?? supabaseKey
     let headers = new HeadersConstructor(init?.headers)
@@ -31,6 +51,50 @@ export const fetchWithAuth = (
       headers.set('Authorization', `Bearer ${accessToken}`)
     }
 
+    if (traceTargets) {
+      const traceHeaders = await getTraceHeaders(input, traceTargets, respectSampling)
+
+      if (traceHeaders) {
+        if (traceHeaders.traceparent && !headers.has('traceparent')) {
+          headers.set('traceparent', traceHeaders.traceparent)
+        }
+        if (traceHeaders.tracestate && !headers.has('tracestate')) {
+          headers.set('tracestate', traceHeaders.tracestate)
+        }
+        if (traceHeaders.baggage && !headers.has('baggage')) {
+          headers.set('baggage', traceHeaders.baggage)
+        }
+      }
+    }
+
     return fetch(input, { ...init, headers })
   }
 }
+
+async function getTraceHeaders(
+  input: RequestInfo | URL,
+  targets: TracePropagationTarget[],
+  respectSampling: boolean
+): Promise<TraceContext | null> {
+  const targetUrl: string | URL =
+    typeof input === 'string' ? input : input instanceof URL ? input : input.url
+
+  if (!shouldPropagateToTarget(targetUrl, targets)) {
+    return null
+  }
+
+  const traceContext = await extractTraceContext()
+
+  if (!traceContext || !traceContext.traceparent) {
+    return null
+  }
+
+  if (respectSampling) {
+    const parsed = parseTraceParent(traceContext.traceparent)
+    if (parsed && !parsed.isSampled) {
+      return null
+    }
+  }
+
+  return traceContext
+}

package/src/lib/helpers.ts

@@ -1,5 +1,11 @@
 // helpers.ts
-import { SupabaseClientOptions } from './types'
+import { SupabaseClientOptions, TracePropagationOptions } from './types'
+
+function normalizeTracePropagation(
+  value: TracePropagationOptions | boolean | undefined
+): TracePropagationOptions | undefined {
+  return typeof value === 'boolean' ? { enabled: value } : value
+}
 
 export function uuid() {
   return 'xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx'.replace(/[xy]/g, function (c) {
@@ -15,6 +21,13 @@ export function ensureTrailingSlash(url: string): string {
 
 export const isBrowser = () => typeof window !== 'undefined'
 
+export type ResolvedSupabaseClientOptions<SchemaName> = Omit<
+  Required<SupabaseClientOptions<SchemaName>>,
+  'tracePropagation'
+> & {
+  tracePropagation: TracePropagationOptions
+}
+
 export function applySettingDefaults<
   Database = any,
   SchemaName extends string & keyof Database = 'public' extends keyof Database
@@ -23,7 +36,7 @@ export function applySettingDefaults<
 >(
   options: SupabaseClientOptions<SchemaName>,
   defaults: SupabaseClientOptions<any>
-): Required<SupabaseClientOptions<SchemaName>> {
+): ResolvedSupabaseClientOptions<SchemaName> {
   const {
     db: dbOptions,
     auth: authOptions,
@@ -37,7 +50,11 @@ export function applySettingDefaults<
     global: DEFAULT_GLOBAL_OPTIONS,
   } = defaults
 
-  const result: Required<SupabaseClientOptions<SchemaName>> = {
+  // Accept either a boolean shorthand or an options object on both sides.
+  const tracePropagationOptions = normalizeTracePropagation(options.tracePropagation)
+  const DEFAULT_TRACE_PROPAGATION_OPTIONS = normalizeTracePropagation(defaults.tracePropagation)
+
+  const result: ResolvedSupabaseClientOptions<SchemaName> = {
     db: {
       ...DEFAULT_DB_OPTIONS,
       ...dbOptions,
@@ -59,6 +76,14 @@ export function applySettingDefaults<
         ...(globalOptions?.headers ?? {}),
       },
     },
+    tracePropagation: {
+      enabled:
+        tracePropagationOptions?.enabled ?? DEFAULT_TRACE_PROPAGATION_OPTIONS?.enabled ?? false,
+      respectSamplingDecision:
+        tracePropagationOptions?.respectSamplingDecision ??
+        DEFAULT_TRACE_PROPAGATION_OPTIONS?.respectSamplingDecision ??
+        true,
+    },
     accessToken: async () => '',
   }
 

package/src/lib/types.ts

@@ -25,6 +25,42 @@ export interface SupabaseAuthClientOptions extends GoTrueClientOptions {}
 
 export type Fetch = typeof fetch
 
+/**
+ * Configuration options for trace context propagation.
+ *
+ * Enables distributed tracing across Supabase services using W3C Trace Context
+ * and OpenTelemetry standards. When enabled, the SDK automatically attaches
+ * trace context headers (traceparent, tracestate, baggage) to outgoing requests
+ * to Supabase domains.
+ *
+ * @see https://www.w3.org/TR/trace-context/
+ * @see https://opentelemetry.io/docs/concepts/context-propagation/
+ */
+export interface TracePropagationOptions {
+  /**
+   * Enable trace propagation. Disabled by default.
+   *
+   * When enabled, automatically detects and propagates active trace context
+   * from the OpenTelemetry API to outgoing Supabase requests. Trace context
+   * is only propagated to Supabase domains (*.supabase.co, *.supabase.in,
+   * localhost) for security.
+   *
+   * @default false
+   */
+  enabled?: boolean
+
+  /**
+   * Respect upstream sampling decisions.
+   *
+   * When true, trace context will not be propagated if the upstream trace
+   * indicates non-sampling (sampled flag = 0 in traceparent header).
+   * This helps reduce overhead when traces are not being collected.
+   *
+   * @default true
+   */
+  respectSamplingDecision?: boolean
+}
+
 export type SupabaseClientOptions<SchemaName> = {
   /**
    * The Postgres schema which your tables belong to. Must be on the list of exposed schemas in Supabase. Defaults to `public`.
@@ -175,6 +211,28 @@ export type SupabaseClientOptions<SchemaName> = {
    * authentications concurrently in the same application.
    */
   accessToken?: () => Promise<string | null>
+  /**
+   * Enable OpenTelemetry / W3C trace context propagation to Supabase services.
+   *
+   * Disabled by default. Pass `true` for the common case (auto-detect an
+   * active OTel context and inject `traceparent` / `tracestate` / `baggage`
+   * headers) or an object for fine-grained control.
+   *
+   * Requires `@opentelemetry/api` to be installed in your application; if
+   * not present, the SDK silently no-ops.
+   *
+   * @example
+   * ```ts
+   * // Shorthand — opt in with defaults.
+   * createClient(url, key, { tracePropagation: true })
+   *
+   * // Advanced — always propagate, even for non-sampled traces.
+   * createClient(url, key, {
+   *   tracePropagation: { enabled: true, respectSamplingDecision: false },
+   * })
+   * ```
+   */
+  tracePropagation?: TracePropagationOptions | boolean
 }
 
 /**

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.105.5-beta.8'
+export const version = '2.106.0-canary.1'