better-supabase 0.13.0 → 0.14.0

package/dist/executor-BDAGTc_O.js

@@ -0,0 +1,207 @@
+import { r as isPlainObject } from "./clone-CkG0-hlI.js";
+import { c as mapDbError, d as withMaxAffected, n as dbError } from "./errors-03ysrOt4.js";
+import { a as ok, r as err, s as toDbError } from "./result-B3m7xtRY.js";
+import { n as quoteIdent, t as compileSql } from "./sql-CVYjOUyG.js";
+import { t as fromPgError } from "./pg-error-B5QLDcbG.js";
+//#region src/postgres/executor.ts
+/**
+* A `count(*)::bigint`, which node-postgres returns as text. A count past
+* `Number.MAX_SAFE_INTEGER` fails instead of losing precision.
+*/
+function countOf(value) {
+	const count = value === null || value === void 0 ? 0 : typeof value === "number" ? value : typeof value === "bigint" || typeof value === "string" ? Number(value) : NaN;
+	if (!Number.isSafeInteger(count) || count < 0) throw new TypeError(`Unreadable row count: ${String(value)}`);
+	return count;
+}
+/** `Plan Rows` of the top node of an `explain (format json)` result. */
+async function plannedRows(client, query) {
+	const [first] = await client.queryRaw(query.text, [...query.params]);
+	const raw = first?.["QUERY PLAN"];
+	const plan = typeof raw === "string" ? JSON.parse(raw) : raw;
+	const top = Array.isArray(plan) ? plan[0] : void 0;
+	const rows = isPlainObject(top) && isPlainObject(top["Plan"]) ? top["Plan"]["Plan Rows"] : void 0;
+	if (typeof rows !== "number" || !Number.isFinite(rows) || rows < 0) throw new TypeError("The query plan has no row estimate");
+	return Math.min(Math.round(rows), Number.MAX_SAFE_INTEGER);
+}
+async function run(client, plan, op) {
+	const rows = plan.rows ? (await client.queryRaw(plan.rows.text, [...plan.rows.params])).map((entry) => entry.row) : [];
+	let count = null;
+	if (plan.count) {
+		const [first] = await client.queryRaw(plan.count.text, [...plan.count.params]);
+		count = first ? countOf(first.count) : 0;
+		if (plan.plannedCount && plan.countThreshold !== void 0 && count > plan.countThreshold) count = Math.max(count, await plannedRows(client, plan.plannedCount));
+	} else if (plan.plannedCount) count = await plannedRows(client, plan.plannedCount);
+	else if (op.kind !== "select") count = rows.length;
+	for (const next of plan.chunks ?? []) {
+		const more = await run(client, next, op);
+		rows.push(...more.rows);
+		count = (count ?? 0) + (more.count ?? 0);
+	}
+	return {
+		rows,
+		count
+	};
+}
+/**
+* Executes repository operations as SQL on a direct Postgres connection. Rows
+* have the same shape as over PostgREST. RLS applies when the client runs as
+* the caller (`ctx.postgres`, `createPostgres().asUser()`).
+*
+* `maxAffected` fails the statement itself, so its writes roll back. A call's
+* `timeout` is checked before the statement starts; set `statement_timeout` on
+* the connection to bound a running statement. `retry` does nothing here.
+*
+* `count: "planned"` reads the planner's row estimate from `explain (format
+* json)`; `count: "estimated"` counts exactly up to `estimatedCountThreshold`
+* rows and uses the estimate past it, like PostgREST.
+*/
+function postgresExecutor(client, options = {}) {
+	const signatures = /* @__PURE__ */ new Map();
+	const compile = options.estimatedCountThreshold === void 0 ? {} : { estimatedCountThreshold: options.estimatedCountThreshold };
+	const executeOn = (scoped, op, context) => executeWith(scoped, op, context, compile);
+	return {
+		name: "postgres",
+		functionSources: true,
+		execute: (op, context) => executeOn(client, op, context),
+		rpc: (name, args, context) => callFunction(client, name, args, context, signatures),
+		async batch(ops, context) {
+			if (!client.transaction) return Promise.all(ops.map((op) => executeOn(client, op, context)));
+			try {
+				return await client.transaction(async (scoped) => {
+					const results = [];
+					for (const op of ops) {
+						const result = await executeOn(scoped, op, context);
+						if (!result.ok) throw new BatchFailed();
+						results.push(result);
+					}
+					return results;
+				});
+			} catch (cause) {
+				if (!(cause instanceof BatchFailed)) {
+					const raw = fromPgError(cause);
+					if (!raw) throw cause;
+					const error = mapDbError(raw, context.errorMappers);
+					return ops.map(() => err(error));
+				}
+				return Promise.all(ops.map((op) => executeOn(client, op, context)));
+			}
+		}
+	};
+}
+var BatchFailed = class extends Error {};
+async function executeWith(client, op, context, options) {
+	let plan;
+	try {
+		plan = compileSql(op, options);
+	} catch (cause) {
+		return err(toDbError(cause));
+	}
+	if (plan.never) return ok({
+		rows: [],
+		count: 0
+	});
+	if (context.signal?.aborted) return err(dbError("aborted", "The request was aborted"));
+	const together = plan.chunks !== void 0 || plan.rows !== void 0 && plan.count !== void 0;
+	let result;
+	try {
+		result = together && client.transaction ? await client.transaction((scoped) => run(scoped, plan, op)) : await run(client, plan, op);
+	} catch (cause) {
+		const raw = fromPgError(cause);
+		const error = raw ? mapDbError(raw, context.errorMappers) : toDbError(cause);
+		return err(withMaxAffected(error, op.kind === "update" || op.kind === "delete" ? op.maxAffected : void 0));
+	}
+	if (op.kind === "select" && op.single) {
+		if (result.rows.length > 1) return err(dbError("multiple_rows", `Expected one ${op.table.key} row`));
+		if (result.rows.length === 0 && op.single === "one") return err(dbError("not_found", `No ${op.table.key} row matched`));
+	}
+	return ok(result);
+}
+const JSON_TYPES = /* @__PURE__ */ new Set(["json", "jsonb"]);
+const NO_NAMES = /* @__PURE__ */ new Set();
+/**
+* Undefined_function, invalid_function_definition and datatype_mismatch: the
+* function changed.
+*/
+const CHANGED_FUNCTION = /* @__PURE__ */ new Set([
+	"42883",
+	"42P13",
+	"42804"
+]);
+async function signatureOf(client, name, context, cache) {
+	const fn = context.function;
+	if (fn) return {
+		returnsSet: fn.returnsSet,
+		returnsVoid: fn.returns === "void",
+		json: new Set(fn.args.filter((arg) => JSON_TYPES.has(arg.type)).map((arg) => arg.name)),
+		outputOnly: NO_NAMES
+	};
+	const key = `${context.schema}.${name}`;
+	const cached = cache.get(key);
+	if (cached) return cached;
+	const found = await lookUp(client, name, context.schema);
+	if (found) cache.set(key, found);
+	return found;
+}
+async function lookUp(client, name, schema) {
+	const [found] = await client.queryRaw("select p.proretset as returns_set, p.prorettype = 'pg_catalog.void'::pg_catalog.regtype as returns_void, p.proargnames as arg_names, p.proargmodes::text[] as arg_modes, (select array_agg(t.typname::text order by a.ordinality) from unnest(p.proargtypes::oid[]) with ordinality as a(oid, ordinality) join pg_catalog.pg_type t on t.oid = a.oid) as arg_types from pg_catalog.pg_proc p join pg_catalog.pg_namespace n on n.oid = p.pronamespace where n.nspname = $1 and p.proname = $2 limit 1", [schema, name]);
+	if (!found) return;
+	const json = /* @__PURE__ */ new Set();
+	const outputOnly = /* @__PURE__ */ new Set();
+	if (found.arg_names && found.arg_types) {
+		const modes = found.arg_modes;
+		for (const [index, mode] of (modes ?? []).entries()) {
+			const argName = found.arg_names[index];
+			if ((mode === "o" || mode === "t") && argName) outputOnly.add(argName);
+		}
+		const inputIndexes = modes ? modes.flatMap((mode, index) => mode === "i" || mode === "v" || mode === "b" ? [index] : []) : found.arg_names.map((_, index) => index);
+		for (const [position, index] of inputIndexes.entries()) {
+			const argName = found.arg_names[index];
+			const type = found.arg_types[position];
+			if (typeof argName === "string" && type !== void 0 && JSON_TYPES.has(type)) json.add(argName);
+		}
+	}
+	return {
+		returnsSet: found.returns_set,
+		returnsVoid: found.returns_void,
+		json,
+		outputOnly
+	};
+}
+function argValue(value, json) {
+	if (value === null) return null;
+	if (json) return JSON.stringify(value);
+	if (typeof value === "bigint") return value.toString();
+	if (Array.isArray(value)) return value.map((item) => argValue(item, false));
+	if (isPlainObject(value)) return JSON.stringify(value);
+	if (typeof value === "object" && !(value instanceof Date) && !(value instanceof Uint8Array)) return String(value);
+	return value;
+}
+async function callFunction(client, name, args, context, cache) {
+	if (context.signal?.aborted) return err(dbError("aborted", "The request was aborted"));
+	try {
+		const signature = await signatureOf(client, name, context, cache);
+		if (!signature) return err(mapDbError({
+			code: "PGRST202",
+			message: `Could not find the function ${context.schema}.${name} in the database`
+		}, context.errorMappers));
+		const params = [];
+		const named = Object.entries(args).filter(([key, value]) => value !== void 0 && !signature.outputOnly.has(key)).map(([key, value]) => {
+			params.push(argValue(value, signature.json.has(key)));
+			return `${quoteIdent(key)} => $${String(params.length)}`;
+		});
+		const call = `${quoteIdent(context.schema)}.${quoteIdent(name)}(${named.join(", ")})`;
+		if (signature.returnsVoid) {
+			await client.queryRaw(`select ${call}`, params);
+			return ok(null);
+		}
+		const source = context.select ? `(select ${context.select.map(({ column, cast }) => cast ? `bs_call.${quoteIdent(column)}::${cast} as ${quoteIdent(column)}` : `bs_call.${quoteIdent(column)}`).join(", ")} from ${call} as bs_call)` : call;
+		const values = (await client.queryRaw(`select to_json(bs_call) as value from ${source} as bs_call`, params)).map((row) => row.value);
+		return ok(signature.returnsSet ? values : values[0] ?? null);
+	} catch (cause) {
+		const raw = fromPgError(cause);
+		if (raw?.code && CHANGED_FUNCTION.has(raw.code)) cache.delete(`${context.schema}.${name}`);
+		return err(raw ? mapDbError(raw, context.errorMappers) : toDbError(cause));
+	}
+}
+//#endregion
+export { postgresExecutor as t };

