better-supabase 0.7.1 → 0.9.0

package/dist/blocks/employees/index.js

@@ -0,0 +1,289 @@
+import { t as temporal } from "../../temporal-required-DqRzr7i0.js";
+import { a as ok, t as AsyncResult } from "../../result-BlgnMB0H.js";
+import { n as isRecord } from "../../guards-6F2bCtQR.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, S as optionalInstant, d as enumOrThrow, k as recordsOf, n as applyTemporal, o as blockCall } from "../../block-helpers-CfG_MvDR.js";
+import { i as wrapTransport, n as extendBlock, r as withBlockHooks } from "../../block-hooks-BsXncUlZ.js";
+import { n as blockFields } from "../../block-fields-ffD6Gxe4.js";
+import { n as defineBlock } from "../../define-block-B6Gjs57G.js";
+import { o as optionalMoneyOf, t as amountText } from "../../money-codec-C_-K5ZUU.js";
+import { i as refOf, n as compact, r as plainDate } from "../../sales-shared-SblIgCgI.js";
+import { t as employeesSqlOptions } from "../../options-DWpz3V3F.js";
+//#region src/blocks/employees/employees.ts
+const STATUSES = [
+	"preboarding",
+	"active",
+	"on_leave",
+	"offboarded"
+];
+const PERIODS = [
+	"hour",
+	"week",
+	"month",
+	"year"
+];
+const COLUMNS = /* @__PURE__ */ new Set([
+	"id",
+	"tenant_id",
+	"user_id",
+	"name",
+	"email",
+	"job_title",
+	"team_id",
+	"manager_id",
+	"employment_type",
+	"status",
+	"start_date",
+	"end_date",
+	"offboard_reason",
+	"origin_type",
+	"origin_id",
+	"created_by",
+	"created_at",
+	"updated_at",
+	"depth",
+	"direct_reports"
+]);
+function argOf(value) {
+	if (typeof value === "bigint") return value.toString();
+	if (value instanceof temporal().PlainDate) return value.toString();
+	return value;
+}
+const argsOf = (input) => Object.fromEntries(Object.entries(input).map(([key, value]) => [key, argOf(value)]));
+/** A contract as `add_employee_contract` reads it: the salary as text and its currency. */
+function contractArgs(input) {
+	const { salary, ...rest } = input;
+	return {
+		...argsOf(rest),
+		...salary === void 0 ? {} : {
+			salary: amountText(salary),
+			currency: salary.currency
+		}
+	};
+}
+function requiredDate(value, field) {
+	const date = plainDate(value);
+	if (date === void 0) throw new TypeError(`${field} is missing`);
+	return date;
+}
+const num = (value) => value === null || value === void 0 ? void 0 : Number(value);
+function employeeOf(value) {
+	const row = recordOf(value, "employee");
+	return compact({
+		id: textOf(row["id"]),
+		organizationId: textOf(row["tenant_id"]),
+		name: textOf(row["name"]),
+		email: optionalText(row["email"]),
+		userId: optionalText(row["user_id"]),
+		jobTitle: optionalText(row["job_title"]),
+		teamId: optionalText(row["team_id"]),
+		managerId: optionalText(row["manager_id"]),
+		employmentType: optionalText(row["employment_type"]),
+		status: enumOrThrow(row["status"], STATUSES, "employee status"),
+		startDate: plainDate(row["start_date"]),
+		endDate: plainDate(row["end_date"]),
+		offboardReason: optionalText(row["offboard_reason"]),
+		origin: refOf(row["origin_type"], row["origin_id"]),
+		createdAt: optionalInstant(row["created_at"]),
+		fields: Object.fromEntries(Object.entries(row).filter(([key]) => !COLUMNS.has(key)))
+	});
+}
+function contactsOf(value) {
+	return Array.isArray(value) ? value.filter(isRecord).map((item) => compact({
+		name: textOf(item["name"]),
+		phone: optionalText(item["phone"]),
+		relation: optionalText(item["relation"])
+	})) : [];
+}
+function privateOf(value) {
+	const row = recordOf(value, "private details");
+	const address = row["address"];
+	return compact({
+		employeeId: textOf(row["employee_id"]),
+		nationalId: optionalText(row["national_id"]),
+		iban: optionalText(row["iban"]),
+		birthDate: plainDate(row["birth_date"]),
+		personalEmail: optionalText(row["personal_email"]),
+		phone: optionalText(row["phone"]),
+		address: isRecord(address) ? address : void 0,
+		emergencyContacts: contactsOf(row["emergency_contacts"]),
+		offboardedAt: optionalInstant(row["offboarded_at"]),
+		anonymizedAt: optionalInstant(row["anonymized_at"])
+	});
+}
+function contractOf(value) {
+	const row = recordOf(value, "contract");
+	const period = row["salary_period"];
+	return compact({
+		id: textOf(row["id"]),
+		employeeId: textOf(row["employee_id"]),
+		startsOn: requiredDate(row["starts_on"], "startsOn"),
+		endsOn: plainDate(row["ends_on"]),
+		hoursPerWeek: num(row["hours_per_week"]),
+		salary: optionalMoneyOf(row["salary"], row["currency"], "contract salary"),
+		salaryPeriod: period === null || period === void 0 ? void 0 : enumOrThrow(period, PERIODS, "salary period"),
+		note: optionalText(row["note"])
+	});
+}
+const BUILT_IN = /* @__PURE__ */ new Set([
+	"name",
+	"email",
+	"userId",
+	"jobTitle",
+	"teamId",
+	"managerId",
+	"employmentType",
+	"status",
+	"startDate",
+	"endDate"
+]);
+/**
+* The employees block: the people an organization employs, their manager,
+* team and status, the org chart, offboarding, and private details and
+* contracts behind employees.view_sensitive.
+*/
+function createEmployees(options) {
+	applyTemporal(options);
+	const call = blockCall(options.transport, options.schema, options.mappers);
+	const fields = blockFields(options.fields, "employee fields");
+	const parsed = (employee) => AsyncResult.from(() => fields.read(employee.fields)).map((value) => ({
+		...employee,
+		fields: value
+	}));
+	const entries = (value, name) => recordsOf(value, name).map((row) => ({
+		employee: employeeOf(row),
+		depth: num(row["depth"]) ?? 0,
+		directReports: num(row["direct_reports"]) ?? 0
+	}));
+	const chart = (fn, args) => call(fn, args, (value) => entries(value, fn)).andThen((rows) => AsyncResult.from(async () => {
+		const out = [];
+		for (const row of rows) {
+			const read = await parsed(row.employee);
+			if (!read.ok) return read;
+			out.push({
+				...read.data,
+				depth: row.depth,
+				directReports: row.directReports
+			});
+		}
+		return ok(out);
+	}));
+	const attrsOf = (input) => AsyncResult.from(() => fields.write({ ...input.fields })).map((extra) => {
+		const { fields: _fields, ...rest } = input;
+		return {
+			...argsOf(rest),
+			...argsOf(extra)
+		};
+	});
+	return withBlockHooks({
+		create: (organizationId, input) => attrsOf(input).andThen((attrs) => call("create_employee", {
+			tenant: organizationId,
+			attrs
+		}, employeeOf)).andThen(parsed),
+		update: (changes) => AsyncResult.from(async () => {
+			for (const change of changes) {
+				if (BUILT_IN.has(change.field)) continue;
+				const valid = await fields.write({ [change.field]: change.value });
+				if (!valid.ok) return valid;
+			}
+			return ok(changes);
+		}).andThen((checked) => call("update_employees", { changes: checked.map((change) => ({
+			employeeId: change.employeeId,
+			field: change.field,
+			value: argOf(change.value)
+		})) }, (value) => {
+			const row = recordOf(value, "update_employees");
+			return {
+				accepted: recordsOf(row["accepted"], "accepted").map((item) => ({
+					employeeId: textOf(item["employeeId"]),
+					field: textOf(item["field"])
+				})),
+				rejected: recordsOf(row["rejected"], "rejected").map((item) => compact({
+					employeeId: textOf(item["employeeId"]),
+					field: textOf(item["field"]),
+					hint: optionalText(item["hint"]),
+					reason: textOf(item["reason"])
+				}))
+			};
+		})),
+		offboard: (employeeId, offboard = {}) => call("offboard_employee", {
+			employee: employeeId,
+			end_date: offboard.endDate?.toString() ?? null,
+			reason: offboard.reason ?? null
+		}, employeeOf).andThen(parsed),
+		orgChart: (organizationId, rootId) => chart("org_chart", {
+			tenant: organizationId,
+			root: rootId ?? null
+		}),
+		reportsOf: (managerId, reports = {}) => chart("reports_of", {
+			manager: managerId,
+			indirect: reports.indirect ?? false
+		}),
+		fromApplication: (applicationId, overrides = {}) => attrsOf(overrides).andThen((attrs) => call("employee_from_application", {
+			application: applicationId,
+			attrs
+		}, employeeOf)).andThen(parsed),
+		privateDetails: (employeeId) => call("employee_private_details", { employee: employeeId }, (value) => value === null || value === void 0 ? void 0 : privateOf(value)),
+		savePrivateDetails: (employeeId, input) => call("save_employee_private_details", {
+			employee: employeeId,
+			attrs: argsOf({
+				...input,
+				...input.emergencyContacts ? { emergencyContacts: input.emergencyContacts.map((contact) => ({ ...contact })) } : {}
+			})
+		}, privateOf),
+		contracts: (employeeId) => call("employee_contracts", { employee: employeeId }, (value) => recordsOf(value, "employee_contracts").map(contractOf)),
+		addContract: (employeeId, input) => call("add_employee_contract", {
+			employee: employeeId,
+			attrs: contractArgs(input)
+		}, contractOf)
+	}, options.hooks, {
+		block: "employees",
+		...options.logger ? { logger: options.logger } : {}
+	});
+}
+/**
+* The `config.subjects` entry for employees, so comments, files, tags and
+* search attach to them. Pass `schema` when the module isn't in
+* `better_supabase`.
+*/
+function employeesSubjects(options = {}) {
+	return { employee: {
+		table: `${options.schema ?? "better_supabase"}.employees`,
+		idType: "uuid",
+		tenant: "tenant_id",
+		title: "name",
+		permissions: {
+			read: "employees.read",
+			write: "employees.write"
+		},
+		search: {
+			title: "name",
+			body: ["email", "job_title"]
+		},
+		...options.url === void 0 ? {} : { url: options.url }
+	} };
+}
+//#endregion
+//#region src/blocks/employees/events.ts
+/** The `employees` block's event types, for its manifest and `onBlockEvent`. */
+const employeesEvents = defineEvents({
+	"employee.created": event(),
+	"employee.updated": event(),
+	"employee.offboarded": event(),
+	"employee.manager_changed": event()
+});
+//#endregion
+//#region src/blocks/employees/manifest.ts
+/** The `employees` block's manifest (ADR 0029). */
+const employeesBlock = defineBlock({
+	name: "employees",
+	sql: ["employees"],
+	options: { employees: employeesSqlOptions },
+	events: employeesEvents,
+	create: createEmployees,
+	category: "people",
+	recipes: ["employee-directory"]
+});
+//#endregion
+export { createEmployees, dbTransport, employeesBlock, employeesEvents, employeesSubjects, extendBlock, rpcTransport, sqlTransport, withBlockHooks, wrapTransport };

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

