better-supabase 0.11.0 → 0.13.0

package/dist/executor-DXfgDsKd.d.ts

@@ -0,0 +1,37 @@
+import { r as Executor } from "./executor-C29668fO.js";
+//#region src/postgres/executor.d.ts
+/**
+ * Anything that runs parameterized SQL: `ctx.postgres` from
+ * `@supabase/server/middleware/postgres`, or a client from `createPostgres()`.
+ */
+interface SqlClient {
+  queryRaw<T = Record<string, unknown>>(text: string, params?: unknown[]): Promise<T[]>;
+  /**
+   * Runs `fn` on one connection in one transaction. Optional; without it
+   * `db.$many` sends its statements separately.
+   */
+  transaction?<T>(fn: (client: SqlClient) => Promise<T>): Promise<T>;
+}
+interface PostgresExecutorOptions {
+  /**
+   * Rows an `estimated` count counts exactly before it switches to the
+   * planner's estimate, like PostgREST's `db-max-rows`. Defaults to 1000.
+   */
+  readonly estimatedCountThreshold?: number;
+}
+/**
+ * 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.
+ */
+declare function postgresExecutor(client: SqlClient, options?: PostgresExecutorOptions): Executor;
+//#endregion
+export { SqlClient as n, postgresExecutor as r, PostgresExecutorOptions as t };

package/dist/executor-D_viYkhf.d.ts

