better-supabase 0.13.0 → 0.15.0

package/dist/better-result/index.d.ts

@@ -1,8 +1,7 @@
-import { b as DbError, n as BetterResultApi, t as AsyncResult } from "../result-mijqfoJN.js";
-import { B as TableKey, D as PrimaryKeyValue, G as Update, S as Insert, V as TableMeta, W as UniqueWhere, a as AnyModels, i as AnyFunctions } from "../types-DmshMaXz.js";
-import { r as ApplyExtension } from "../plugin-DouW0Kvg.js";
-import { A as UpsertManyArgs, Ct as ReadArgs, D as RpcOptions, E as RpcArgs, F as InferReadSetParams, I as ReadSet, J as QuerySpec, M as WriteManyArgs, N as SearchArgs, O as UpdateArgs, P as SearchScore, S as RawRpcOptions, St as Payload, T as Returned, Tt as RequestArgs, U as ReadSetResult, _ as OverloadArgs, a as CursorPageArgs, b as PageOf, c as DeleteArgs, ct as CountArgs, d as ManyResult, dt as FindManyArgs, et as AggregateArgs, f as ManyReturningArgs, ft as FindOnlyArgs, g as OffsetRangeArgs, h as OffsetPageArgs, j as WriteArgs, k as UpsertArgs, kt as WhereInput, l as DeleteExt, o as Db, p as NoArgName, q as InferResult, rt as AggregateResult, u as FindExt, ut as FindFirstArgs, v as OverloadReturns, x as PlainName, y as OverloadedName } from "../define-D0LSXmUP.js";
-import { a as ListExtra, d as ListQuery, i as ListDefinition, o as ListPage, s as ListPagination } from "../list-query-Dx5cAqG6.js";
+import { b as DbError, n as BetterResultApi, t as AsyncResult } from "../result-DZeA5KS6.js";
+import { Ct as ApplyExtension, K as Insert, O as AnyFunctions, Z as PrimaryKeyValue, dt as TableMeta, ht as Update, k as AnyModels, ut as TableKey } from "../types-DFdg_4yN.js";
+import { $ as SearchScore, A as OffsetRangeArgs, B as RowFilter, Bt as Payload, C as GetKey, D as NoArgName, Dt as CountArgs, E as ManyWriteArgs, F as PlainName, G as UpsertManyArgs, H as RpcOptions, I as RawRpcOptions, K as WriteArgs, M as OverloadReturns, N as OverloadedName, Nt as ListArgs, P as PageOf, Q as SearchArgs, S as FindExt, St as AggregateResult, T as ManyResult, U as UpdateArgs, V as RpcArgs, W as UpsertArgs, _ as CursorPageArgs, b as DeleteArgs, ct as ReadSetResult, et as InferReadSetParams, ft as InferResult, j as OverloadArgs, k as OffsetPageArgs, kt as GetArgs, pt as QuerySpec, q as WriteManyArgs, tt as ReadSet, v as Db, w as ManyOutcome, x as DeleteExt, yt as AggregateArgs, z as Returned } from "../define-DFBnQyYg.js";
+import { a as ListExtra, d as ListQuery, i as ListDefinition, o as ListPage, s as ListPagination } from "../list-query-BDVutLFr.js";
 import { Result } from "better-result";
 //#region src/better-result/better-result.d.ts
 /**
@@ -33,40 +32,31 @@ type Out<T, Err> = Promise<Result<T, Err>>;
 interface BetterResultRepository<M extends AnyModels, T extends TableKey<M>, E, Err> {
   readonly $tableName: T;
   readonly $meta: TableMeta;
-  findMany<const A extends FindManyArgs<M, T> & FindExt<E, M, T>>(args?: A): Out<Payload<M, T, A>[], Err>;
-  findFirst<const A extends FindFirstArgs<M, T> & FindExt<E, M, T>>(args?: A): Out<Payload<M, T, A> | null, Err>;
-  findOnly<const A extends FindOnlyArgs<M, T> & FindExt<E, M, T>>(args: A): Out<Payload<M, T, A> | null, Err>;
-  findUnique<const A extends ReadArgs<M, T> & {
-    readonly where: UniqueWhere<M, T>;
-  } & FindExt<E, M, T>>(args: A): Out<Payload<M, T, A> | null, Err>;
-  findById<const A extends ReadArgs<M, T> & FindExt<E, M, T>>(id: PrimaryKeyValue<M, T>, args?: A): Out<Payload<M, T, A>, Err>;
+  list<const A extends ListArgs<M, T> & FindExt<E, M, T>>(args?: A): Out<Payload<M, T, A>[], Err>;
+  page<const A extends (OffsetPageArgs<M, T> | OffsetRangeArgs<M, T> | CursorPageArgs<M, T>) & FindExt<E, M, T>>(args: A): Out<PageOf<M, T, A>, Err>;
+  get<const A extends GetArgs<M, T> & FindExt<E, M, T>>(key: GetKey<M, T>, args?: A): Out<A extends {
+    readonly optional: true;
+  } ? Payload<M, T, A> | null : Payload<M, T, A>, Err>;
   count(args?: CountArgs<M, T> & FindExt<E, M, T>): Out<number, Err>;
   aggregate<const A extends AggregateArgs<M, T> & FindExt<E, M, T>>(args: A): Out<AggregateResult<M, T, A>, Err>;
-  exists(args?: RequestArgs & {
-    readonly where?: WhereInput<M, T>;
-  } & FindExt<E, M, T>): Out<boolean, Err>;
-  paginate<const A extends (OffsetPageArgs<M, T> | OffsetRangeArgs<M, T> | CursorPageArgs<M, T>) & FindExt<E, M, T>>(args: A): Out<PageOf<M, T, A>, Err>;
   create<const A extends WriteArgs<M, T> = {}>(data: Insert<M, T>, args?: A): Out<Returned<M, T, A>, Err>;
-  createMany<const A extends WriteManyArgs<M, T> = {}>(rows: readonly Insert<M, T>[], args?: A): Out<A extends {
-    readonly returning: false;
-  } ? {
+  create<const A extends WriteManyArgs<M, T> = {}>(rows: readonly Insert<M, T>[], args?: A): Out<ManyOutcome<M, T, A, true>, Err>;
+  update(filter: RowFilter<M, T>, patch: Update<M, T>): Out<{
     count: number;
-  } : Payload<M, T, A>[], Err>;
-  update<const A extends UpdateArgs<M, T> = {}>(id: PrimaryKeyValue<M, T>, patch: Update<M, T>, args?: A): Out<Returned<M, T, A>, Err>;
-  updateMany<const A extends ManyReturningArgs<M, T> & {
-    readonly data: Update<M, T>;
+  }, Err>;
+  update<const A extends ManyWriteArgs<M, T> & {
     readonly allowAll?: boolean;
-  } & FindExt<E, M, T>>(args: A): Out<ManyResult<M, T, A>, Err>;
+  } & FindExt<E, M, T>>(filter: RowFilter<M, T>, patch: NoInfer<Update<M, T>>, args: A): Out<ManyResult<M, T, A>, Err>;
+  update<const A extends UpdateArgs<M, T> = {}>(id: PrimaryKeyValue<M, T>, patch: Update<M, T>, args?: A): Out<Returned<M, T, A>, Err>;
   upsert<const A extends UpsertArgs<M, T> = {}>(data: Insert<M, T>, args?: A): Out<A extends {
     readonly ignoreDuplicates: true;
   } ? Returned<M, T, A> | null : Returned<M, T, A>, Err>;
-  upsertMany<const A extends UpsertManyArgs<M, T> = {}>(rows: readonly Insert<M, T>[], args?: A): Out<A extends {
-    readonly returning: false;
-  } ? {
+  upsert<const A extends UpsertManyArgs<M, T> = {}>(rows: readonly Insert<M, T>[], args?: A): Out<ManyOutcome<M, T, A, true>, Err>;
+  delete(filter: RowFilter<M, T>): Out<{
     count: number;
-  } : Payload<M, T, A>[], Err>;
+  }, Err>;
+  delete<const A extends ManyWriteArgs<M, T> & DeleteExt<E, M, T> & FindExt<E, M, T>>(filter: RowFilter<M, T>, args: A): Out<ManyResult<M, T, A>, Err>;
   delete(id: PrimaryKeyValue<M, T>, args?: DeleteArgs & DeleteExt<E, M, T>): Out<void, Err>;
-  deleteMany<const A extends ManyReturningArgs<M, T> & DeleteExt<E, M, T> & FindExt<E, M, T>>(args: A): Out<ManyResult<M, T, A>, Err>;
 }
 /**
  * Plugin methods that return an `AsyncResult` return a better-result value. A
@@ -118,7 +108,7 @@ type BetterResultDb<M extends AnyModels, F extends AnyFunctions, E, C, Err> = {
  *   DbFailure,
  * );
  * const rdb = withBetterResult(db, toResult);
- * const customer = await rdb.customers.findById(id); // Result<Customer, NotFound | DbFailure>
+ * const customer = await rdb.customers.get(id); // Result<Customer, NotFound | DbFailure>
  * ```
  */
 export declare function withBetterResult<M extends AnyModels, F extends AnyFunctions, E, C, const X extends BetterResultConverter>(db: Db<M, F, E, C>, toResult: X): BetterResultDb<M, F, E, C, ConvertedError<X>>;

