better-supabase 0.13.0 → 0.15.0

package/dist/blocks/enrichment/index.js

@@ -0,0 +1,251 @@
+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 { A as requiredInstant, B as dbTransport, C as optionalText, D as recordOf, H as rpcTransport, I as textOf, U as sqlTransport, k as recordsOf, n as applyTemporal, o as blockCall } from "../../block-helpers-CtBdjgO4.js";
+import { i as wrapTransport, n as extendBlock, r as withBlockHooks } from "../../block-hooks-BfxX3682.js";
+import { n as event, t as defineEvents } from "../../event-map-CtPFhcOp.js";
+import { n as defineBlock } from "../../define-block-BGqOO8B3.js";
+//#region src/blocks/enrichment/providers.ts
+/** Checks the provider's `apiVersion` and name before the block uses it. */
+function enrichmentProviderOf(provider) {
+	const version = provider.apiVersion;
+	if (version !== 1) throw new TypeError(`enrichment "${provider.name}" targets enrichment provider API ${String(version)}; this better-supabase supports 1. Upgrade better-supabase or use a release of the provider for API 1.`);
+	if (!/^[a-z][a-z0-9_-]{0,62}$/u.test(provider.name)) throw new TypeError(`enrichment provider name "${provider.name}" must be lowercase letters, digits, "-" or "_"`);
+	return provider;
+}
+/** The bare host of a website or domain: no scheme, `www.`, port or path. */
+function domainOf(value) {
+	if (value === void 0) return;
+	const host = value.trim().toLowerCase().replace(/^[a-z][a-z0-9+.-]*:\/\//u, "").replace(/^www\./u, "").split(/[/:?#]/u)[0];
+	return host !== void 0 && /^[a-z0-9.-]+\.[a-z]{2,}$/u.test(host) ? host : void 0;
+}
+const text = (value) => typeof value === "string" && value.trim().length > 0 ? value.trim() : void 0;
+const count = (value) => typeof value === "number" && Number.isFinite(value) ? value : void 0;
+/** Leaves out the keys whose value is undefined, so results store as JSON. */
+function defined(value) {
+	return Object.fromEntries(Object.entries(value).filter(([, entry]) => entry !== void 0));
+}
+function companyProfile(body) {
+	const location = isRecord(body["location"]) ? body["location"] : {};
+	const website = text(body["website"]);
+	return defined({
+		name: text(body["display_name"]) ?? text(body["name"]),
+		domain: domainOf(website),
+		website,
+		industry: text(body["industry"]),
+		employees: count(body["employee_count"]),
+		foundedYear: count(body["founded"]),
+		country: text(location["country"]),
+		city: text(location["locality"]),
+		linkedinUrl: text(body["linkedin_url"]),
+		description: text(body["summary"])
+	});
+}
+function personProfile(data) {
+	return defined({
+		title: text(data["job_title"]),
+		phone: text(data["mobile_phone"]),
+		companyName: text(data["job_company_name"]),
+		country: text(data["location_country"]),
+		city: text(data["location_locality"]),
+		linkedinUrl: text(data["linkedin_url"])
+	});
+}
+async function httpError(provider, response) {
+	const body = await response.text().catch(() => "");
+	const message = `${provider} answered ${String(response.status)}${body.length > 0 ? `: ${body.slice(0, 300)}` : ""}`;
+	const retry = Number(response.headers.get("retry-after"));
+	const retryAfter = Number.isFinite(retry) && retry > 0 ? retry : void 0;
+	const retrying = retryAfter === void 0 ? {} : { retryAfter };
+	if (response.status === 401 || response.status === 403) return err(dbError("unauthorized", message, { hint: "ENRICHMENT_KEY_REFUSED" }));
+	if (response.status === 429) return err(dbError("rate_limited", message, retrying));
+	return err(dbError("network", message, retrying));
+}
+/**
+* The People Data Labs company and person enrichment APIs (v5), over `fetch`. A
+* company is matched by its website or domain and name, a person by email, name
+* and company domain.
+*/
+function peopleDataLabsEnrichment(options) {
+	const run = options.fetch ?? fetch;
+	const base = options.baseUrl ?? "https://api.peopledatalabs.com";
+	const minLikelihood = options.minLikelihood ?? 6;
+	const get = (path, query, signal) => AsyncResult.from(async () => {
+		const params = new URLSearchParams();
+		for (const [key, value] of Object.entries(query)) if (value !== void 0) params.set(key, value);
+		const response = await run(`${base}${path}?${params.toString()}`, {
+			method: "GET",
+			headers: {
+				accept: "application/json",
+				"x-api-key": options.apiKey
+			},
+			...signal === void 0 ? {} : { signal }
+		});
+		if (response.status === 404) return ok(void 0);
+		if (!response.ok) return httpError("peopledatalabs", response);
+		const body = await response.json();
+		return ok(isRecord(body) ? body : {});
+	});
+	return {
+		apiVersion: 1,
+		name: "peopledatalabs",
+		company: (input) => get("/v5/company/enrich", {
+			website: domainOf(input.domain) ?? domainOf(input.website),
+			name: input.name
+		}, input.signal).map((body) => body === void 0 ? void 0 : companyProfile(body)),
+		person: (input) => get("/v5/person/enrich", {
+			email: input.email,
+			phone: input.phone,
+			name: input.name,
+			company: input.companyDomain,
+			min_likelihood: String(minLikelihood)
+		}, input.signal).map((body) => body !== void 0 && isRecord(body["data"]) ? personProfile(body["data"]) : void 0)
+	};
+}
+//#endregion
+//#region src/blocks/enrichment/enrichment.ts
+function resultOf(value) {
+	const row = recordOf(value, "enrichment");
+	const data = row["data"];
+	const filled = row["filled"];
+	return {
+		id: textOf(row["id"]),
+		organizationId: textOf(row["organizationId"]),
+		subjectType: textOf(row["subjectType"]),
+		subjectId: textOf(row["subjectId"]),
+		provider: textOf(row["provider"]),
+		status: row["status"] === "matched" ? "matched" : "not_found",
+		data: recordOf(data ?? {}, "enrichment.data"),
+		filled: Array.isArray(filled) ? filled.map((entry) => textOf(entry)) : [],
+		fetchedAt: requiredInstant(row["fetchedAt"], "fetchedAt"),
+		requestedBy: optionalText(row["requestedBy"])
+	};
+}
+function targetOf(value) {
+	const row = recordOf(value, "enrichment_target");
+	const optional = (key) => {
+		const entry = optionalText(row[key]);
+		return entry === void 0 ? {} : { [key]: entry };
+	};
+	return {
+		subjectType: textOf(row["subjectType"]),
+		subjectId: textOf(row["subjectId"]),
+		name: textOf(row["name"]),
+		kind: row["kind"] === "person" ? "person" : "company",
+		...optional("domain"),
+		...optional("website"),
+		...optional("email"),
+		...optional("phone"),
+		...optional("companyDomain")
+	};
+}
+const STOPPING = /* @__PURE__ */ new Set(["rate_limited", "unauthorized"]);
+function createEnrichment(options) {
+	applyTemporal(options);
+	const provider = enrichmentProviderOf(options.provider);
+	const call = blockCall(options.transport, options.schema, options.mappers);
+	const lookup = (target, signal) => {
+		const signalled = signal === void 0 ? {} : { signal };
+		if (target.kind === "company") return provider.company({
+			name: target.name,
+			...target.domain === void 0 ? {} : { domain: target.domain },
+			...target.website === void 0 ? {} : { website: target.website },
+			...signalled
+		});
+		return provider.person({
+			name: target.name,
+			...target.email === void 0 ? {} : { email: target.email },
+			...target.phone === void 0 ? {} : { phone: target.phone },
+			...target.companyDomain === void 0 ? {} : { companyDomain: target.companyDomain },
+			...signalled
+		});
+	};
+	const store = (target, profile, fill) => call("record_enrichment", {
+		subject_type: target.subjectType,
+		subject_id: target.subjectId,
+		provider: provider.name,
+		result: profile === void 0 ? { status: "not_found" } : {
+			status: "matched",
+			data: profile
+		},
+		fill
+	}, resultOf);
+	const enrichTarget = (target, fill, signal) => AsyncResult.from(async () => {
+		const found = await lookup(target, signal);
+		return found.ok ? store(target, found.data, fill) : found;
+	});
+	return withBlockHooks({
+		enrich: (subject, enrich = {}) => AsyncResult.from(async () => {
+			const target = await call("enrichment_target", {
+				subject_type: subject.type,
+				subject_id: subject.id
+			}, targetOf);
+			return target.ok ? enrichTarget(target.data, enrich.fill ?? options.fill ?? true, enrich.signal) : target;
+		}),
+		enrichDue: (run = {}) => AsyncResult.from(async () => {
+			const due = await call("enrichment_due", {
+				provider: provider.name,
+				max_count: run.limit ?? null,
+				stale_after: run.staleAfter ?? null,
+				subject_type: run.subjectType ?? null
+			}, (value) => recordsOf(value, "enrichment_due").map(targetOf));
+			if (!due.ok) return due;
+			let matched = 0;
+			let notFound = 0;
+			let failed = 0;
+			for (const target of due.data) {
+				const result = await enrichTarget(target, options.fill ?? true, run.signal);
+				if (result.ok) {
+					if (result.data.status === "matched") matched += 1;
+					else notFound += 1;
+				} else {
+					failed += 1;
+					options.logger?.warn("enrichment failed", {
+						provider: provider.name,
+						subjectType: target.subjectType,
+						subjectId: target.subjectId,
+						kind: result.error.kind
+					});
+					if (STOPPING.has(result.error.kind)) break;
+				}
+			}
+			return ok({
+				checked: matched + notFound + failed,
+				matched,
+				notFound,
+				failed
+			});
+		}),
+		of: (subject) => call("enrichments_of", {
+			subject_type: subject.type,
+			subject_id: subject.id
+		}, (value) => recordsOf(value, "enrichments_of").map(resultOf))
+	}, options.hooks, {
+		block: "enrichment",
+		...options.logger ? { logger: options.logger } : {}
+	});
+}
+//#endregion
+//#region src/blocks/enrichment/events.ts
+/** The `enrichment` block's event types, for its manifest and `onBlockEvent`. */
+const enrichmentEvents = defineEvents({ "party.enriched": event() });
+//#endregion
+//#region src/blocks/enrichment/manifest.ts
+/** The `enrichment` block's manifest (ADR 0029). */
+const enrichmentBlock = defineBlock({
+	name: "enrichment",
+	sql: ["enrichment"],
+	events: enrichmentEvents,
+	create: createEnrichment,
+	category: "crm",
+	providers: [{
+		option: "provider",
+		type: "EnrichmentProvider",
+		from: "better-supabase/blocks/enrichment",
+		required: true,
+		description: "Looks companies and people up.",
+		example: "peopleDataLabsEnrichment({ apiKey: process.env[\"PDL_API_KEY\"] ?? \"\" })"
+	}]
+});
+//#endregion
+export { createEnrichment, dbTransport, domainOf, enrichmentBlock, enrichmentEvents, enrichmentProviderOf, extendBlock, peopleDataLabsEnrichment, rpcTransport, sqlTransport, withBlockHooks, wrapTransport };

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

@@ -0,0 +1,182 @@
+/// <reference lib="esnext.temporal" />
+import { T as ErrorMapper, t as AsyncResult } from "../../result-DZeA5KS6.js";
+import { $ as RecordRef } from "../../types-DFdg_4yN.js";
+import { Ct as Events } from "../../events-vcqenSYU.js";
+import { n as Logger } from "../../logger-DWVYUmwi.js";
+import { a as BlockTenantOptions, r as BlockTemporalOptions } from "../../block-helpers-CRpAHrp_.js";
+import { a as dbTransport, i as RpcClient, o as rpcTransport, s as sqlTransport, t as BlockTransport } from "../../block-transport-DWZSJrwN.js";
+import { a as BlockTransportMiddleware, d as extendBlock, f as withBlockHooks, n as BlockHooks, p as wrapTransport } from "../../block-hooks-DZN2w69m.js";
+import { t as EnrollmentsSqlOptions } from "../../options-CSCXNYJO.js";
+import { c as BlockOf, rn as RecordBinding } from "../../define-block-BVcLQ3DF.js";
+//#region src/blocks/enrollments/enrollments.d.ts
+interface EnrollmentsOptions extends BlockTemporalOptions, BlockTenantOptions {
+  readonly transport: BlockTransport;
+  /**
+   * The module schema, or its API schema: `defineBlocks` passes it from
+   * `blocks.generated.ts`.
+   */
+  readonly schema?: string;
+  /** `withBlockHooks` hooks around the client's methods. */
+  readonly hooks?: NoInfer<BlockHooks<Enrollments>>;
+  /** Receives the errors `after` hooks throw. Default: `console`. */
+  readonly logger?: Logger;
+  readonly mappers?: readonly ErrorMapper[];
+}
+declare const STATUSES: readonly ["active", "completed", "cancelled"];
+/** Where an enrollment stands. A cancelled one keeps its completed steps. */
+type EnrollmentStatus = (typeof STATUSES)[number];
+/** A step of a program. */
+interface EnrollmentStep {
+  /** Lowercase letters, digits, `_`, `.` or `-`, starting with a letter. */
+  readonly id: string;
+  readonly title?: string;
+  readonly description?: string;
+}
+/** A program of steps that subjects enroll in. */
+interface EnrollmentProgram {
+  readonly id: string;
+  readonly organizationId: string;
+  /** Unique in the organization; it can't change. */
+  readonly key: string;
+  readonly name: string;
+  readonly description?: string;
+  /** The subject types it enrolls; empty enrolls any. */
+  readonly subjectTypes: readonly string[];
+  readonly steps: readonly EnrollmentStep[];
+  readonly enabled: boolean;
+  /** Raised each time the steps change. */
+  readonly version: number;
+  readonly createdBy?: string;
+  readonly createdAt: Temporal.Instant;
+  readonly updatedAt: Temporal.Instant;
+}
+/** A program to create (without `id`) or change (with it). */
+interface EnrollmentProgramInput {
+  readonly id?: string;
+  /**
+   * The version you read; a stale one fails with
+   * `ENROLLMENTS_PROGRAM_CONFLICT`.
+   */
+  readonly version?: number;
+  readonly key?: string;
+  readonly name?: string;
+  readonly description?: string | null;
+  readonly subjectTypes?: readonly string[];
+  readonly steps?: readonly EnrollmentStep[];
+  readonly enabled?: boolean;
+}
+/** A completed step of an enrollment. */
+interface EnrollmentProgress {
+  readonly step: string;
+  readonly completedAt: Temporal.Instant;
+  readonly completedBy?: string;
+}
+/** A subject's enrollment in a program, with its completed steps. */
+interface Enrollment {
+  readonly id: string;
+  /** Unset for a user's own onboarding checklist. */
+  readonly organizationId?: string;
+  /** The program key; `onboarding:<checklist>` for an onboarding checklist. */
+  readonly program: string;
+  readonly programVersion?: number;
+  readonly subject: RecordRef;
+  readonly status: EnrollmentStatus;
+  /** The program's step ids when it enrolled or last changed. */
+  readonly steps: readonly string[];
+  readonly completedSteps: number;
+  readonly totalSteps: number;
+  /** Oldest first. */
+  readonly progress: readonly EnrollmentProgress[];
+  readonly enrolledBy?: string;
+  readonly enrolledAt: Temporal.Instant;
+  readonly completedAt?: Temporal.Instant;
+  readonly cancelledAt?: Temporal.Instant;
+  readonly updatedAt: Temporal.Instant;
+}
+interface EnrollmentsFilter {
+  readonly program?: string;
+  readonly subject?: RecordRef;
+  readonly status?: EnrollmentStatus;
+  /** Default 50, at most 200. */
+  readonly pageSize?: number;
+  /** Enrollments changed before this instant, for the next page. */
+  readonly before?: Temporal.Instant;
+}
+interface Enrollments {
+  /** Creates or changes a program; changing its steps raises its version. */
+  saveProgram(program: EnrollmentProgramInput): AsyncResult<EnrollmentProgram>;
+  /** The organization's programs by key. */
+  programs(): AsyncResult<readonly EnrollmentProgram[]>;
+  /** Deletes a program with its enrollments; `false` when it was gone. */
+  deleteProgram(programId: string): AsyncResult<boolean>;
+  /**
+   * Enrolls a subject. An enrolled subject keeps its enrollment, and a
+   * cancelled one starts again with its completed steps.
+   */
+  enroll(program: string, subject: RecordRef): AsyncResult<Enrollment>;
+  /** A subject's enrollment in a program, or `null`. */
+  enrollment(program: string, subject: RecordRef): AsyncResult<Enrollment | null>;
+  /**
+   * The organization's enrollments, most recently changed first. Without
+   * `enrollments.read`, the caller's own.
+   */
+  list(filter?: EnrollmentsFilter): AsyncResult<readonly Enrollment[]>;
+  /** Marks a step done; completing the last step completes the enrollment. */
+  complete(enrollmentId: string, step: string): AsyncResult<Enrollment>;
+  /** Marks a step not done again. */
+  reset(enrollmentId: string, step: string): AsyncResult<Enrollment>;
+  /** Cancels an active enrollment; its completed steps stay. */
+  cancel(enrollmentId: string): AsyncResult<Enrollment>;
+}
+/** The `enrollments` SQL module as typed calls. */
+export declare function createEnrollments(options: EnrollmentsOptions): Enrollments;
+//#endregion
+//#region src/blocks/enrollments/events.d.ts
+/** `enrollment_program.saved` and `enrollment_program.deleted`. */
+interface EnrollmentProgramEventData {
+  readonly organizationId: string;
+  /** The program. */
+  readonly id: string;
+  readonly key: string;
+  readonly version: number;
+}
+/**
+ * `enrollment.created`, `enrollment.step_completed`, `enrollment.completed` and
+ * `enrollment.cancelled`. Only enrollments in an organization emit them, so a
+ * user's own onboarding checklist doesn't.
+ */
+interface EnrollmentEventData {
+  readonly organizationId: string;
+  /** The enrollment. */
+  readonly id: string;
+  /** The program key; `onboarding:<checklist>` for an onboarding checklist. */
+  readonly program: string;
+  readonly subjectType: string;
+  readonly subjectId: string;
+  readonly status: "active" | "completed" | "cancelled";
+  /** The step, for `enrollment.step_completed`. */
+  readonly step: string | null;
+  readonly completedSteps: number;
+  readonly totalSteps: number;
+}
+/** The events of the `enrollments` block: type to data. */
+type EnrollmentsEvents = {
+  readonly "enrollment_program.saved": EnrollmentProgramEventData;
+  readonly "enrollment_program.deleted": EnrollmentProgramEventData;
+  readonly "enrollment.created": EnrollmentEventData;
+  readonly "enrollment.step_completed": EnrollmentEventData;
+  readonly "enrollment.completed": EnrollmentEventData;
+  readonly "enrollment.cancelled": EnrollmentEventData;
+};
+/** The `enrollments` block's event types, for its manifest and `onBlockEvent`. */
+export declare const enrollmentsEvents: Events<EnrollmentsEvents>;
+//#endregion
+//#region src/blocks/enrollments/record-binding.d.ts
+/** A record's enrollments: the programs it is in, with their progress. */
+export declare const enrollmentsBinding: RecordBinding<Enrollments, readonly Enrollment[]>;
+//#endregion
+//#region src/blocks/enrollments/manifest.d.ts
+/** The `enrollments` block's manifest (ADR 0029). */
+export declare const enrollmentsBlock: BlockOf<"enrollments", typeof createEnrollments, EnrollmentsEvents, Record<never, never>, never, typeof enrollmentsBinding>;
+//#endregion
+export { type BlockHooks, type BlockTransport, type BlockTransportMiddleware, type Enrollment, type EnrollmentEventData, type EnrollmentProgram, type EnrollmentProgramEventData, type EnrollmentProgramInput, type EnrollmentProgress, type EnrollmentStatus, type EnrollmentStep, type Enrollments, type EnrollmentsEvents, type EnrollmentsFilter, type EnrollmentsOptions, type EnrollmentsSqlOptions, type RpcClient, dbTransport, extendBlock, rpcTransport, sqlTransport, withBlockHooks, wrapTransport };

package/dist/blocks/enrollments/index.js

@@ -0,0 +1,173 @@
+import { n as isRecord } from "../../guards-6F2bCtQR.js";
+import { t as enrollmentsSqlOptions } from "../../options-BYOtaF7w.js";
+import { A as requiredInstant, B as dbTransport, C as optionalText, D as recordOf, H as rpcTransport, I as textOf, S as optionalInstant, U as sqlTransport, d as enumOrThrow, k as recordsOf, m as instantArg, n as applyTemporal, o as blockCall } from "../../block-helpers-CtBdjgO4.js";
+import { i as wrapTransport, n as extendBlock, r as withBlockHooks } from "../../block-hooks-BfxX3682.js";
+import { t as defineRecordBinding } from "../../record-bindings-DkBJpC5A.js";
+import { n as event, t as defineEvents } from "../../event-map-CtPFhcOp.js";
+import { n as defineBlock } from "../../define-block-BGqOO8B3.js";
+import { t as requireOrganization } from "../../block-tenant-DHp7subc.js";
+//#region src/blocks/enrollments/enrollments.ts
+const STATUSES = [
+	"active",
+	"completed",
+	"cancelled"
+];
+function optional(key, value) {
+	if (value === void 0) return {};
+	const out = {};
+	out[key] = value;
+	return out;
+}
+const texts = (value) => Array.isArray(value) ? value.map((item) => textOf(item)) : [];
+function stepOf(value, fn) {
+	const row = recordOf(value, fn);
+	return {
+		id: textOf(row["id"]),
+		...optional("title", optionalText(row["title"])),
+		...optional("description", optionalText(row["description"]))
+	};
+}
+function programOf(value, fn) {
+	const row = recordOf(value, fn);
+	return {
+		id: textOf(row["id"]),
+		organizationId: textOf(row["organizationId"]),
+		key: textOf(row["key"]),
+		name: textOf(row["name"]),
+		subjectTypes: texts(row["subjectTypes"]),
+		steps: recordsOf(row["steps"] ?? [], fn).map((step) => stepOf(step, fn)),
+		enabled: row["enabled"] !== false,
+		version: Number(row["version"] ?? 1),
+		createdAt: requiredInstant(row["createdAt"], "createdAt"),
+		updatedAt: requiredInstant(row["updatedAt"], "updatedAt"),
+		...optional("description", optionalText(row["description"])),
+		...optional("createdBy", optionalText(row["createdBy"]))
+	};
+}
+function progressOf(value, fn) {
+	const row = recordOf(value, fn);
+	return {
+		step: textOf(row["step"]),
+		completedAt: requiredInstant(row["completedAt"], "completedAt"),
+		...optional("completedBy", optionalText(row["completedBy"]))
+	};
+}
+function enrollmentOf(value, fn) {
+	const row = recordOf(value, fn);
+	const version = row["programVersion"];
+	return {
+		id: textOf(row["id"]),
+		program: textOf(row["program"]),
+		subject: {
+			type: textOf(row["subjectType"]),
+			id: textOf(row["subjectId"])
+		},
+		status: enumOrThrow(row["status"], STATUSES, "enrollment status"),
+		steps: texts(row["steps"]),
+		completedSteps: Number(row["completedSteps"] ?? 0),
+		totalSteps: Number(row["totalSteps"] ?? 0),
+		progress: recordsOf(row["progress"] ?? [], fn).map((item) => progressOf(item, fn)),
+		enrolledAt: requiredInstant(row["enrolledAt"], "enrolledAt"),
+		updatedAt: requiredInstant(row["updatedAt"], "updatedAt"),
+		...optional("organizationId", optionalText(row["organizationId"])),
+		...optional("programVersion", typeof version === "number" ? version : void 0),
+		...optional("enrolledBy", optionalText(row["enrolledBy"])),
+		...optional("completedAt", optionalInstant(row["completedAt"])),
+		...optional("cancelledAt", optionalInstant(row["cancelledAt"]))
+	};
+}
+function programArg(program) {
+	const out = {};
+	for (const [key, value] of Object.entries(program)) if (value !== void 0) out[key] = value;
+	return out;
+}
+/** The `enrollments` SQL module as typed calls. */
+function createEnrollments(options) {
+	applyTemporal(options);
+	const call = blockCall(options.transport, options.schema, options.mappers);
+	const tenant = () => requireOrganization(options.tenant);
+	const one = (fn) => (value) => enrollmentOf(value, fn);
+	return withBlockHooks({
+		saveProgram: (program) => tenant().andThen((organizationId) => call("save_enrollment_program", {
+			tenant: organizationId,
+			program: programArg(program)
+		}, (value) => programOf(value, "save_enrollment_program"))),
+		programs: () => tenant().andThen((organizationId) => call("enrollment_programs", { tenant: organizationId }, (value) => recordsOf(value, "enrollment_programs").map((row) => programOf(row, "enrollment_programs")))),
+		deleteProgram: (programId) => call("delete_enrollment_program", { program_id: programId }, (value) => value === true),
+		enroll: (program, subject) => tenant().andThen((organizationId) => call("enroll", {
+			tenant: organizationId,
+			program,
+			subject_type: subject.type,
+			subject_id: subject.id
+		}, one("enroll"))),
+		enrollment: (program, subject) => tenant().andThen((organizationId) => call("enrollment", {
+			tenant: organizationId,
+			program,
+			subject_type: subject.type,
+			subject_id: subject.id
+		}, (value) => isRecord(value) ? enrollmentOf(value, "enrollment") : null)),
+		list: (filter = {}) => tenant().andThen((organizationId) => call("list_enrollments", {
+			tenant: organizationId,
+			program: filter.program ?? null,
+			subject_type: filter.subject?.type ?? null,
+			subject_id: filter.subject?.id ?? null,
+			status: filter.status ?? null,
+			page_size: filter.pageSize ?? null,
+			before: instantArg(filter.before) ?? null
+		}, (value) => recordsOf(value, "list_enrollments").map((row) => enrollmentOf(row, "list_enrollments")))),
+		complete: (enrollmentId, step) => call("complete_enrollment_step", {
+			enrollment_id: enrollmentId,
+			step
+		}, one("complete_enrollment_step")),
+		reset: (enrollmentId, step) => call("reset_enrollment_step", {
+			enrollment_id: enrollmentId,
+			step
+		}, one("reset_enrollment_step")),
+		cancel: (enrollmentId) => call("cancel_enrollment", { enrollment_id: enrollmentId }, one("cancel_enrollment"))
+	}, options.hooks, {
+		block: "enrollments",
+		...options.logger ? { logger: options.logger } : {}
+	});
+}
+//#endregion
+//#region src/blocks/enrollments/events.ts
+/** The `enrollments` block's event types, for its manifest and `onBlockEvent`. */
+const enrollmentsEvents = defineEvents({
+	"enrollment_program.saved": event(),
+	"enrollment_program.deleted": event(),
+	"enrollment.created": event(),
+	"enrollment.step_completed": event(),
+	"enrollment.completed": event(),
+	"enrollment.cancelled": event()
+});
+//#endregion
+//#region src/blocks/enrollments/record-binding.ts
+/** A record's enrollments: the programs it is in, with their progress. */
+const enrollmentsBinding = defineRecordBinding({
+	permissions: {
+		read: "read",
+		write: "enroll"
+	},
+	module: "enrollments",
+	load: (client, subject) => client.list({ subject }),
+	events: [
+		"enrollment.created",
+		"enrollment.step_completed",
+		"enrollment.completed",
+		"enrollment.cancelled"
+	]
+});
+//#endregion
+//#region src/blocks/enrollments/manifest.ts
+/** The `enrollments` block's manifest (ADR 0029). */
+const enrollmentsBlock = defineBlock({
+	name: "enrollments",
+	sql: ["enrollments"],
+	options: { enrollments: enrollmentsSqlOptions },
+	events: enrollmentsEvents,
+	create: createEnrollments,
+	record: enrollmentsBinding,
+	category: "collaboration"
+});
+//#endregion
+export { createEnrollments, dbTransport, enrollmentsBinding, enrollmentsBlock, enrollmentsEvents, extendBlock, rpcTransport, sqlTransport, withBlockHooks, wrapTransport };

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

@@ -1,11 +1,11 @@
-import { T as ErrorMapper, t as AsyncResult } from "../../result-mijqfoJN.js";
+import { T as ErrorMapper, t as AsyncResult } from "../../result-DZeA5KS6.js";
 import { n as Logger } from "../../logger-DWVYUmwi.js";
-import { n as SqlClient } from "../../executor-DXfgDsKd.js";
-import { a as dbTransport, o as rpcTransport, s as sqlTransport, t as BlockTransport } from "../../block-transport-DBPhgF3W.js";
-import { n as BlockHooks } from "../../block-hooks-BadAniNI.js";
-import { s as BlockOf } from "../../define-block-MyM4lH42.js";
-import { i as hasEntitlement, n as EntitlementKey, t as EntitlementClaimOptions } from "../../entitlements-CMGsO4gL.js";
-import { a as createFeatureGateController, i as FeatureGateSnapshot, n as FeatureGateController, r as FeatureGateControllerOptions, t as FeatureGateActions } from "../../client-G7NGXZKe.js";
+import { n as SqlClient } from "../../executor-hGjrop3A.js";
+import { a as dbTransport, o as rpcTransport, s as sqlTransport, t as BlockTransport } from "../../block-transport-DWZSJrwN.js";
+import { n as BlockHooks } from "../../block-hooks-DZN2w69m.js";
+import { c as BlockOf } from "../../define-block-BVcLQ3DF.js";
+import { n as Controller, t as AuthPort } from "../../controller-BrP0gn47.js";
+import { i as hasEntitlement, n as EntitlementKey, t as EntitlementClaimOptions } from "../../entitlements-CJpYQXeE.js";
 //#region src/blocks/entitlements/entitlements.d.ts
 /** The Stripe event sent when a customer's active entitlements change. */
 export declare const ENTITLEMENTS_UPDATED = "entitlements.active_entitlement_summary.updated";
@@ -53,4 +53,44 @@ export declare function createEntitlements(options: EntitlementsOptions): Entitl
 /** The `entitlements` block's manifest (ADR 0029). */
 export declare const entitlementsBlock: BlockOf<"entitlements", typeof createEntitlements>;
 //#endregion
-export { type BlockTransport, type EntitlementClaimOptions, type EntitlementKey, type Entitlements, type EntitlementsOptions, type FeatureGateActions, type FeatureGateController, type FeatureGateControllerOptions, type FeatureGateSnapshot, createFeatureGateController, dbTransport, hasEntitlement, rpcTransport, sqlTransport };
+//#region src/blocks/entitlements/client.d.ts
+interface FeatureGateControllerOptions {
+  readonly auth: AuthPort;
+  /** The plan feature, such as `exports`: a key of `entitlements.source.plans`. */
+  readonly feature: string;
+  /**
+   * The organization to check. Default the session's active one, from the
+   * tenant claim.
+   */
+  readonly organizationId?: string | null;
+  /**
+   * `config.claims.features` (default `features`), or `{ claim, keys }` for
+   * short codes.
+   */
+  readonly claim?: string | EntitlementClaimOptions;
+  /** The tenant claim, `config.claims.tenant` (default `tenant_id`). */
+  readonly tenantClaim?: string;
+}
+interface FeatureGateSnapshot {
+  /**
+   * `undefined` while the session loads; false when signed out or outside an
+   * organization.
+   */
+  readonly allowed: boolean | undefined;
+  /** The organization the check ran for. */
+  readonly organizationId: string | undefined;
+}
+interface FeatureGateActions {
+  /** Checks the session again, such as after a refresh the gate did not hear of. */
+  readonly recheck: () => void;
+}
+type FeatureGateController = Controller<FeatureGateSnapshot, FeatureGateActions>;
+/**
+ * Whether the active organization's plan includes `feature`, from the session's
+ * plan-features claim. It updates when the session does, so a session refresh
+ * after checkout opens the gate. UX only: enforce the feature in RLS with
+ * `better_supabase.has_entitlement()`.
+ */
+export declare function createFeatureGateController(options: FeatureGateControllerOptions): FeatureGateController;
+//#endregion
+export { type BlockTransport, type EntitlementClaimOptions, type EntitlementKey, type Entitlements, type EntitlementsOptions, type FeatureGateActions, type FeatureGateController, type FeatureGateControllerOptions, type FeatureGateSnapshot, dbTransport, hasEntitlement, rpcTransport, sqlTransport };