better-supabase 0.7.0 → 0.8.0

package/dist/env/index.js

@@ -14,7 +14,8 @@ const ENV_VARIABLES = {
 	dbUrl: ["SUPABASE_DB_URL", "DATABASE_URL"],
 	jwksUrl: ["SUPABASE_JWKS_URL"],
 	jwks: ["SUPABASE_JWKS"],
-	readUrl: ["SUPABASE_READ_URL"]
+	readUrl: ["SUPABASE_READ_URL"],
+	jwtSecret: ["SUPABASE_JWT_SECRET"]
 };
 const LOOPBACK = /^(localhost|127(?:\.\d{1,3}){3}|\[::1\])$/;
 const HOSTED = /^([a-z0-9]{20})\.supabase\.co$/;
@@ -166,6 +167,11 @@ function parseEnv(source, options = {}) {
 	const jwks = rawInline ? checkJwks(rawInline, issues) : void 0;
 	const rawRead = first(source, ENV_VARIABLES.readUrl);
 	const readUrl = rawRead ? checkUrl(rawRead, ENV_VARIABLES.readUrl, issues) : void 0;
+	const jwtSecret = first(source, ENV_VARIABLES.jwtSecret);
+	if (jwtSecret !== void 0 && jwtSecret.length < 32) issues.push({
+		variables: ENV_VARIABLES.jwtSecret,
+		message: "must be at least 32 characters"
+	});
 	if (issues.length > 0 || !url || !publishableKey) return {
 		ok: false,
 		issues
@@ -188,7 +194,8 @@ function parseEnv(source, options = {}) {
 			} : {},
 			...dbUrl ? { dbUrl } : {},
 			...projectRef ? { projectRef } : {},
-			...readUrl ? { readUrl: readUrl.href.replace(/\/+$/, "") } : {}
+			...readUrl ? { readUrl: readUrl.href.replace(/\/+$/, "") } : {},
+			...jwtSecret ? { jwtSecret } : {}
 		}
 	};
 }

package/dist/{errors-B11Duf73.js → errors-2M6CKMP4.js}

@@ -204,6 +204,11 @@ function mapBuiltin(raw) {
 				hint: postgrestHint ? `${base.hint} ${advice}` : advice
 			});
 		}
+		case "25006": return dbError("forbidden", "This connection is read-only, so the write was refused", {
+			...base,
+			details: base.details ?? message,
+			hint: base.hint ?? "The transaction is read-only, such as in a read-only support session; writes need a writable connection."
+		});
 		case "P0001": return dbError("raised", message, base);
 		case "P0002": return dbError("not_found", message, base);
 		case "57014": return dbError("timeout", message, base);

package/dist/{errors-DLjJHPLK.js → errors-rZ7VIqp6.js}

@@ -1,6 +1,6 @@
 import { t as DbException } from "./db-exception-CnWcYPxL.js";