@@ -0,0 +1,179 @@
+import { E as RawDbError } from "./result-mijqfoJN.js";
+import { V as TableMeta } from "./types-DmshMaXz.js";
+import { r as Executor, v as Operation } from "./executor-C29668fO.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;
+}
+/** 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 _, fromSqliteError as a, quoteSqliteIdent as b, SqliteCompilerOptions as c, SqliteKeyedPlan as d, SqliteKeys as f, SqliteSelectPlan as g, SqliteReturning as h, SqliteContextLike as i, SqliteDecode as l, SqliteQuery as m, PowerSyncExecutorOptions as n, postgrestTimestamp as o, SqlitePlan as p, powersyncExecutor as r, SqliteColumn as s, PowerSyncDatabaseLike as t, SqliteInsertPlan as u, compileSqlite as v, sqliteValue as x, likeToGlob as y };

package/dist/executor-QtVn0axs.js

@@ -0,0 +1,147 @@
+import { a as evaluateCondition, c as isGraphRecord, i as durationMs, n as conditionOf, p as validateGraph, t as approved, u as topologicalOrder } from "./graph-B4eubUQG.js";
+//#region src/blocks/workflow-builder/executor.ts
+/** The hook token of an approval node without `requestApproval`. */
+const approvalToken = (runKey, node) => `${runKey}:${node}`;
+const active = (edge, ran) => {
+	const outcome = ran.get(edge.source);
+	if (outcome === void 0) return false;
+	return edge.branch === void 0 || String(outcome) === edge.branch;
+};
+/**
+* The runtime fields of a static executor's `meta`: spread them into the
+* runtime passed to `executeGraph`, so a run starts at its trigger node,
+* conditions read its subject, and a test run returns its stubs instead of
+* running steps.
+*/
+function graphRunFields(meta) {
+	const record = isGraphRecord(meta) ? meta : {};
+	const text = (key) => typeof record[key] === "string" ? record[key] : void 0;
+	const subject = record["subject"];
+	const stubs = record["stubs"];
+	const version = text("versionId");
+	const tenant = text("tenant");
+	const triggerNode = text("triggerNode");
+	return {
+		runKey: text("runKey") ?? "",
+		...version === void 0 ? {} : { version },
+		...tenant === void 0 ? {} : { tenant },
+		...isGraphRecord(subject) ? { subject: {
+			type: String(subject["type"]),
+			id: String(subject["id"])
+		} } : {},
+		...triggerNode === void 0 ? {} : { triggerNode },
+		...record["mode"] === "test" ? { stubs: isGraphRecord(stubs) ? stubs : {} } : {}
+	};
+}
+/** A test run's stub for `node`, or `fallback` when it has none. */
+function stubOf(stubs, node, fallback) {
+	return Object.hasOwn(stubs, node) ? stubs[node] : fallback;
+}
+/**
+* The trigger node a run starts at: `requested` when the graph has it, else the
+* graph's only trigger. Throws when neither picks one.
+*/
+function startNodeOf(graph, requested) {
+	const triggers = graph.nodes.filter((node) => node.kind === "trigger");
+	const start = requested === void 0 ? triggers.length === 1 ? triggers[0]?.id : void 0 : triggers.find((node) => node.id === requested)?.id;
+	if (start === void 0) throw new TypeError("workflow-builder: pass the trigger node the run starts at, the id of one of the graph's trigger nodes");
+	return start;
+}
+/**
+* Runs `graph` in dependency order from its start trigger
+* (`runtime.triggerNode`): a node runs when the trigger reaches it through
+* edges whose sources ran (and, from a condition or an approval, took the
+* edge's branch). Returns each node's output by id. It only calls `runtime`, so
+* it is deterministic and runs inside a `"use workflow"` function as the static
+* executor.
+*/
+async function executeGraph(graph, input, runtime) {
+	const errors = validateGraph(graph);
+	if (errors.length > 0) throw new TypeError(`workflow-builder: ${errors.join("; ")}`);
+	const start = startNodeOf(graph, runtime.triggerNode);
+	const order = topologicalOrder(graph) ?? [];
+	const incoming = /* @__PURE__ */ new Map();
+	for (const edge of graph.edges) incoming.set(edge.target, [...incoming.get(edge.target) ?? [], edge]);
+	const results = {};
+	const ran = /* @__PURE__ */ new Map();
+	for (const node of order) {
+		if (node.kind === "trigger") {
+			if (node.id !== start) continue;
+		} else if (!(incoming.get(node.id) ?? []).some((edge) => active(edge, ran))) continue;
+		const { output, outcome } = await runNode(node, input, results, runtime);
+		results[node.id] = output;
+		ran.set(node.id, outcome);
+	}
+	return results;
+}
+const extrasOf = (runtime) => ({
+	...runtime.version === void 0 ? {} : { version: runtime.version },
+	...runtime.tenant === void 0 ? {} : { tenant: runtime.tenant },
+	...runtime.subject === void 0 ? {} : { subject: runtime.subject }
+});
+async function runNode(node, input, results, runtime) {
+	switch (node.kind) {
+		case "trigger": return {
+			output: input,
+			outcome: true
+		};
+		case "step": return {
+			output: (runtime.stubs === void 0 ? await runtime.step({
+				node: node.id,
+				step: node.step ?? "",
+				config: node.config ?? {},
+				input,
+				results: { ...results },
+				runKey: runtime.runKey,
+				...extrasOf(runtime)
+			}) : stubOf(runtime.stubs, node.id, { stubbed: true })) ?? null,
+			outcome: true
+		};
+		case "sleep":
+			if (runtime.stubs === void 0) await runtime.sleep(durationMs(node.config?.["duration"]) ?? 0);
+			return {
+				output: null,
+				outcome: true
+			};
+		case "approval": {
+			if (runtime.stubs !== void 0) {
+				const payload = stubOf(runtime.stubs, node.id, { approved: true });
+				return {
+					output: payload ?? null,
+					outcome: approved(payload)
+				};
+			}
+			const token = runtime.requestApproval === void 0 ? approvalToken(runtime.runKey, node.id) : await runtime.requestApproval({
+				node: node.id,
+				config: node.config ?? {},
+				input,
+				results: { ...results },
+				runKey: runtime.runKey,
+				...extrasOf(runtime)
+			});
+			const payload = await runtime.approval(token, node.id);
+			return {
+				output: payload ?? null,
+				outcome: approved(payload)
+			};
+		}
+		case "condition": {
+			const condition = conditionOf(node);
+			const outcome = condition !== void 0 && evaluateCondition(condition, {
+				input,
+				results,
+				subject: runtime.subject
+			});
+			return {
+				output: outcome,
+				outcome
+			};
+		}
+		default: {
+			const unknown = node.kind;
+			throw new TypeError(`workflow-builder: unknown node kind ${String(unknown)}`);
+		}
+	}
+}
+//#endregion
+export { startNodeOf as i, executeGraph as n, graphRunFields as r, approvalToken as t };

package/dist/expo/index.d.ts

