better-supabase 0.5.0 → 0.6.0

package/dist/executor-DvsBbNBS.d.ts

@@ -0,0 +1,261 @@
+import { f as Result, w as ErrorMapper } from "./result-D7y2fT87.js";
+import { O as RelationMeta, R as TableMeta, d as Codec, g as FunctionMeta } from "./types-6BdhkmZe.js";
+//#region src/ir/types.d.ts
+/**
+ * The query IR. Every repository call becomes one of these operations; the
+ * executor compiles it to PostgREST or SQL. Column names in the IR are
+ * database names; `Selection` carries the app aliases.
+ */
+type ColumnOp = "eq" | "neq" | "gt" | "gte" | "lt" | "lte" | "in" | "is" | "like" | "ilike" | "match" | "imatch" | "contains" | "containedBy" | "overlaps" | "fts";
+type Quantifier = "some" | "none" | "every";
+type Condition = {
+  readonly kind: "and";
+  readonly items: readonly Condition[];
+} | {
+  readonly kind: "or";
+  readonly items: readonly Condition[];
+} | {
+  readonly kind: "not";
+  readonly item: Condition;
+} | {
+  readonly kind: "column";
+  readonly column: string;
+  readonly op: ColumnOp;
+  readonly value: unknown;
+  /** Full-text search configuration for `fts`. */
+  readonly config?: string;
+  /**
+   * The column is `json`/`jsonb`: containment values are JSON documents,
+   * also when they are arrays, never Postgres array literals.
+   */
+  readonly json?: true;
+  /**
+   * Keys into a json column: the condition compares the text at this path
+   * (`column->a->>b`, `column #>> '{a,b}'`), and `is null` holds when the
+   * key is missing or JSON `null`.
+   */
+  readonly path?: readonly string[];
+} | {
+  readonly kind: "relation";
+  readonly name: string;
+  readonly relation: RelationMeta;
+  readonly target: TableMeta;
+  readonly quantifier: Quantifier;
+  readonly where: Condition | undefined;
+};
+interface SelectColumn {
+  /** Key in the returned row. */
+  readonly alias: string;
+  /** Database column name. */
+  readonly column: string;
+  /** Read the column as text, so exact `int8`/`numeric` values survive JSON. */
+  readonly cast?: "text";
+  /** Decodes the returned value (see `ColumnMeta.codec`). */
+  readonly codec?: Codec;
+}
+interface OrderTerm {
+  readonly column: string;
+  readonly direction: "asc" | "desc";
+  readonly nulls?: "first" | "last";
+  /**
+   * Added by the repository (the primary key order of `findMany`), not asked
+   * for by the caller, so a split read may sort it approximately.
+   */
+  readonly implicit?: true;
+  /**
+   * Sort `aggregate()` groups by this aggregate of `column`; `count` counts
+   * the group's rows and its `column` is `*`.
+   */
+  readonly aggregate?: AggregateFn | "count";
+  /** Sort by `column` of this to-one relation's row (only on the root table). */
+  readonly relation?: {
+    readonly name: string;
+    readonly relation: RelationMeta;
+    readonly target: TableMeta;
+  };
+}
+interface Include {
+  readonly alias: string;
+  readonly relation: RelationMeta;
+  readonly target: TableMeta;
+  readonly selection: Selection;
+  readonly where: Condition | undefined;
+  readonly orderBy: readonly OrderTerm[];
+  readonly limit: number | undefined;
+  /** Drop parent rows without a match (`!inner`). */
+  readonly required: boolean;
+  /**
+   * `_count` include: returns the number of matching related rows instead of
+   * rows, folded into `row._count[count]` when decoded.
+   */
+  readonly count?: string;
+  /**
+   * `_sum`/`_avg`/`_min`/`_max` include: `selection.aggregate` holds the
+   * measures, folded into `row[`_${fn}`][name]` when decoded.
+   */
+  readonly aggregate?: {
+    readonly fn: AggregateFn;
+    readonly name: string;
+  };
+}
+type AggregateFn = "sum" | "avg" | "min" | "max";
+interface Measure {
+  readonly fn: AggregateFn;
+  /** Key in the returned row (`_sum_amount`, or the column alias in an include). */
+  readonly key: string;
+  /** App column name, the key under `_sum` in the decoded row. */
+  readonly alias: string;
+  /** Database column name. */
+  readonly column: string;
+  /** Read the result as text, so exact `int8`/`numeric` values survive JSON. */
+  readonly cast?: "text";
+  readonly codec?: Codec;
+}
+/**
+ * Aggregates instead of rows. `Selection.columns` become the grouping
+ * columns; without any, the result is exactly one row.
+ */
+interface Aggregation {
+  /** Also return `_count`, the number of rows in each group. */
+  readonly count: boolean;
+  readonly measures: readonly Measure[];
+}
+interface Selection {
+  readonly columns: readonly SelectColumn[];
+  readonly includes: readonly Include[];
+  readonly aggregate?: Aggregation;
+}
+type CountMode = "exact" | "planned" | "estimated";
+interface SelectOp {
+  readonly kind: "select";
+  readonly table: TableMeta;
+  readonly selection: Selection;
+  readonly where: Condition | undefined;
+  readonly orderBy: readonly OrderTerm[];
+  readonly limit: number | undefined;
+  readonly offset: number | undefined;
+  readonly count: CountMode | undefined;
+  /** Only count, return no rows. */
+  readonly head: boolean;
+  readonly single: "one" | "maybe" | undefined;
+  /** `limit` includes one row past the page, which `paginate()` reads to set `hasMore`. */
+  readonly lookAhead?: boolean;
+  /** `limit` bounds a check, not a page: `findOnly` reads two rows to detect a second match. */
+  readonly unpaged?: boolean;
+  /**
+   * Read from this set-returning function instead of the table (`db.$search`).
+   * Only executors with `functionSources` honor it.
+   */
+  readonly source?: FunctionSource;
+}
+/** A function returning `setof <table>`, called with named arguments. */
+interface FunctionSource {
+  readonly schema: string;
+  readonly name: string;
+  readonly args: Readonly<Record<string, unknown>>;
+}
+/** The statement a mutation runs. */
+type MutationKind = "insert" | "upsert" | "update" | "delete";
+/** What the caller asked for: `softDelete` is a `delete` that a plugin turned into an update. */
+type MutationIntent = MutationKind | "softDelete";
+interface MutationBase {
+  /**
+   * What the caller asked for, when a plugin rewrote the mutation into
+   * another kind. The plugin that rewrites it sets this; mutation events
+   * report it.
+   */
+  readonly intent?: MutationIntent;
+  /**
+   * How a mutation without `returning` counts the rows it wrote. Defaults to
+   * `exact`; SQL executors always return the statement's own row count.
+   */
+  readonly count?: CountMode;
+}
+interface BoundedMutation extends MutationBase {
+  /**
+   * The most rows the statement may change. More fails with `max_affected`
+   * and writes nothing. Over PostgREST it needs PostgREST 13 or later.
+   */
+  readonly maxAffected?: number;
+}
+interface InsertOp extends MutationBase {
+  readonly kind: "insert";
+  readonly table: TableMeta;
+  /** Rows keyed by database column names. */
+  readonly rows: readonly Readonly<Record<string, unknown>>[];
+  readonly returning: Selection | undefined;
+  readonly onConflict: {
+    readonly columns: readonly string[];
+    readonly action: "update" | "ignore";
+  } | undefined;
+  /**
+   * In a multi-row insert, columns some rows leave out become `null`
+   * instead of their column default.
+   */
+  readonly defaultToNull: boolean;
+}
+interface UpdateOp extends BoundedMutation {
+  readonly kind: "update";
+  readonly table: TableMeta;
+  /** Keyed by database column names. */
+  readonly set: Readonly<Record<string, unknown>>;
+  readonly where: Condition | undefined;
+  readonly returning: Selection | undefined;
+}
+interface DeleteOp extends BoundedMutation {
+  readonly kind: "delete";
+  readonly table: TableMeta;
+  readonly where: Condition | undefined;
+  readonly returning: Selection | undefined;
+}
+type Operation = SelectOp | InsertOp | UpdateOp | DeleteOp;
+type MutationOp = InsertOp | UpdateOp | DeleteOp;
+declare const and: (...items: (Condition | undefined)[]) => Condition | undefined;
+declare const or: (...items: Condition[]) => Condition;
+declare const not: (item: Condition) => Condition;
+declare const column: (name: string, op: ColumnOp, value: unknown) => Condition;
+//#endregion
+//#region src/core/executor.d.ts
+interface ExecuteContext {
+  /** Already includes the call's `timeout`, when it has one. */
+  readonly signal?: AbortSignal;
+  readonly errorMappers: readonly ErrorMapper[];
+  /**
+   * The call's `retry` setting. PostgREST passes it to postgrest-js, which
+   * retries idempotent requests on network errors, 503 and 520; executors
+   * without retries ignore it.
+   */
+  readonly retry?: boolean;
+}
+interface ExecuteResult {
+  /** Rows keyed by the aliases in the operation's selection. */
+  readonly rows: readonly Record<string, unknown>[];
+  readonly count: number | null;
+}
+/**
+ * Runs IR operations. PostgREST (`postgrestExecutor`) and SQL
+ * (`better-supabase/postgres`) are built in; any other backend can implement
+ * this interface and prove it with `testExecutor` from `better-supabase/testing`.
+ */
+interface Executor {
+  readonly name: string;
+  /** Honors `SelectOp.source`. `db.$search` fails on executors without it. */
+  readonly functionSources?: boolean;
+  execute(op: Operation, context: ExecuteContext): Promise<Result<ExecuteResult>>;
+  /** Calls a database function. Optional; `db.$rpc` fails without it. */
+  rpc?(name: string, args: Readonly<Record<string, unknown>>, context: RpcContext): Promise<Result<unknown>>;
+  /**
+   * Runs several reads together, for `db.$many`: one transaction on a SQL
+   * connection. Returns one result per operation, in order. Optional;
+   * without it `db.$many` runs the operations in parallel.
+   */
+  batch?(ops: readonly Operation[], context: ExecuteContext): Promise<readonly Result<ExecuteResult>[]>;
+}
+interface RpcContext extends ExecuteContext {
+  readonly schema: string;
+  /** The function is `stable`: send it as a GET, so read replicas can serve it. */
+  readonly get?: boolean;
+  readonly function?: FunctionMeta;
+}
+//#endregion
+export { Selection as C, not as D, column as E, or as O, SelectOp as S, and as T, MutationOp as _, AggregateFn as a, Quantifier as b, Condition as c, FunctionSource as d, Include as f, MutationKind as g, MutationIntent as h, RpcContext as i, CountMode as l, Measure as m, ExecuteResult as n, Aggregation as o, InsertOp as p, Executor as r, ColumnOp as s, ExecuteContext as t, DeleteOp as u, Operation as v, UpdateOp as w, SelectColumn as x, OrderTerm as y };