-import { n as dbError, o as isDbError } from "./errors-B11Duf73.js";
-import { s as toDbError } from "./result-DzUbqgdW.js";
+import { n as dbError, o as isDbError } from "./errors-2M6CKMP4.js";
+import { s as toDbError } from "./result-DEqHCMKP.js";
 //#region src/storage/errors.ts
 /** Maps a Storage error (`StorageApiError`, fetch failures) to a `DbError`. */
 function fromStorageError(raw, table) {

package/dist/{escape-like-ImTK0ps_.d.ts → escape-like-DDWoHzh_.d.ts}

@@ -1,4 +1,4 @@
-import { b as DbError, x as DbErrorKind } from "./result-D7y2fT87.js";
+import { b as DbError, x as DbErrorKind } from "./result-BchM1XZn.js";
 //#region src/core/db-exception.d.ts
 /** Thrown by `.orThrow()`. Carries the plain `DbError` as `error`. */
 declare class DbException extends Error {

package/dist/eve/index.d.ts

@@ -1,8 +1,8 @@
-import { a as ResolveAuthOptions, r as AuthState } from "../resolve-ChTYeTEl.js";
-import { i as CredentialRef, r as CredentialProvider } from "../provider-D-UEMvSD.js";
-import { i as AiChat } from "../ai-chat-7amvXjmQ.js";
-import { a as Inbox } from "../inbox-i7E1ppo6.js";
-import { a as EveMemoryToolsContext, c as MemoryDocumentConflictError, d as supabaseDocumentBackend, f as supabaseMemory, i as EveMemoryTool, l as SupabaseDocumentBackendOptions, m as EveSessionContext, n as EveMemoryContext, o as EveRecallMessage, p as EveSessionAuth, r as EveMemoryProvider, s as EveRecallResult, t as EveDocumentBackend, u as SupabaseMemoryOptions } from "../eve-gT2Fpjut.js";
+import { a as ResolveAuthOptions, r as AuthState } from "../resolve-MxXVWyhd.js";
+import { i as CredentialRef, r as CredentialProvider } from "../provider-ib9wzUDz.js";
+import { i as AiChat } from "../ai-chat-DXkMy74O.js";
+import { a as Inbox } from "../inbox-Cd1KCEBL.js";
+import { a as EveMemoryToolsContext, c as MemoryDocumentConflictError, d as supabaseDocumentBackend, f as supabaseMemory, i as EveMemoryTool, l as SupabaseDocumentBackendOptions, m as EveSessionContext, n as EveMemoryContext, o as EveRecallMessage, p as EveSessionAuth, r as EveMemoryProvider, s as EveRecallResult, t as EveDocumentBackend, u as SupabaseMemoryOptions } from "../eve-CoAIcCkq.js";
 //#region src/eve/auth.d.ts
 /** Thrown by `supabaseAuth` so eve answers with `response` instead of downgrading to anonymous. */
 export declare class EveAuthRejection extends Error {

package/dist/eve/index.js

@@ -1,8 +1,9 @@
 import { t as DbException } from "../db-exception-CnWcYPxL.js";
+import { n as isRecord } from "../guards-6F2bCtQR.js";
 import { a as tenantClaimPaths, n as claimAt, t as DEFAULT_CLAIMS } from "../claims-PqzCxaTD.js";
-import { i as resolveAuth } from "../resolve-tJZY3FEa.js";
-import { t as isAnonymousUser } from "../view-BeFcRV6G.js";
-import { d as isRecord } from "../block-helpers-DWHxHsEQ.js";
+import { r as resolveAuth } from "../resolve-Bvgf3ut_.js";
+import { t as isAnonymousUser } from "../view-D5ryq3gz.js";
+import { t as importOptionalPeer } from "../optional-peer-D1pi-skw.js";
 //#region src/eve/ids.ts
 /** A UUID (version 8) from the SHA-256 of `input`, so the same input always gets the same id. */
 async function stableUuid(input) {
@@ -348,14 +349,7 @@ const isToolsModule = (value) => isRecord(value) && typeof value["defineTool"] =
 * Loads `eve/tools` when the provider first builds its tools. The specifier
 * is a variable so bundlers leave the optional peer out.
 */
-async function loadTools() {
-	const specifier = "eve/tools";
-	try {
-		return await import(specifier);
-	} catch {
-		return;
-	}
-}
+const loadTools = () => importOptionalPeer("eve/tools");
 const isRecallResult = (value) => isRecord(value) && Array.isArray(value["messages"]) && value["messages"].every((message) => isRecord(message) && typeof message["content"] === "string");
 /**
 * An eve memory provider over the memory and knowledge blocks. Every read

package/dist/{eve-gT2Fpjut.d.ts → eve-CoAIcCkq.d.ts}

@@ -1,5 +1,5 @@
-import { r as Knowledge, u as KnowledgeSearchOptions } from "./knowledge-BXBbT0Tr.js";
-import { t as Memory } from "./types-DGs5L0VN.js";
+import { r as Knowledge, u as KnowledgeSearchOptions } from "./knowledge-CAReFpRA.js";
+import { t as Memory } from "./types-DSJ3-m9X.js";
 //#region src/eve/types.d.ts
 /**
  * eve's `SessionAuthContext`, typed structurally so this entry never imports

package/dist/events/index.d.ts

@@ -1,4 +1,4 @@
-import { A as CredentialEventData, B as OrganizationEventData, C as BlockEventMap, D as BlockEventsMatching, E as BlockEventType, F as InvitationEventData, G as StorageObjectEventData, H as ScimEventData, I as InviteCodeEventData, J as WebhookEventData, K as SupportEventData, L as NotificationEventData, M as FlagEventData, N as InboxEventData, O as CommentEventData, P as IncomingWebhookEventData, Q as onBlockEvent, R as OrganizationDeletionEventData, S as BlockEvent, T as BlockEventPattern, U as SettingEventData, V as PushDeviceEventData, W as SsoProviderEventData, X as WorkflowRunEventData, Y as WorkflowEventData, Z as blockEventAttributes, _ as AttachmentEventData, b as BLOCK_EVENT_RENAMES, d as AgentEventData, f as AiChatEventData, g as ApiKeyEventData, h as AnnouncementEventData, j as DataExportEventData, k as ConnectorEventData, m as AiToolEventData, p as AiProviderKeyEventData, q as WaitlistEventData, v as AuditRevealEventData, w as BlockEventMeta, x as BillingEventData, y as BLOCK_ATTRIBUTES, z as OrganizationDomainEventData } from "../events-DWDhx77e.js";
-import { a as blockCloudEvent, i as ForwardBlockOptions, n as CloudEventOptions, o as forwardBlockEvents, r as EventSink, t as CloudEvent } from "../cloud-event-C1JCc1bH.js";
-import { a as RowEventData, c as httpSink, d as toHttp, i as ROW_EVENT_TYPES, l as isCloudEvent, n as HttpMode, o as forwardMutations, r as HttpSinkOptions, s as fromHttp, t as ForwardOptions, u as toCloudEvents } from "../index-ClmjK_o-.js";
-export { type AgentEventData, type AiChatEventData, type AiProviderKeyEventData, type AiToolEventData, type AnnouncementEventData, type ApiKeyEventData, type AttachmentEventData, type AuditRevealEventData, BLOCK_ATTRIBUTES, BLOCK_EVENT_RENAMES, type BillingEventData, type BlockEvent, type BlockEventMap, type BlockEventMeta, type BlockEventPattern, type BlockEventType, type BlockEventsMatching, type CloudEvent, type CloudEventOptions, type CommentEventData, type ConnectorEventData, type CredentialEventData, type DataExportEventData, type EventSink, type FlagEventData, type ForwardBlockOptions, ForwardOptions, HttpMode, HttpSinkOptions, type InboxEventData, type IncomingWebhookEventData, type InvitationEventData, type InviteCodeEventData, type NotificationEventData, type OrganizationDeletionEventData, type OrganizationDomainEventData, type OrganizationEventData, type PushDeviceEventData, ROW_EVENT_TYPES, RowEventData, type ScimEventData, type SettingEventData, type SsoProviderEventData, type StorageObjectEventData, type SupportEventData, type WaitlistEventData, type WebhookEventData, type WorkflowEventData, type WorkflowRunEventData, blockCloudEvent, blockEventAttributes, forwardBlockEvents, forwardMutations, fromHttp, httpSink, isCloudEvent, onBlockEvent, toCloudEvents, toHttp };
+import { A as CredentialEventData, B as OrganizationEventData, C as BlockEventMap, D as BlockEventsMatching, E as BlockEventType, F as InvitationEventData, G as StorageObjectEventData, H as ScimEventData, I as InviteCodeEventData, J as WebhookEventData, K as SupportEventData, L as NotificationEventData, M as FlagEventData, N as InboxEventData, O as CommentEventData, P as IncomingWebhookEventData, Q as onBlockEvent, R as OrganizationDeletionEventData, S as BlockEvent, T as BlockEventPattern, U as SettingEventData, V as PushDeviceEventData, W as SsoProviderEventData, X as WorkflowRunEventData, Y as WorkflowEventData, Z as blockEventAttributes, _ as AttachmentEventData, b as BLOCK_EVENT_RENAMES, d as AgentEventData, f as AiChatEventData, g as ApiKeyEventData, h as AnnouncementEventData, j as DataExportEventData, k as ConnectorEventData, m as AiToolEventData, p as AiProviderKeyEventData, q as WaitlistEventData, v as AuditRevealEventData, w as BlockEventMeta, x as BillingEventData, y as BLOCK_ATTRIBUTES, z as OrganizationDomainEventData } from "../events-D1BOCll8.js";
+import { a as ForwardBlockOptions, i as EventSink, n as CloudEventOptions, o as blockCloudEvent, r as DataschemaContext, s as forwardBlockEvents, t as CloudEvent } from "../cloud-event-Dune0KI7.js";
+import { a as RowEventData, c as httpSink, d as toHttp, i as ROW_EVENT_TYPES, l as isCloudEvent, n as HttpMode, o as forwardMutations, r as HttpSinkOptions, s as fromHttp, t as ForwardOptions, u as toCloudEvents } from "../index-CicIyqOe.js";
+export { type AgentEventData, type AiChatEventData, type AiProviderKeyEventData, type AiToolEventData, type AnnouncementEventData, type ApiKeyEventData, type AttachmentEventData, type AuditRevealEventData, BLOCK_ATTRIBUTES, BLOCK_EVENT_RENAMES, type BillingEventData, type BlockEvent, type BlockEventMap, type BlockEventMeta, type BlockEventPattern, type BlockEventType, type BlockEventsMatching, type CloudEvent, type CloudEventOptions, type CommentEventData, type ConnectorEventData, type CredentialEventData, type DataExportEventData, type DataschemaContext, type EventSink, type FlagEventData, type ForwardBlockOptions, ForwardOptions, HttpMode, HttpSinkOptions, type InboxEventData, type IncomingWebhookEventData, type InvitationEventData, type InviteCodeEventData, type NotificationEventData, type OrganizationDeletionEventData, type OrganizationDomainEventData, type OrganizationEventData, type PushDeviceEventData, ROW_EVENT_TYPES, RowEventData, type ScimEventData, type SettingEventData, type SsoProviderEventData, type StorageObjectEventData, type SupportEventData, type WaitlistEventData, type WebhookEventData, type WorkflowEventData, type WorkflowRunEventData, blockCloudEvent, blockEventAttributes, forwardBlockEvents, forwardMutations, fromHttp, httpSink, isCloudEvent, onBlockEvent, toCloudEvents, toHttp };

package/dist/events/index.js

@@ -1,7 +1,7 @@
 import { s as nowInstant } from "../temporal-BJGitm-h.js";
-import { n as forwardBlockEvents, t as blockCloudEvent } from "../cloud-event-BnmD5fb9.js";
+import { i as forwardBlockEvents, n as blockCloudEvent, r as dataschemaOf } from "../cloud-event-CTh9Sr5w.js";
 import { t as jsonReplacer } from "../json-CEnpTHlZ.js";
-import { a as onBlockEvent, n as BLOCK_EVENT_RENAMES, r as blockEventAttributes, t as BLOCK_ATTRIBUTES } from "../block-events-CrT8r7Fe.js";
+import { i as blockEventAttributes, n as BLOCK_EVENT_RENAMES, o as onBlockEvent, t as BLOCK_ATTRIBUTES } from "../block-events-DTxU5tfr.js";
 //#region src/events/index.ts
 const ROW_EVENT_TYPES = {
 	insert: "dev.better-supabase.row.created",
@@ -31,6 +31,10 @@ function toCloudEvents(notice, options) {
 	const tenant = notice.tenant ?? notice.context.tenant;
 	const rows = notice.rows.length > 0 ? notice.rows : notice.keys ?? [];
 	const actorId = notice.context.actor?.id;
+	const dataschema = dataschemaOf(options, {
+		type,
+		table: notice.table
+	});
 	return rows.map((row) => {
 		const subject = subjectOf(options.meta, notice.table, row);
 		return {
@@ -41,6 +45,7 @@ function toCloudEvents(notice, options) {
 			...subject ? { subject } : {},
 			time,
 			datacontenttype: "application/json",
+			...dataschema,
 			data: {
 				table: notice.table,
 				row,

package/dist/{events-DWDhx77e.d.ts → events-D1BOCll8.d.ts}

@@ -1,7 +1,7 @@
 /// <reference lib="esnext.temporal" />
-import { b as DbError } from "./result-D7y2fT87.js";
-import { g as MutationKind, h as MutationIntent, v as Operation } from "./executor-DvsBbNBS.js";
-import { m as RequestContext } from "./plugin-FGY8UhYm.js";
+import { b as DbError } from "./result-BchM1XZn.js";
+import { g as MutationKind, h as MutationIntent, v as Operation } from "./executor-Drzu3dBK.js";
+import { m as RequestContext } from "./plugin-CPK2HsbY.js";
 import { n as Logger } from "./logger-DWVYUmwi.js";
 //#region src/core/block-events.d.ts
 /** `support.*`: support sessions, where a platform admin views the app as a user. */
@@ -530,7 +530,9 @@ type EventHandler<K extends EventName> = (event: BetterSupabaseEvents[K]) => voi
 declare class EventHub {
   #private;
   readonly logger: Logger;
-  constructor(logger?: Logger);
+  /** The definition's `now` option; block events take their `time` from it. */
+  readonly now: (() => Temporal.Instant) | undefined;
+  constructor(logger?: Logger, now?: () => Temporal.Instant);
   on<K extends EventName>(name: K, handler: EventHandler<K>): () => void;
   has(name: EventName): boolean;
   /**

package/dist/{executor-Bq28caBo.js → executor-B-fD7DLt.js}

@@ -1,9 +1,10 @@
 import { t as DbException } from "./db-exception-CnWcYPxL.js";
-import { c as mapDbError, n as dbError } from "./errors-B11Duf73.js";
-import { n as invalidRequest } from "./build-BXIzE6Xv.js";
+import { c as mapDbError, n as dbError } from "./errors-2M6CKMP4.js";
+import { n as invalidRequest } from "./build-meLuYGri.js";
 import { t as lookupOf } from "./lookup-BaP5bI27.js";
-import { a as ok, r as err, s as toDbError } from "./result-DzUbqgdW.js";
+import { a as ok, r as err, s as toDbError } from "./result-DEqHCMKP.js";
 import { n as simplifyOrFalse } from "./simplify-DDO0j0LI.js";
+import { n as whereClause, t as integer } from "./shared-DTneRoxi.js";
 //#region src/compile/sqlite.ts
 /**
 * The operation needs something the SQLite dialect can't express: an
@@ -250,14 +251,6 @@ function dbName(table, app) {
 	if (!meta) invalidRequest(`Unknown column "${app}" on "${table.key}"`, table.key);
 	return meta.db;
 }
-function integer(value) {
-	if (!Number.isInteger(value) || value < 0) invalidRequest(`Expected a non-negative integer, got ${value}`);
-	return value;
-}
-function whereClause(parts) {
-	const present = parts.filter((part) => part !== void 0);
-	return present.length > 0 ? ` where ${present.join(" and ")}` : "";
-}
 function keyColumns(table) {
 	if (table.primaryKey.length === 0) unsupported("a write to a table without a primary key", table);
 	return table.primaryKey.map((app) => dbName(table, app));
@@ -292,7 +285,8 @@ function selectPlan(compiler, op) {
 	if (simple.never) return { kind: "never" };
 	const alias = compiler.alias();
 	const { list, columns } = compiler.selection(op.selection, op.table, alias);
-	const filter = whereClause([simple.condition ? compiler.condition(simple.condition, op.table, alias) : void 0]);
+	const where = simple.condition ? compiler.condition(simple.condition, op.table, alias) : void 0;
+	const filter = whereClause([where]);
 	const from = `${compiler.table(op.table)} as ${alias}`;
 	const filterParams = [...compiler.params];
 	const count = op.count || op.head ? {
@@ -434,25 +428,16 @@ const sqliteCompiler = {
 	target: "sqlite",
 	compile: (op) => compileSqlite(op)
 };
-/**
-* Compiles every operation a list definition runs (the page, its count and
-* the facet counts) for SQLite, without a database. Returns the first
-* `unsupported` or `invalid_request` error, so a test or a dev build fails
-* before a native screen does.
-*
-* ```ts
-* expect(await checkSqlite(betterSupabase, customerList)).toEqual({ ok: true, data: undefined });
-* ```
-*/
 async function checkSqlite(betterSupabase, list, options = {}) {
-	let failure;
+	const failures = /* @__PURE__ */ new Map();
 	const probe = {
 		name: "sqlite-check",
 		execute(op) {
 			try {
 				compileSqlite(op, options);
 			} catch (cause) {
-				failure ??= toDbError(cause);
+				const failure = toDbError(cause);
+				if (!failures.has(failure.message)) failures.set(failure.message, failure);
 				return Promise.resolve(err(failure));
 			}
 			return Promise.resolve(ok({
@@ -470,10 +455,14 @@ async function checkSqlite(betterSupabase, list, options = {}) {
 	};
 	const db = betterSupabase.connect(probe);
 	await list.run(db, query);
-	return failure ? err(failure) : ok(void 0);
+	if (options.all) await list.run(db, list.defaults);
+	const found = [...failures.values()];
+	if (options.all) return found;
+	const [first] = found;
+	return first ? err(first) : ok(void 0);
 }
 //#endregion
-//#region src/powersync/executor.ts
+//#region src/sqlite/executor.ts
 const UNIQUE = /(?:UNIQUE|PRIMARY KEY) constraint failed: (.+)$/m;
 const NOT_NULL = /NOT NULL constraint failed: (?:[^.\s]+\.)?(\S+)/;
 const CHECK = /CHECK constraint failed: ?(\S+)?/;
@@ -668,7 +657,10 @@ async function executeOn(db, op, context, options) {
 	try {
 		plan = compileSqlite(op.kind === "insert" ? await withIds(db, op, options.newId) : op, options);
 	} catch (cause) {
-		return err(toDbError(cause));
+		const error = toDbError(cause);
+		const { fallback } = options;
+		if (fallback && op.kind === "select" && error.kind === "unsupported") return fallback.execute(op, context);
+		return err(error);
 	}
 	if (plan.kind === "never") return ok({
 		rows: [],
@@ -693,26 +685,51 @@ function mapped(cause, mappers) {
 	return raw ? mapDbError(raw, mappers) : toDbError(cause);
 }
 /**
+* Runs repository operations on a 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 the database'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.
+*/
+function sqliteExecutor(db, options = {}, name = "sqlite") {
+	const { fallback } = options;
+	const rpc = fallback?.rpc?.bind(fallback);
+	return {
+		name,
+		...fallback?.functionSources ? { functionSources: true } : {},
+		execute: (op, context) => executeOn(db, op, context, options),
+		...rpc ? { rpc } : {}
+	};
+}
+//#endregion
+//#region src/powersync/executor.ts
+/**
 * 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.
+* 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));
+* const db = betterSupabase.connect(
+*   powersyncExecutor(powersync, { fallback: postgrestExecutor(supabase) }),
+* );
 * ```
 */
 function powersyncExecutor(db, options = {}) {
-	return {
-		name: "powersync",
-		execute: (op, context) => executeOn(db, op, context, options)
-	};
+	return sqliteExecutor(db, options, "powersync");
 }
 //#endregion
-export { sqliteCompiler as a, quoteSqliteIdent as c, checkSqlite as i, sqliteValue as l, postgrestTimestamp as n, compileSqlite as o, powersyncExecutor as r, likeToGlob as s, fromSqliteError as t };
+export { sqliteCompiler as a, quoteSqliteIdent as c, checkSqlite as i, sqliteValue as l, fromSqliteError as n, compileSqlite as o, postgrestTimestamp as r, likeToGlob as s, powersyncExecutor as t };

package/dist/executor-B_Hfobee.js

@@ -0,0 +1,162 @@
+import { r as isPlainObject } from "./clone-dN9XOL1K.js";
+import { c as mapDbError, n as dbError, u as withMaxAffected } from "./errors-2M6CKMP4.js";
+import { a as ok, r as err, s as toDbError } from "./result-DEqHCMKP.js";
+import { n as quoteIdent, t as compileSql } from "./sql-CwuqaQ4Y.js";
+//#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, 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", [context.schema, name]);
+	if (!found) return void 0;
+	const json = /* @__PURE__ */ new Set();
+	if (found.arg_names && found.arg_types) {
+		const modes = found.arg_modes;
+		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 (argName != null && type !== void 0 && JSON_TYPES.has(type)) json.add(argName);
+		}
+	}
+	return {
+		returnsSet: found.returns_set,
+		returnsVoid: found.returns_void,
+		json
+	};
+}
+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 { postgresExecutor as n, fromPgError as t };

package/dist/{executor-BVBFM86G.d.ts → executor-CpxLPCiz.d.ts}

@@ -1,4 +1,4 @@
-import { T as WorkflowGraph } from "./types-AYOvcyep.js";
+import { T as WorkflowGraph } from "./types-CD6yCDx3.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 {

package/dist/{executor-CaWigTyR.d.ts → executor-DfEtf0cq.d.ts}

@@ -1,6 +1,6 @@
-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";
+import { T as RawDbError } from "./result-BchM1XZn.js";
+import { R as TableMeta } from "./types-CoE5Zwy4.js";
+import { r as Executor, v as Operation } from "./executor-Drzu3dBK.js";
 //#region src/compile/sqlite.d.ts
 /** A value SQLite binds: booleans become `0`/`1`, objects JSON text. */
 type SqliteValue = string | number | bigint | null;
@@ -84,38 +84,32 @@ declare function likeToGlob(pattern: string): string;
  */
 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. */
+//#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>;
 }
-/**
- * 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 {
+/** 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>;
-  onChange?(handler: {
-    onChange: (event: {
-      changedTables: string[];
-    }) => Promise<void> | void;
-  }, options?: {
-    tables?: string[];
-    throttleMs?: number;
-    signal?: AbortSignal;
-  }): () => void;
 }
-interface PowerSyncExecutorOptions extends SqliteCompilerOptions {
+interface SqliteExecutorOptions extends SqliteCompilerOptions {
   /**
-   * A primary key for an insert that leaves it out. PowerSync tables key on
+   * 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()` (PowerSync registers it).
+   * `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:
@@ -127,22 +121,44 @@ declare function fromSqliteError(cause: unknown): RawDbError | undefined;
  * 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;
+}
+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) returns a
- * `DbError` of kind `unsupported` without running anything.
+ * 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));
+ * const db = betterSupabase.connect(
+ *   powersyncExecutor(powersync, { fallback: postgrestExecutor(supabase) }),
+ * );
  * ```
  */
 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 };
+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-DvsBbNBS.d.ts → executor-Drzu3dBK.d.ts}

@@ -1,5 +1,5 @@
-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";
+import { f as Result, w as ErrorMapper } from "./result-BchM1XZn.js";
+import { O as RelationMeta, R as TableMeta, d as Codec, g as FunctionMeta } from "./types-CoE5Zwy4.js";
 //#region src/ir/types.d.ts
 /**
  * The query IR. Every repository call becomes one of these operations; the

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

@@ -1,5 +1,5 @@
-import { T as RawDbError } from "./result-D7y2fT87.js";
-import { r as Executor } from "./executor-DvsBbNBS.js";
+import { T as RawDbError } from "./result-BchM1XZn.js";
+import { r as Executor } from "./executor-Drzu3dBK.js";
 //#region src/postgres/executor.d.ts
 /**
  * Anything that runs parameterized SQL: `ctx.postgres` from