@@ -0,0 +1,125 @@
+/// <reference lib="esnext.temporal" />
+import { t as AsyncResult, w as ErrorMapper } from "../../result-Cj3yWhjH.js";
+import { wt as Events } from "../../events-CTreRrgP.js";
+import { _ as EngagementEventData } from "../../index-BlqrGvb3.js";
+import { n as Logger } from "../../logger-DWVYUmwi.js";
+import { t as StandardSchemaV1 } from "../../standard-C3_AAF3g.js";
+import { a as dbTransport, i as RpcClient, o as rpcTransport, s as sqlTransport, t as BlockTransport } from "../../block-transport-DaGGXjIw.js";
+import { r as BlockTemporalOptions } from "../../block-helpers-C86hPEjI.js";
+import { a as BlockTransportMiddleware, d as extendBlock, f as withBlockHooks, n as BlockHooks, p as wrapTransport } from "../../block-hooks-BLPWD3Jt.js";
+import { r as FieldsOf } from "../../block-fields-5UA84ZUg.js";
+import { s as BlockOf } from "../../define-block-CLZMEFeK.js";
+//#region src/blocks/engagements/engagements.d.ts
+/** A record an engagement is on. */
+interface EngagementSubject {
+  readonly type: string;
+  readonly id: string;
+}
+/** A call, email, meeting, note or task logged on one or more records. */
+interface Engagement<F extends object = Record<never, never>> {
+  readonly id: string;
+  readonly organizationId: string;
+  /** `call`, `email`, `meeting`, `note`, `task` or a configured type. */
+  readonly type: string;
+  readonly title: string;
+  readonly body?: string;
+  /** How it went, such as `connected`, `no_answer` or `replied`. */
+  readonly outcome?: string;
+  readonly ownerId?: string;
+  readonly dueAt?: Temporal.Instant;
+  readonly doneAt?: Temporal.Instant;
+  readonly durationSeconds?: number;
+  /** The id in the system it came from, such as a mail or calendar provider. */
+  readonly externalRef?: string;
+  /** The records it is on; the first is its main record. */
+  readonly subjects: readonly EngagementSubject[];
+  /** Open and past its due time. */
+  readonly overdue: boolean;
+  readonly createdBy?: string;
+  readonly createdAt: Temporal.Instant;
+  /** The app's extra columns (`options.extraColumns`), by column name. */
+  readonly fields: Readonly<Record<string, unknown>> & F;
+}
+/** The fields of a write. On update, left out keeps the value and `null` clears it. */
+interface EngagementInput<F extends object = Record<never, never>> {
+  readonly type?: string;
+  readonly title?: string;
+  readonly body?: string | null;
+  readonly outcome?: string | null;
+  /** Defaults to the caller on `log`. */
+  readonly ownerId?: string | null;
+  readonly dueAt?: Temporal.Instant | null;
+  readonly doneAt?: Temporal.Instant | null;
+  readonly durationSeconds?: number | null;
+  /** Logging the same `externalRef` again updates the engagement. */
+  readonly externalRef?: string | null;
+  /** Values for the extra columns, by column name. */
+  readonly fields?: Partial<F> & Readonly<Record<string, unknown>>;
+}
+/** `F` types the engagements' extra columns, from the `fields` schema. */
+interface Engagements<F extends object = Record<never, never>> {
+  /** Logs an engagement on the records in `subjects`, the first being its main record. */
+  log(organizationId: string, input: EngagementInput<F> & {
+    readonly type: string;
+    readonly title: string;
+  }, subjects: readonly EngagementSubject[]): AsyncResult<Engagement<F>>;
+  /** Changes an engagement, and its records when `subjects` is given. */
+  update(id: string, input: EngagementInput<F>, subjects?: readonly EngagementSubject[]): AsyncResult<Engagement<F>>;
+  /** Marks it done now, with an outcome, or open again with `done: false`. */
+  complete(id: string, options?: {
+    readonly done?: boolean;
+    readonly outcome?: string;
+  }): AsyncResult<Engagement<F>>;
+  remove(id: string): AsyncResult<boolean>;
+  /** A record's engagements, newest first (50 by default, at most 200). */
+  of(subject: EngagementSubject, options?: {
+    readonly types?: readonly string[];
+    readonly before?: Temporal.Instant;
+    readonly limit?: number;
+  }): AsyncResult<Engagement<F>[]>;
+  /** The next open engagement with a due time on a record, or `undefined`. */
+  next(subject: EngagementSubject): AsyncResult<Engagement<F> | undefined>;
+  /** A member's open engagements, earliest due first. Default: the caller's. */
+  open(organizationId: string, options?: {
+    readonly ownerId?: string;
+    readonly dueBefore?: Temporal.Instant;
+    readonly limit?: number;
+  }): AsyncResult<Engagement<F>[]>;
+}
+interface EngagementsOptions<S extends StandardSchemaV1 | undefined = undefined> extends BlockTemporalOptions {
+  readonly transport: BlockTransport;
+  /** The module schema, or its API schema: `defineBlocks` passes it from `blocks.generated.ts`. */
+  readonly schema?: string;
+  /**
+   * A Standard Schema for the engagements' extra columns
+   * (`blocks.engagements.options.extraColumns`), keyed by column name. It
+   * types and parses `fields` on reads and validates them on writes.
+   */
+  readonly fields?: S;
+  readonly hooks?: NoInfer<BlockHooks<Engagements<FieldsOf<S>>>>;
+  readonly logger?: Logger;
+  readonly mappers?: readonly ErrorMapper[];
+}
+/**
+ * The engagements block: calls, emails, meetings, notes and tasks on any
+ * record registered in `config.subjects`, for a record's activity panel, a
+ * "next step" and a member's task list.
+ */
+export declare function createEngagements<S extends StandardSchemaV1 | undefined = undefined>(options: EngagementsOptions<S>): Engagements<FieldsOf<S>>;
+//#endregion
+//#region src/blocks/engagements/events.d.ts
+/** The events of the `engagements` block: type to data. */
+type EngagementsEvents = {
+  readonly "engagement.logged": EngagementEventData;
+  readonly "engagement.updated": EngagementEventData;
+  readonly "engagement.completed": EngagementEventData;
+  readonly "engagement.deleted": EngagementEventData;
+};
+/** The `engagements` block's event types, for its manifest and `onBlockEvent`. */
+export declare const engagementsEvents: Events<EngagementsEvents>;
+//#endregion
+//#region src/blocks/engagements/manifest.d.ts
+/** The `engagements` block's manifest (ADR 0029). */
+export declare const engagementsBlock: BlockOf<"engagements", typeof createEngagements, EngagementsEvents>;
+//#endregion
+export { type BlockHooks, type BlockTransport, type BlockTransportMiddleware, type Engagement, type EngagementInput, type EngagementSubject, type Engagements, type EngagementsEvents, type EngagementsOptions, type RpcClient, dbTransport, extendBlock, rpcTransport, sqlTransport, withBlockHooks, wrapTransport };

