better-supabase 0.9.0 → 0.11.0

package/dist/blocks/vercel-marketplace/index.d.ts

@@ -0,0 +1,193 @@
+/// <reference lib="esnext.temporal" />
+import { T as ErrorMapper, t as AsyncResult } from "../../result-BREt7qOh.js";
+import { wt as Events } from "../../events-P3raDX2E.js";
+import { n as Logger } from "../../logger-DWVYUmwi.js";
+import { s as sqlTransport, t as BlockTransport } from "../../block-transport-DezJPPA0.js";
+import { r as BlockTemporalOptions } from "../../block-helpers-CjcQM1yA.js";
+import { n as BlockHooks } from "../../block-hooks-DcPJHztl.js";
+import { s as BlockOf } from "../../define-block-CPyJ95rq.js";
+import { n as Jwks } from "../../jws-35a8VhFV.js";
+//#region src/blocks/vercel-marketplace/vercel-marketplace.d.ts
+/** An installation of the integration by a Vercel team. */
+interface MarketplaceInstallation {
+  readonly id: string;
+  readonly configurationId: string;
+  readonly teamId: string | undefined;
+  readonly userId: string | undefined;
+  /** The app's own tenant for this installation, once the app linked one. */
+  readonly tenant: string | undefined;
+  readonly status: "active" | "suspended" | "removed";
+  readonly metadata: Readonly<Record<string, unknown>>;
+}
+interface MarketplaceResource {
+  readonly id: string;
+  readonly installationId: string;
+  /** The resource id Vercel uses. */
+  readonly externalId: string;
+  readonly name: string;
+  readonly planId: string | undefined;
+  readonly status: "pending" | "ready" | "suspended" | "deleted";
+  readonly metadata: Readonly<Record<string, unknown>>;
+}
+interface MarketplaceInvoice {
+  readonly id: string;
+  readonly installationId: string;
+  readonly externalId: string;
+  readonly state: string;
+  readonly total: number;
+  readonly currency: string;
+}
+interface MeterReport {
+  readonly id: string;
+  readonly installationId: string;
+  readonly resourceExternalId: string;
+  readonly meterId: string;
+  readonly quantity: number;
+  readonly reported: boolean;
+}
+/** What a verified Vercel webhook did. */
+interface MarketplaceWebhookResult {
+  readonly type: string;
+  /** `false` for an event type the block ignores. */
+  readonly handled: boolean;
+}
+/** The claims of the `id_token` Vercel returns from the SSO exchange. */
+interface MarketplaceSsoClaims {
+  readonly configurationId: string;
+  readonly teamId: string | undefined;
+  readonly userId: string | undefined;
+  readonly userEmail: string | undefined;
+  readonly resourceId: string | undefined;
+  readonly path: string | undefined;
+  readonly claims: Readonly<Record<string, unknown>>;
+}
+interface VercelMarketplaceOptions extends BlockTemporalOptions {
+  /** A service-role transport: every function is granted to `service_role` only. */
+  readonly transport: BlockTransport;
+  /** The integration's client secret: signs webhooks and authenticates the SSO exchange. */
+  readonly clientSecret: string;
+  /** The integration's client id, for the SSO exchange and the `aud` claim. */
+  readonly clientId: string;
+  /**
+   * A bearer token for the Marketplace API on behalf of an installation, for
+   * invoices and usage. Vercel hands it out at installation; the app stores it.
+   */
+  readonly accessToken?: (configurationId: string) => Promise<string>;
+  readonly schema?: string;
+  readonly mappers?: readonly ErrorMapper[];
+  /** `withBlockHooks` hooks around the client's methods, such as a check before a resource is provisioned. */
+  readonly hooks?: BlockHooks<VercelMarketplace>;
+  /** Receives the errors `after` hooks throw. Default: `console`. */
+  readonly logger?: Logger;
+  readonly fetch?: typeof fetch;
+  /** Default `https://api.vercel.com`. */
+  readonly apiUrl?: string;
+  /** Keys for the SSO `id_token`. Default: Vercel's published JWKS. */
+  readonly jwks?: Jwks | URL | (() => Promise<Jwks>);
+}
+interface InvoiceItem {
+  readonly billingPlanId: string;
+  readonly resourceId?: string;
+  readonly name: string;
+  readonly details?: string;
+  /** Minor-unit-free decimal, as Vercel takes it: a string such as `"0.50"`. */
+  readonly price: string;
+  readonly quantity: number;
+  readonly units: string;
+  readonly total: string;
+}
+interface SubmitInvoiceInput {
+  readonly configurationId: string;
+  readonly invoiceDate: Temporal.Instant;
+  readonly periodStart: Temporal.Instant;
+  readonly periodEnd: Temporal.Instant;
+  readonly items: readonly InvoiceItem[];
+  /** Marks the invoice as a test for Vercel's review. */
+  readonly test?: boolean;
+}
+interface ReportUsageInput {
+  readonly configurationId: string;
+  readonly periodStart: Temporal.Instant;
+  readonly periodEnd: Temporal.Instant;
+  readonly meters: readonly {
+    readonly meterId: string;
+    readonly quantity: number;
+    /** The Vercel resource the quantity belongs to; omit for the installation. */
+    readonly resourceId?: string;
+  }[];
+}
+interface VercelMarketplace {
+  /** Whether `signature` is the HMAC-SHA1 of the raw body under the client secret. */
+  verifyWebhook(body: string, signature: string | null): Promise<boolean>;
+  /** Verifies a webhook request and applies it: removals and invoice states. */
+  handleWebhook(request: Request): AsyncResult<MarketplaceWebhookResult>;
+  /** Exchanges the SSO `code`, verifies the `id_token` and keeps the installation current. */
+  exchangeSso(input: {
+    readonly code: string;
+    readonly state?: string;
+  }): AsyncResult<MarketplaceSsoClaims>;
+  installation(configurationId: string): AsyncResult<MarketplaceInstallation | undefined>;
+  /** Records an installation, for the provider's install callback. */
+  upsertInstallation(input: {
+    readonly configurationId: string;
+    readonly teamId?: string;
+    readonly userId?: string;
+    readonly tenant?: string;
+    readonly metadata?: Readonly<Record<string, unknown>>;
+  }): AsyncResult<MarketplaceInstallation>;
+  upsertPlan(input: {
+    readonly id: string;
+    readonly name: string;
+    readonly kind?: "subscription" | "prepayment";
+    readonly details?: Readonly<Record<string, unknown>>;
+  }): AsyncResult<void>;
+  /** Provisions or updates a resource, for the provider's resource endpoints. */
+  upsertResource(input: {
+    readonly configurationId: string;
+    readonly externalId: string;
+    readonly name: string;
+    readonly planId?: string;
+    readonly status?: MarketplaceResource["status"];
+    readonly metadata?: Readonly<Record<string, unknown>>;
+  }): AsyncResult<MarketplaceResource>;
+  /** Sends an invoice to Vercel for the period. */
+  submitInvoice(input: SubmitInvoiceInput): AsyncResult<{
+    readonly id: string;
+  }>;
+  /**
+   * Stores the quantities, then sends the ones Vercel has not accepted yet.
+   * A failed send leaves them stored, so the next call retries them.
+   */
+  reportUsage(input: ReportUsageInput): AsyncResult<readonly MeterReport[]>;
+}
+/** Vercel Marketplace provider state, webhooks, SSO and billing. */
+export declare function createVercelMarketplace(options: VercelMarketplaceOptions): VercelMarketplace;
+//#endregion
+//#region src/blocks/vercel-marketplace/events.d.ts
+/** `marketplace_installation.*`: the Vercel team's installation of the integration. */
+interface MarketplaceInstallationEventData {
+  readonly installationId: string;
+  readonly configurationId: string;
+  readonly teamId: string | null;
+}
+/** `marketplace_invoice.state_changed`: Vercel moved an invoice to a new state. */
+interface MarketplaceInvoiceEventData {
+  readonly installationId: string;
+  readonly invoiceId: string;
+  readonly externalId: string;
+  readonly state: string;
+}
+/** The events of the `vercel-marketplace` block: type to data. */
+type VercelMarketplaceEvents = {
+  readonly "marketplace_installation.upserted": MarketplaceInstallationEventData;
+  readonly "marketplace_installation.removed": MarketplaceInstallationEventData;
+  readonly "marketplace_invoice.state_changed": MarketplaceInvoiceEventData;
+};
+/** The `vercel-marketplace` block's event types, for its manifest and `onBlockEvent`. */
+export declare const vercelMarketplaceEvents: Events<VercelMarketplaceEvents>;
+//#endregion
+//#region src/blocks/vercel-marketplace/manifest.d.ts
+/** The `vercel-marketplace` block's manifest (ADR 0029). */
+export declare const vercelMarketplaceBlock: BlockOf<"vercel-marketplace", typeof createVercelMarketplace, VercelMarketplaceEvents>;
+//#endregion
+export { type BlockTransport, type InvoiceItem, type MarketplaceInstallation, type MarketplaceInstallationEventData, type MarketplaceInvoice, type MarketplaceInvoiceEventData, type MarketplaceResource, type MarketplaceSsoClaims, type MarketplaceWebhookResult, type MeterReport, type ReportUsageInput, type SubmitInvoiceInput, type VercelMarketplace, type VercelMarketplaceEvents, type VercelMarketplaceOptions, sqlTransport };