package/dist/better-result/index.js

@@ -1,4 +1,4 @@
-import { o as toBetterResult, t as AsyncResult } from "../result-DIT_qp4G.js";
+import { o as toBetterResult, t as AsyncResult } from "../result-ntFBW2p2.js";
 //#region src/better-result/better-result.ts
 const HELPERS = [
 	"$rpc",
@@ -58,7 +58,7 @@ function view(db, convert) {
 *   DbFailure,
 * );
 * const rdb = withBetterResult(db, toResult);
-* const customer = await rdb.customers.findById(id); // Result<Customer, NotFound | DbFailure>
+* const customer = await rdb.customers.get(id); // Result<Customer, NotFound | DbFailure>
 * ```
 */
 function withBetterResult(db, toResult) {

package/dist/bind-CrMBwrPN.d.ts

@@ -0,0 +1,104 @@
+import { O as AnyFunctions, k as AnyModels } from "./types-DFdg_4yN.js";
+import { o as BlockTenant } from "./block-helpers-CRpAHrp_.js";
+import { t as BetterSupabase, v as Db } from "./define-DFBnQyYg.js";
+import { n as DataEngine } from "./data-engine-BWoz9lED.js";
+import { Dn as GeneratedBlocks } from "./define-block-BVcLQ3DF.js";
+import { rt as BetterQueries } from "./index-DLq69k3F.js";
+import { t as ClientPorts } from "./ports-sx226JUL.js";
+import { SupabaseClient } from "@supabase/supabase-js";
+//#region src/client/bind.d.ts
+interface AuthUser {
+  readonly id: string;
+  readonly email?: string;
+  readonly role?: string;
+}
+/**
+ * What the UI needs to know. Claims are decoded, not verified: RLS enforces
+ * access. A token refresh that changes only `exp`, `iat`, `nbf` or `jti` keeps
+ * the previous snapshot, so read expiry from the session, not here.
+ */
+type AuthSnapshot = {
+  readonly status: "loading";
+  readonly user: null;
+  readonly claims: null;
+} | {
+  readonly status: "signed-out";
+  readonly user: null;
+  readonly claims: null;
+} | {
+  readonly status: "signed-in";
+  readonly user: AuthUser;
+  readonly claims: Readonly<Record<string, unknown>>;
+};
+interface ClientAuth {
+  readonly current: () => AuthSnapshot;
+  /** `useSyncExternalStore`-compatible. */
+  readonly subscribe: (listener: () => void) => () => void;
+}
+interface BetterClient<M extends AnyModels, F extends AnyFunctions, E, C = unknown, P = unknown, B = unknown> {
+  /**
+   * The definition the client was created from (schema metadata, specs, live
+   * queries).
+   */
+  readonly betterSupabase: BetterSupabase<M, unknown, F, E, C, P, B>;
+  readonly supabase: SupabaseClient;
+  /** Repositories with the current session's actor and claims. */
+  readonly db: Db<M, F, E, SupabaseClient, B>;
+  /** TanStack Query option factories over `db`. */
+  readonly queries: BetterQueries<M, E, F>;
+  readonly auth: ClientAuth;
+  /**
+   * The platform services block controllers use: storage, shortcuts, files,
+   * push, links.
+   */
+  readonly ports: ClientPorts;
+  /** `blockConfig` from `blocks.generated.ts`, when passed. */
+  readonly blocks?: GeneratedBlocks;
+  /**
+   * The organization block hooks act in: the `organization` option, or the
+   * session's organization claim.
+   */
+  readonly tenant?: BlockTenant;
+  /** The data hooks' engine, when the `engine` option set one. */
+  readonly engine?: DataEngine;
+  /**
+   * Stops following `supabase`'s session. Call it when the client goes away
+   * before the app does: Fast Refresh, tests, a client per account.
+   */
+  readonly dispose: () => void;
+}
+interface BindClientOptions {
+  /**
+   * `staleTime` for every query option in `queries`. Above zero, a remount or a
+   * window focus reuses cached rows instead of refetching them.
+   */
+  readonly staleTime?: number;
+  /**
+   * Platform services for the block hooks. React Native apps pass
+   * `nativePorts()` from `better-supabase/client/native`.
+   */
+  readonly ports?: ClientPorts;
+  /**
+   * `blockConfig` from `blocks.generated.ts`: the block hooks call the schema,
+   * function names and topics `gen` wrote.
+   */
+  readonly blocks?: GeneratedBlocks;
+  /**
+   * The organization `db` and the hooks act in. Default the session's
+   * organization claim; pass a function for one picked in the UI.
+   */
+  readonly organization?: BlockTenant;
+  /**
+   * Where the data hooks keep their reads; default one in memory. An engine
+   * over a local database (`powersyncEngine`, `sqliteEngine`) also runs `db`
+   * there.
+   */
+  readonly engine?: DataEngine;
+}
+/**
+ * Repositories that follow `supabase`'s session, TanStack Query options and an
+ * auth store, for a supabase-js client you created yourself.
+ */
+declare function bindClient<M extends AnyModels, D, F extends AnyFunctions, E, C = unknown, P = unknown, B = unknown>(betterSupabase: BetterSupabase<M, D, F, E, C, P, B>, supabase: SupabaseClient, options?: BindClientOptions): BetterClient<M, F, E, C, P, B>;
+//#endregion
+export { ClientAuth as a, BindClientOptions as i, AuthUser as n, bindClient as o, BetterClient as r, AuthSnapshot as t };

package/dist/block-authors-BDV3y1SP.js

@@ -0,0 +1,14 @@
+import { n as isRecord } from "./guards-6F2bCtQR.js";
+import { C as optionalText } from "./block-helpers-CtBdjgO4.js";
+//#region src/core/block-authors.ts
+/** A row's `author` object as an `Author`, or `undefined`. */
+function authorOf(value) {
+	if (!isRecord(value) || typeof value["id"] !== "string") return;
+	return {
+		id: value["id"],
+		name: optionalText(value["name"]),
+		avatarUrl: optionalText(value["avatarUrl"] ?? value["avatar_url"])
+	};
+}
+//#endregion
+export { authorOf as t };

package/dist/block-authors-DzXLUiIq.d.ts

@@ -0,0 +1,12 @@
+//#region src/core/block-authors.d.ts
+/**
+ * Who wrote a comment or uploaded a file, from `profiles` (with the `profiles`
+ * module): its display name and avatar URL.
+ */
+interface Author {
+  readonly id: string;
+  readonly name: string | undefined;
+  readonly avatarUrl: string | undefined;
+}
+//#endregion
+export { Author as t };

package/dist/block-env-B_uEM2xz.d.ts

@@ -0,0 +1,32 @@
+import { Dn as GeneratedBlocks } from "./define-block-BVcLQ3DF.js";
+import { n as TopicPort } from "./watch-topic-BcGfvZOE.js";
+import { t as ClientPorts } from "./ports-sx226JUL.js";
+import { t as AuthPort } from "./controller-BrP0gn47.js";
+import { SupabaseClient } from "@supabase/supabase-js";
+//#region src/blocks/block-env.d.ts
+/**
+ * What the block bindings hand their controllers: the provider's client,
+ * session, ports, generated block config and tenant.
+ */
+interface BlockEnv {
+  readonly supabase: SupabaseClient;
+  readonly auth: AuthPort;
+  readonly ports: ClientPorts & {
+    readonly topic: TopicPort;
+  };
+  /** `blockConfig` from `blocks.generated.ts`, when the client has it. */
+  readonly config: GeneratedBlocks | undefined;
+  /**
+   * The tenant the hooks act in now: the client's `tenant`, which
+   * `createClient` defaults to the session's tenant claim.
+   */
+  readonly tenant: () => string | undefined;
+}
+type EnvKey = "auth" | "ports";
+/**
+ * A controller's options as a binding takes them: `auth` and `ports` come from
+ * the provider unless the caller passes its own.
+ */
+type BlockOptions<O> = Omit<O, EnvKey> & Partial<Pick<O, Extract<keyof O, EnvKey>>>;
+//#endregion
+export { BlockOptions as n, BlockEnv as t };

package/dist/block-event-listener-Bu6G0TFH.js

@@ -0,0 +1,16 @@
+//#region src/core/block-event-listener.ts
+const matches = (pattern, type) => pattern.endsWith(".*") ? type.startsWith(pattern.slice(0, -1)) : pattern === type;
+/**
+* Listens to the block events that match `pattern` (`'support.started'` or
+* `'support.*'`), typed by `events`: a block's events, `defineBlocks(...)` or
+* `defineEvents(...)`. Returns a function that stops listening.
+*/
+function onBlockEvent(betterSupabase, events, pattern, handler) {
+	const known = new Set(events.types);
+	return betterSupabase.events.on("block", (event) => {
+		if (!known.has(event.type) || !matches(pattern, event.type)) return;
+		handler(event);
+	});
+}
+//#endregion
+export { onBlockEvent as t };

package/dist/block-events-pBXPzwnW.js

@@ -0,0 +1,83 @@
+import { t as cloneValue } from "./clone-CkG0-hlI.js";
+import { s as nowInstant } from "./temporal-DLZlWbOi.js";
+//#region src/core/block-events.ts
+/**
+* Event types that changed name in 0.6, old to new, for sinks and consumers
+* that still receive the old ones (`BLOCK_EVENT_RENAMES[type] ?? type`).
+* `better-supabase codemod 0.6` rewrites the string literals.
+*/
+const BLOCK_EVENT_RENAMES = {
+	"org.created": "organization.created",
+	"org.updated": "organization.updated",
+	"org.deleted": "organization.deleted",
+	"org.member_added": "organization.member_added",
+	"org.member_removed": "organization.member_removed",
+	"org.member_left": "organization.member_left",
+	"org.role_changed": "organization.role_changed",
+	"org.ownership_transferred": "organization.ownership_transferred",
+	"org.switched": "organization.switched"
+};
+/**
+* Fixed OpenTelemetry attribute names for block work, so dashboards and queries
+* can rely on them.
+*/
+const BLOCK_ATTRIBUTES = {
+	event: "better_supabase.block.event",
+	tenant: "better_supabase.tenant",
+	actor: "better_supabase.actor.id",
+	supportSessionId: "better_supabase.support.session_id",
+	organizationId: "better_supabase.organization.id",
+	invitationId: "better_supabase.invitation.id",
+	notificationType: "better_supabase.notification.type",
+	webhookEndpointId: "better_supabase.webhook.endpoint_id"
+};
+/** The `BLOCK_ATTRIBUTES` an event carries. */
+function blockEventAttributes(event) {
+	const attributes = { [BLOCK_ATTRIBUTES.event]: event.type };
+	if (event.tenant) attributes[BLOCK_ATTRIBUTES.tenant] = event.tenant;
+	if (event.actorId) attributes[BLOCK_ATTRIBUTES.actor] = event.actorId;
+	const data = Object.fromEntries(Object.entries(event.data));
+	const add = (key, value) => {
+		if (typeof value === "string" && value.length > 0) attributes[key] = value;
+	};
+	add(BLOCK_ATTRIBUTES.supportSessionId, data["sessionId"]);
+	add(BLOCK_ATTRIBUTES.organizationId, data["organizationId"]);
+	add(BLOCK_ATTRIBUTES.invitationId, data["invitationId"]);
+	add(BLOCK_ATTRIBUTES.notificationType, data["type"]);
+	add(BLOCK_ATTRIBUTES.webhookEndpointId, data["endpointId"]);
+	return attributes;
+}
+/**
+* Emits a block event on `events` with a copy of `data`. Does nothing without a
+* `block` handler, so blocks call it unconditionally. `M` is the emitting
+* block's event map.
+*/
+function emitBlockEvent(events, type, data, meta = {}) {
+	if (!events.has("block")) return;
+	const copy = cloneValue(data);
+	const event = {
+		...meta,
+		type,
+		data: copy,
+		time: (events.now ?? nowInstant)()
+	};
+	events.emit("block", event);
+}
+/**
+* The `emit` a block creator calls with its own event map: skips the work
+* without an event hub and adds the actor and request context from the block's
+* options.
+*/
+function blockEmitter(options) {
+	return (type, data, subject, tenant) => {
+		if (!options.events) return;
+		emitBlockEvent(options.events, type, data, {
+			subject,
+			...tenant ? { tenant } : {},
+			...options.actorId ? { actorId: options.actorId } : {},
+			...options.context ? { context: options.context } : {}
+		});
+	};
+}
+//#endregion
+export { emitBlockEvent as a, blockEventAttributes as i, BLOCK_EVENT_RENAMES as n, blockEmitter as r, BLOCK_ATTRIBUTES as t };

package/dist/block-fields-BE7pInWZ.d.ts

@@ -0,0 +1,58 @@
+import { f as Result, t as AsyncResult } from "./result-DZeA5KS6.js";
+import { t as StandardSchemaV1 } from "./standard-DBV730sF.js";
+//#region src/core/block-fields.d.ts
+/** The fields a `fields` schema adds, or none when the block has no schema. */
+type FieldsOf<S> = S extends StandardSchemaV1<unknown, infer O> ? O extends object ? O : never : Record<never, never>;
+/** The extra columns of a row, keyed by database name, typed by `F`. */
+type ExtraFields<F extends object = Record<never, never>> = Readonly<Record<string, unknown>> & F;
+/** A row whose extra columns a block read under `fields`. */
+interface WithExtraFields {
+  readonly fields: Readonly<Record<string, unknown>>;
+}
+/**
+ * Parses and validates the extra fields an app adds to a block's table, with
+ * any Standard Schema (zod, valibot, arktype) for an object.
+ */
+interface BlockFields<T extends object> {
+  /**
+   * Parses a row the block read: the schema's output replaces the fields it
+   * covers, and the other fields stay as read. A row the schema rejects is a
+   * `validation` error.
+   */
+  read<R extends object>(row: R): Promise<Result<R & T>>;
+  /**
+   * Validates the fields a write sets. Issues about fields the write leaves out
+   * are ignored, so partial updates pass; the database applies its defaults and
+   * `not null` checks. A rejected write is a `validation` error, and nothing is
+   * sent to the database.
+   */
+  write<A extends object>(attrs: A): Promise<Result<A>>;
+  /**
+   * Parses the `fields` of a row the block read: the extra columns its SQL
+   * returns under `fields`, keyed by database name.
+   */
+  readonly row: <R extends WithExtraFields>(row: R) => AsyncResult<R & {
+    readonly fields: ExtraFields<T>;
+  }>;
+  /** `row` for each row, stopping at the first rejected one. */
+  readonly rows: <R extends WithExtraFields>(rows: readonly R[]) => AsyncResult<(R & {
+    readonly fields: ExtraFields<T>;
+  })[]>;
+  /**
+   * Validates the extra fields a write sets, as the jsonb argument the SQL
+   * function takes; `undefined` without any, so the argument is left out.
+   */
+  readonly args: (fields: object | undefined) => AsyncResult<Readonly<Record<string, unknown>> | undefined>;
+}
+/**
+ * The extra columns a block row carries, by column name, typed by its `fields`
+ * schema.
+ */
+type RowFields<F extends object> = Readonly<Record<string, unknown>> & F;
+/**
+ * The `fields` helper block creators use. Without a schema, reads and writes
+ * pass through unchanged.
+ */
+declare function blockFields<T extends object = Record<never, never>>(schema: StandardSchemaV1 | undefined, label: string): BlockFields<T>;
+//#endregion
+export { WithExtraFields as a, RowFields as i, ExtraFields as n, blockFields as o, FieldsOf as r, BlockFields as t };

package/dist/block-fields-DE_FgpOU.js

@@ -0,0 +1,139 @@
+import { n as dbError } from "./errors-BVFgt8BZ.js";
+import { n as isRecord } from "./guards-6F2bCtQR.js";
+import { a as ok, r as err, t as AsyncResult } from "./result-ntFBW2p2.js";
+import { t as toIssues } from "./standard-BA3mLh6w.js";
+//#region src/core/block-fields.ts
+/** Parses the `fields` of one row with `fields.read`. */
+function readFields(fields, row) {
+	return AsyncResult.from(() => fields.read(row.fields)).map((parsed) => ({
+		...row,
+		fields: parsed
+	}));
+}
+/** Parses the `fields` of each row; the first rejected row fails the read. */
+function readAllFields(fields, rows) {
+	return AsyncResult.from(async () => {
+		const out = [];
+		for (const row of rows) {
+			const parsed = await fields.read(row.fields);
+			if (!parsed.ok) return parsed;
+			out.push({
+				...row,
+				fields: parsed.data
+			});
+		}
+		return ok(out);
+	});
+}
+/**
+* Validates the `fields` a write sets with `fields.write`, then builds the
+* call. A write without fields skips the check and passes none.
+*/
+function writeFields(fields, values, then) {
+	if (values === void 0) return then(void 0);
+	return AsyncResult.from(() => fields.write({ ...values })).andThen(then);
+}
+/** The `fields` object of a row a block function returned, or none. */
+function rowFields(value) {
+	return isRecord(value) ? value : {};
+}
+async function run(schema, value) {
+	return schema["~standard"].validate(value);
+}
+const invalid = (label, issues) => err(dbError("validation", `Invalid ${label}`, { issues }));
+/**
+* The `fields` helper block creators use. Without a schema, reads and writes
+* pass through unchanged.
+*/
+function blockFields(schema, label) {
+	const fields = {
+		async read(row) {
+			if (schema === void 0) return ok(row);
+			const outcome = await run(schema, row);
+			if (outcome.issues) return invalid(label, toIssues(outcome.issues));
+			if (!isRecord(outcome.value)) return invalid(label, [{ message: "fields must parse to an object" }]);
+			return ok({
+				...row,
+				...outcome.value
+			});
+		},
+		async write(attrs) {
+			if (schema === void 0) return ok(attrs);
+			const outcome = await run(schema, attrs);
+			if (!outcome.issues) {
+				if (!isRecord(outcome.value)) return ok(attrs);
+				const parsed = outcome.value;
+				const picked = Object.fromEntries(Object.keys(attrs).filter((key) => key in parsed).map((key) => [key, parsed[key]]));
+				return ok({
+					...attrs,
+					...picked
+				});
+			}
+			const given = new Set(Object.keys(attrs));
+			const relevant = toIssues(outcome.issues).filter((issue) => {
+				const [first] = issue.path ?? [];
+				return first === void 0 || given.has(String(first));
+			});
+			if (relevant.length === 0) return ok(attrs);
+			return invalid(label, relevant);
+		},
+		row: (row) => AsyncResult.from(() => fields.read(row.fields)).map((parsed) => ({
+			...row,
+			fields: parsed
+		})),
+		rows: (rows) => AsyncResult.from(async () => {
+			const out = [];
+			for (const row of rows) {
+				const parsed = await fields.row(row);
+				if (!parsed.ok) return parsed;
+				out.push(parsed.data);
+			}
+			return ok(out);
+		}),
+		args: (extra) => AsyncResult.from(async () => {
+			if (extra === void 0 || Object.keys(extra).length === 0) return ok(void 0);
+			const checked = await fields.write({ ...extra });
+			return checked.ok ? ok(checked.data) : checked;
+		})
+	};
+	return fields;
+}
+/** The keys of a write the block doesn't type itself: its extra fields. */
+const extraOf = (input, known) => Object.fromEntries(Object.entries(input).filter(([key]) => !known.has(key)));
+/** The extra columns a block read returns under its `fields` key. */
+const extraFieldsOf = (value) => isRecord(value) && isRecord(value["fields"]) ? value["fields"] : {};
+/**
+* Parses the extra columns of `raw` (a row a block function returned) and adds
+* them to `row`, the block's typed row. The row's own keys win, so an extra
+* column never replaces one the block types.
+*/
+async function withFields(fields, raw, row) {
+	const parsed = await fields.read(extraFieldsOf(raw));
+	if (!parsed.ok) return parsed;
+	return ok({
+		...parsed.data,
+		...row
+	});
+}
+/** `withFields` over a list of pairs: the raw row and the typed row. */
+async function allWithFields(fields, rows) {
+	const out = [];
+	for (const [raw, row] of rows) {
+		const parsed = await withFields(fields, raw, row);
+		if (!parsed.ok) return parsed;
+		out.push(parsed.data);
+	}
+	return ok(out);
+}
+/**
+* Validates the extra fields of a write: `{ fields }` to spread into the call's
+* arguments, or `{}` when the write sets none, so a module without extra
+* columns is called as before.
+*/
+async function extraFieldsArg(fields, extra) {
+	if (Object.keys(extra).length === 0) return ok({});
+	const valid = await fields.write(extra);
+	return valid.ok ? ok({ fields: valid.data }) : valid;
+}
+//#endregion
+export { readAllFields as a, withFields as c, extraOf as i, writeFields as l, blockFields as n, readFields as o, extraFieldsArg as r, rowFields as s, allWithFields as t };

package/dist/block-helpers-CRpAHrp_.d.ts

@@ -0,0 +1,62 @@
+import { T as ErrorMapper, t as AsyncResult } from "./result-DZeA5KS6.js";
+import { t as BlockTransport } from "./block-transport-DWZSJrwN.js";
+//#region src/core/tenant-source.d.ts
+/**
+ * Where a block reads the active tenant: an organization id, or a function that
+ * returns the current one, such as `() => db.$context.tenant` on the server or
+ * the session's tenant claim in the browser.
+ */
+type BlockTenant = string | (() => string | null | undefined);
+//#endregion
+//#region src/core/block-tenant.d.ts
+/** The `tenant` option of the blocks whose methods work in one tenant. */
+interface BlockTenantOptions {
+  /**
+   * The organization the calls act in. `createBlocks` and `createBlockClient`
+   * pass the request's tenant; a call without one fails with
+   * `TENANT_REQUIRED`.
+   */
+  readonly tenant?: BlockTenant;
+}
+//#endregion
+//#region src/core/block-helpers.d.ts
+/** The `temporal` option every block creator takes. */
+interface BlockTemporalOptions {
+  /**
+   * The Temporal namespace for runtimes without a global one, such as `import {
+   * Temporal } from "temporal-polyfill"`. Blocks use it instead of
+   * `globalThis.Temporal`, which stays untouched; like `defineSupabase(schema,
+   * { temporal })`, it applies to the whole process.
+   */
+  readonly temporal?: typeof Temporal;
+}
+/** The options every block creator shares. */
+interface BlockOptions extends BlockTemporalOptions, BlockTenantOptions {
+  /**
+   * `sqlTransport(ctx.postgres)` for members, or `rpcTransport` over an API
+   * schema.
+   */
+  readonly transport: BlockTransport;
+  /**
+   * The transport for service-only calls (jobs, purges). Defaults to
+   * `transport`.
+   */
+  readonly service?: BlockTransport;
+  /** The module's schema, or its API schema. Default `better_supabase`. */
+  readonly schema?: string;
+  /** Error mappers that run before the built-in ones. */
+  readonly mappers?: readonly ErrorMapper[];
+}
+/** Calls one block function and maps a rejection to a `DbError`. */
+type BlockCall = <T>(fn: string, args: Readonly<Record<string, unknown>>, then: (value: unknown) => T | Promise<T>) => AsyncResult<T>;
+/**
+ * One page of a list. `cursor` is the previous page's `next` cursor or last
+ * item, in the shape each list documents.
+ */
+interface CursorPageOptions<Cursor> {
+  /** The most items to return. Each list documents its default and maximum. */
+  readonly limit?: number;
+  readonly cursor?: Cursor;
+}
+//#endregion
+export { BlockTenantOptions as a, CursorPageOptions as i, BlockOptions as n, BlockTenant as o, BlockTemporalOptions as r, BlockCall as t };