@@ -1,38 +1,48 @@
-import { a as AnyModels, i as AnyFunctions } from "../types-BrpW5ixT.js";
-import { t as BetterSupabase } from "../define-M_r1d2AT.js";
-import { a as ServerContext, c as ServerOptions, n as BetterServer, r as ContextOptions } from "../server-types-BKN_R4Ws.js";
-import { i as MiddlewareOptions, r as GuardOptions } from "../respond-CEBC6KUX.js";
-import { t as Validated } from "../shared-DDSjEGDR.js";
+import { a as AnyModels, i as AnyFunctions } from "../types-DmshMaXz.js";
+import { t as BetterSupabase } from "../define-D0LSXmUP.js";
+import { a as ServerContext, c as ServerOptions, n as BetterServer, r as ContextOptions } from "../server-types-D_cQ6OxZ.js";
+import { i as MiddlewareOptions, r as GuardOptions } from "../respond-QW-f1yio.js";
+import { t as Validated } from "../shared-CRRfQAKG.js";
 import { AnyEntry, Contributions } from "@supabase/middleware";
 import { ImmutableRequest, MiddlewareFunction } from "expo-server";
 //#region src/bridges/expo.d.ts
 /** Route parameters from the file name (`[id]`, `[...slug]`). */
 type ExpoParams = Record<string, string | string[]>;
 interface ToExpoOptions {
-  /** The host's env object for `getEnv`, read per request (EAS Hosting runs on Workers). */
+  /**
+   * The host's env object for `getEnv`, read per request (EAS Hosting runs on
+   * Workers).
+   */
   readonly env?: (request: Request) => unknown;
 }
 /**
- * Runs an entry array around an Expo Router API route handler
- * (`export const GET = toExpo([...], handler)`). Short-circuit responses
- * (a 401 from the guard, a CORS preflight) answer before the handler runs,
- * and the handler's response passes back through the entries.
+ * Runs an entry array around an Expo Router API route handler (`export const
+ * GET = toExpo([...], handler)`). Short-circuit responses (a 401 from the
+ * guard, a CORS preflight) answer before the handler runs, and the handler's
+ * response passes back through the entries.
  */
 export declare function toExpo<const Entries extends readonly AnyEntry[]>(entries: Entries & Validated<Entries>, handler: (request: Request, ctx: Contributions<Entries>, params: ExpoParams) => Response | Promise<Response>, options?: ToExpoOptions): (request: Request, params?: ExpoParams) => Promise<Response>;
 //#endregion
 //#region src/expo/index.d.ts
-/** A request as Expo Router passes it: `ImmutableRequest` in loaders and middleware, `Request` in API routes. */
+/**
+ * A request as Expo Router passes it: `ImmutableRequest` in loaders and
+ * middleware, `Request` in API routes.
+ */
 export type ExpoRequest = Request | ImmutableRequest;
 export interface ExpoOptions extends ServerOptions {
-  /** Include error details in problem responses. Defaults to `NODE_ENV === 'development'`. */
+  /**
+   * Include error details in problem responses. Defaults to `NODE_ENV ===
+   * 'development'`.
+   */
   readonly exposeErrors?: boolean;
 }
 export interface ExpoContextOptions extends Omit<ContextOptions, "refresh">, GuardOptions {
   /**
    * Refresh an expired cookie session and write the new cookies with
-   * `setResponseHeaders`. Defaults to true; bearer tokens never refresh.
-   * When `bs.middleware()` already ran for the request, the context reads the
-   * session it refreshed and never calls Auth again, whatever this option says.
+   * `setResponseHeaders`. Defaults to true; bearer tokens never refresh. When
+   * `bs.middleware()` already ran for the request, the context reads the
+   * session it refreshed and never calls Auth again, whatever this option
+   * says.
    */
   readonly refresh?: boolean;
 }