package/dist/blocks/vercel-marketplace/index.js

@@ -0,0 +1,300 @@
+import { n as dbError } from "../../errors-BV1SKTVs.js";
+import { a as ok, r as err, t as AsyncResult } from "../../result-DIeYscA3.js";
+import { n as isRecord } from "../../guards-6F2bCtQR.js";
+import { t as vercelMarketplaceSqlOptions } from "../../options-RKYdmIdV.js";
+import { n as event, t as defineEvents } from "../../event-map-Dy2vKHai.js";
+import { r as timingSafeEqual } from "../../hmac-BgpThYQW.js";
+import { i as sqlTransport } from "../../block-transport-J7ZepTq2.js";
+import { C as optionalText, D as recordOf, I as textOf, f as errorText, k as recordsOf, n as applyTemporal, o as blockCall } from "../../block-helpers-DkVZNDrj.js";
+import { c as verifyCompact, t as JwsError } from "../../jws-CwBB5QAT.js";
+import { t as jwksSource } from "../../jwks-cache-C4rA69hD.js";
+import { r as withBlockHooks } from "../../block-hooks-C22vuIUd.js";
+import { n as defineBlock } from "../../define-block-B6Gjs57G.js";
+//#region src/blocks/vercel-marketplace/vercel-marketplace.ts
+const API = "https://api.vercel.com";
+const JWKS = "https://marketplace.vercel.com/.well-known/jwks.json";
+const ISSUER = "https://marketplace.vercel.com";
+const SIGNATURE_HEADER = "x-vercel-signature";
+const encoder = new TextEncoder();
+function installationOf(value) {
+	const row = recordOf(value, "marketplace_installations");
+	const status = row["status"];
+	return {
+		id: textOf(row["id"]),
+		configurationId: textOf(row["configuration_id"]),
+		teamId: optionalText(row["team_id"]),
+		userId: optionalText(row["user_id"]),
+		tenant: optionalText(row["tenant"]),
+		status: status === "suspended" || status === "removed" ? status : "active",
+		metadata: isRecord(row["metadata"]) ? row["metadata"] : {}
+	};
+}
+function resourceOf(value) {
+	const row = recordOf(value, "marketplace_resources");
+	const status = row["status"];
+	return {
+		id: textOf(row["id"]),
+		installationId: textOf(row["installation_id"]),
+		externalId: textOf(row["external_id"]),
+		name: textOf(row["name"]),
+		planId: optionalText(row["plan_id"]),
+		status: status === "pending" || status === "suspended" || status === "deleted" ? status : "ready",
+		metadata: isRecord(row["metadata"]) ? row["metadata"] : {}
+	};
+}
+function meterReportOf(value) {
+	const row = recordOf(value, "marketplace_meter_reports");
+	return {
+		id: textOf(row["id"]),
+		installationId: textOf(row["installation_id"]),
+		resourceExternalId: textOf(row["resource_external_id"]),
+		meterId: textOf(row["meter_id"]),
+		quantity: Number(row["quantity"]),
+		reported: row["reported_at"] !== null && row["reported_at"] !== void 0
+	};
+}
+async function sha1Hex(secret, body) {
+	const key = await crypto.subtle.importKey("raw", encoder.encode(secret), {
+		name: "HMAC",
+		hash: "SHA-1"
+	}, false, ["sign"]);
+	const signed = await crypto.subtle.sign("HMAC", key, encoder.encode(body));
+	return Array.from(new Uint8Array(signed), (byte) => byte.toString(16).padStart(2, "0")).join("");
+}
+function invalid(message, hint) {
+	return err(dbError("invalid_request", message, { hint }));
+}
+/** A string field of a JSON object, or `undefined`. */
+function field(value, name) {
+	return isRecord(value) ? optionalText(value[name]) : void 0;
+}
+/** The payload object of a Vercel webhook, whose fields sit under `payload`. */
+function payloadOf(body) {
+	return isRecord(body["payload"]) ? body["payload"] : {};
+}
+/** Vercel Marketplace provider state, webhooks, SSO and billing. */
+function createVercelMarketplace(options) {
+	applyTemporal(options);
+	const call = blockCall(options.transport, options.schema, options.mappers);
+	const http = options.fetch ?? fetch;
+	const base = options.apiUrl ?? API;
+	const keys = jwksSource(options.jwks ?? new URL(JWKS), { rsa: true });
+	const verifyWebhook = async (body, signature) => signature !== null && timingSafeEqual(await sha1Hex(options.clientSecret, body), signature.trim().toLowerCase());
+	const send = async (configurationId, path, payload) => {
+		if (options.accessToken === void 0) return invalid("Pass accessToken to talk to the Marketplace API", "MARKETPLACE_NO_TOKEN");
+		try {
+			const token = await options.accessToken(configurationId);
+			const response = await http(`${base}/v1/installations/${encodeURIComponent(configurationId)}${path}`, {
+				method: "POST",
+				headers: {
+					authorization: `Bearer ${token}`,
+					"content-type": "application/json"
+				},
+				body: JSON.stringify(payload)
+			});
+			if (!response.ok) return err(dbError("network", `Vercel answered ${response.status} for ${path}`, { hint: "MARKETPLACE_API_FAILED" }));
+			const text = await response.text();
+			return ok(text === "" ? {} : JSON.parse(text));
+		} catch (cause) {
+			return err(dbError("network", errorText(cause)));
+		}
+	};
+	const client = {
+		verifyWebhook,
+		handleWebhook: (request) => AsyncResult.from(async () => {
+			const body = await request.text();
+			if (!await verifyWebhook(body, request.headers.get(SIGNATURE_HEADER))) return err(dbError("invalid_request", "The webhook signature does not match", { hint: "MARKETPLACE_SIGNATURE" }));
+			let event;
+			try {
+				event = JSON.parse(body);
+			} catch {
+				return invalid("The webhook body is not JSON", "MARKETPLACE_BODY");
+			}
+			if (!isRecord(event) || typeof event["type"] !== "string") return invalid("The webhook has no type", "MARKETPLACE_BODY");
+			const type = event["type"];
+			const payload = payloadOf(event);
+			const configurationId = field(payload, "installationId") ?? field(isRecord(payload["configuration"]) ? payload["configuration"] : {}, "id") ?? field(payload, "configurationId");
+			if (configurationId === void 0) return ok({
+				type,
+				handled: false
+			});
+			if (type === "integration-configuration.removed") return call("remove_marketplace_installation", { configuration_id: configurationId }, () => void 0).map(() => ({
+				type,
+				handled: true
+			}));
+			if (type.startsWith("marketplace.invoice.")) {
+				const externalId = field(payload, "invoiceId");
+				if (externalId === void 0) return invalid("The invoice event has no invoiceId", "MARKETPLACE_BODY");
+				const createdAt = event["createdAt"];
+				return call("record_marketplace_invoice", {
+					configuration_id: configurationId,
+					external_id: externalId,
+					state: type.slice(20),
+					event_at: typeof createdAt === "number" ? new Date(createdAt).toISOString() : (/* @__PURE__ */ new Date()).toISOString()
+				}, () => void 0).map(() => ({
+					type,
+					handled: true
+				}));
+			}
+			return ok({
+				type,
+				handled: false
+			});
+		}),
+		exchangeSso: ({ code, state }) => AsyncResult.from(async () => {
+			try {
+				const response = await http(`${base}/v1/integrations/sso/token`, {
+					method: "POST",
+					headers: { "content-type": "application/x-www-form-urlencoded" },
+					body: new URLSearchParams({
+						code,
+						client_id: options.clientId,
+						client_secret: options.clientSecret,
+						...state === void 0 ? {} : { state }
+					})
+				});
+				if (!response.ok) return err(dbError("network", `Vercel answered ${response.status} to the code`, { hint: "MARKETPLACE_SSO_FAILED" }));
+				const token = field(await response.json(), "id_token");
+				if (token === void 0) return invalid("Vercel returned no id_token", "MARKETPLACE_SSO_FAILED");
+				let verified = await keys(false);
+				if (!verified.ok) return err(verified.error);
+				let claims;
+				try {
+					claims = (await verifyCompact(token, verified.data, { algorithms: ["RS256"] })).payload;
+				} catch (cause) {
+					if (!(cause instanceof JwsError) || cause.code !== "JWS_KEY") throw cause;
+					verified = await keys(true);
+					if (!verified.ok) return err(verified.error);
+					claims = (await verifyCompact(token, verified.data, { algorithms: ["RS256"] })).payload;
+				}
+				const audience = claims["aud"];
+				const now = Math.floor(Date.now() / 1e3);
+				if (claims["iss"] !== ISSUER || !(audience === options.clientId || Array.isArray(audience) && audience.includes(options.clientId)) || typeof claims["exp"] !== "number" || claims["exp"] <= now) return invalid("The id_token is not for this integration or has expired", "MARKETPLACE_SSO_CLAIMS");
+				const configurationId = textOf(claims["installation_id"]);
+				if (configurationId === "") return invalid("The id_token names no installation", "MARKETPLACE_SSO_CLAIMS");
+				const teamId = optionalText(claims["account_id"]);
+				const userId = optionalText(claims["user_id"]);
+				const stored = await client.upsertInstallation({
+					configurationId,
+					...teamId === void 0 ? {} : { teamId },
+					...userId === void 0 ? {} : { userId }
+				});
+				if (!stored.ok) return err(stored.error);
+				return ok({
+					configurationId,
+					teamId,
+					userId,
+					userEmail: optionalText(claims["user_email"]),
+					resourceId: optionalText(claims["resource_id"]),
+					path: optionalText(claims["path"]),
+					claims
+				});
+			} catch (cause) {
+				return err(dbError("network", errorText(cause)));
+			}
+		}),
+		installation: (configurationId) => call("marketplace_installation", { configuration_id: configurationId }, (value) => isRecord(value) ? installationOf(value) : void 0),
+		upsertInstallation: (input) => call("upsert_marketplace_installation", {
+			configuration_id: input.configurationId,
+			team_id: input.teamId ?? null,
+			user_id: input.userId ?? null,
+			tenant: input.tenant ?? null,
+			metadata: input.metadata ?? {}
+		}, installationOf),
+		upsertPlan: (input) => call("upsert_marketplace_plan", {
+			id: input.id,
+			name: input.name,
+			kind: input.kind ?? "subscription",
+			details: input.details ?? {}
+		}, () => void 0),
+		upsertResource: (input) => call("upsert_marketplace_resource", {
+			configuration_id: input.configurationId,
+			external_id: input.externalId,
+			name: input.name,
+			plan_id: input.planId ?? null,
+			status: input.status ?? "ready",
+			metadata: input.metadata ?? {}
+		}, resourceOf),
+		submitInvoice: (input) => AsyncResult.from(async () => {
+			const sent = await send(input.configurationId, "/billing/invoices", {
+				externalId: `${input.configurationId}-${input.periodStart.toString()}`,
+				invoiceDate: input.invoiceDate.toString(),
+				period: {
+					start: input.periodStart.toString(),
+					end: input.periodEnd.toString()
+				},
+				items: input.items,
+				...input.test === void 0 ? {} : { test: input.test }
+			});
+			if (!sent.ok) return err(sent.error);
+			return ok({ id: field(sent.data, "invoiceId") ?? "" });
+		}),
+		reportUsage: (input) => AsyncResult.from(async () => {
+			const stored = [];
+			for (const meter of input.meters) {
+				const row = await call("record_marketplace_meter_report", {
+					configuration_id: input.configurationId,
+					meter_id: meter.meterId,
+					period_start: input.periodStart.toString(),
+					period_end: input.periodEnd.toString(),
+					quantity: meter.quantity,
+					resource_external_id: meter.resourceId ?? ""
+				}, meterReportOf);
+				if (!row.ok) return err(row.error);
+				stored.push(row.data);
+			}
+			const pending = await call("unreported_marketplace_meter_reports", { configuration_id: input.configurationId }, (value) => recordsOf(value, "unreported").map(meterReportOf));
+			if (!pending.ok) return err(pending.error);
+			if (pending.data.length === 0) return ok(stored);
+			const sent = await send(input.configurationId, "/billing", {
+				timestamp: input.periodEnd.toString(),
+				eod: input.periodEnd.toString(),
+				period: {
+					start: input.periodStart.toString(),
+					end: input.periodEnd.toString()
+				},
+				usage: pending.data.map((report) => ({
+					...report.resourceExternalId === "" ? {} : { resourceId: report.resourceExternalId },
+					name: report.meterId,
+					type: "total",
+					units: "count",
+					dayValue: report.quantity,
+					periodValue: report.quantity,
+					planValue: report.quantity
+				}))
+			});
+			if (!sent.ok) return err(sent.error);
+			const marked = await call("mark_marketplace_meter_reported", { ids: pending.data.map((report) => report.id) }, () => void 0);
+			if (!marked.ok) return err(marked.error);
+			return ok(stored.map((report) => ({
+				...report,
+				reported: true
+			})));
+		})
+	};
+	return withBlockHooks(client, options.hooks, {
+		block: "vercel-marketplace",
+		...options.logger ? { logger: options.logger } : {}
+	});
+}
+//#endregion
+//#region src/blocks/vercel-marketplace/events.ts
+/** The `vercel-marketplace` block's event types, for its manifest and `onBlockEvent`. */
+const vercelMarketplaceEvents = defineEvents({
+	"marketplace_installation.upserted": event(),
+	"marketplace_installation.removed": event(),
+	"marketplace_invoice.state_changed": event()
+});
+//#endregion
+//#region src/blocks/vercel-marketplace/manifest.ts
+/** The `vercel-marketplace` block's manifest (ADR 0029). */
+const vercelMarketplaceBlock = defineBlock({
+	name: "vercel-marketplace",
+	sql: ["vercel-marketplace"],
+	options: { "vercel-marketplace": vercelMarketplaceSqlOptions },
+	events: vercelMarketplaceEvents,
+	create: createVercelMarketplace,
+	category: "developer"
+});
+//#endregion
+export { createVercelMarketplace, sqlTransport, vercelMarketplaceBlock, vercelMarketplaceEvents };