package/dist/executor-BElVQpaB.d.ts

@@ -0,0 +1,188 @@
+import { E as RawDbError } from "./result-C6jDfedy.js";
+import { ht as TableMeta, r as Executor, v as Operation } from "./executor-CPyrQdjh.js";
+//#region src/compile/sqlite.d.ts
+/** A value SQLite binds: booleans become `0`/`1`, objects JSON text. */
+type SqliteValue = string | number | bigint | null;
+interface SqliteQuery {
+  readonly text: string;
+  readonly params: readonly SqliteValue[];
+}
+/** How the executor turns a returned SQLite value back into its PostgREST shape. */
+type SqliteDecode = "boolean" | "json" | "timestamptz" | "raw";
+interface SqliteColumn {
+  /** Key in the returned row. */
+  readonly alias: string;
+  readonly decode: SqliteDecode;
+  /**
+   * An include, read as JSON (`decode: "json"`): the rows or the one row it
+   * holds decode by these columns.
+   */
+  readonly nested?: SqliteNested;
+}
+interface SqliteNested {
+  /** A JSON array of rows, or one row (or `null`). */
+  readonly many: boolean;
+  readonly columns: readonly SqliteColumn[];
+}
+/** Primary key values of the rows a write touches, in key column order. */
+type SqliteKeys = readonly (readonly SqliteValue[])[];
+/** A read: the rows, a count, or both. */
+interface SqliteSelectPlan {
+  readonly kind: "select";
+  readonly rows: SqliteQuery | undefined;
+  readonly count: SqliteQuery | undefined;
+  readonly columns: readonly SqliteColumn[];
+}
+/**
+ * An insert as one statement per row. PowerSync tables are views with `INSTEAD
+ * OF` triggers, which take neither `RETURNING` nor `ON CONFLICT`, so the
+ * executor checks for a conflicting row itself and reads the written rows back
+ * by key.
+ */
+interface SqliteInsertPlan {
+  readonly kind: "insert";
+  readonly rows: readonly {
+    readonly key: readonly SqliteValue[];
+    /** The row's tenant; an upsert never updates another tenant's row. */
+    readonly tenant: SqliteValue | undefined;
+    readonly insert: SqliteQuery;
+    /** Finds a row that conflicts on the `onConflict` columns. */
+    readonly existing: SqliteQuery | undefined;
+    /** Updates the conflicting row (`onConflict.action: 'update'`), by its key. */
+    readonly update: ((key: readonly SqliteValue[]) => SqliteQuery) | undefined;
+  }[];
+  readonly conflict: "update" | "ignore" | undefined;
+  readonly returning: SqliteReturning | undefined;
+}
+/** An update or delete: select the keys, then write by key. */
+interface SqliteKeyedPlan {
+  readonly kind: "update" | "delete";
+  readonly keys: SqliteQuery;
+  readonly apply: (keys: SqliteKeys) => SqliteQuery;
+  readonly returning: SqliteReturning | undefined;
+  /** More selected keys than this fails with `max_affected` before any write. */
+  readonly maxAffected?: number;
+}
+interface SqliteReturning {
+  readonly read: (keys: SqliteKeys) => SqliteQuery;
+  readonly columns: readonly SqliteColumn[];
+}
+type SqlitePlan = {
+  readonly kind: "never";
+} | SqliteSelectPlan | SqliteInsertPlan | SqliteKeyedPlan;
+interface SqliteCompilerOptions {
+  /**
+   * The SQLite table or view for a table. Defaults to its database name without
+   * the schema, which is how PowerSync names its views.
+   */
+  readonly tableName?: (table: TableMeta) => string;
+}
+declare function quoteSqliteIdent(name: string): string;
+/** A JavaScript value as a SQLite parameter. */
+declare function sqliteValue(value: unknown): SqliteValue;
+/**
+ * A LIKE pattern (backslash escapes) as a GLOB pattern, which SQLite matches
+ * case-sensitively, like Postgres `like`.
+ */
+declare function likeToGlob(pattern: string): string;
+/**
+ * Compiles IR operations for SQLite (PowerSync's local database). Reads become
+ * one statement; writes become steps the executor runs in a write transaction.
+ * Throws a `DbException` with kind `unsupported` for what SQLite can't express,
+ * before anything runs.
+ */
+declare function compileSqlite(op: Operation, options?: SqliteCompilerOptions): SqlitePlan;
+//#endregion
+//#region src/sqlite/executor.d.ts
+/** What a SQLite database, transaction or lock context can run. */
+interface SqliteContextLike {
+  getAll<T>(sql: string, parameters?: unknown[]): Promise<T[]>;
+  execute(sql: string, parameters?: unknown[]): Promise<unknown>;
+}
+/**
+ * What a SQLite database the executor can run on provides: reads, writes and
+ * write transactions.
+ */
+interface SqliteDatabaseLike extends SqliteContextLike {
+  writeTransaction<T>(callback: (tx: SqliteContextLike) => Promise<T>): Promise<T>;
+  /** Runs a list's rows and its count on one snapshot when present. */
+  readTransaction?<T>(callback: (tx: SqliteContextLike) => Promise<T>): Promise<T>;
+}
+interface SqliteExecutorOptions extends SqliteCompilerOptions {
+  /**
+   * A primary key for an insert that leaves it out. Offline-first tables key on
+   * a text `id` that the client creates. Defaults to `crypto.randomUUID()`,
+   * else SQLite's `uuid()`.
+   */
+  readonly newId?: (table: TableMeta) => string | Promise<string>;
+  /**
+   * Runs what SQLite can't, usually `postgrestExecutor(supabase)`: reads that
+   * compile to `unsupported` (includes, full-text search, function sources) and
+   * `db.$rpc`. Writes never fall back, so the upload queue stays the only write
+   * path. Offline, the fallback's error comes back.
+   */
+  readonly fallback?: Executor;
+}
+/**
+ * A SQLite constraint error in the shape `mapDbError` reads from Postgres: its
+ * SQLSTATE, and the columns in Postgres's `Key (...)` detail format.
+ */
+declare function fromSqliteError(cause: unknown): RawDbError | undefined;
+/**
+ * Timestamp text as PostgREST sends it (`2026-01-02T10:00:00.5+00:00`), from
+ * whatever the sync wrote (`2026-01-02 10:00:00.500000Z`).
+ */
+declare function postgrestTimestamp(value: string): string;
+//#endregion
+//#region src/powersync/executor.d.ts
+/**
+ * The part of `PowerSyncDatabase` (`@powersync/react-native`, `@powersync/web`,
+ * `@powersync/node`) the executor uses. Typed by shape, so better-supabase
+ * doesn't depend on PowerSync.
+ */
+interface PowerSyncDatabaseLike extends SqliteDatabaseLike {
+  onChange?(handler: {
+    onChange: (event: {
+      changedTables: string[];
+    }) => Promise<void> | void;
+  }, options?: {
+    tables?: string[];
+    throttleMs?: number;
+    signal?: AbortSignal;
+  }): () => void;
+  /** The sync status `watch`'s `refresh` reads to skip runs while offline. */
+  readonly currentStatus?: {
+    readonly connected: boolean;
+  };
+  /** Status updates; `watch`'s `refresh.onReconnect` listens to them. */
+  registerListener?(listener: {
+    statusChanged?: (status: {
+      readonly connected: boolean;
+    }) => void;
+  }): () => void;
+}
+type PowerSyncExecutorOptions = SqliteExecutorOptions;
+/**
+ * Runs repository operations on PowerSync's local SQLite database, so the same
+ * repositories and list definitions work offline on native. Reads return rows
+ * in the PostgREST shape (booleans, parsed JSON, ISO timestamps); writes go
+ * through PowerSync's upload queue. What SQLite can't express (includes,
+ * full-text search, function sources) and `db.$rpc` return a `DbError` of kind
+ * `unsupported` without running anything, or run on `options.fallback` when you
+ * pass one. `maxAffected` is checked against the selected keys before any
+ * write; a call's `timeout` and `signal` are checked before the statements
+ * start, and `retry` does nothing here. A `bigint` beyond
+ * `Number.MAX_SAFE_INTEGER` comes back as its decimal string instead of a
+ * rounded number.
+ *
+ * ```ts
+ * const db = betterSupabase.connect(
+ *   powersyncExecutor(powersync, {
+ *     fallback: postgrestExecutor(supabase),
+ *   }),
+ * );
+ * ```
+ */
+declare function powersyncExecutor(db: PowerSyncDatabaseLike, options?: PowerSyncExecutorOptions): Executor;
+//#endregion
+export { sqliteValue as S, SqliteSelectPlan as _, fromSqliteError as a, likeToGlob as b, SqliteCompilerOptions as c, SqliteKeyedPlan as d, SqliteKeys as f, SqliteReturning as g, SqliteQuery as h, SqliteContextLike as i, SqliteDecode as l, SqlitePlan as m, PowerSyncExecutorOptions as n, postgrestTimestamp as o, SqliteNested as p, powersyncExecutor as r, SqliteColumn as s, PowerSyncDatabaseLike as t, SqliteInsertPlan as u, SqliteValue as v, quoteSqliteIdent as x, compileSqlite as y };