better-supabase 0.14.0 → 0.15.0

package/dist/react-router/index.d.ts

@@ -1,10 +1,10 @@
-import { M as AnyFunctions, N as AnyModels } from "../executor-CPyrQdjh.js";
-import { s as PermissionRef, t as AnyAuthorizer } from "../authorizer-DFP3gHv8.js";
-import { t as BetterSupabase } from "../define-Dw7pRO4h.js";
-import { n as BetterServer } from "../server-types-BOs-eFpo.js";
-import { a as AuthorizedContext, c as ResourceLoaderContext, i as AuthorizeOptions, l as Unwrapped, n as ActionParsed, o as BlockActionOptions, r as ActionResult, s as BlockRequireOptions } from "../kit-DKfbNTAA.js";
-import { t as RefusalRedirects } from "../refusal-efy5bZMd.js";
-import { n as FrameworkOptions, r as LocalsResource, t as FrameworkLocals } from "../framework-FxfJpyoF.js";
+import { O as AnyFunctions, k as AnyModels } from "../types-DFdg_4yN.js";
+import { l as PermissionRef, t as AnyAuthorizer } from "../authorizer-B6X09otb.js";
+import { t as BetterSupabase } from "../define-DFBnQyYg.js";
+import { n as BetterServer } from "../server-types-CFtehAsr.js";
+import { a as AuthorizedContext, c as ResourceLoaderContext, i as AuthorizeOptions, l as Unwrapped, n as ActionParsed, o as BlockActionOptions, r as ActionResult, s as BlockRequireOptions } from "../kit-DOwKpSkA.js";
+import { t as RefusalRedirects } from "../refusal-CSntB_x8.js";
+import { n as FrameworkOptions, r as LocalsResource, t as FrameworkLocals } from "../framework-BKyTeS-j.js";
 import { t as Validated } from "../shared-CRRfQAKG.js";
 import { AnyEntry, Contributions } from "@supabase/middleware";
 import { StandardSchemaV1 } from "@standard-schema/spec";