@@ -44,24 +54,24 @@ export interface ExpoMiddlewareOptions extends MiddlewareOptions {
   readonly redirectTo?: string;
   /**
    * Paths every caller may open, such as `/` or `/pricing`. An entry matches
-   * the path itself and everything under it (`/auth` matches
-   * `/auth/callback`). The `redirectTo` path and everything under it are
-   * always public, so its callback routes never loop back to it.
+   * the path itself and everything under it (`/auth` matches `/auth/callback`).
+   * The `redirectTo` path and everything under it are always public, so its
+   * callback routes never loop back to it.
    */
   readonly publicPaths?: readonly string[];
 }
 export interface BetterExpo<M extends AnyModels, F extends AnyFunctions, E, C = unknown, P = unknown, B = unknown> extends BetterServer<M, F, E, C, P, B> {
   /**
-   * The verified caller for a server loader, API route or middleware: a
-   * bearer token first, the session cookie second. Refreshed session
-   * cookies go out through `setResponseHeaders`. With `allow`, a refused
-   * caller throws a `StatusError` (401 or 403) that Expo Router answers.
+   * The verified caller for a server loader, API route or middleware: a bearer
+   * token first, the session cookie second. Refreshed session cookies go out
+   * through `setResponseHeaders`. With `allow`, a refused caller throws a
+   * `StatusError` (401 or 403) that Expo Router answers.
    */
   request(request: ExpoRequest, options?: ExpoContextOptions): Promise<ServerContext<M, F, E, C, P, B>>;
   /**
-   * A server loader (`export const loader = bs.loader(...)`) that runs `fn`
-   * as the caller. A `DbException` from `.orThrow()` becomes a `StatusError`
-   * with the error's status. Throws during static rendering, which has no request.
+   * A server loader (`export const loader = bs.loader(...)`) that runs `fn` as
+   * the caller. A `DbException` from `.orThrow()` becomes a `StatusError` with
+   * the error's status. Throws during static rendering, which has no request.
    */
   loader<T>(fn: (ctx: ServerContext<M, F, E, C, P, B>, params: ExpoParams, request: ImmutableRequest) => Promise<T> | T, options?: ExpoContextOptions): (request: ImmutableRequest | undefined, params: ExpoParams) => Promise<T>;
   /**
@@ -71,7 +81,8 @@ export interface BetterExpo<M extends AnyModels, F extends AnyFunctions, E, C =
   handler(fn: (request: Request, ctx: ServerContext<M, F, E, C, P, B>, params: ExpoParams) => unknown, options?: MiddlewareOptions): (request: Request, params?: ExpoParams) => Promise<Response>;
   /**
    * `+middleware.ts`: refreshes an expired cookie session once per request,
-   * before loaders run, and redirects refused callers when `redirectTo` is set.
+   * before loaders run, and redirects refused callers when `redirectTo` is
+   * set.
    */
   middleware(options?: ExpoMiddlewareOptions): MiddlewareFunction;
 }

package/dist/expo/index.js

@@ -1,19 +1,19 @@
 import { t as DbException } from "../db-exception-CnWcYPxL.js";