package/dist/blocks/engagements/index.js

@@ -0,0 +1,143 @@
+import { a as ok, t as AsyncResult } from "../../result-BlgnMB0H.js";
+import { n as isRecord } from "../../guards-6F2bCtQR.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, S as optionalInstant, k as recordsOf, m as instantArg, n as applyTemporal, o as blockCall } from "../../block-helpers-CfG_MvDR.js";
+import { i as wrapTransport, n as extendBlock, r as withBlockHooks } from "../../block-hooks-BsXncUlZ.js";
+import { n as blockFields } from "../../block-fields-ffD6Gxe4.js";
+import { n as defineBlock } from "../../define-block-B6Gjs57G.js";
+import { t as engagementsSqlOptions } from "../../options-BAW2ZlZ8.js";
+//#region src/blocks/engagements/engagements.ts
+function engagementOf(value) {
+	const row = recordOf(value, "engagement");
+	const optional = {
+		body: optionalText(row["body"]),
+		outcome: optionalText(row["outcome"]),
+		ownerId: optionalText(row["owner_user_id"]),
+		dueAt: optionalInstant(row["due_at"]),
+		doneAt: optionalInstant(row["done_at"]),
+		durationSeconds: typeof row["duration_seconds"] === "number" ? row["duration_seconds"] : void 0,
+		externalRef: optionalText(row["external_ref"]),
+		createdBy: optionalText(row["created_by"])
+	};
+	return {
+		id: textOf(row["id"]),
+		organizationId: textOf(row["tenant_id"]),
+		type: textOf(row["type"]),
+		title: textOf(row["title"]),
+		subjects: recordsOf(row["subjects"], "engagement subjects").map((subject) => ({
+			type: textOf(subject["type"]),
+			id: textOf(subject["id"])
+		})),
+		overdue: row["overdue"] === true,
+		createdAt: requiredInstant(row["created_at"], "createdAt"),
+		fields: isRecord(row["fields"]) ? row["fields"] : {},
+		...Object.fromEntries(Object.entries(optional).filter(([, value]) => value !== void 0))
+	};
+}
+/** The attrs of a write: the keys the input sets, instants as ISO text. */
+function attrsOf(input) {
+	const { dueAt, doneAt, ...rest } = input;
+	return {
+		...rest,
+		...dueAt === void 0 ? {} : { dueAt: instantArg(dueAt) ?? null },
+		...doneAt === void 0 ? {} : { doneAt: instantArg(doneAt) ?? null }
+	};
+}
+const subjectsArg = (subjects) => subjects.map((subject) => ({
+	type: subject.type,
+	id: subject.id
+}));
+/**
+* The engagements block: calls, emails, meetings, notes and tasks on any
+* record registered in `config.subjects`, for a record's activity panel, a
+* "next step" and a member's task list.
+*/
+function createEngagements(options) {
+	applyTemporal(options);
+	const call = blockCall(options.transport, options.schema, options.mappers);
+	const fields = blockFields(options.fields, "engagement fields");
+	const parsed = (engagement) => AsyncResult.from(() => fields.read(engagement.fields)).map((value) => ({
+		...engagement,
+		fields: value
+	}));
+	const parsedAll = (engagements) => AsyncResult.from(async () => {
+		const out = [];
+		for (const engagement of engagements) {
+			const read = await parsed(engagement);
+			if (!read.ok) return read;
+			out.push(read.data);
+		}
+		return ok(out);
+	});
+	/** The attrs of a write, with the extra fields checked first. */
+	const checked = (input) => {
+		const { fields: extra, ...rest } = input;
+		if (extra === void 0) return AsyncResult.ok(attrsOf(rest));
+		return AsyncResult.from(() => fields.write({ ...extra })).map((valid) => ({
+			...attrsOf(rest),
+			fields: valid
+		}));
+	};
+	return withBlockHooks({
+		log: (organizationId, input, subjects) => checked(input).andThen((attrs) => call("log_engagement", {
+			tenant: organizationId,
+			attrs,
+			subjects: subjectsArg(subjects)
+		}, engagementOf)).andThen(parsed),
+		update: (id, input, subjects) => checked(input).andThen((attrs) => call("update_engagement", {
+			engagement: id,
+			attrs,
+			subjects: subjects === void 0 ? null : subjectsArg(subjects)
+		}, engagementOf)).andThen(parsed),
+		complete: (id, complete = {}) => call("complete_engagement", {
+			engagement: id,
+			done: complete.done ?? true,
+			outcome: complete.outcome ?? null
+		}, engagementOf).andThen(parsed),
+		remove: (id) => call("delete_engagement", { engagement: id }, (value) => value === true),
+		of: (subject, list = {}) => call("engagements_of", {
+			subject_type: subject.type,
+			subject_id: subject.id,
+			types: list.types === void 0 ? null : [...list.types],
+			before: instantArg(list.before) ?? null,
+			page_size: list.limit ?? null
+		}, (value) => recordsOf(value, "engagements_of").map(engagementOf)).andThen(parsedAll),
+		next: (subject) => call("next_engagement", {
+			subject_type: subject.type,
+			subject_id: subject.id
+		}, (value) => value === null ? void 0 : engagementOf(value)).andThen((found) => found === void 0 ? AsyncResult.ok(void 0) : parsed(found)),
+		open: (organizationId, list = {}) => call("open_engagements", {
+			tenant: organizationId,
+			owner: list.ownerId ?? null,
+			due_before: instantArg(list.dueBefore) ?? null,
+			page_size: list.limit ?? null
+		}, (value) => recordsOf(value, "open_engagements").map(engagementOf)).andThen(parsedAll)
+	}, options.hooks, {
+		block: "engagements",
+		...options.logger ? { logger: options.logger } : {}
+	});
+}
+//#endregion
+//#region src/blocks/engagements/events.ts
+/** The `engagements` block's event types, for its manifest and `onBlockEvent`. */
+const engagementsEvents = defineEvents({
+	"engagement.logged": event(),
+	"engagement.updated": event(),
+	"engagement.completed": event(),
+	"engagement.deleted": event()
+});
+//#endregion
+//#region src/blocks/engagements/manifest.ts
+/** The `engagements` block's manifest (ADR 0029). */
+const engagementsBlock = defineBlock({
+	name: "engagements",
+	sql: ["engagements"],
+	options: { engagements: engagementsSqlOptions },
+	events: engagementsEvents,
+	create: createEngagements,
+	category: "crm",
+	recipes: ["activity-timeline"]
+});
+//#endregion
+export { createEngagements, dbTransport, engagementsBlock, engagementsEvents, extendBlock, rpcTransport, sqlTransport, withBlockHooks, wrapTransport };

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