@@ -64,8 +64,8 @@ interface ReactRouterOptions extends FrameworkOptions {
 }
 interface BetterReactRouter<M extends AnyModels, F extends AnyFunctions, E, C = unknown, P = unknown, Ref = string, B = unknown> extends BetterServer<M, F, E, C, P, B> {
   /**
-   * The context key the middleware sets: `context.get(bs.contextKey)`, or
-   * `bs.locals(args)`.
+   * The context key the middleware sets: `context.get(bsb.contextKey)`, or
+   * `bsb.locals(args)`.
    */
   readonly contextKey: unknown;
   /**
@@ -73,7 +73,10 @@ interface BetterReactRouter<M extends AnyModels, F extends AnyFunctions, E, C =
    * session cookie on navigations and form posts, and sets the context.
    */
   readonly middleware: (args: ReactRouterArgs, next: () => Promise<Response>) => Promise<Response>;
-  /** `db`, `bs`, `auth`, `tenant` and the serializable `session` of the request. */
+  /**
+   * `db`, `bsb`, `auth`, `tenant` and the serializable `session` of the
+   * request.
+   */
   locals(args: ReactRouterArgs): FrameworkLocals<M, F, E, C, P, B>;
   /**
    * A loader that runs the guard first. A refused caller gets a redirect to

package/dist/react-router/index.js

@@ -1,10 +1,10 @@
-import { o as problemResponse } from "../problem-BWElIgIb.js";
-import { c as extendServer, o as withFlush, s as createServer } from "../adapter-BCFAg58A.js";
-import { o as settle, t as defaultExpose } from "../respond-z_yfyitp.js";
-import { i as requireCaller, o as runAction } from "../kit-Ct4Z6GIO.js";
+import { o as problemResponse } from "../problem-Bf0cJ7tk.js";
+import { c as extendServer, o as withFlush, s as createServer } from "../adapter-B0b6MXYS.js";
+import { o as settle, t as defaultExpose } from "../respond-C3CcOZlA.js";
+import { i as requireCaller, o as runAction } from "../kit-5l-o8RxL.js";
 import { n as bufferInPlace, t as around } from "../shared-Bf-I13Ht.js";
-import { i as localsOf, n as actionInput, r as frameworkEntry } from "../framework-CXoyWGgd.js";
-import { r as refusalResponse } from "../refusal-DXydjgsS.js";
+import { i as localsOf, n as actionInput, r as frameworkEntry } from "../framework-DDdkR7FX.js";
+import { r as refusalResponse } from "../refusal-ByBZcm0V.js";
 //#region src/bridges/react-router.ts
 /**
 * Runs an entry array as React Router server middleware. The contributions are
@@ -43,7 +43,7 @@ function createReactRouter(betterSupabase, options) {
 		} catch {
 			value = void 0;
 		}
-		if (typeof value !== "object" || value === null || !("bs" in value)) throw new TypeError("better-supabase: no context; add bs.middleware to the root route's middleware export");
+		if (typeof value !== "object" || value === null || !("bsb" in value)) throw new TypeError("better-supabase: no context; add bsb.middleware to the root route's middleware export");
 		return value;
 	};
 	return extendServer(server, {
@@ -59,7 +59,7 @@ function createReactRouter(betterSupabase, options) {
 		loader(loaderOptions, fn) {
 			return async (args) => {
 				const scope = locals(args);
-				const caller = await requireCaller(scope.bs.auth, loaderOptions, scope.tenant, options.authorizer, scope);
+				const caller = await requireCaller(scope.bsb.auth, loaderOptions, scope.tenant, server.authorizer, scope);
 				if ("kind" in caller) throw refusalResponse(caller, args.request, options, expose);
 				const ctx = {
 					...scope,
@@ -76,10 +76,10 @@ function createReactRouter(betterSupabase, options) {
 		action(actionOptions, fn) {
 			return async (args) => {
 				const scope = locals(args);
-				return await runAction(scope.bs.auth, actionOptions, await actionInput(args.request), scope.tenant, (parsed, caller) => fn(parsed, {
+				return await runAction(scope.bsb.auth, actionOptions, await actionInput(args.request), scope.tenant, (parsed, caller) => fn(parsed, {
 					...scope,
 					...caller
-				}, args), options.authorizer, scope);
+				}, args), server.authorizer, scope);
 			};
 		}
 	});

package/dist/read-set-BnKnofIj.js

@@ -0,0 +1,199 @@
+import { n as dbError } from "./errors-BVFgt8BZ.js";
+import { n as isQuerySpec, r as specTables } from "./spec-DTWkHzYZ.js";
+//#region src/core/read-set.ts
+const NAME = /^[a-z][a-z0-9_]{0,59}$/;
+const PARAM = /^[a-z_][a-z0-9_]*$/i;
+const TYPE = /^(?:[a-z_][a-z0-9_]*\.)?[a-z_][a-z0-9_]*(?:\[\])?$/;
+/** `jsonb_build_object` takes at most 100 arguments. */
+const MAX_ENTRIES = 50;
+/**
+* Placeholders are `NUL bsb:<name> NUL`: no real parameter value holds a NUL.
+* Auth placeholders start with `@`, which no parameter name can.
+*/
+const NUL = "\0";
+const SENTINEL = /* @__PURE__ */ new RegExp(`${NUL}bsb:(@?[a-z_][a-z0-9_]*)${NUL}`, "gi");
+const EXACT = /* @__PURE__ */ new RegExp(`^${NUL}bsb:(@?[a-z_][a-z0-9_]*)${NUL}$`, "i");
+function sentinel(name) {
+	return `${NUL}bsb:${name}${NUL}`;
+}
+const AUTH = { uid: sentinel("@uid") };
+function tagged(name, array) {
+	if (!name.startsWith("@")) return {
+		kind: "param",
+		name,
+		array
+	};
+	return name === "@uid" ? {
+		kind: "auth",
+		name: "uid",
+		array
+	} : void 0;
+}
+/**
+* Registers reads that run as one round trip:
+*
+* ```ts
+* export const appChrome = defineReadSet(
+*   betterSupabase,
+*   "app_chrome",
+*   { params: { userId: "uuid" } },
+*   (s, p) => ({
+*     unread: s.notifications.count({
+*       where: { userId: p.userId, readAt: null },
+*     }),
+*     me: s.profiles.get({ where: { id: p.userId } }, { optional: true }),
+*   }),
+* );
+* ```
+*
+* `p` holds placeholders, not values: pass them straight into `where` (or
+* `in`), where the function reads them from its `p jsonb` argument.
+*/
+function defineReadSet(betterSupabase, name, options, build) {
+	if (!NAME.test(name)) throw new TypeError(`better-supabase: read set name "${name}" must be snake_case and at most 60 characters`);
+	const params = options.params ?? {};
+	const placeholders = {};
+	for (const [key, type] of Object.entries(params)) {
+		if (!PARAM.test(key)) throw new TypeError(`better-supabase: read set "${name}" has an invalid parameter name "${key}"`);
+		if (!TYPE.test(type)) throw new TypeError(`better-supabase: read set "${name}" parameter "${key}" has an invalid type "${type}"`);
+		placeholders[key] = type.endsWith("[]") ? [sentinel(key)] : sentinel(key);
+	}
+	const specs = build(betterSupabase.spec, placeholders, AUTH);
+	const entries = Object.entries(specs);
+	if (entries.length === 0 || entries.length > MAX_ENTRIES) throw new TypeError(`better-supabase: read set "${name}" needs between 1 and ${MAX_ENTRIES} reads`);
+	for (const [key, spec] of entries) if (!isQuerySpec(spec)) throw new TypeError(`better-supabase: read set "${name}" entry "${key}" is not a spec from betterSupabase.spec`);
+	warnUnscopedReads(betterSupabase, name, specs);
+	return {
+		kind: "read-set",
+		name,
+		functionName: `rs_${name}`,
+		params,
+		roles: options.roles ?? ["authenticated"],
+		specs,
+		definition: betterSupabase
+	};
+}
+/**
+* The generated function runs the reads as compiled at `gen` time, without the
+* runtime's `transformQuery` plugins, so tenant and soft-delete filters that
+* only those plugins add never reach it.
+*/
+function warnUnscopedReads(betterSupabase, name, specs) {
+	const filtering = betterSupabase.plugins.filter((plugin) => plugin.transformQuery !== void 0 && plugin.scopes?.length !== 0);
+	if (filtering.length === 0) return;
+	const { meta } = betterSupabase;
+	const filters = (plugin, key) => {
+		const flags = meta.tables[key]?.flags;
+		return plugin.scopes === void 0 || plugin.scopes.some((flag) => flags?.[flag] !== void 0);
+	};
+	const tables = [...new Set(Object.values(specs).flatMap((spec) => specTables(meta, spec)))].filter((key) => filtering.some((plugin) => filters(plugin, key)));
+	if (tables.length === 0) return;
+	const scoping = filtering.filter((plugin) => tables.some((key) => filters(plugin, key))).map((plugin) => plugin.name);
+	betterSupabase.events.logger.warn(`read set "${name}" reads ${tables.join(", ")}, which ${scoping.join(", ")} scope at runtime; its generated function only sees those filters when the specs spell them out (or RLS enforces them)`, {
+		readSet: name,
+		tables,
+		plugins: scoping
+	});
+}
+function isReadSet(value) {
+	return typeof value === "object" && value !== null && value.kind === "read-set" && typeof value.name === "string";
+}
+/** The placeholder a string or array carries, if it is exactly one. */
+function placeholderOf(value) {
+	if (typeof value === "string") {
+		const match = EXACT.exec(value);
+		return match ? tagged(match[1], false) : void 0;
+	}
+	if (Array.isArray(value) && value.length === 1) {
+		const inner = placeholderOf(value[0]);
+		return inner && !inner.array ? {
+			...inner,
+			array: true
+		} : inner;
+	}
+}
+/** Splits a string around the placeholders inside it. */
+function splitPlaceholders(value) {
+	const parts = [];
+	let last = 0;
+	for (const match of value.matchAll(SENTINEL)) {
+		if (match.index > last) parts.push({ text: value.slice(last, match.index) });
+		const placeholder = tagged(match[1], false);
+		parts.push(placeholder ?? { text: match[0] });
+		last = match.index + match[0].length;
+	}
+	if (last < value.length) parts.push({ text: value.slice(last) });
+	return parts;
+}
+function hasPlaceholder(value) {
+	return value.includes(`${NUL}bsb:`);
+}
+/** Whether any string inside `value` is (or holds) a placeholder. */
+function containsPlaceholder(value) {
+	if (typeof value === "string") return hasPlaceholder(value);
+	if (Array.isArray(value)) return value.some(containsPlaceholder);
+	if (typeof value === "object" && value !== null) return Object.values(value).some(containsPlaceholder);
+	return false;
+}
+/** Whether the set's specs read the caller's identity. */
+function readSetUsesAuth(set) {
+	return Object.values(set.specs).some((spec) => usesAuth(spec.args));
+}
+function usesAuth(value) {
+	if (typeof value === "string") return [...value.matchAll(SENTINEL)].some((match) => match[1].startsWith("@"));
+	if (Array.isArray(value)) return value.some(usesAuth);
+	if (typeof value === "object" && value !== null) return Object.values(value).some(usesAuth);
+	return false;
+}
+/** Missing or wrongly typed parameters, as messages. */
+function checkParams(set, values) {
+	const problems = [];
+	for (const [key, type] of Object.entries(set.params)) {
+		const value = values?.[key];
+		if (value === void 0 || value === null) problems.push(`missing parameter "${key}"`);
+		else if (type.endsWith("[]") !== Array.isArray(value)) problems.push(`parameter "${key}" must be ${type.endsWith("[]") ? "an array" : "a single value"}`);
+	}
+	return problems;
+}
+/**
+* The specs with every placeholder replaced by its value; `auth.uid` takes the
+* `sub` claim, which must be verified. `noCaller` is set when the set reads
+* `auth.uid` and there is no `sub`: the specs then match no user, and only the
+* function, which reads `auth.uid()` itself, can run the set.
+*/
+function bindParams(set, values, context) {
+	const sub = context.claims?.["sub"];
+	const uid = typeof sub === "string" && sub !== "" ? sub : null;
+	const valueOf = (placeholder) => placeholder.kind === "auth" ? uid : values?.[placeholder.name];
+	const bind = (value) => {
+		const placeholder = placeholderOf(value);
+		if (placeholder) {
+			const bound = valueOf(placeholder);
+			return placeholder.kind === "auth" && placeholder.array ? [bound] : bound;
+		}
+		if (typeof value === "string") {
+			if (!hasPlaceholder(value)) return value;
+			return splitPlaceholders(value).map((part) => "text" in part ? part.text : String(valueOf(part) ?? "")).join("");
+		}
+		if (Array.isArray(value)) return value.map(bind);
+		if (typeof value === "object" && value !== null) {
+			if (Object.getPrototypeOf(value) !== Object.prototype) return value;
+			return Object.fromEntries(Object.entries(value).map(([key, entry]) => [key, bind(entry)]));
+		}
+		return value;
+	};
+	return {
+		specs: Object.fromEntries(Object.entries(set.specs).map(([key, spec]) => [key, {
+			...spec,
+			args: spec.args.map(bind)
+		}])),
+		noCaller: uid === null && readSetUsesAuth(set) ? dbError("invalid_request", `db.$many(${set.name}): the read set reads auth.uid, but this connection has no user claims. Connect with the user's verified claims ({ claims: { sub } }), or call it over PostgREST, where the function reads auth.uid().`) : void 0
+	};
+}
+/** App keys of every table the set reads. */
+function readSetTables(set, meta) {
+	const schema = meta ?? set.definition.meta;
+	return [...new Set(Object.values(set.specs).flatMap((spec) => specTables(schema, spec)))];
+}
+//#endregion
+export { hasPlaceholder as a, readSetTables as c, defineReadSet as i, splitPlaceholders as l, checkParams as n, isReadSet as o, containsPlaceholder as r, placeholderOf as s, bindParams as t };

package/dist/realtime/index.d.ts

@@ -1,8 +1,8 @@
-import { A as AccessPolicySql, j as AccessTopicPolicy } from "../executor-CPyrQdjh.js";
+import { D as AccessTopicPolicy, E as AccessPolicySql } from "../types-DFdg_4yN.js";
+import { $ as TemplateValues, Q as TemplateParams } from "../bucket-CiNi8sIw.js";
 import { t as RealtimeStatus } from "../realtime-status-BhNkb-Ow.js";
-import { $ as TemplateValues, Q as TemplateParams } from "../bucket-TkB7_xv8.js";
-import { A as TriggerTopic, C as TopicSubscription, D as TriggerLookup, E as TopicTriggerValue, F as FanOutResult, I as TopicFanOutOptions, M as defineTopic, N as rowChange, O as TriggerOptions, P as rowKeys, S as TopicSubscribeOptions, T as TopicTriggerOptions, _ as TopicMessage, a as PresenceOutput, b as TopicPermission, c as RealtimeClient, d as SubscribeOptions, f as Subscription, g as TopicHandlers, h as TopicEvent, i as PresenceOptions, j as TriggerValue, k as TriggerPayloadMode, l as RowChange, m as Topic, n as PresenceInput, o as PresenceSchema, p as SubscriptionStatus, r as PresenceMember, s as PresenceSubscription, t as EventSchemas, u as RowKeys, v as TopicOptions, w as TopicTriggerLookup, x as TopicSqlOptions, y as TopicPayload } from "../topic-D9j8G2dw.js";
-import { a as watchTopic, i as topicPort, n as TopicPort, r as TopicWatch, t as TopicHandle } from "../watch-topic-CIT3UlAh.js";
-import { a as LiveSource, c as liveQuery, d as SubjectPresenceTopic, f as SubjectPresenceValues, h as subjectPresenceValues, i as LiveQueryOptions, l as liveTopic, m as subjectPresenceTopic, n as LiveCountOptions, o as LiveSubscription, p as subjectPresence, r as LiveCountSeed, s as liveCount, t as CountRunner, u as SUBJECT_PRESENCE_TEMPLATE } from "../index-eTY4kJzo.js";
-import { n as subjectReaders, t as SubjectReadersOptions } from "../subject-readers-DEZ45DQF.js";
-export { type AccessPolicySql, type AccessTopicPolicy, type CountRunner, type EventSchemas, type FanOutResult, type LiveCountOptions, type LiveCountSeed, type LiveQueryOptions, type LiveSource, type LiveSubscription, type PresenceInput, type PresenceMember, type PresenceOptions, type PresenceOutput, type PresenceSchema, type PresenceSubscription, type RealtimeClient, type RealtimeStatus, type RowChange, type RowKeys, SUBJECT_PRESENCE_TEMPLATE, type SubjectPresenceTopic, type SubjectPresenceValues, type SubjectReadersOptions, type SubscribeOptions, type Subscription, type SubscriptionStatus, type TemplateParams, type TemplateValues, type Topic, type TopicEvent, type TopicFanOutOptions, type TopicHandle, type TopicHandlers, type TopicMessage, type TopicOptions, type TopicPayload, type TopicPermission, type TopicPort, type TopicSqlOptions, type TopicSubscribeOptions, type TopicSubscription, type TopicTriggerLookup, type TopicTriggerOptions, type TopicTriggerValue, type TopicWatch, type TriggerLookup, type TriggerOptions, type TriggerPayloadMode, type TriggerTopic, type TriggerValue, defineTopic, liveCount, liveQuery, liveTopic, rowChange, rowKeys, subjectPresence, subjectPresenceTopic, subjectPresenceValues, subjectReaders, topicPort, watchTopic };
+import { A as TriggerTopic, C as TopicSubscription, D as TriggerLookup, E as TopicTriggerValue, F as FanOutResult, I as TopicFanOutOptions, M as defineTopic, N as rowChange, O as TriggerOptions, P as rowKeys, S as TopicSubscribeOptions, T as TopicTriggerOptions, _ as TopicMessage, a as PresenceOutput, b as TopicPermission, c as RealtimeClient, d as SubscribeOptions, f as Subscription, g as TopicHandlers, h as TopicEvent, i as PresenceOptions, j as TriggerValue, k as TriggerPayloadMode, l as RowChange, m as Topic, n as PresenceInput, o as PresenceSchema, p as SubscriptionStatus, r as PresenceMember, s as PresenceSubscription, t as EventSchemas, u as RowKeys, v as TopicOptions, w as TopicTriggerLookup, x as TopicSqlOptions, y as TopicPayload } from "../topic-CJrQZQaa.js";
+import { a as watchTopic, i as topicPort, n as TopicPort, r as TopicWatch, t as TopicHandle } from "../watch-topic-BcGfvZOE.js";
+import { _ as subjectPresenceValues, a as LiveSource, c as liveCount, d as realtimeChanges, f as SUBJECT_PRESENCE_TEMPLATE, g as subjectPresenceTopic, h as subjectPresence, i as LiveQueryOptions, l as liveQuery, m as SubjectPresenceValues, n as LiveCountOptions, o as LiveSubscription, p as SubjectPresenceTopic, r as LiveCountSeed, s as RealtimeChangesOptions, t as CountRunner, u as liveTopic } from "../index-B938YqY-.js";
+import { n as subjectReaders, t as SubjectReadersOptions } from "../subject-readers-BNSzkqw_.js";
+export { type AccessPolicySql, type AccessTopicPolicy, type CountRunner, type EventSchemas, type FanOutResult, type LiveCountOptions, type LiveCountSeed, type LiveQueryOptions, type LiveSource, type LiveSubscription, type PresenceInput, type PresenceMember, type PresenceOptions, type PresenceOutput, type PresenceSchema, type PresenceSubscription, type RealtimeChangesOptions, type RealtimeClient, type RealtimeStatus, type RowChange, type RowKeys, SUBJECT_PRESENCE_TEMPLATE, type SubjectPresenceTopic, type SubjectPresenceValues, type SubjectReadersOptions, type SubscribeOptions, type Subscription, type SubscriptionStatus, type TemplateParams, type TemplateValues, type Topic, type TopicEvent, type TopicFanOutOptions, type TopicHandle, type TopicHandlers, type TopicMessage, type TopicOptions, type TopicPayload, type TopicPermission, type TopicPort, type TopicSqlOptions, type TopicSubscribeOptions, type TopicSubscription, type TopicTriggerLookup, type TopicTriggerOptions, type TopicTriggerValue, type TopicWatch, type TriggerLookup, type TriggerOptions, type TriggerPayloadMode, type TriggerTopic, type TriggerValue, defineTopic, liveCount, liveQuery, liveTopic, realtimeChanges, rowChange, rowKeys, subjectPresence, subjectPresenceTopic, subjectPresenceValues, subjectReaders, topicPort, watchTopic };

package/dist/realtime/index.js

@@ -1,7 +1,7 @@
-import { n as liveQuery, r as liveTopic, t as liveCount } from "../live-CZtRMh62.js";
+import { i as realtimeChanges, n as liveQuery, r as liveTopic, t as liveCount } from "../live-C21DgbsD.js";
 import { n as watchTopic, t as topicPort } from "../watch-topic-CuaWfCuv.js";
-import { t as subjectReaders } from "../subject-readers-CsTpx44c.js";
-import { n as rowChange, r as rowKeys, t as defineTopic } from "../topic-CPOmMgkf.js";
+import { t as subjectReaders } from "../subject-readers-B-pQ9Mmo.js";
+import { n as rowChange, r as rowKeys, t as defineTopic } from "../topic-ikV_pLTX.js";
 //#region src/realtime/subject-presence.ts
 /** The presence topic template; the subjects module's policies authorize it. */
 const SUBJECT_PRESENCE_TEMPLATE = "presence:{subjectType}:{subjectId}";
@@ -34,4 +34,4 @@ function subjectPresenceValues(subject) {
 	} : null;
 }
 //#endregion