-import { c as toProblem } from "../problem-JRCohp1j.js";
-import { a as unexpectedResponse, c as extendServer, s as createServer, x as refreshFor } from "../adapter-B2WRsRIg.js";
-import { m as serializeCookie } from "../resolve-f8QNuYI3.js";
-import { a as respond, r as guard, t as defaultExpose } from "../respond-Bhp3G__q.js";
-import { t as withBetterSupabase } from "../composite-BFatHqOU.js";
-import { r as handoffOf } from "../shared-BmMcMoW9.js";
+import { c as toProblem } from "../problem-D0KDiYPk.js";
+import { a as unexpectedResponse, c as extendServer, s as createServer, x as refreshFor } from "../adapter-D8dW6p2A.js";
+import { m as serializeCookie } from "../resolve-sy3_Gz0i.js";
+import { a as respond, r as guard, t as defaultExpose } from "../respond-DjEmE_DN.js";
+import { t as withBetterSupabase } from "../composite-BgSdL5tk.js";
+import { r as handoffOf } from "../shared-Bf-I13Ht.js";
 import { bufferRequest, pipeline, seedContext } from "@supabase/middleware";
 import { StatusError, setResponseHeaders } from "expo-server";
 //#region src/bridges/expo.ts
 const PARAMS = Symbol("toExpo.params");
 /**
-* Runs an entry array around an Expo Router API route handler
-* (`export const GET = toExpo([...], handler)`). Short-circuit responses
-* (a 401 from the guard, a CORS preflight) answer before the handler runs,
-* and the handler's response passes back through the entries.
+* Runs an entry array around an Expo Router API route handler (`export const
+* GET = toExpo([...], handler)`). Short-circuit responses (a 401 from the
+* guard, a CORS preflight) answer before the handler runs, and the handler's
+* response passes back through the entries.
 */
 function toExpo(entries, handler, options = {}) {
 	const run = pipeline(entries, (request, ctx) => Promise.resolve(handler(request, ctx, handoffOf(ctx, PARAMS))));
@@ -29,7 +29,10 @@ function under(path, prefix) {
 	const base = prefix.endsWith("/") ? prefix.slice(0, -1) : prefix;
 	return base === "" ? path === "/" : path === base || path.startsWith(`${base}/`);
 }
-/** `ImmutableRequest` has no body and immutable headers; the resolver only reads URL, method and headers. */
+/**
+* `ImmutableRequest` has no body and immutable headers; the resolver only reads
+* URL, method and headers.
+*/
 function toRequest(request) {
 	if (request instanceof Request) return request;
 	return new Request(request.url, {
@@ -38,9 +41,9 @@ function toRequest(request) {
 	});
 }
 /**
-* expo-server wraps the incoming request in a new `ImmutableRequest` for the
-* middleware and for each loader, so a handoff can't key on the object. The
-* old cookie header pins it to one session: another request with the same key
+* Expo-server wraps the incoming request in a new `ImmutableRequest` for the
+* middleware and for each loader, so a handoff can't key on the object. The old
+* cookie header pins it to one session: another request with the same key
 * carries the same cookies and would refresh to the same session.
 */
 const HANDOFF_TTL_MS = 1e4;

package/dist/expo-sqlite/index.d.ts

@@ -1,6 +1,6 @@
-import { r as Executor } from "../executor-BnMC0lj3.js";
-import { n as PowerSyncExecutorOptions, t as PowerSyncDatabaseLike } from "../executor-CvsNcQsa.js";
-import { a as checkSqlite, n as sqliteTables, r as watch, t as WatchOptions } from "../watch-ry70AEm6.js";
+import { r as Executor } from "../executor-C29668fO.js";
+import { n as PowerSyncExecutorOptions, t as PowerSyncDatabaseLike } from "../executor-D_viYkhf.js";
+import { a as checkSqlite, n as sqliteTables, r as watch, t as WatchOptions } from "../watch-CYeMXFtj.js";
 //#region src/expo-sqlite/executor.d.ts
 /** What an expo-sqlite database or exclusive transaction can run. */
 interface ExpoSqliteContextLike {
@@ -8,8 +8,8 @@ interface ExpoSqliteContextLike {
   runAsync(source: string, params: unknown[]): Promise<unknown>;
 }
 /**
- * The part of expo-sqlite's `SQLiteDatabase` the executor uses. Typed by
- * shape, so better-supabase doesn't depend on expo-sqlite.
+ * The part of expo-sqlite's `SQLiteDatabase` the executor uses. Typed by shape,
+ * so better-supabase doesn't depend on expo-sqlite.
  */
 interface ExpoSqliteDatabaseLike extends ExpoSqliteContextLike {
   /** Filters change events to this database when several are open. */
@@ -24,8 +24,8 @@ interface DatabaseChangeEventLike {
   readonly databaseFilePath?: string;
 }
 /**
- * expo-sqlite's `addDatabaseChangeListener`. Open the database with
- * `{ enableChangeListener: true }` so it reports changes.
+ * Expo-sqlite's `addDatabaseChangeListener`. Open the database with `{
+ * enableChangeListener: true }` so it reports changes.
  */
 type AddDatabaseChangeListener = (listener: (event: DatabaseChangeEventLike) => void) => {
   remove(): void;
@@ -36,21 +36,24 @@ interface ExpoSqliteOptions extends PowerSyncExecutorOptions {
 }
 /**
  * An expo-sqlite database in the shape the SQLite executor, `watch()` and
- * `useWatch()` read. Writes run in `withExclusiveTransactionAsync` on
- * native and `withTransactionAsync` on web.
+ * `useWatch()` read. Writes run in `withExclusiveTransactionAsync` on native
+ * and `withTransactionAsync` on web.
  */
 export declare function expoSqliteDatabase(db: ExpoSqliteDatabaseLike, options?: Pick<ExpoSqliteOptions, "addDatabaseChangeListener">): PowerSyncDatabaseLike;
 /**
- * Runs repository operations on an expo-sqlite database, without PowerSync:
- * the same repositories and list definitions work on a local database the
- * app owns. Reads return rows in the PostgREST shape; what SQLite can't
- * express returns a `DbError` of kind `unsupported`. An insert that leaves
- * out a text or uuid key gets `crypto.randomUUID()`, else a UUID from
- * SQLite.
+ * Runs repository operations on an expo-sqlite database, without PowerSync: the
+ * same repositories and list definitions work on a local database the app owns.
+ * Reads return rows in the PostgREST shape; what SQLite can't express returns a
+ * `DbError` of kind `unsupported`. An insert that leaves out a text or uuid key
+ * gets `crypto.randomUUID()`, else a UUID from SQLite.
  *
  * ```ts
- * const sqlite = await openDatabaseAsync("app.db", { enableChangeListener: true });
- * const db = betterSupabase.connect(expoSqliteExecutor(sqlite, { addDatabaseChangeListener }));
+ * const sqlite = await openDatabaseAsync("app.db", {
+ *   enableChangeListener: true,
+ * });
+ * const db = betterSupabase.connect(
+ *   expoSqliteExecutor(sqlite, { addDatabaseChangeListener }),
+ * );
  * ```
  */
 export declare function expoSqliteExecutor(db: ExpoSqliteDatabaseLike, options?: ExpoSqliteOptions): Executor;

package/dist/expo-sqlite/index.js

@@ -1,8 +1,11 @@
-import { n as watch, t as sqliteTables } from "../watch-BAuIzC2r.js";
-import { i as checkSqlite, t as powersyncExecutor } from "../executor-BiB0wMBA.js";
+import { n as watch, t as sqliteTables } from "../watch-Cnd6XDnU.js";
+import { i as checkSqlite, t as powersyncExecutor } from "../executor-DK2F9Zis.js";
 //#region src/expo-sqlite/executor.ts
 const DEFAULT_THROTTLE_MS = 30;
-/** A UUID v4 from SQLite's `randomblob`, for runtimes without `crypto.randomUUID`. */
+/**
+* A UUID v4 from SQLite's `randomblob`, for runtimes without
+* `crypto.randomUUID`.
+*/
 const UUID_SQL = "select lower(hex(randomblob(4)) || '-' || hex(randomblob(2)) || '-4' || substr(hex(randomblob(2)), 2) || '-' || substr('89ab', 1 + (abs(random()) % 4), 1) || substr(hex(randomblob(2)), 2) || '-' || hex(randomblob(6))) as id";
 function contextOf(db) {
 	return {
@@ -40,8 +43,8 @@ function changesOf(db, addListener) {
 }
 /**
 * An expo-sqlite database in the shape the SQLite executor, `watch()` and
-* `useWatch()` read. Writes run in `withExclusiveTransactionAsync` on
-* native and `withTransactionAsync` on web.
+* `useWatch()` read. Writes run in `withExclusiveTransactionAsync` on native
+* and `withTransactionAsync` on web.
 */
 function expoSqliteDatabase(db, options = {}) {
 	const context = contextOf(db);
@@ -71,16 +74,19 @@ function randomId() {
 	return crypto?.randomUUID?.();
 }
 /**
-* Runs repository operations on an expo-sqlite database, without PowerSync:
-* the same repositories and list definitions work on a local database the
-* app owns. Reads return rows in the PostgREST shape; what SQLite can't
-* express returns a `DbError` of kind `unsupported`. An insert that leaves
-* out a text or uuid key gets `crypto.randomUUID()`, else a UUID from
-* SQLite.
+* Runs repository operations on an expo-sqlite database, without PowerSync: the
+* same repositories and list definitions work on a local database the app owns.
+* Reads return rows in the PostgREST shape; what SQLite can't express returns a
+* `DbError` of kind `unsupported`. An insert that leaves out a text or uuid key
+* gets `crypto.randomUUID()`, else a UUID from SQLite.
 *
 * ```ts
-* const sqlite = await openDatabaseAsync("app.db", { enableChangeListener: true });
-* const db = betterSupabase.connect(expoSqliteExecutor(sqlite, { addDatabaseChangeListener }));
+* const sqlite = await openDatabaseAsync("app.db", {
+*   enableChangeListener: true,
+* });
+* const db = betterSupabase.connect(
+*   expoSqliteExecutor(sqlite, { addDatabaseChangeListener }),
+* );
 * ```
 */
 function expoSqliteExecutor(db, options = {}) {