better-supabase 0.13.0 → 0.14.0

package/dist/plugins/validation/index.d.ts

@@ -1,5 +1,5 @@
-import { t as StandardSchemaV1 } from "../../standard-16AIDny5.js";
-import { d as Plugin } from "../../plugin-DouW0Kvg.js";
+import { t as StandardSchemaV1 } from "../../standard-DbQsD2xZ.js";
+import { d as Plugin } from "../../plugin-Ar5546xh.js";
 //#region src/plugins/validation/index.d.ts
 export interface TableValidators {
   /** Validates inserts and upserts, with app-cased keys. */

package/dist/plugins/validation/index.js

@@ -1,8 +1,8 @@
-import { t as DbException } from "../../db-exception-CnWcYPxL.js";
-import { n as dbError } from "../../errors-D7u24ZJH.js";
-import { i as encodeValue, r as decodeValue } from "../../wire-BJhepFbv.js";
+import { t as DbException } from "../../db-exception-Lngc1W49.js";
+import { n as dbError } from "../../errors-03ysrOt4.js";
+import { i as encodeValue, r as decodeValue } from "../../wire-Bizdxvp-.js";
 import { r as definePlugin } from "../../plugin-D9bYbYli.js";
-import { n as validate } from "../../standard-l10kE0yS.js";
+import { n as validate } from "../../standard-DtkpFGkS.js";
 import { n as toDb, t as toApp } from "../../casing-DdFWEtqr.js";
 //#region src/plugins/validation/index.ts
 /**

package/dist/pool-CRkU15dA.d.ts

@@ -0,0 +1,123 @@
+import { r as Executor } from "./executor-CPyrQdjh.js";
+import { o as EventHub } from "./events-DbLjvxDX.js";
+import { n as Logger } from "./logger-DWVYUmwi.js";
+import { n as SqlClient } from "./executor-CsTaO3AT.js";
+//#region src/postgres/pool.d.ts
+/** The part of a `pg` pool client `createPostgres` uses. */
+interface PgPoolClient {
+  query(text: string, values?: unknown[]): Promise<{
+    rows: unknown[];
+  }>;
+  release(): void;
+}
+/** The part of a `pg.Pool` `createPostgres` uses. */
+interface PgPool {
+  connect(): Promise<PgPoolClient>;
+  end(): Promise<void>;
+  /** `pg.Pool` reports errors of idle connections here. */
+  on?(event: "error", listener: (error: Error) => void): unknown;
+}
+/** Statement timeouts in milliseconds by the role a transaction runs as. */
+interface PostgresTimeouts {
+  /**
+   * The connection-string role (`admin` and `transaction` without claims).
+   * Unset by default.
+   */
+  readonly admin?: number;
+  /** Defaults to 8000, Supabase's setting for the role. */
+  readonly authenticated?: number;
+  /** Defaults to 3000, Supabase's setting for the role. */
+  readonly anon?: number;
+}
+interface PostgresOptions {
+  /**
+   * Defaults to `$SUPABASE_DB_URL`, `$DATABASE_URL`, `$POSTGRES_URL`, then
+   * `$POSTGRES_URL_NON_POOLING`, the first one set.
+   */
+  readonly connectionString?: string;
+  /** An existing pool to run on instead of opening one. `end()` ends it. */
+  readonly pool?: PgPool;
+  readonly max?: number;
+  /**
+   * Statement timeout in milliseconds, applied per transaction: one value for
+   * every role, or one per role. `set role` doesn't apply the role's own
+   * `statement_timeout`, so `authenticated` and `anon` get Supabase's 8 s and 3
+   * s unless you set them.
+   */
+  readonly statementTimeout?: number | PostgresTimeouts;
+  /**
+   * Ends a session that stays idle inside a transaction this long, in
+   * milliseconds, so `transaction(fn)` can't hold a connection while `fn` waits
+   * on something else. Defaults to 15000; `0` turns it off. Statements outside
+   * a transaction don't set it.
+   */
+  readonly idleInTransactionTimeout?: number;
+  /** How long `connect` waits for a connection, in milliseconds. Defaults to 10000. */
+  readonly connectionTimeout?: number;
+  /** How long an unused connection stays open, in milliseconds. Defaults to 10000. */
+  readonly idleTimeout?: number;
+  /**
+   * `betterSupabase.events`: an error on an idle pooled connection arrives as
+   * an `error` event instead of crashing the process.
+   */
+  readonly events?: EventHub;
+  /**
+   * Where idle-connection errors go without `error` handlers. Defaults to the
+   * console.
+   */
+  readonly logger?: Logger;
+}
+/** JWT claims to run as. `role` must be `authenticated` or `anon`. */
+interface SqlClaims {
+  readonly sub?: string;
+  readonly role?: string;
+  readonly [claim: string]: unknown;
+}
+/** What every transaction of a user session sets besides the claims and role. */
+interface SessionOptions {
+  /**
+   * Transaction-local settings, e.g. `{ 'better_supabase.tenant': id }`. Names
+   * need a dot (custom settings); `role` and `request.jwt.claims` are set from
+   * the claims.
+   */
+  readonly settings?: Readonly<Record<string, string>>;
+  /** Runs every transaction with `begin read only`: writes fail with 25006. */
+  readonly readOnly?: boolean;
+  /**
+   * Statement timeout in milliseconds for this session's transactions, instead
+   * of the role's `statementTimeout` from `createPostgres`.
+   */
+  readonly statementTimeout?: number;
+}
+interface BetterPostgres {
+  /** Connects as the connection-string role. On Supabase that bypasses RLS. */
+  readonly admin: SqlClient;
+  /** Runs every query as the given user, with RLS, like PostgREST does. */
+  asUser(claims: SqlClaims, options?: SessionOptions): SqlClient;
+  /** Runs every query as `anon`. */
+  readonly anon: SqlClient;
+  /**
+   * Repositories' executor as the given user
+   * (`postgresExecutor(asUser(claims))`). `createServer` calls it for
+   * `ctx.sql`, so only apps that pass `postgres` bundle the SQL compiler.
+   */
+  executorFor(claims: SqlClaims, options?: SessionOptions): Executor;
+  /**
+   * Runs `fn` in one transaction. Pass claims to run it as a user; the session
+   * options apply with or without them.
+   */
+  transaction<T>(fn: (client: SqlClient) => Promise<T>, options?: {
+    readonly claims?: SqlClaims;
+  } & SessionOptions): Promise<T>;
+  end(): Promise<void>;
+  [Symbol.asyncDispose](): Promise<void>;
+}
+/**
+ * A pooled Postgres connection for jobs, scripts and tests. Each query (or
+ * transaction) runs in its own transaction; claims and role are
+ * transaction-local, so nothing leaks back into the pool. An `admin` query with
+ * no timeout to set runs on its own, without `begin` and `commit`.
+ */
+declare function createPostgres(options?: PostgresOptions): BetterPostgres;
+//#endregion
+export { PostgresTimeouts as a, createPostgres as c, PostgresOptions as i, PgPool as n, SessionOptions as o, PgPoolClient as r, SqlClaims as s, BetterPostgres as t };

package/dist/pool-errors-B17BQRW-.js

@@ -0,0 +1,27 @@
+import { c as mapDbError } from "./errors-03ysrOt4.js";
+import { s as toDbError } from "./result-B3m7xtRY.js";
+import { t as consoleLogger } from "./logger-glM28NVN.js";
+import { n as errorEvent } from "./events-D6IZ5CE8.js";
+import { t as fromPgError } from "./pg-error-B5QLDcbG.js";
+//#region src/postgres/pool-errors.ts
+/**
+* Listens for errors on idle pooled connections, such as a server restart or an
+* ended session. `pg.Pool` emits them as an `error` event, and Node exits on an
+* `error` event nobody listens to. The listener reports the error and never
+* throws.
+*/
+function watchPoolErrors(pool, options) {
+	pool.on?.("error", (cause) => {
+		try {
+			const raw = fromPgError(cause);
+			const error = raw ? mapDbError(raw, []) : toDbError(cause);
+			if (options.events?.has("error")) {
+				options.events.emit("error", errorEvent(error));
+				return;
+			}
+			(options.logger ?? options.events?.logger ?? consoleLogger).error("an idle Postgres connection failed", { error });
+		} catch {}
+	});
+}
+//#endregion
+export { watchPoolErrors as t };

package/dist/ports-DsJicwI2.d.ts

@@ -0,0 +1,89 @@
+import { t as AsyncResult } from "./result-C6jDfedy.js";
+import { n as TopicPort } from "./watch-topic-CIT3UlAh.js";
+import { SupabaseClient } from "@supabase/supabase-js";
+//#region src/client/ports.d.ts
+/**
+ * A string store: `localStorage` on the web (`webStorage()`), AsyncStorage,
+ * MMKV or SecureStore on React Native (`nativeStorage()`).
+ */
+interface StoragePort {
+  readonly get: (key: string) => Promise<string | null>;
+  readonly set: (key: string, value: string) => Promise<void>;
+  readonly remove: (key: string) => Promise<void>;
+}
+/** A key combination. `mod` is Cmd on macOS and Ctrl elsewhere. */
+interface Shortcut {
+  readonly key: string;
+  readonly mod?: boolean;
+  readonly shift?: boolean;
+  readonly alt?: boolean;
+}
+/** Runs `run` on each press of `shortcut` until the returned function is called. */
+type KeyboardPort = (shortcut: Shortcut, run: () => void) => () => void;
+/** A file the user picked, readable on every platform. */
+interface PickedFile {
+  readonly name: string;
+  /** The MIME type, when the platform reports one. */
+  readonly type: string | undefined;
+  readonly size: number | undefined;
+  /** The local URI on React Native; `undefined` on the web. */
+  readonly uri: string | undefined;
+  /** The bytes: a `Blob` on the web, an `ArrayBuffer` on React Native. */
+  readonly read: () => Promise<Blob | ArrayBuffer>;
+}
+interface PickFilesOptions {
+  /** MIME types or extensions, such as `image/*` or `.pdf`. */
+  readonly accept?: readonly string[];
+  readonly multiple?: boolean;
+}
+/**
+ * Opens the platform's file picker; resolves with no files when the user
+ * cancels.
+ */
+type FilePickerPort = (options?: PickFilesOptions) => Promise<readonly PickedFile[]>;
+interface UploadDestination {
+  readonly bucket: string;
+  readonly path: string;
+  readonly upsert?: boolean;
+}
+/** Uploads a picked file and resolves with its stored path. */
+type UploadPort = (file: PickedFile, to: UploadDestination) => AsyncResult<{
+  readonly path: string;
+}>;
+/** The device's push token for the platform's push service. */
+interface PushTokenPort {
+  /** The push provider the token belongs to, such as `expo` or `webpush`. */
+  readonly provider: string;
+  /**
+   * The token, asking for permission first unless `request` is false. Resolves
+   * with `null` when the user denies it or the platform has none.
+   */
+  readonly token: (options?: {
+    readonly request?: boolean;
+  }) => Promise<string | null>;
+}
+/** The URL the app opened with, and the ones it opens later. */
+interface DeepLinkPort {
+  readonly initial: () => Promise<string | null>;
+  readonly subscribe: (listener: (url: string) => void) => () => void;
+}
+/**
+ * The platform services block controllers use. `createClient` from
+ * `better-supabase/client` fills the web ports, and `nativePorts()` from
+ * `better-supabase/client/native` the React Native ones.
+ */
+interface ClientPorts {
+  readonly topic?: TopicPort;
+  readonly storage?: StoragePort;
+  readonly keyboard?: KeyboardPort;
+  readonly files?: FilePickerPort;
+  readonly upload?: UploadPort;
+  readonly push?: PushTokenPort;
+  readonly links?: DeepLinkPort;
+}
+/** A storage port that keeps values in memory, for tests and server renders. */
+declare function memoryStorage(initial?: Readonly<Record<string, string>>): StoragePort;
+/** The upload port over Supabase Storage, for web and native picked files alike. */
+declare function storageUpload(supabase: Pick<SupabaseClient, "storage">): UploadPort;
+//#endregion
+export { PickFilesOptions as a, Shortcut as c, UploadPort as d, memoryStorage as f, KeyboardPort as i, StoragePort as l, DeepLinkPort as n, PickedFile as o, storageUpload as p, FilePickerPort as r, PushTokenPort as s, ClientPorts as t, UploadDestination as u };

package/dist/ports-yajgT0t0.js

@@ -0,0 +1,139 @@
+import { a as ok, r as err, t as AsyncResult } from "./result-B3m7xtRY.js";
+import { n as decodeJwtPayload } from "./base64-B9Wlsdj7.js";
+import { i as userContext } from "./impersonation-CZD9AOAk.js";
+import { n as claimedTenant, t as hasAuthModule } from "./auth-module-BEFESDC4.js";
+import { n as identityKey } from "./user-change-CSR_prhd.js";
+import { t as createQueries } from "./queries-Dw8y9bvz.js";
+import { t as fromStorageError } from "./errors-DZx8w-MH.js";
+//#region src/client/bind.ts
+const LOADING = {
+	status: "loading",
+	user: null,
+	claims: null
+};
+const SIGNED_OUT = {
+	status: "signed-out",
+	user: null,
+	claims: null
+};
+/**
+* `session.user`, or `undefined` when auth-js put its placeholder there: with
+* `tokens-only` cookies and no user in `userStorage`, reading `id` throws.
+*/
+function storedUser(session) {
+	try {
+		return typeof session.user.id === "string" ? session.user : void 0;
+	} catch {
+		return;
+	}
+}
+const text = (value) => typeof value === "string" && value !== "" ? value : void 0;
+function snapshotOf(session) {
+	if (!session) return SIGNED_OUT;
+	const claims = decodeJwtPayload(session.access_token) ?? {};
+	const stored = storedUser(session);
+	const id = text(claims["sub"]) ?? stored?.id;
+	if (id === void 0) return SIGNED_OUT;
+	const email = text(claims["email"]) ?? text(stored?.email);
+	const role = text(claims["role"]) ?? text(stored?.role);
+	return {
+		status: "signed-in",
+		user: {
+			id,
+			...email ? { email } : {},
+			...role ? { role } : {}
+		},
+		claims
+	};
+}
+function contextOf(snapshot) {
+	if (snapshot.status !== "signed-in") return {
+		actor: {
+			id: "anon",
+			kind: "anon",
+			role: "anon"
+		},
+		claims: { role: "anon" }
+	};
+	return userContext(snapshot.user, snapshot.claims);
+}
+/**
+* Repositories that follow `supabase`'s session, TanStack Query options and an
+* auth store, for a supabase-js client you created yourself.
+*/
+function bindClient(betterSupabase, supabase, options = {}) {
+	let snapshot = LOADING;
+	let db;
+	const listeners = /* @__PURE__ */ new Set();
+	const followsAuth = hasAuthModule(supabase);
+	if (!followsAuth) snapshot = snapshotOf(null);
+	const onChange = (_event, session) => {
+		const next = snapshotOf(session);
+		if (next.status === snapshot.status && identityKey(next) === identityKey(snapshot)) return;
+		snapshot = next;
+		db = void 0;
+		for (const listener of listeners) listener();
+	};
+	const subscription = followsAuth ? supabase.auth.onAuthStateChange(onChange) : void 0;
+	const client = {
+		betterSupabase,
+		supabase,
+		ports: options.ports ?? {},
+		...options.blocks === void 0 ? {} : { blocks: options.blocks },
+		tenant: options.tenant ?? (() => claimedTenant(snapshot, betterSupabase.meta)),
+		get db() {
+			db ??= betterSupabase.connect(supabase, contextOf(snapshot));
+			return db;
+		},
+		queries: createQueries(betterSupabase, () => client.db, options.staleTime === void 0 ? {} : { staleTime: options.staleTime }),
+		dispose: () => {
+			subscription?.data.subscription.unsubscribe();
+			listeners.clear();
+		},
+		auth: {
+			current: () => snapshot,
+			subscribe: (listener) => {
+				listeners.add(listener);
+				return () => {
+					listeners.delete(listener);
+				};
+			}
+		}
+	};
+	return client;
+}
+//#endregion
+//#region src/client/ports.ts
+/** A storage port that keeps values in memory, for tests and server renders. */
+function memoryStorage(initial = {}) {
+	const values = new Map(Object.entries(initial));
+	return {
+		get: (key) => Promise.resolve(values.get(key) ?? null),
+		set: (key, value) => {
+			values.set(key, value);
+			return Promise.resolve();
+		},
+		remove: (key) => {
+			values.delete(key);
+			return Promise.resolve();
+		}
+	};
+}
+/** The upload port over Supabase Storage, for web and native picked files alike. */
+function storageUpload(supabase) {
+	return (file, to) => AsyncResult.from(async () => {
+		try {
+			const body = await file.read();
+			const { data, error } = await supabase.storage.from(to.bucket).upload(to.path, body, {
+				...file.type === void 0 ? {} : { contentType: file.type },
+				...to.upsert === void 0 ? {} : { upsert: to.upsert }
+			});
+			if (error) return err(fromStorageError(error, to.bucket));
+			return ok({ path: data.path });
+		} catch (cause) {
+			return err(fromStorageError(cause, to.bucket));
+		}
+	});
+}
+//#endregion
+export { storageUpload as n, bindClient as r, memoryStorage as t };

package/dist/postgres/index.d.ts

@@ -1,8 +1,8 @@
-import { E as RawDbError } from "../result-mijqfoJN.js";
-import { v as Operation } from "../executor-C29668fO.js";
-import { n as SqlClient, r as postgresExecutor, t as PostgresExecutorOptions } from "../executor-DXfgDsKd.js";
-import { a as PostgresTimeouts, c as createPostgres, i as PostgresOptions, n as PgPool, o as SessionOptions, r as PgPoolClient, s as SqlClaims, t as BetterPostgres } from "../pool-Bu8zXGzI.js";
-import { t as Compiler } from "../compiler-DCotQWcs.js";
+import { E as RawDbError } from "../result-C6jDfedy.js";
+import { v as Operation } from "../executor-CPyrQdjh.js";
+import { n as SqlClient, r as postgresExecutor, t as PostgresExecutorOptions } from "../executor-CsTaO3AT.js";
+import { a as PostgresTimeouts, c as createPostgres, i as PostgresOptions, n as PgPool, o as SessionOptions, r as PgPoolClient, s as SqlClaims, t as BetterPostgres } from "../pool-CRkU15dA.js";
+import { t as Compiler } from "../compiler-BCyHFI6n.js";
 //#region src/postgres/pg-error.d.ts
 /** Node-postgres error fields to the shape `mapDbError` reads. */
 export declare function fromPgError(error: unknown): RawDbError | undefined;

package/dist/postgres/index.js

@@ -1,7 +1,7 @@
-import { n as quoteIdent, t as compileSql } from "../sql-CQIikLnQ.js";
+import { n as quoteIdent, t as compileSql } from "../sql-CVYjOUyG.js";
 import { t as fromPgError } from "../pg-error-B5QLDcbG.js";
-import { t as postgresExecutor } from "../executor-C5uyGttm.js";
-import { t as watchPoolErrors } from "../pool-errors-DOZ3oDeS.js";
+import { t as postgresExecutor } from "../executor-BDAGTc_O.js";
+import { t as watchPoolErrors } from "../pool-errors-B17BQRW-.js";
 import { Pool } from "pg";
 //#region src/postgres/pool.ts
 /** Supabase sets no idle-in-transaction timeout; 15 s frees a stuck connection. */

package/dist/postgrest-DHLlN2nS.d.ts

@@ -0,0 +1,53 @@
+import { v as Operation } from "./executor-CPyrQdjh.js";
+//#region src/compile/postgrest.d.ts
+/**
+ * A compiled PostgREST request, expressed as calls on the public postgrest-js
+ * builder so it works with any supabase-js client.
+ */
+interface PostgrestPlan {
+  /** `select` parameter, or `undefined` for mutations without returning. */
+  readonly select: string | undefined;
+  readonly filters: readonly PlanFilter[];
+  readonly orders: readonly PlanOrder[];
+  readonly limits: readonly PlanLimit[];
+  readonly range: {
+    readonly from: number;
+    readonly to: number;
+  } | undefined;
+  /** The condition can never match; skip the request. */
+  readonly never: boolean;
+  /** `Prefer: max-affected` on an update or delete (PostgREST 13 and later). */
+  readonly maxAffected?: number;
+}
+interface PostgrestCompileOptions {
+  /**
+   * The PostgREST version the request goes to, from `postgrestVersion` in the
+   * config. `maxAffected` needs 13 or later; older versions fail with
+   * `invalid_request` before any request. Defaults to `"13"`.
+   */
+  readonly postgrestVersion?: string;
+}
+type PlanFilter = {
+  readonly kind: "filter";
+  readonly path: string;
+  readonly operator: string;
+  readonly value: string;
+} | {
+  readonly kind: "or";
+  readonly expression: string;
+  readonly referencedTable: string | undefined;
+};
+interface PlanOrder {
+  readonly column: string;
+  readonly ascending: boolean;
+  readonly nullsFirst: boolean | undefined;
+  readonly referencedTable: string | undefined;
+}
+interface PlanLimit {
+  readonly count: number;
+  readonly referencedTable: string | undefined;
+}
+/** Compiles an operation into a PostgREST plan. */
+declare function compilePostgrest(op: Operation, options?: PostgrestCompileOptions): PostgrestPlan;
+//#endregion
+export { PostgrestPlan as a, PostgrestCompileOptions as i, PlanLimit as n, compilePostgrest as o, PlanOrder as r, PlanFilter as t };

package/dist/powersync/index.d.ts

@@ -1,7 +1,7 @@
-import { t as AuthSnapshot } from "../bind-DcXLU1ul.js";
-import { _ as SqliteValue, a as fromSqliteError, b as quoteSqliteIdent, c as SqliteCompilerOptions, d as SqliteKeyedPlan, f as SqliteKeys, g as SqliteSelectPlan, h as SqliteReturning, i as SqliteContextLike, l as SqliteDecode, m as SqliteQuery, n as PowerSyncExecutorOptions, o as postgrestTimestamp, p as SqlitePlan, r as powersyncExecutor, s as SqliteColumn, t as PowerSyncDatabaseLike, u as SqliteInsertPlan, v as compileSqlite, x as sqliteValue, y as likeToGlob } from "../executor-D_viYkhf.js";
-import { a as checkSqlite, i as CheckSqliteOptions, n as sqliteTables, o as sqliteCompiler, r as watch, t as WatchOptions } from "../watch-CYeMXFtj.js";
-import { a as UploadConnector, c as UploadRepository, d as uploadOutcome, i as RejectedStore, l as UploadRoute, n as CrudQueueLike, o as UploadConnectorOptions, r as RejectedChange, s as UploadOutcome, t as CrudEntryLike, u as createUploadConnector } from "../connector-CKcTPJRV.js";
+import { t as AuthSnapshot } from "../bind-Dz8y3T5T.js";
+import { S as sqliteValue, _ as SqliteSelectPlan, a as fromSqliteError, b as likeToGlob, c as SqliteCompilerOptions, d as SqliteKeyedPlan, f as SqliteKeys, g as SqliteReturning, h as SqliteQuery, i as SqliteContextLike, l as SqliteDecode, m as SqlitePlan, n as PowerSyncExecutorOptions, o as postgrestTimestamp, p as SqliteNested, r as powersyncExecutor, s as SqliteColumn, t as PowerSyncDatabaseLike, u as SqliteInsertPlan, v as SqliteValue, x as quoteSqliteIdent, y as compileSqlite } from "../executor-BElVQpaB.js";
+import { a as checkSqlite, i as CheckSqliteOptions, n as sqliteTables, o as sqliteCompiler, r as watch, t as WatchOptions } from "../watch-DziJudwj.js";
+import { a as RejectedStore, c as UploadErrorContext, d as UploadRepository, f as UploadRoute, g as uploadRoute, h as uploadOutcome, i as RejectedChange, l as UploadFunction, m as createUploadConnector, n as CrudEntryLike, o as UploadConnector, p as UploadRouteOptions, r as CrudQueueLike, s as UploadConnectorOptions, t as CreateUploadRepository, u as UploadOutcome } from "../connector-BdCE4Efp.js";
 //#region src/powersync/auth.d.ts
 /** The part of a PowerSync database `syncWithAuth` drives. */
 interface SyncedDatabaseLike<C> {
@@ -39,4 +39,4 @@ interface SyncWithAuthOptions<C> {
  */
 export declare function syncWithAuth<C>(db: SyncedDatabaseLike<C>, auth: AuthSourceLike, options: SyncWithAuthOptions<C>): () => void;
 //#endregion
-export { type AuthSourceLike, type CheckSqliteOptions, type CrudEntryLike, type CrudQueueLike, type PowerSyncDatabaseLike, type PowerSyncExecutorOptions, type RejectedChange, type RejectedStore, type SqliteColumn, type SqliteCompilerOptions, type SqliteContextLike, type SqliteDecode, type SqliteInsertPlan, type SqliteKeyedPlan, type SqliteKeys, type SqlitePlan, type SqliteQuery, type SqliteReturning, type SqliteSelectPlan, type SqliteValue, type SyncWithAuthOptions, type SyncedDatabaseLike, type UploadConnector, type UploadConnectorOptions, type UploadOutcome, type UploadRepository, type UploadRoute, type WatchOptions, checkSqlite, compileSqlite, createUploadConnector, fromSqliteError, likeToGlob, postgrestTimestamp, powersyncExecutor, quoteSqliteIdent, sqliteCompiler, sqliteTables, sqliteValue, uploadOutcome, watch };
+export { type AuthSourceLike, type CheckSqliteOptions, type CreateUploadRepository, type CrudEntryLike, type CrudQueueLike, type PowerSyncDatabaseLike, type PowerSyncExecutorOptions, type RejectedChange, type RejectedStore, type SqliteColumn, type SqliteCompilerOptions, type SqliteContextLike, type SqliteDecode, type SqliteInsertPlan, type SqliteKeyedPlan, type SqliteKeys, type SqliteNested, type SqlitePlan, type SqliteQuery, type SqliteReturning, type SqliteSelectPlan, type SqliteValue, type SyncWithAuthOptions, type SyncedDatabaseLike, type UploadConnector, type UploadConnectorOptions, type UploadErrorContext, type UploadFunction, type UploadOutcome, type UploadRepository, type UploadRoute, type UploadRouteOptions, type WatchOptions, checkSqlite, compileSqlite, createUploadConnector, fromSqliteError, likeToGlob, postgrestTimestamp, powersyncExecutor, quoteSqliteIdent, sqliteCompiler, sqliteTables, sqliteValue, uploadOutcome, uploadRoute, watch };

package/dist/powersync/index.js

@@ -1,7 +1,7 @@
-import { n as dbError } from "../errors-D7u24ZJH.js";
-import { r as err } from "../result-DIT_qp4G.js";
-import { n as watch, t as sqliteTables } from "../watch-Cnd6XDnU.js";
-import { a as sqliteCompiler, c as quoteSqliteIdent, i as checkSqlite, l as sqliteValue, n as fromSqliteError, o as compileSqlite, r as postgrestTimestamp, s as likeToGlob, t as powersyncExecutor } from "../executor-DK2F9Zis.js";
+import { n as dbError } from "../errors-03ysrOt4.js";
+import { a as ok, r as err } from "../result-B3m7xtRY.js";
+import { n as watch, t as sqliteTables } from "../watch-CfMT6vX7.js";
+import { a as sqliteCompiler, c as quoteSqliteIdent, i as checkSqlite, l as sqliteValue, n as fromSqliteError, o as compileSqlite, r as postgrestTimestamp, s as likeToGlob, t as powersyncExecutor } from "../executor-o9HkOJ0m.js";
 //#region src/powersync/auth.ts
 /**
 * Syncs while a user is signed in: connects on sign-in, and on sign-out (or a
@@ -103,18 +103,38 @@ function rejectedStore() {
 		}
 	};
 }
-function replay(route, entry) {
-	if (typeof route === "function") return route(entry);
-	const data = entry.opData ?? {};
-	switch (entry.op) {
-		case "PUT": return route.upsert({
-			...data,
+function sessionError(cause) {
+	const failure = typeof cause === "object" && cause !== null ? cause : {};
+	const name = "name" in failure ? failure.name : void 0;
+	const message = "message" in failure && typeof failure.message === "string" ? failure.message : String(cause);
+	return cause instanceof TypeError || name === "AuthRetryableFetchError" ? dbError("network", message) : dbError("unauthorized", message);
+}
+function unsupportedOp(entry, route) {
+	return err(dbError("unsupported", `better-supabase: a ${route} upload route can't replay PowerSync op ${entry.op}`));
+}
+function uploadRoute(repository, options = {}) {
+	const put = options.put ?? "upsert";
+	return async (entry) => {
+		const row = {
+			...entry.opData,
 			id: entry.id
-		});
-		case "PATCH": return route.update(entry.id, data);
-		case "DELETE": return route.delete(entry.id);
-		default: return Promise.resolve(err(dbError("unsupported", `better-supabase: unknown PowerSync op ${entry.op}`)));
-	}
+		};
+		const id = entry.id;
+		switch (entry.op) {
+			case "PUT":
+				if (put === "create" && "create" in repository) {
+					const result = await repository.create(row);
+					return !result.ok && result.error.kind === "conflict" ? ok(void 0) : result;
+				}
+				return "upsert" in repository ? repository.upsert(row) : unsupportedOp(entry, put);
+			case "PATCH": return put === "upsert" && "update" in repository ? repository.update(id, entry.opData ?? {}) : unsupportedOp(entry, put);
+			case "DELETE": return repository.delete(id);
+			default: return err(dbError("unsupported", `better-supabase: unknown PowerSync op ${entry.op}`));
+		}
+	};
+}
+function replay(route, entry) {
+	return typeof route === "function" ? route(entry) : uploadRoute(route)(entry);
 }
 /**
 * A PowerSync connector that authenticates with the Supabase session and
@@ -137,15 +157,24 @@ function replay(route, entry) {
 function createUploadConnector(options) {
 	const rejected = rejectedStore();
 	const batchSize = options.batchSize ?? 100;
-	const signedIn = async () => {
-		const { data } = await options.supabase.auth.getSession();
-		return data.session !== null;
+	const currentSession = async () => {
+		try {
+			const { data, error } = await options.supabase.auth.getSession();
+			if (error) {
+				options.onError?.(sessionError(error), { phase: "credentials" });
+				return;
+			}
+			return data.session;
+		} catch (cause) {
+			options.onError?.(sessionError(cause), { phase: "credentials" });
+			return;
+		}
 	};
+	const signedIn = async () => await currentSession() !== null;
 	return {
 		rejected,
 		async fetchCredentials() {
-			const { data } = await options.supabase.auth.getSession();
-			const session = data.session;
+			const session = await currentSession();
 			if (!session) return null;
 			return {
 				endpoint: options.endpoint,
@@ -166,6 +195,7 @@ function createUploadConnector(options) {
 				switch (outcome) {
 					case "retry":
 						if (error.kind === "unauthorized" && !await signedIn()) return;
+						options.onError?.(error, { phase: "upload" });
 						throw new Error(error.message);
 					case "conflict": {
 						const change = {
@@ -195,4 +225,4 @@ function createUploadConnector(options) {
 	};
 }
 //#endregion
-export { checkSqlite, compileSqlite, createUploadConnector, fromSqliteError, likeToGlob, postgrestTimestamp, powersyncExecutor, quoteSqliteIdent, sqliteCompiler, sqliteTables, sqliteValue, syncWithAuth, uploadOutcome, watch };
+export { checkSqlite, compileSqlite, createUploadConnector, fromSqliteError, likeToGlob, postgrestTimestamp, powersyncExecutor, quoteSqliteIdent, sqliteCompiler, sqliteTables, sqliteValue, syncWithAuth, uploadOutcome, uploadRoute, watch };

package/dist/powersync/react/index.d.ts

@@ -1,6 +1,6 @@
-import { b as DbError, f as Result } from "../../result-mijqfoJN.js";
-import { t as PowerSyncDatabaseLike } from "../../executor-D_viYkhf.js";
-import { i as RejectedStore, r as RejectedChange } from "../../connector-CKcTPJRV.js";
+import { b as DbError, f as Result } from "../../result-C6jDfedy.js";
+import { t as PowerSyncDatabaseLike } from "../../executor-BElVQpaB.js";
+import { a as RejectedStore, i as RejectedChange } from "../../connector-BdCE4Efp.js";
 //#region src/powersync/react/index.d.ts
 export interface UseWatchOptions<T> {
   readonly db: PowerSyncDatabaseLike;

package/dist/powersync/react/index.js

@@ -1,5 +1,5 @@
 "use client";
-import { n as watch } from "../../watch-Cnd6XDnU.js";
+import { n as watch } from "../../watch-CfMT6vX7.js";
 import { useEffect, useMemo, useRef, useState, useSyncExternalStore } from "react";
 //#region src/powersync/react/index.ts
 /**