-export { SUBJECT_PRESENCE_TEMPLATE, defineTopic, liveCount, liveQuery, liveTopic, rowChange, rowKeys, subjectPresence, subjectPresenceTopic, subjectPresenceValues, subjectReaders, topicPort, watchTopic };
+export { SUBJECT_PRESENCE_TEMPLATE, defineTopic, liveCount, liveQuery, liveTopic, realtimeChanges, rowChange, rowKeys, subjectPresence, subjectPresenceTopic, subjectPresenceValues, subjectReaders, topicPort, watchTopic };

package/dist/record-bindings-DkBJpC5A.js

@@ -0,0 +1,26 @@
+import { n as entitySchema } from "./entity-schema-BDv6w-OQ.js";
+//#region src/blocks/record-bindings.ts
+/** Describes a binding of a block's record page (`apiVersion: 1`). */
+function defineRecordBinding(definition) {
+	return {
+		...definition,
+		apiVersion: 1,
+		events: definition.events ?? [],
+		writes: definition.writes ?? {}
+	};
+}
+/** Describes one write of a binding, typed by its client and input. */
+function recordBindingWrite(write) {
+	return write;
+}
+/** The input schema of a write on one row, such as removing a comment. */
+const recordRowInput = entitySchema({
+	title: "RecordRowInput",
+	fields: { id: { kind: "uuid" } }
+});
+/** Whether a block event type matches a binding's `events` entry. */
+function recordEventMatches(pattern, type) {
+	return pattern.endsWith("*") ? type.startsWith(pattern.slice(0, -1)) : pattern === type;
+}
+//#endregion
+export { recordRowInput as i, recordBindingWrite as n, recordEventMatches as r, defineRecordBinding as t };