package/dist/blocks/versions/index.d.ts

@@ -1,13 +1,13 @@
 /// <reference lib="esnext.temporal" />
-import { t as AsyncResult } from "../../result-Cj3yWhjH.js";
-import { A as CollaborationEventData, wt as Events } from "../../events-CTreRrgP.js";
+import { t as AsyncResult } from "../../result-BREt7qOh.js";
+import { A as CollaborationEventData, wt as Events } from "../../events-P3raDX2E.js";
 import { n as Logger } from "../../logger-DWVYUmwi.js";
-import { t as StandardSchemaV1 } from "../../standard-C3_AAF3g.js";
-import { a as dbTransport, o as rpcTransport, s as sqlTransport, t as BlockTransport } from "../../block-transport-DaGGXjIw.js";
-import { n as BlockOptions } from "../../block-helpers-C86hPEjI.js";
-import { n as BlockHooks } from "../../block-hooks-BLPWD3Jt.js";
-import { n as ExtraFields, r as FieldsOf } from "../../block-fields-5UA84ZUg.js";
-import { s as BlockOf } from "../../define-block-CLZMEFeK.js";
+import { t as StandardSchemaV1 } from "../../standard-BcUQuUgu.js";
+import { a as dbTransport, o as rpcTransport, s as sqlTransport, t as BlockTransport } from "../../block-transport-DezJPPA0.js";
+import { n as BlockOptions } from "../../block-helpers-CjcQM1yA.js";
+import { n as BlockHooks } from "../../block-hooks-DcPJHztl.js";
+import { n as ExtraFields, r as FieldsOf } from "../../block-fields-DnaDbgZS.js";
+import { s as BlockOf } from "../../define-block-CPyJ95rq.js";
 //#region src/blocks/versions/json-patch.d.ts
 /** A JSON value, as a version's content holds it. */
 type JsonValue = null | boolean | number | string | readonly JsonValue[] | {
@@ -139,13 +139,17 @@ interface Versions<F extends object = Record<never, never>> {
   getShared(token: string): AsyncResult<Version | null>;
   /** Writes the version back to its subject and records that as a new version. */
   restore(id: string): AsyncResult<RestoreResult>;
+  /**
+   * Writes only `fields` of the version back; the subject's other columns
+   * keep their current values. Needs a subject type with `columns`.
+   */
+  restoreFields(id: string, fields: readonly string[]): AsyncResult<RestoreResult>;
   /** Names a version, which keeps it; `null` removes the name. */
   label(id: string, label: string | null): AsyncResult<boolean>;
   delete(id: string): AsyncResult<boolean>;
   /** The RFC 6902 patch from version `fromId` to version `toId`. */
   diff(fromId: string, toId: string): AsyncResult<JsonPatchOperation[]>;
 }
-/** The `versions` SQL module as typed calls. */
 export declare function createVersions<S extends StandardSchemaV1 | undefined = undefined>(options: VersionsOptions<S>): Versions<FieldsOf<S>>;
 //#endregion
 //#region src/blocks/versions/events.d.ts

package/dist/blocks/versions/index.js

@@ -1,11 +1,11 @@
 import { n as isRecord } from "../../guards-6F2bCtQR.js";
+import { t as versionsSqlOptions } from "../../options-DXqcJyOP.js";
 import { n as event, t as defineEvents } from "../../event-map-Dy2vKHai.js";
-import { i as sqlTransport, r as rpcTransport, t as dbTransport } from "../../block-transport-G4t1umrR.js";
-import { A as requiredInstant, C as optionalText, D as recordOf, I as textOf, d as enumOrThrow, k as recordsOf, n as applyTemporal, o as blockCall } from "../../block-helpers-CfG_MvDR.js";
-import { r as withBlockHooks } from "../../block-hooks-BsXncUlZ.js";
-import { n as blockFields } from "../../block-fields-ffD6Gxe4.js";
+import { i as sqlTransport, r as rpcTransport, t as dbTransport } from "../../block-transport-J7ZepTq2.js";
+import { A as requiredInstant, C as optionalText, D as recordOf, I as textOf, d as enumOrThrow, k as recordsOf, n as applyTemporal, o as blockCall } from "../../block-helpers-DkVZNDrj.js";
+import { r as withBlockHooks } from "../../block-hooks-C22vuIUd.js";
+import { n as blockFields } from "../../block-fields-Bv1hV855.js";
 import { n as defineBlock } from "../../define-block-B6Gjs57G.js";
-import { t as versionsSqlOptions } from "../../options-DXqcJyOP.js";
 //#region src/blocks/versions/json-patch.ts
 /** Thrown by `applyPatch` for an operation RFC 6902 calls an error. */
 var JsonPatchError = class extends Error {
@@ -216,6 +216,14 @@ function snapshotOf(value, fn) {
 	};
 }
 /** The `versions` SQL module as typed calls. */
+function restoreOf(value) {
+	const row = recordOf(value, "restore_version");
+	return {
+		...snapshotOf(row, "restore_version"),
+		restoredFrom: Number(row["restoredFrom"]),
+		content: jsonOf(row["content"])
+	};
+}
 function createVersions(options) {
 	applyTemporal(options);
 	const call = blockCall(options.transport, options.schema, options.mappers);
@@ -240,14 +248,11 @@ function createVersions(options) {
 			before: page.before ?? null
 		}, (value) => recordsOf(value, "list_versions").map((row) => versionOf(row, "list_versions"))).andThen(fields.rows),
 		get,
-		restore: (id) => call("restore_version", { version_id: id }, (value) => {
-			const row = recordOf(value, "restore_version");
-			return {
-				...snapshotOf(row, "restore_version"),
-				restoredFrom: Number(row["restoredFrom"]),
-				content: jsonOf(row["content"])
-			};
-		}),
+		restore: (id) => call("restore_version", { version_id: id }, restoreOf),
+		restoreFields: (id, fields) => call("restore_version", {
+			version_id: id,
+			fields: [...fields]
+		}, restoreOf),
 		label: (id, label) => call("label_version", {
 			version_id: id,
 			label
@@ -277,7 +282,7 @@ const versionsBlock = defineBlock({
 	events: versionsEvents,
 	create: createVersions,
 	category: "content",
-	recipes: ["version-history"]
+	recipes: ["version-history", "record-history"]
 });
 //#endregion
 export { JsonPatchError, applyPatch, createPatch, createVersions, dbTransport, jsonEqual, rpcTransport, sqlTransport, versionsBlock, versionsEvents };

package/dist/blocks/waitlist/index.d.ts

@@ -1,14 +1,14 @@
 /// <reference lib="esnext.temporal" />
-import { t as AsyncResult } from "../../result-Cj3yWhjH.js";
-import { G as InviteCodeEventData, Z as OrganizationEventData, mt as WaitlistEventData, wt as Events } from "../../events-CTreRrgP.js";
+import { t as AsyncResult } from "../../result-BREt7qOh.js";
+import { G as InviteCodeEventData, Z as OrganizationEventData, mt as WaitlistEventData, wt as Events } from "../../events-P3raDX2E.js";
 import { n as Logger } from "../../logger-DWVYUmwi.js";
-import { t as StandardSchemaV1 } from "../../standard-C3_AAF3g.js";
-import { a as dbTransport, o as rpcTransport, s as sqlTransport, t as BlockTransport } from "../../block-transport-DaGGXjIw.js";
-import { n as BlockOptions } from "../../block-helpers-C86hPEjI.js";
-import { n as BlockHooks } from "../../block-hooks-BLPWD3Jt.js";
-import { n as ExtraFields, r as FieldsOf } from "../../block-fields-5UA84ZUg.js";
-import { s as BlockOf } from "../../define-block-CLZMEFeK.js";
-import { n as VerifyOptions } from "../../signatures-BMdJ7neI.js";
+import { t as StandardSchemaV1 } from "../../standard-BcUQuUgu.js";
+import { a as dbTransport, o as rpcTransport, s as sqlTransport, t as BlockTransport } from "../../block-transport-DezJPPA0.js";
+import { n as BlockOptions } from "../../block-helpers-CjcQM1yA.js";
+import { n as BlockHooks } from "../../block-hooks-DcPJHztl.js";
+import { n as ExtraFields, r as FieldsOf } from "../../block-fields-DnaDbgZS.js";
+import { s as BlockOf } from "../../define-block-CPyJ95rq.js";
+import { n as VerifyOptions } from "../../signatures-BXlDXV3D.js";
 //#region src/blocks/waitlist/waitlist.d.ts
 type WaitlistStatus = "waiting" | "approved" | "rejected" | "joined";
 /** An entry. `F` types the extra columns the `fields` schema describes. */

package/dist/blocks/waitlist/index.js

@@ -1,12 +1,12 @@
 import { n as isRecord } from "../../guards-6F2bCtQR.js";
+import { t as waitlistSqlOptions } from "../../options-EsUh744F.js";
 import { n as event, t as defineEvents } from "../../event-map-Dy2vKHai.js";
-import { i as sqlTransport, r as rpcTransport, t as dbTransport } from "../../block-transport-G4t1umrR.js";
-import { C as optionalText, D as recordOf, I as textOf, R as toInstant, S as optionalInstant, k as recordsOf, m as instantArg, n as applyTemporal, o as blockCall } from "../../block-helpers-CfG_MvDR.js";
-import { r as withBlockHooks } from "../../block-hooks-BsXncUlZ.js";
-import { n as blockFields } from "../../block-fields-ffD6Gxe4.js";
+import { i as sqlTransport, r as rpcTransport, t as dbTransport } from "../../block-transport-J7ZepTq2.js";
+import { C as optionalText, D as recordOf, I as textOf, R as toInstant, S as optionalInstant, k as recordsOf, m as instantArg, n as applyTemporal, o as blockCall } from "../../block-helpers-DkVZNDrj.js";
+import { r as withBlockHooks } from "../../block-hooks-C22vuIUd.js";
+import { n as blockFields } from "../../block-fields-Bv1hV855.js";
 import { n as defineBlock } from "../../define-block-B6Gjs57G.js";
-import { r as hookError, t as authHook } from "../../verify-EQcC3Khp.js";
-import { t as waitlistSqlOptions } from "../../options-EsUh744F.js";
+import { r as hookError, t as authHook } from "../../verify-DnU-uWU2.js";
 //#region src/blocks/waitlist/waitlist.ts
 const STATUSES = /* @__PURE__ */ new Set([
 	"waiting",