@@ -1,6 +1,11 @@
-import { t as AsyncResult } from "../../result-D7y2fT87.js";
-import { t as SqlClient } from "../../executor-DbvExCFC.js";
-import { i as hasEntitlement, n as EntitlementKey, t as EntitlementClaimOptions } from "../../entitlements-BKSVGtrG.js";
+import { t as AsyncResult, w as ErrorMapper } from "../../result-Cj3yWhjH.js";
+import { n as Logger } from "../../logger-DWVYUmwi.js";
+import { n as SqlClient } from "../../executor-BBHgjUJu.js";
+import { a as dbTransport, o as rpcTransport, s as sqlTransport, t as BlockTransport } from "../../block-transport-DaGGXjIw.js";
+import { n as BlockHooks } from "../../block-hooks-BLPWD3Jt.js";
+import { s as BlockOf } from "../../define-block-CLZMEFeK.js";
+import { i as hasEntitlement, n as EntitlementKey, t as EntitlementClaimOptions } from "../../entitlements-CbzCKalR.js";
+import { a as createFeatureGateController, i as FeatureGateSnapshot, n as FeatureGateController, r as FeatureGateControllerOptions, t as FeatureGateActions } from "../../client-BVZtq_rQ.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";
@@ -10,5 +15,36 @@ export declare const ENTITLEMENTS_UPDATED = "entitlements.active_entitlement_sum
  * a job can invalidate their sessions. Empty for other payloads.
  */
 export declare function entitlementMembers(sql: SqlClient, payload: unknown): AsyncResult<readonly string[]>;