package/dist/record-form-BYs9xv_N.d.ts

@@ -0,0 +1,82 @@
+import { Sn as EntitySchema } from "./define-block-BVcLQ3DF.js";
+import { s as FormFieldType } from "./form-definition-BjEtH8BT.js";
+//#region src/records/record-form.d.ts
+/** The input a field renders: a forms block field type, or a date and time. */
+type RecordFormInput = FormFieldType | "datetime";
+/** One field of an entity form, in render order. */
+interface RecordFormField {
+  /** The input key, or the custom field key. */
+  readonly key: string;
+  readonly label: string;
+  readonly input: RecordFormInput;
+  readonly required: boolean;
+  /** `entity` for the block's input, `custom` for the tenant's custom fields. */
+  readonly source: "entity" | "custom";
+  readonly description?: string;
+  /** The values an `option` or `multi` field offers. */
+  readonly options?: readonly string[];
+  readonly minimum?: number;
+  readonly maximum?: number;
+  readonly minLength?: number;
+  readonly maxLength?: number;
+  /** A custom field marked sensitive. */
+  readonly sensitive?: boolean;
+}
+/** A custom field definition; `customFields.listDefinitions(entity)` fits. */
+interface RecordFormCustomField {
+  readonly key: string;
+  readonly label: string;
+  readonly type: string;
+  readonly required: boolean;
+  readonly sensitive?: boolean;
+}
+/** What a submitted form splits into: the block input and the custom values. */
+interface RecordFormValues<T> {
+  readonly input: T;
+  readonly custom: Readonly<Record<string, unknown>>;
+}
+type RecordFormResult<T> = ({
+  readonly ok: true;
+} & RecordFormValues<T>) | {
+  readonly ok: false;
+  /** One message per field key; `""` for an issue not on one field. */
+  readonly errors: Readonly<Record<string, string>>;
+};
+interface RecordForm<T> {
+  readonly fields: readonly RecordFormField[];
+  /** Checks the values with the entity schema and the custom fields' `required`. */
+  validate(values: Readonly<Record<string, unknown>>): Promise<RecordFormResult<T>>;
+}
+interface RecordFormOptions<T> {
+  /**
+   * The input keys to show, in order. Default: every key the schema accepts,
+   * except read-only ones.
+   */
+  readonly fields?: readonly (keyof T & string)[];
+  /** Labels by key. Default: the key in words (`dueAt` is `Due at`). */
+  readonly labels?: Readonly<Partial<Record<string, string>>>;
+  /** The tenant's custom fields for the entity, shown after the input fields. */
+  readonly customFields?: readonly RecordFormCustomField[];
+  /**
+   * The zone a `datetime-local` value is read in for an instant field. Default:
+   * `UTC`.
+   */
+  readonly timeZone?: string;
+}
+/**
+ * The fields of a form for one of a block's entities, from its input schema
+ * (`block.schemas.<entity>.input`) and the tenant's custom fields. `validate`
+ * runs the schema, so the form accepts what the block's `create` accepts.
+ *
+ * ```ts
+ * const form = recordForm(tasksBlock.schemas.work_item.input, {
+ *   fields: ["title", "body", "priority", "dueAt"],
+ *   customFields: await customFields
+ *     .listDefinitions("work_item")
+ *     .orThrow(),
+ * });
+ * ```
+ */
+declare function recordForm<T>(schema: EntitySchema<T>, options?: RecordFormOptions<T>): RecordForm<T>;
+//#endregion
+export { RecordFormOptions as a, recordForm as c, RecordFormInput as i, RecordFormCustomField as n, RecordFormResult as o, RecordFormField as r, RecordFormValues as s, RecordForm as t };

