better-supabase 0.5.1 → 0.6.0

package/dist/executor-C-R4pucm.js

@@ -0,0 +1,83 @@
+import { a as evaluateCondition, c as topologicalOrder, i as durationMs, l as validateGraph, n as conditionOf, t as approved } from "./graph-BGyLLFLX.js";
+//#region src/blocks/workflow-builder/executor.ts
+/** The hook token of an approval node. */
+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;
+};
+/**
+* Runs `graph` in dependency order: 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 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 (!(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;
+}
+async function runNode(node, input, results, runtime) {
+	switch (node.kind) {
+		case "trigger": return {
+			output: input,
+			outcome: true
+		};
+		case "step": return {
+			output: await runtime.step({
+				node: node.id,
+				step: node.step ?? "",
+				config: node.config ?? {},
+				input,
+				results: { ...results },
+				runKey: runtime.runKey
+			}) ?? null,
+			outcome: true
+		};
+		case "sleep":
+			await runtime.sleep(durationMs(node.config?.["duration"]) ?? 0);
+			return {
+				output: null,
+				outcome: true
+			};
+		case "approval": {
+			const payload = await runtime.approval(approvalToken(runtime.runKey, node.id), node.id);
+			return {
+				output: payload ?? null,
+				outcome: approved(payload)
+			};
+		}
+		case "condition": {
+			const condition = conditionOf(node);
+			const outcome = condition !== void 0 && evaluateCondition(condition, {
+				input,
+				results
+			});
+			return {
+				output: outcome,
+				outcome
+			};
+		}
+		default: {
+			const unknown = node.kind;
+			throw new TypeError(`workflow-builder: unknown node kind ${String(unknown)}`);
+		}
+	}
+}
+//#endregion
+export { executeGraph as n, approvalToken as t };

package/dist/executor-CaWigTyR.d.ts

@@ -0,0 +1,148 @@
+import { T as RawDbError } from "./result-D7y2fT87.js";
+import { R as TableMeta } from "./types-6BdhkmZe.js";
+import { r as Executor, v as Operation } from "./executor-DvsBbNBS.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/powersync/executor.d.ts
+/** What a PowerSync database, transaction or lock context can run. */
+interface SqliteContextLike {
+  getAll<T>(sql: string, parameters?: unknown[]): Promise<T[]>;
+  execute(sql: string, parameters?: unknown[]): Promise<unknown>;
+}
+/**
+ * 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 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>;
+  onChange?(handler: {
+    onChange: (event: {
+      changedTables: string[];
+    }) => Promise<void> | void;
+  }, options?: {
+    tables?: string[];
+    throttleMs?: number;
+    signal?: AbortSignal;
+  }): () => void;
+}
+interface PowerSyncExecutorOptions extends SqliteCompilerOptions {
+  /**
+   * A primary key for an insert that leaves it out. PowerSync tables key on
+   * a text `id` that the client creates. Defaults to
+   * `crypto.randomUUID()`, else SQLite's `uuid()` (PowerSync registers it).
+   */
+  readonly newId?: (table: TableMeta) => string | Promise<string>;
+}
+/**
+ * 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;
+/**
+ * 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) returns a
+ * `DbError` of kind `unsupported` without running anything.
+ * `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));
+ * ```
+ */
+declare function powersyncExecutor(db: PowerSyncDatabaseLike, options?: PowerSyncExecutorOptions): Executor;
+//#endregion
+export { SqliteValue as _, postgrestTimestamp as a, quoteSqliteIdent as b, SqliteCompilerOptions as c, SqliteKeyedPlan as d, SqliteKeys as f, SqliteSelectPlan as g, SqliteReturning as h, fromSqliteError as i, SqliteDecode as l, SqliteQuery as m, PowerSyncExecutorOptions as n, powersyncExecutor as o, SqlitePlan as p, SqliteContextLike as r, SqliteColumn as s, PowerSyncDatabaseLike as t, SqliteInsertPlan as u, compileSqlite as v, sqliteValue as x, likeToGlob as y };

package/dist/executor-D14tGopJ.d.ts