package/dist/expo/index.d.ts

@@ -0,0 +1,79 @@
+import { a as AnyModels, i as AnyFunctions } from "../types-6BdhkmZe.js";
+import { t as BetterSupabase } from "../define-CJJkkr1-.js";
+import { i as ServerContext, n as ContextOptions, o as ServerOptions, t as BetterServer } from "../server-CeVeeXwz.js";
+import { i as MiddlewareOptions, r as GuardOptions } from "../respond-DoBijysA.js";
+import { t as Validated } from "../shared-DDSjEGDR.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). */
+  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.
+ */
+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. */
+export type ExpoRequest = Request | ImmutableRequest;
+export interface ExpoOptions extends ServerOptions {
+  /** 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.
+   */
+  readonly refresh?: boolean;
+}
+export interface ExpoMiddlewareOptions extends MiddlewareOptions {
+  /**
+   * Where a caller `allow` refuses goes, e.g. `/sign-in`. Without it the
+   * middleware lets every request through and only refreshes the session.
+   */
+  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.
+   */
+  readonly publicPaths?: readonly string[];
+}
+export interface BetterExpo<M extends AnyModels, F extends AnyFunctions, E, C = unknown, P = unknown> extends BetterServer<M, F, E, C, P> {
+  /**
+   * 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>>;
+  /**
+   * 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>, params: ExpoParams, request: ImmutableRequest) => Promise<T> | T, options?: ExpoContextOptions): (request: ImmutableRequest | undefined, params: ExpoParams) => Promise<T>;
+  /**
+   * An API route handler (`export const GET = bs.handler(...)`): `Result`s
+   * become JSON or Problem Details, `undefined` becomes 204.
+   */
+  handler(fn: (request: Request, ctx: ServerContext<M, F, E, C, P>, 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.
+   */
+  middleware(options?: ExpoMiddlewareOptions): MiddlewareFunction;
+}
+/** Expo Router integration: server loaders, API routes and `+middleware.ts`. */
+export declare function createExpo<M extends AnyModels, D, F extends AnyFunctions, E, C = unknown, P = unknown>(betterSupabase: BetterSupabase<M, D, F, E, C, P>, options?: ExpoOptions): BetterExpo<M, F, E, C, P>;
+//#endregion
+export type { ExpoParams, GuardOptions, MiddlewareOptions, ToExpoOptions };

package/dist/expo/index.js

@@ -0,0 +1,129 @@
+import { t as DbException } from "../db-exception-CnWcYPxL.js";
+import { o as toProblem } from "../problem-BreOl8b8.js";
+import { a as unexpectedResponse, c as extendServer, s as createServer, y as refreshFor } from "../adapter-Bc1o3zyy.js";
+import { m as serializeCookie } from "../resolve-D_IcnvFd.js";
+import { a as respond, r as guard, t as defaultExpose } from "../respond-BUgsXNgk.js";
+import { t as withBetterSupabase } from "../composite-DhE66P5u.js";
+import { r as handoffOf } from "../shared-CBxosKK3.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.
+*/
+function toExpo(entries, handler, options = {}) {
+	const run = pipeline(entries, (request, ctx) => Promise.resolve(handler(request, ctx, handoffOf(ctx, PARAMS))));
+	return (request, params = {}) => run(request.body ? bufferRequest(request) : request, {
+		...seedContext(options.env?.(request)),
+		[PARAMS]: params
+	});
+}
+//#endregion
+//#region src/expo/index.ts
+/** `path` is `prefix` or a path under it. */
+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. */
+function toRequest(request) {
+	if (request instanceof Request) return request;
+	return new Request(request.url, {
+		method: request.method,
+		headers: new Headers(request.headers)
+	});
+}
+/** Sends the cookies and headers `ctx.apply` would add to a response. */
+function writeHeaders(ctx) {
+	const cookies = ctx.cookies().map(serializeCookie);
+	const others = Object.entries(ctx.resolution.headers);
+	if (cookies.length === 0 && others.length === 0) return;
+	setResponseHeaders((headers) => {
+		const sent = new Set(headers.getSetCookie());
+		for (const cookie of cookies) if (!sent.has(cookie)) headers.append("set-cookie", cookie);
+		for (const [name, value] of others) headers.set(name, value);
+	});
+}
+function statusError(error, expose) {
+	const problem = toProblem(error, { expose });
+	return new StatusError(problem.status, {
+		error: problem.title,
+		...problem
+	});
+}
+/** Expo Router integration: server loaders, API routes and `+middleware.ts`. */
+function createExpo(betterSupabase, options = {}) {
+	const server = createServer(betterSupabase, options);
+	const expose = options.exposeErrors ?? defaultExpose();
+	const request = async (incoming, contextOptions = {}) => {
+		const { allow, aal, scopes, refresh = true, ...rest } = contextOptions;
+		const ctx = await server.context(toRequest(incoming), {
+			...rest,
+			refresh
+		});
+		writeHeaders(ctx);
+		if (allow !== void 0 || aal !== void 0 || scopes !== void 0) {
+			const denied = guard(ctx.auth, allow, aal, scopes);
+			if (denied) throw statusError(denied, expose);
+		}
+		return ctx;
+	};
+	return extendServer(server, {
+		request,
+		loader(fn, loaderOptions) {
+			return async (incoming, params) => {
+				if (!incoming) throw new StatusError(500, "better-supabase: bs.loader() needs a request; static rendering has none (use createStaticLoader)");
+				const ctx = await request(incoming, loaderOptions);
+				try {
+					return await fn(ctx, params, incoming);
+				} catch (cause) {
+					if (cause instanceof DbException) throw statusError(cause.error, expose);
+					throw cause;
+				}
+			};
+		},
+		handler(fn, handlerOptions = {}) {
+			return toExpo([withBetterSupabase(server, {
+				...handlerOptions,
+				expose
+			})], async (incoming, ctx, params) => {
+				const instance = new URL(incoming.url).pathname;
+				try {
+					return await respond(() => fn(incoming, ctx.bs, params), {
+						instance,
+						expose
+					});
+				} catch (cause) {
+					return unexpectedResponse(cause, {
+						instance,
+						expose
+					});
+				}
+			});
+		},
+		middleware(middlewareOptions = {}) {
+			const { redirectTo, allow, aal, scopes, publicPaths = [] } = middlewareOptions;
+			return async (incoming) => {
+				const resolved = toRequest(incoming);
+				const ctx = await server.context(resolved, { refresh: refreshFor(middlewareOptions.refresh, resolved) ?? true });
+				const url = new URL(incoming.url);
+				const target = redirectTo === void 0 ? void 0 : new URL(redirectTo, url);
+				if (!target || under(url.pathname, target.pathname) || publicPaths.some((path) => under(url.pathname, path)) || !guard(ctx.auth, allow, aal, scopes)) {
+					writeHeaders(ctx);
+					return;
+				}
+				target.searchParams.set("next", url.pathname + url.search);
+				return ctx.apply(new Response(null, {
+					status: 303,
+					headers: { location: target.href }
+				}));
+			};
+		}
+	});
+}
+//#endregion
+export { createExpo, toExpo };

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

@@ -0,0 +1,58 @@
+import { r as Executor } from "../executor-DvsBbNBS.js";
+import { n as PowerSyncExecutorOptions, t as PowerSyncDatabaseLike } from "../executor-CaWigTyR.js";
+import { i as checkSqlite, n as sqliteTables, r as watch, t as WatchOptions } from "../watch-DI34G86j.js";
+//#region src/expo-sqlite/executor.d.ts
+/** What an expo-sqlite database or exclusive transaction can run. */
+interface ExpoSqliteContextLike {
+  getAllAsync<T>(source: string, params: unknown[]): Promise<T[]>;
+  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.
+ */
+interface ExpoSqliteDatabaseLike extends ExpoSqliteContextLike {
+  /** Filters change events to this database when several are open. */
+  readonly databasePath?: string;
+  withTransactionAsync(task: () => Promise<void>): Promise<void>;
+  /** Native only: isolates the transaction from other queries on `db`. */
+  withExclusiveTransactionAsync?(task: (txn: ExpoSqliteContextLike) => Promise<void>): Promise<void>;
+}
+/** The fields of an expo-sqlite change event the watcher reads. */
+interface DatabaseChangeEventLike {
+  readonly tableName: string;
+  readonly databaseFilePath?: string;
+}
+/**
+ * expo-sqlite's `addDatabaseChangeListener`. Open the database with
+ * `{ enableChangeListener: true }` so it reports changes.
+ */
+type AddDatabaseChangeListener = (listener: (event: DatabaseChangeEventLike) => void) => {
+  remove(): void;
+};
+interface ExpoSqliteOptions extends PowerSyncExecutorOptions {
+  /** Enables `watch()` and `useWatch()` on the database. */
+  readonly addDatabaseChangeListener?: AddDatabaseChangeListener;
+}
+/**
+ * An expo-sqlite database in the shape the SQLite executor, `watch()` and
+ * `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.
+ *
+ * ```ts
+ * const sqlite = await openDatabaseAsync("app.db", { enableChangeListener: true });
+ * const db = betterSupabase.connect(expoSqliteExecutor(sqlite, { addDatabaseChangeListener }));
+ * ```
+ */
+export declare function expoSqliteExecutor(db: ExpoSqliteDatabaseLike, options?: ExpoSqliteOptions): Executor;
+//#endregion
+export { type AddDatabaseChangeListener, type DatabaseChangeEventLike, type ExpoSqliteContextLike, type ExpoSqliteDatabaseLike, type ExpoSqliteOptions, type WatchOptions, checkSqlite, sqliteTables, watch };

package/dist/expo-sqlite/index.js

@@ -0,0 +1,104 @@
+import { n as watch, t as sqliteTables } from "../watch-Xuxrvxq-.js";
+import { i as checkSqlite, r as powersyncExecutor } from "../executor-Bq28caBo.js";
+//#region src/expo-sqlite/executor.ts
+const DEFAULT_THROTTLE_MS = 30;
+/** 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 {
+		getAll: (sql, parameters = []) => db.getAllAsync(sql, parameters),
+		execute: (sql, parameters = []) => db.runAsync(sql, parameters)
+	};
+}
+function changesOf(db, addListener) {
+	return (handler, options = {}) => {
+		const tables = options.tables ? new Set(options.tables) : void 0;
+		const throttleMs = options.throttleMs ?? DEFAULT_THROTTLE_MS;
+		let pending = /* @__PURE__ */ new Set();
+		let timer;
+		const flush = () => {
+			timer = void 0;
+			const changedTables = [...pending];
+			pending = /* @__PURE__ */ new Set();
+			if (changedTables.length > 0) handler.onChange({ changedTables });
+		};
+		const subscription = addListener((event) => {
+			if (event.databaseFilePath !== void 0 && db.databasePath !== void 0 && event.databaseFilePath !== db.databasePath) return;
+			if (tables && !tables.has(event.tableName)) return;
+			pending.add(event.tableName);
+			timer ??= setTimeout(flush, throttleMs);
+		});
+		const stop = () => {
+			subscription.remove();
+			if (timer !== void 0) clearTimeout(timer);
+			timer = void 0;
+			pending = /* @__PURE__ */ new Set();
+		};
+		options.signal?.addEventListener("abort", stop, { once: true });
+		return stop;
+	};
+}
+/**
+* An expo-sqlite database in the shape the SQLite executor, `watch()` and
+* `useWatch()` read. Writes run in `withExclusiveTransactionAsync` on
+* native and `withTransactionAsync` on web.
+*/
+function expoSqliteDatabase(db, options = {}) {
+	const context = contextOf(db);
+	const database = {
+		...context,
+		async writeTransaction(callback) {
+			let box;
+			if (db.withExclusiveTransactionAsync) await db.withExclusiveTransactionAsync(async (txn) => {
+				box = { value: await callback(contextOf(txn)) };
+			});
+			else await db.withTransactionAsync(async () => {
+				box = { value: await callback(context) };
+			});
+			if (!box) throw new TypeError("expo-sqlite skipped the transaction");
+			return box.value;
+		}
+	};
+	const addListener = options.addDatabaseChangeListener;
+	return addListener ? {
+		...database,
+		onChange: changesOf(db, addListener)
+	} : database;
+}
+/** Hermes has no `crypto` unless the app installs a polyfill. */
+function randomId() {
+	const { crypto } = globalThis;
+	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.
+*
+* ```ts
+* const sqlite = await openDatabaseAsync("app.db", { enableChangeListener: true });
+* const db = betterSupabase.connect(expoSqliteExecutor(sqlite, { addDatabaseChangeListener }));
+* ```
+*/
+function expoSqliteExecutor(db, options = {}) {
+	const database = expoSqliteDatabase(db, options);
+	const newId = options.newId ?? (async (_table) => {
+		const random = randomId();
+		if (random !== void 0) return random;
+		const [row] = await database.getAll(UUID_SQL);
+		if (!row) throw new TypeError("SQLite returned no id");
+		return row.id;
+	});
+	return {
+		...powersyncExecutor(database, {
+			...options,
+			newId
+		}),
+		name: "expo-sqlite"
+	};
+}
+//#endregion
+export { checkSqlite, expoSqliteDatabase, expoSqliteExecutor, sqliteTables, watch };