package/dist/record-type-DRbnlj5q.js

@@ -0,0 +1,221 @@
+import { n as dbError } from "./errors-BVFgt8BZ.js";
+import { t as AsyncResult } from "./result-ntFBW2p2.js";
+import { t as can } from "./permissions-controller-BMsqIE5T.js";
+//#region src/records/bindings.ts
+/** The block key, module and binding a binding name refers to. */
+function findBinding(blocks, name) {
+	const binding = blocks[name]?.record;
+	return binding === void 0 ? void 0 : {
+		key: name,
+		module: binding.module ?? blocks[name]?.sql[0] ?? name,
+		binding
+	};
+}
+function clientOf(clients, key) {
+	return clients[key];
+}
+function missing(name, detail) {
+	return dbError("invalid_request", `Record binding "${name}" ${detail}`);
+}
+/**
+* A `can` for `loadBindings` from the caller's `PermissionSet` and the
+* `permissions` constant of `blocks.generated.ts`: a binding needs the key its
+* module's action names there. An action with no key there is allowed, and RLS
+* decides.
+*/
+function bindingCan(set, permissions) {
+	return ({ module, action }) => {
+		const key = permissions[module]?.[action];
+		return key === void 0 || can(set, key);
+	};
+}
+/**
+* Loads a record's bindings in parallel, each one settled: `ok` with its rows,
+* `error` with a `DbError`, or `hidden` when `can` says the caller can't read
+* it, which never runs its query. It never throws.
+*
+* ```ts
+* const { comments, tags } = await loadBindings(
+*   { blocks: blockSet.blocks, clients: blocks },
+*   { type: "customer", id },
+*   ["comments", "tags"],
+*   { can: bindingCan(permissionSet, permissions) },
+* );
+* ```
+*/
+async function loadBindings(source, subject, names, options = {}) {
+	const settled = await Promise.all(names.map(async (name) => {
+		const found = findBinding(source.blocks, name);
+		if (found === void 0) return [name, {
+			kind: "error",
+			error: missing(name, "is in no block")
+		}];
+		if (!(options.can?.({
+			binding: name,
+			module: found.module,
+			action: found.binding.permissions.read
+		}) ?? true)) return [name, { kind: "hidden" }];
+		const client = clientOf(source.clients, found.key);
+		if (client === void 0) return [name, {
+			kind: "error",
+			error: missing(name, `needs the "${found.key}" block built`)
+		}];
+		const load = found.binding.load;
+		const given = options.options?.[name];
+		const result = await load(client, subject, given);
+		return [name, result.ok ? {
+			kind: "ok",
+			data: result.data
+		} : {
+			kind: "error",
+			error: result.error
+		}];
+	}));
+	return Object.fromEntries(settled);
+}
+/**
+* How many rows a binding has for each of `subjects`, keyed by `subjectKey`
+* (`type:id`), for a badge on each row of a list. A binding without `count`
+* fails with `unsupported`.
+*/
+function countBinding(source, name, subjects) {
+	const found = findBinding(source.blocks, name);
+	const client = found && clientOf(source.clients, found.key);
+	if (found?.binding.count === void 0 || client === void 0) return AsyncResult.err(dbError("unsupported", `Record binding "${name}" can't count rows`));
+	const count = found.binding.count;
+	return count(client, subjects);
+}
+//#endregion
+//#region src/records/record-type.ts
+/** Describes one subject's record page from the blocks that own its bindings. */
+function defineRecordType(spec) {
+	const bindings = Object.entries(spec.blocks).flatMap(([key, block]) => block.record === void 0 ? [] : [key]);
+	return {
+		...spec,
+		bindings
+	};
+}
+/** The record a record type's page shows. */
+function recordSubject(feature, id) {
+	return {
+		type: feature.type,
+		id
+	};
+}
+/** The block key, module and write that `binding.write` names. */
+function findBindingWrite(feature, binding, write) {
+	const found = findBinding(feature.blocks, binding);
+	const entry = found?.binding.writes?.[write];
+	return found === void 0 || entry === void 0 ? void 0 : {
+		key: found.key,
+		module: found.module,
+		write: entry,
+		permission: entry.permission ?? found.binding.permissions.write
+	};
+}
+function keyOf(feature, module, action) {
+	return action === void 0 ? void 0 : feature.permissions?.[module]?.[action];
+}
+/**
+* The permission keys a record type's bindings check, for one
+* `access.permissions(keys)` call.
+*/
+function recordPermissionKeys(feature) {
+	const keys = /* @__PURE__ */ new Set();
+	for (const name of feature.bindings) {
+		const found = findBinding(feature.blocks, name);
+		if (found === void 0) continue;
+		const { permissions, writes = {} } = found.binding;
+		const actions = [permissions.read, ...Object.values(writes).map((write) => write.permission ?? permissions.write)];
+		for (const action of actions) {
+			const key = keyOf(feature, found.module, action);
+			if (key !== void 0) keys.add(key);
+		}
+	}
+	return [...keys];
+}
+/**
+* What the caller may do on each of a record type's bindings, from its
+* `PermissionSet`. A binding action with no key in `permissions` is allowed,
+* and so is everything when `set` is `undefined` (no access block): RLS and
+* each function's checks decide.
+*/
+function recordCan(feature, set) {
+	const allowed = (module, action) => {
+		if (set === void 0) return true;
+		const key = keyOf(feature, module, action);
+		return key === void 0 || can(set, key);
+	};
+	return Object.fromEntries(feature.bindings.flatMap((name) => {
+		const found = findBinding(feature.blocks, name);
+		if (found === void 0) return [];
+		const { permissions, writes = {} } = found.binding;
+		return [[name, {
+			read: allowed(found.module, permissions.read),
+			...Object.fromEntries(Object.entries(writes).map(([write, entry]) => [write, allowed(found.module, entry.permission ?? permissions.write)]))
+		}]];
+	}));
+}
+/** The write names of each of a record type's bindings. */
+function bindingWrites(feature) {
+	return feature.bindings.map((binding) => [binding, Object.keys(findBinding(feature.blocks, binding)?.binding.writes ?? {})]);
+}
+/**
+* Runs `binding.write` with the client its block's creator made, which
+* `clients` holds under the block's key.
+*/
+function runBindingWrite(feature, clients, binding, write, subject, input) {
+	const found = findBindingWrite(feature, binding, write);
+	const client = clients[found?.key ?? ""];
+	if (found === void 0 || client === void 0) return AsyncResult.err(dbError("invalid_request", `Record binding "${binding}" has no write "${write}" with its block built`));
+	const run = found.write.run;
+	return run(client, subject, input);
+}
+function isObject(value) {
+	return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+/**
+* A Standard Schema for `{ id, input }`: a non-empty record id and the input
+* `schema` validates, whose issues get the `input` path.
+*/
+function recordWriteInput(schema) {
+	const check = (inner, id) => inner.issues === void 0 ? { value: {
+		id,
+		input: inner.value
+	} } : { issues: inner.issues.map((issue) => ({
+		...issue,
+		path: ["input", ...issue.path ?? []]
+	})) };
+	return { "~standard": {
+		version: 1,
+		vendor: "better-supabase",
+		validate: (value) => {
+			if (!isObject(value)) return { issues: [{ message: "Expected an object" }] };
+			const { id, input } = value;
+			if (typeof id !== "string" || id === "") return { issues: [{
+				message: "Expected a record id",
+				path: ["id"]
+			}] };
+			const inner = schema["~standard"].validate(input ?? {});
+			return inner instanceof Promise ? inner.then((settled) => check(settled, id)) : check(inner, id);
+		}
+	} };
+}
+function isTemporal(value) {
+	return Object.prototype.toString.call(value).startsWith("[object Temporal.");
+}
+/**
+* `value` with every Temporal value replaced by its ISO 8601 string, for data
+* passed from a Server Component or returned from a Server Action.
+*/
+function plainData(value) {
+	const walk = (entry) => {
+		if (typeof entry !== "object" || entry === null) return entry;
+		if (isTemporal(entry)) return entry.toString();
+		if (Array.isArray(entry)) return entry.map(walk);
+		return Object.fromEntries(Object.entries(entry).map(([key, field]) => [key, walk(field)]));
+	};
+	return walk(value);
+}
+//#endregion
+export { recordCan as a, recordWriteInput as c, countBinding as d, findBinding as f, plainData as i, runBindingWrite as l, defineRecordType as n, recordPermissionKeys as o, loadBindings as p, findBindingWrite as r, recordSubject as s, bindingWrites as t, bindingCan as u };