@@ -0,0 +1,36 @@
+import { T as WorkflowGraph } from "./types-BI-0Sl2v.js";
+//#region src/blocks/workflow-builder/executor.d.ts
+/** What a step node passes to the engine's step: plain data, so it serializes. */
+interface GraphStepCall {
+  /** The node id, which `workflow_node_runs` keys on. */
+  readonly node: string;
+  /** The library step's name. */
+  readonly step: string;
+  readonly config: Readonly<Record<string, unknown>>;
+  /** The trigger's input. */
+  readonly input: unknown;
+  /** The outputs of the nodes that ran before it, by node id. */
+  readonly results: Readonly<Record<string, unknown>>;
+  /** The run's key; approval hooks use `<runKey>:<node>` as their token. */
+  readonly runKey: string;
+}
+/** What the engine does for each kind of node. */
+interface GraphRuntime {
+  readonly runKey: string;
+  step(call: GraphStepCall): PromiseLike<unknown>;
+  sleep(ms: number): PromiseLike<unknown>;
+  /** Waits for the approval hook with `token` and returns its payload. */
+  approval(token: string, node: string): PromiseLike<unknown>;
+}
+/** The hook token of an approval node. */
+declare const approvalToken: (runKey: string, node: string) => string;
+/**
+ * Runs `graph` in dependency order: 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.
+ */
+declare function executeGraph(graph: WorkflowGraph, input: unknown, runtime: GraphRuntime): Promise<Record<string, unknown>>;
+//#endregion
+export { executeGraph as i, GraphStepCall as n, approvalToken as r, GraphRuntime as t };

package/dist/{executor-Cghdstwu.d.ts → executor-DbvExCFC.d.ts}

@@ -1,4 +1,5 @@
-import { C as RawDbError, r as Executor } from "./executor-BunPOO-k.js";
+import { T as RawDbError } from "./result-D7y2fT87.js";
+import { r as Executor } from "./executor-DvsBbNBS.js";
 //#region src/postgres/executor.d.ts
 /**
  * Anything that runs parameterized SQL: `ctx.postgres` from
@@ -18,6 +19,11 @@ declare function fromPgError(error: unknown): RawDbError | undefined;
  * 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.
  */
 declare function postgresExecutor(client: SqlClient): Executor;
 //#endregion

package/dist/{sql-Coh6n4cC.js → executor-De1Of3m3.js}

@@ -1,5 +1,9 @@
-import { a as invalidRequest, n as simplifyOrFalse } from "./simplify-_0oUKqCd.js";
+import { n as isPlainObject } from "./clone-BfgmLU90.js";
+import { c as mapDbError, n as dbError, t as MAX_AFFECTED_MARKER, u as withMaxAffected } from "./errors-B11Duf73.js";
+import { n as invalidRequest } from "./build-BXIzE6Xv.js";
 import { t as lookupOf } from "./lookup-BaP5bI27.js";
+import { a as ok, r as err, s as toDbError } from "./result-DzUbqgdW.js";
+import { n as simplifyOrFalse } from "./simplify-DDO0j0LI.js";
 //#region src/compile/sql.ts
 const MAX_PARAMS = 65535;
 const MAX_PAIRS = 50;