+interface EntitlementsOptions {
+  /** The member's transport: `sqlTransport(postgres.asUser(claims))` or `rpcTransport(supabase)`. */
+  readonly transport: BlockTransport;
+  /** The module's schema, or its API schema. Default `better_supabase`. */
+  readonly schema?: string;
+  readonly mappers?: readonly ErrorMapper[];
+  /** `withBlockHooks` hooks around `has` and `value`. */
+  readonly hooks?: BlockHooks<Entitlements>;
+  /** Receives the errors `after` hooks throw. */
+  readonly logger?: Logger;
+}
+/** A member's reads of the tenant's entitlements, as `has_entitlement` and `entitlement_value` check them. */
+interface Entitlements {
+  /** Whether the tenant has `key`; `false` when the caller is not a member. */
+  has(organizationId: string, key: string): AsyncResult<boolean>;
+  /**
+   * The feature's value: a number or text from the plan catalog's value
+   * column, `true` for a feature without one, and `undefined` when the
+   * tenant lacks it or the caller is not a member.
+   */
+  value(organizationId: string, key: string): AsyncResult<unknown>;
+}
+/**
+ * Reads the caller's entitlements through the `entitlements` module's
+ * `has_entitlement` and `entitlement_value`, which check membership.
+ */
+export declare function createEntitlements(options: EntitlementsOptions): Entitlements;
+//#endregion
+//#region src/blocks/entitlements/manifest.d.ts
+/** The `entitlements` block's manifest (ADR 0029). */
+export declare const entitlementsBlock: BlockOf<"entitlements", typeof createEntitlements>;
 //#endregion