@@ -28,7 +32,7 @@ function rowComparison(condition) {
 		const terms = index === 0 ? [item] : item.kind === "and" ? item.items : [];
 		if (terms.length !== index + 1) return null;
 		const step = terms[index];
-		if (step.kind !== "column" || step.op !== "gt" && step.op !== "lt") return null;
+		if (step.kind !== "column" || step.path || step.op !== "gt" && step.op !== "lt") return null;
 		for (const [at, term] of terms.slice(0, index).entries()) {
 			const prev = steps[at];
 			if (term.kind !== "column" || term.op !== "eq" || term.column !== prev.column || !Object.is(term.value, prev.value)) return null;
@@ -86,7 +90,7 @@ var SqlCompiler = class {
 		}
 	}
 	columnCondition(condition, table, alias) {
-		const column = this.column(alias, condition.column);
+		const column = condition.path ? `(${this.column(alias, condition.column)} #>> ${this.param(condition.path, "text[]")})` : this.column(alias, condition.column);
 		const { value } = condition;
 		switch (condition.op) {
 			case "eq": return `${column} = ${this.param(value)}`;
@@ -97,6 +101,8 @@ var SqlCompiler = class {
 			case "lte": return `${column} <= ${this.param(value)}`;
 			case "like": return `${column} like ${this.param(value)}`;
 			case "ilike": return `${column} ilike ${this.param(value)}`;
+			case "match": return `${column} ~ ${this.param(value)}`;
+			case "imatch": return `${column} ~* ${this.param(value)}`;
 			case "in":
 				if (!Array.isArray(value)) invalidRequest("\"in\" needs an array");
 				return `${column} = any(${this.param(value)})`;
@@ -109,7 +115,7 @@ var SqlCompiler = class {
 			case "containedBy":
 			case "overlaps": {
 				const operator = condition.op === "contains" ? "@>" : condition.op === "containedBy" ? "<@" : "&&";
-				return Array.isArray(value) ? `${column} ${operator} ${this.param(value)}` : `${column} ${operator} ${this.param(JSON.stringify(value), "jsonb")}`;
+				return Array.isArray(value) && !condition.json ? `${column} ${operator} ${this.param(value)}` : `${column} ${operator} ${this.param(JSON.stringify(value), "jsonb")}`;
 			}
 			case "fts": {
 				const config = condition.config ? `${this.param(condition.config, "regconfig")}, ` : "";
@@ -127,12 +133,26 @@ var SqlCompiler = class {
 			return `${this.column(targetAlias, dbColumn(target, reference))} = ${this.column(sourceAlias, dbColumn(source, column))}`;
 		}).join(" and ");
 	}
-	orderBy(terms, alias) {
+	orderBy(terms, alias, table) {
 		return terms.map((term) => {
 			const nulls = term.nulls ? ` nulls ${term.nulls}` : "";
-			return `${this.column(alias, term.column)} ${term.direction}${nulls}`;
+			return `${this.sortKey(term, alias, table)} ${term.direction}${nulls}`;
 		}).join(", ");
 	}
+	/**
+	* A column, an aggregate of the group, or the column of a to-one
+	* relation's row as a scalar subquery.
+	*/
+	sortKey(term, alias, table) {
+		if (term.aggregate === "count") return "count(*)";
+		if (term.aggregate) return `${term.aggregate}(${this.column(alias, term.column)})`;
+		const { relation } = term;
+		if (!relation) return this.column(alias, term.column);
+		if (!table) invalidRequest("A relation sort needs the root table");
+		const target = this.alias();
+		const join = this.join(relation.relation, table, alias, relation.target, target);
+		return `(select ${this.column(target, term.column)} from ${tableRef(relation.target)} as ${target} where ${join} limit 1)`;
+	}
 	/** `json_build_object('alias', t0."col", ...)` for a selection. */
 	rowExpression(selection, table, alias) {
 		const pairs = selection.columns.map((entry) => `'${entry.alias.replaceAll("'", "''")}', ${this.column(alias, entry.column)}${entry.cast ? `::${entry.cast}` : ""}`);
@@ -221,7 +241,7 @@ function compileSql(op) {
 			} : void 0;
 			return {
 				rows: {
-					text: `select ${compiler.rowExpression(op.selection, op.table, alias)} as row from ${from}${filter}${op.selection.aggregate && op.selection.columns.length > 0 ? ` group by ${op.selection.columns.map((entry) => compiler.column(alias, entry.column)).join(", ")}` : ""}${op.orderBy.length > 0 ? ` order by ${compiler.orderBy(op.orderBy, alias)}` : ""}${op.limit === void 0 ? "" : ` limit ${integer(op.limit)}`}${op.offset === void 0 ? "" : ` offset ${integer(op.offset)}`}`,
+					text: `select ${compiler.rowExpression(op.selection, op.table, alias)} as row from ${from}${filter}${op.selection.aggregate && op.selection.columns.length > 0 ? ` group by ${op.selection.columns.map((entry) => compiler.column(alias, entry.column)).join(", ")}` : ""}${op.orderBy.length > 0 ? ` order by ${compiler.orderBy(op.orderBy, alias, op.table)}` : ""}${op.limit === void 0 ? "" : ` limit ${integer(op.limit)}`}${op.offset === void 0 ? "" : ` offset ${integer(op.offset)}`}`,
 					params: compiler.params
 				},
 				count: countQuery,
@@ -259,7 +279,7 @@ function compileSql(op) {
 			};
 			const entries = Object.entries(op.set);
 			if (entries.length === 0) invalidRequest(`Update on "${op.table.key}" sets no columns`);
-			return mutation(`update ${from} set ${entries.map(([column, value]) => `${quoteIdent(column)} = ${compiler.param(value)}`).join(", ")}${whereClause([simple.condition ? compiler.condition(simple.condition, op.table, alias) : void 0])}${returningRows(compiler, op, alias)}`, op.returning !== void 0, compiler.params);
+			return mutation(`update ${from} set ${entries.map(([column, value]) => `${quoteIdent(column)} = ${compiler.param(value)}`).join(", ")}${whereClause([simple.condition ? compiler.condition(simple.condition, op.table, alias) : void 0])}${returningRows(compiler, op, alias)}`, op.returning !== void 0, compiler.params, maxAffectedOf(op));
 		}
 		case "delete": {
 			const simple = simplifyOrFalse(op.where);
@@ -268,7 +288,7 @@ function compileSql(op) {
 				count: void 0,
 				never: true
 			};
-			return mutation(`delete from ${from}${whereClause([simple.condition ? compiler.condition(simple.condition, op.table, alias) : void 0])}${returningRows(compiler, op, alias)}`, op.returning !== void 0, compiler.params);
+			return mutation(`delete from ${from}${whereClause([simple.condition ? compiler.condition(simple.condition, op.table, alias) : void 0])}${returningRows(compiler, op, alias)}`, op.returning !== void 0, compiler.params, maxAffectedOf(op));
 		}
 		default: return op;
 	}
@@ -302,7 +322,40 @@ function tenantGuard(op, alias) {
 	if (column === void 0) return "";
 	return ` where ${alias}.${quoteIdent(column)} = excluded.${quoteIdent(column)}`;
 }
-function mutation(statement, returning, params) {
+function maxAffectedOf(op) {
+	if (op.maxAffected === void 0) return void 0;
+	if (!Number.isInteger(op.maxAffected) || op.maxAffected < 0) invalidRequest(`"maxAffected" must be a non-negative integer, got ${op.maxAffected}`, op.table.key);
+	return op.maxAffected;
+}
+/**
+* The statement's row count, or a cast error naming it when it is above
+* `max`. The cast depends on `count(*)`, so the planner can't fold it into
+* an error for every call; the failed statement rolls its writes back. A
+* query returning rows must use the count (`where c.n >= 0`), or Postgres
+* drops the unused column and never runs the check.
+*/
+function guardedCount(max) {
+	return `case when count(*) > ${max} then ('${MAX_AFFECTED_MARKER}:' || count(*))::int else count(*)::int end`;
+}
+function mutation(statement, returning, params, maxAffected) {
+	if (maxAffected !== void 0) {
+		const guard = guardedCount(maxAffected);
+		return returning ? {
+			rows: {
+				text: `with m as (${statement}), c as (select ${guard} as n from m) select m.row from m cross join c where c.n >= 0`,
+				params
+			},
+			count: void 0,
+			never: false
+		} : {
+			rows: void 0,
+			count: {
+				text: `with m as (${statement}) select ${guard} as count from m`,
+				params
+			},
+			never: false
+		};
+	}
 	if (returning) return {
 		rows: {
 			text: statement,
@@ -321,4 +374,150 @@ function mutation(statement, returning, params) {
 	};
 }
 //#endregion
-export { quoteIdent as n, compileSql as t };
+//#region src/postgres/executor.ts
+function isPgError(value) {
+	return typeof value === "object" && value !== null && typeof value.code === "string";
+}
+/** node-postgres error fields to the shape `mapDbError` reads. */
+function fromPgError(error) {
+	if (!isPgError(error)) return void 0;
+	const raw = {};
+	if (error.code !== void 0) raw.code = error.code;
+	if (error.message !== void 0) raw.message = error.message;
+	if (error.detail !== void 0) raw.details = error.detail;
+	if (error.hint !== void 0) raw.hint = error.hint;
+	if (error.constraint !== void 0) raw.constraint = error.constraint;
+	if (error.column !== void 0) raw.column = error.column;
+	if (error.table !== void 0) raw.table = error.table;
+	return raw;
+}
+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?.count ?? 0;
+	} 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.
+*/
+function postgresExecutor(client) {
+	return {
+		name: "postgres",
+		functionSources: true,
+		execute: (op, context) => executeOn(client, op, context),
+		rpc: (name, args, context) => callFunction(client, name, args, context),
+		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)) throw cause;
+				return Promise.all(ops.map((op) => executeOn(client, op, context)));
+			}
+		}
+	};
+}
+var BatchFailed = class extends Error {};
+async function executeOn(client, op, context) {
+	let plan;
+	try {
+		plan = compileSql(op);
+	} 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"));
+	let result;
+	try {
+		result = plan.chunks && 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"]);
+async function signatureOf(client, name, context) {
+	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))
+	};
+	const [found] = await client.queryRaw("select p.proretset as returns_set, p.prorettype = 'pg_catalog.void'::pg_catalog.regtype as returns_void 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", [context.schema, name]);
+	return found ? {
+		returnsSet: found.returns_set,
+		returnsVoid: found.returns_void,
+		json: /* @__PURE__ */ new Set()
+	} : void 0;
+}
+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) {
+	if (context.signal?.aborted) return err(dbError("aborted", "The request was aborted"));
+	try {
+		const signature = await signatureOf(client, name, context);
+		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(([, value]) => value !== void 0).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 values = (await client.queryRaw(`select to_json(bs_call) as value from ${call} as bs_call`, params)).map((row) => row.value);
+		return ok(signature.returnsSet ? values : values[0] ?? null);
+	} catch (cause) {
+		const raw = fromPgError(cause);
+		return err(raw ? mapDbError(raw, context.errorMappers) : toDbError(cause));
+	}
+}
+//#endregion
+export { quoteIdent as i, postgresExecutor as n, compileSql as r, fromPgError as t };