-export { type EntitlementClaimOptions, type EntitlementKey, hasEntitlement };
+export { type BlockTransport, type EntitlementClaimOptions, type EntitlementKey, type Entitlements, type EntitlementsOptions, type FeatureGateActions, type FeatureGateController, type FeatureGateControllerOptions, type FeatureGateSnapshot, createFeatureGateController, dbTransport, hasEntitlement, rpcTransport, sqlTransport };

package/dist/blocks/entitlements/index.js

@@ -1,25 +1,15 @@
-import { n as entitlementMembers, t as ENTITLEMENTS_UPDATED } from "../../entitlements-DRl6ZJUm.js";
-//#region src/auth/entitlements.ts
-/**
-* Whether the session's plan-features claim grants `key` in `tenantId`.
-* `claim` is `config.claims.features` (default `features`), the claim
-* `better_supabase.feature_claims()` fills, or `{ claim, keys }` when
-* `entitlements.claim.keys` writes short codes. The claim is as fresh as the
-* token: enforce it in RLS with `better_supabase.has_entitlement()`, and
-* refresh the session after checkout. A tenant left out by
-* `entitlements.claim.maxTenants` reads as not granted.
-*/
-function hasEntitlement(session, tenantId, key, claim = "features") {
-	if (session.kind !== "user") return false;
-	const options = typeof claim === "string" ? { claim } : claim;
-	const claims = session.claims;
-	if (!isRecord(claims)) return false;
-	const features = claims[options.claim ?? "features"];
-	if (!isRecord(features) || !Object.hasOwn(features, tenantId)) return false;
-	const keys = features[tenantId];
-	const code = options.keys?.[key] ?? key;
-	return Array.isArray(keys) && keys.includes(code);
-}
-const isRecord = (value) => typeof value === "object" && value !== null;
+import { i as sqlTransport, r as rpcTransport, t as dbTransport } from "../../block-transport-G4t1umrR.js";
+import { n as hasEntitlement, t as createFeatureGateController } from "../../client-Ezlbskjq.js";
+import { n as defineBlock } from "../../define-block-B6Gjs57G.js";
+import { n as createEntitlements, r as entitlementMembers, t as ENTITLEMENTS_UPDATED } from "../../entitlements-BvU5dLpW.js";
+//#region src/blocks/entitlements/manifest.ts
+/** The `entitlements` block's manifest (ADR 0029). */
+const entitlementsBlock = defineBlock({
+	name: "entitlements",
+	sql: ["entitlements"],
+	create: createEntitlements,
+	category: "commerce",
+	recipes: ["feature-gate"]
+});
 //#endregion
-export { ENTITLEMENTS_UPDATED, entitlementMembers, hasEntitlement };
+export { ENTITLEMENTS_UPDATED, createEntitlements, createFeatureGateController, dbTransport, entitlementMembers, entitlementsBlock, hasEntitlement, rpcTransport, sqlTransport };