better-supabase 0.13.0 → 0.15.0

package/dist/blocks/courses/index.js

@@ -0,0 +1,445 @@
+import { n as isRecord } from "../../guards-6F2bCtQR.js";
+import { t as coursesSqlOptions } from "../../options-63AKQNv0.js";
+import { l as isFormDefinition } from "../../form-definition-BTpM_tz1.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 { n as entitySchema } from "../../entity-schema-BDv6w-OQ.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 blockFields } from "../../block-fields-DE_FgpOU.js";
+import { n as defineBlock } from "../../define-block-BGqOO8B3.js";
+import { t as requireOrganization } from "../../block-tenant-DHp7subc.js";
+//#region src/blocks/courses/courses.ts
+const COURSE_STATUSES = [
+	"draft",
+	"published",
+	"archived"
+];
+const LESSON_KINDS = [
+	"content",
+	"video",
+	"quiz"
+];
+const LEARNER_STATUSES = [
+	"active",
+	"completed",
+	"cancelled"
+];
+function optional(key, value) {
+	if (value === void 0) return {};
+	const out = {};
+	out[key] = value;
+	return out;
+}
+const numberOr = (value) => typeof value === "number" ? value : typeof value === "string" && value !== "" ? Number(value) : void 0;
+const booleanOr = (value) => typeof value === "boolean" ? value : void 0;
+function courseOf(value, fn) {
+	const row = recordOf(value, fn);
+	return {
+		id: textOf(row["id"]),
+		organizationId: textOf(row["organizationId"]),
+		key: textOf(row["key"]),
+		title: textOf(row["title"]),
+		status: enumOrThrow(row["status"], COURSE_STATUSES, "course status"),
+		certificate: row["certificate"] !== false,
+		createdAt: requiredInstant(row["createdAt"], "createdAt"),
+		updatedAt: requiredInstant(row["updatedAt"], "updatedAt"),
+		fields: isRecord(row["fields"]) ? row["fields"] : {},
+		...optional("summary", optionalText(row["summary"])),
+		...optional("createdBy", optionalText(row["createdBy"]))
+	};
+}
+function moduleOf(value, fn) {
+	const row = recordOf(value, fn);
+	return {
+		id: textOf(row["id"]),
+		courseId: textOf(row["courseId"]),
+		title: textOf(row["title"]),
+		rank: textOf(row["rank"]),
+		createdAt: requiredInstant(row["createdAt"], "createdAt"),
+		updatedAt: requiredInstant(row["updatedAt"], "updatedAt")
+	};
+}
+function lessonOf(value, fn) {
+	const row = recordOf(value, fn);
+	const body = row["body"];
+	return {
+		id: textOf(row["id"]),
+		courseId: textOf(row["courseId"]),
+		moduleId: textOf(row["moduleId"]),
+		title: textOf(row["title"]),
+		kind: enumOrThrow(row["kind"], LESSON_KINDS, "course lesson kind"),
+		required: row["required"] !== false,
+		rank: textOf(row["rank"]),
+		createdAt: requiredInstant(row["createdAt"], "createdAt"),
+		updatedAt: requiredInstant(row["updatedAt"], "updatedAt"),
+		...optional("body", body === null ? void 0 : body),
+		...optional("mediaUrl", optionalText(row["mediaUrl"])),
+		...optional("formId", optionalText(row["formId"])),
+		...optional("minutes", numberOr(row["minutes"]))
+	};
+}
+function entryOf(value, fn) {
+	const row = recordOf(value, fn);
+	return {
+		lessonId: textOf(row["lessonId"]),
+		startedAt: requiredInstant(row["startedAt"], "startedAt"),
+		attempts: Number(row["attempts"] ?? 0),
+		...optional("completedAt", optionalInstant(row["completedAt"])),
+		...optional("submissionId", optionalText(row["submissionId"])),
+		...optional("score", numberOr(row["score"])),
+		...optional("maxScore", numberOr(row["maxScore"])),
+		...optional("passed", booleanOr(row["passed"]))
+	};
+}
+function certificateOf(value, fn) {
+	const row = recordOf(value, fn);
+	return {
+		id: textOf(row["id"]),
+		courseId: textOf(row["courseId"]),
+		userId: textOf(row["userId"]),
+		code: textOf(row["code"]),
+		issuedAt: requiredInstant(row["issuedAt"], "issuedAt"),
+		...optional("revokedAt", optionalInstant(row["revokedAt"]))
+	};
+}
+function learnerOf(value, fn) {
+	const row = recordOf(value, fn);
+	return {
+		enrollmentId: textOf(row["enrollmentId"]),
+		courseId: textOf(row["courseId"]),
+		organizationId: textOf(row["organizationId"]),
+		userId: textOf(row["userId"]),
+		status: enumOrThrow(row["status"], LEARNER_STATUSES, "learner status"),
+		completedLessons: Number(row["completedLessons"] ?? 0),
+		totalLessons: Number(row["totalLessons"] ?? 0),
+		lessons: recordsOf(row["lessons"] ?? [], fn).map((item) => entryOf(item, fn)),
+		enrolledAt: requiredInstant(row["enrolledAt"], "enrolledAt"),
+		updatedAt: requiredInstant(row["updatedAt"], "updatedAt"),
+		...optional("certificate", isRecord(row["certificate"]) ? certificateOf(row["certificate"], fn) : void 0),
+		...optional("completedAt", optionalInstant(row["completedAt"])),
+		...optional("cancelledAt", optionalInstant(row["cancelledAt"]))
+	};
+}
+function outlineLessonOf(value, fn) {
+	const row = recordOf(value, fn);
+	return {
+		id: textOf(row["id"]),
+		moduleId: textOf(row["moduleId"]),
+		title: textOf(row["title"]),
+		kind: enumOrThrow(row["kind"], LESSON_KINDS, "course lesson kind"),
+		required: row["required"] !== false,
+		rank: textOf(row["rank"]),
+		...optional("minutes", numberOr(row["minutes"])),
+		...optional("completedAt", optionalInstant(row["completedAt"]))
+	};
+}
+function outlineOf(value) {
+	const fn = "course_outline";
+	const row = recordOf(value, fn);
+	return {
+		...courseOf(row, fn),
+		modules: recordsOf(row["modules"] ?? [], fn).map((item) => ({
+			id: textOf(item["id"]),
+			title: textOf(item["title"]),
+			rank: textOf(item["rank"]),
+			lessons: recordsOf(item["lessons"] ?? [], fn).map((lesson) => outlineLessonOf(lesson, fn))
+		})),
+		...optional("progress", isRecord(row["progress"]) ? learnerOf(row["progress"], fn) : void 0)
+	};
+}
+function quizOf(value) {
+	if (!isRecord(value)) return;
+	const definition = value["definition"];
+	const schema = isRecord(value["schema"]) ? value["schema"] : void 0;
+	return {
+		formId: textOf(value["formId"]),
+		title: textOf(value["title"]),
+		status: textOf(value["status"]),
+		...optional("versionId", optionalText(value["versionId"])),
+		...optional("definition", isFormDefinition(definition) ? definition : void 0),
+		...optional("schema", schema)
+	};
+}
+function lessonViewOf(value) {
+	const fn = "course_lesson";
+	const row = recordOf(value, fn);
+	return {
+		...lessonOf(row, fn),
+		...optional("quiz", quizOf(row["quiz"])),
+		...optional("progress", isRecord(row["progress"]) ? entryOf(row["progress"], fn) : void 0)
+	};
+}
+function checkOf(value) {
+	if (!isRecord(value)) return null;
+	return {
+		id: textOf(value["id"]),
+		courseId: textOf(value["courseId"]),
+		courseTitle: textOf(value["courseTitle"]),
+		organizationId: textOf(value["organizationId"]),
+		issuedAt: requiredInstant(value["issuedAt"], "issuedAt"),
+		valid: value["valid"] === true,
+		...optional("revokedAt", optionalInstant(value["revokedAt"]))
+	};
+}
+function definedOf(input) {
+	const out = {};
+	for (const [key, value] of Object.entries(input)) if (value !== void 0) out[key] = value;
+	return out;
+}
+/**
+* The courses block: courses of modules and lessons, quizzes graded by forms,
+* per-lesson progress, completion and certificates, on enrollments.
+*/
+function createCourses(options) {
+	applyTemporal(options);
+	const call = blockCall(options.transport, options.schema, options.mappers);
+	const fields = blockFields(options.fields, "course fields");
+	const tenant = () => requireOrganization(options.tenant);
+	const learner = (fn) => (value) => learnerOf(value, fn);
+	return withBlockHooks({
+		upsert: (course) => {
+			const { fields: extra, ...rest } = course;
+			return tenant().andThen((organizationId) => fields.args(extra).andThen((checked) => call("save_course", {
+				tenant: organizationId,
+				course: {
+					...definedOf(rest),
+					...checked === void 0 ? {} : { fields: checked }
+				}
+			}, (value) => courseOf(value, "save_course")).andThen(fields.row)));
+		},
+		list: (filter = {}) => tenant().andThen((organizationId) => call("list_courses", {
+			tenant: organizationId,
+			status: filter.status ?? null
+		}, (value) => recordsOf(value, "list_courses").map((row) => courseOf(row, "list_courses"))).andThen(fields.rows)),
+		delete: (courseId) => call("delete_course", { course_id: courseId }, (value) => value === true),
+		outline: (courseId) => call("course_outline", { course_id: courseId }, outlineOf).andThen(fields.row),
+		saveModule: (courseId, module) => call("save_course_module", {
+			course_id: courseId,
+			module: definedOf(module)
+		}, (value) => moduleOf(value, "save_course_module")),
+		deleteModule: (moduleId) => call("delete_course_module", { module_id: moduleId }, (value) => value === true),
+		saveLesson: (courseId, lesson) => call("save_course_lesson", {
+			course_id: courseId,
+			lesson: definedOf(lesson)
+		}, (value) => lessonOf(value, "save_course_lesson")),
+		deleteLesson: (lessonId) => call("delete_course_lesson", { lesson_id: lessonId }, (value) => value === true),
+		lesson: (lessonId) => call("course_lesson", { lesson_id: lessonId }, lessonViewOf),
+		enroll: (courseId, userId) => call("enroll_in_course", {
+			course_id: courseId,
+			user_id: userId ?? null
+		}, learner("enroll_in_course")),
+		unenroll: (courseId, userId) => call("unenroll_from_course", {
+			course_id: courseId,
+			user_id: userId ?? null
+		}, learner("unenroll_from_course")),
+		start: (lessonId) => call("start_course_lesson", { lesson_id: lessonId }, (value) => entryOf(value, "start_course_lesson")),
+		complete: (lessonId) => call("complete_course_lesson", {
+			lesson_id: lessonId,
+			done: true
+		}, learner("complete_course_lesson")),
+		reset: (lessonId) => call("complete_course_lesson", {
+			lesson_id: lessonId,
+			done: false
+		}, learner("complete_course_lesson")),
+		submitQuiz: (lessonId, answers) => call("submit_course_quiz", {
+			lesson_id: lessonId,
+			answers
+		}, (value) => {
+			const row = recordOf(value, "submit_course_quiz");
+			return {
+				submission: recordOf(row["submission"], "submit_course_quiz"),
+				passed: row["passed"] === true,
+				progress: learnerOf(row["progress"], "submit_course_quiz")
+			};
+		}),
+		progress: (courseId, userId) => call("course_progress", {
+			course_id: courseId,
+			user_id: userId ?? null
+		}, (value) => isRecord(value) ? learnerOf(value, "course_progress") : null),
+		learners: (courseId, filter = {}) => call("list_course_learners", {
+			course_id: courseId,
+			status: filter.status ?? null,
+			page_size: filter.pageSize ?? null,
+			before: instantArg(filter.before) ?? null
+		}, (value) => recordsOf(value, "list_course_learners").map((row) => learnerOf(row, "list_course_learners"))),
+		verifyCertificate: (code) => call("verify_course_certificate", { code }, checkOf),
+		revokeCertificate: (certificateId) => call("revoke_course_certificate", { certificate_id: certificateId }, (value) => value === true)
+	}, options.hooks, {
+		block: "courses",
+		...options.logger ? { logger: options.logger } : {}
+	});
+}
+//#endregion
+//#region src/blocks/courses/events.ts
+/** The `courses` block's event types, for its manifest and `onBlockEvent`. */
+const coursesEvents = defineEvents({
+	"course.saved": event(),
+	"course.deleted": event(),
+	"course.enrolled": event(),
+	"course.unenrolled": event(),
+	"course.completed": event(),
+	"course_lesson.completed": event(),
+	"course_certificate.issued": event(),
+	"course_certificate.revoked": event()
+});
+//#endregion
+//#region src/blocks/courses/schemas.ts
+/** What `upsert` takes, with the bounds the SQL checks. */
+const courseInputSchema = entitySchema({
+	title: "CourseInput",
+	fields: {
+		id: {
+			kind: "uuid",
+			optional: true
+		},
+		key: {
+			kind: "string",
+			optional: true,
+			minLength: 1,
+			maxLength: 63
+		},
+		title: {
+			kind: "string",
+			optional: true,
+			minLength: 1,
+			maxLength: 200
+		},
+		summary: {
+			kind: "string",
+			optional: true,
+			nullable: true,
+			maxLength: 2e3
+		},
+		status: {
+			kind: "enum",
+			values: [
+				"draft",
+				"published",
+				"archived"
+			],
+			optional: true
+		},
+		certificate: {
+			kind: "boolean",
+			optional: true
+		},
+		fields: {
+			kind: "json",
+			optional: true,
+			description: "The extra columns to set, keyed by database name."
+		}
+	}
+});
+/** What `saveLesson` takes, with the bounds the SQL checks. */
+const courseLessonInputSchema = entitySchema({
+	title: "CourseLessonInput",
+	fields: {
+		id: {
+			kind: "uuid",
+			optional: true
+		},
+		moduleId: {
+			kind: "uuid",
+			optional: true
+		},
+		title: {
+			kind: "string",
+			optional: true,
+			minLength: 1,
+			maxLength: 200
+		},
+		kind: {
+			kind: "enum",
+			values: [
+				"content",
+				"video",
+				"quiz"
+			],
+			optional: true
+		},
+		body: {
+			kind: "unknown",
+			optional: true,
+			description: "The lesson's content, such as a rich-text document."
+		},
+		mediaUrl: {
+			kind: "string",
+			optional: true,
+			nullable: true,
+			maxLength: 2e3
+		},
+		formId: {
+			kind: "uuid",
+			optional: true,
+			nullable: true
+		},
+		required: {
+			kind: "boolean",
+			optional: true
+		},
+		minutes: {
+			kind: "integer",
+			optional: true,
+			nullable: true,
+			minimum: 1,
+			maximum: 1e4
+		},
+		rank: {
+			kind: "string",
+			optional: true,
+			minLength: 1
+		}
+	}
+});
+const courseLearnerSectionInputSchema = entitySchema({
+	title: "CourseLearnerSectionInput",
+	fields: { userId: {
+		kind: "uuid",
+		optional: true
+	} }
+});
+//#endregion
+//#region src/blocks/courses/manifest.ts
+/** The `courses` block's manifest (ADR 0029). */
+const coursesBlock = defineBlock({
+	name: "courses",
+	sql: ["courses"],
+	options: { courses: coursesSqlOptions },
+	events: coursesEvents,
+	schemas: {
+		course: { input: courseInputSchema },
+		course_lesson: { input: courseLessonInputSchema }
+	},
+	create: createCourses,
+	category: "content",
+	recipes: ["course-outline", "lesson-player"]
+});
+//#endregion
+//#region src/blocks/courses/record-binding.ts
+/** A course's learners with their progress, on the course's page. */
+const courseLearnersBinding = defineRecordBinding({
+	permissions: {
+		read: "enroll",
+		write: "enroll"
+	},
+	module: "courses",
+	load: (client, subject) => client.learners(subject.id),
+	events: [
+		"course.*",
+		"course_lesson.*",
+		"course_certificate.*"
+	],
+	writes: {
+		enroll: {
+			input: courseLearnerSectionInputSchema,
+			run: (client, subject, { userId }) => client.enroll(subject.id, userId)
+		},
+		unenroll: {
+			input: courseLearnerSectionInputSchema,
+			run: (client, subject, { userId }) => client.unenroll(subject.id, userId)
+		}
+	}
+});
+//#endregion
+export { courseInputSchema, courseLearnerSectionInputSchema, courseLearnersBinding, courseLessonInputSchema, coursesBlock, coursesEvents, coursesSqlOptions, createCourses, dbTransport, extendBlock, rpcTransport, sqlTransport, withBlockHooks, wrapTransport };

package/dist/blocks/created-by/index.d.ts

@@ -0,0 +1,27 @@
+import { Ft as RequestContext, Mt as Plugin } from "../../types-DFdg_4yN.js";
+import { t as CreatedBySqlOptions } from "../../options-CM6-18FQ.js";
+import { r as Block } from "../../define-block-BVcLQ3DF.js";
+//#region src/blocks/created-by/extension.d.ts
+interface CreatedByExtensionOptions {
+  /**
+   * Custom actor id resolution. Defaults to `context.actor.id` for users and
+   * services.
+   */
+  readonly resolve?: (context: RequestContext) => string | undefined;
+}
+/**
+ * The `created-by` block's repository extension. Stamps the columns generated
+ * as `Flags.actor`: `createdBy` on insert and `updatedBy` on insert and update.
+ * Soft deletes are updates, so they record who deleted the row.
+ * `impersonatedBy` gets `context.actor.impersonator` on an impersonated insert
+ * or update and is left alone otherwise, so a user's own update keeps the
+ * stamp, like the block's `track_actor` trigger. Without an actor (anonymous
+ * requests) nothing is set.
+ */
+export declare function createdByExtension(options?: CreatedByExtensionOptions): Plugin<"actor">;
+//#endregion
+//#region src/blocks/created-by/manifest.d.ts
+/** The `created-by` block's manifest (ADR 0029). */
+export declare const createdByBlock: Block<"created-by">;
+//#endregion
+export type { CreatedByExtensionOptions, CreatedBySqlOptions };

package/dist/blocks/created-by/index.js

@@ -0,0 +1,14 @@
+import { t as createdBySqlOptions } from "../../options-B2swWnJW.js";
+import { n as defineBlock } from "../../define-block-BGqOO8B3.js";
+import { t as createdByExtension } from "../../extension-B-lajjex.js";
+//#region src/blocks/created-by/manifest.ts
+/** The `created-by` block's manifest (ADR 0029). */
+const createdByBlock = defineBlock({
+	name: "created-by",
+	sql: ["created-by"],
+	options: { "created-by": createdBySqlOptions },
+	category: "identity",
+	extension: "createdByExtension"
+});
+//#endregion
+export { createdByBlock, createdByExtension };

package/dist/blocks/custom-fields/index.d.ts

@@ -1,13 +1,15 @@
-import { T as ErrorMapper, t as AsyncResult } from "../../result-mijqfoJN.js";
-import { $ as SaasEventData, et as SaasSubjectEventData, wt as Events } from "../../events-DhGgwqQA.js";
+import { T as ErrorMapper, t as AsyncResult } from "../../result-DZeA5KS6.js";
+import { $ as RecordRef } from "../../types-DFdg_4yN.js";
+import { $ as SaasEventData, Ct as Events, et as SaasSubjectEventData } from "../../events-vcqenSYU.js";
 import { n as Logger } from "../../logger-DWVYUmwi.js";
-import { 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 { t as RankNeighbors } from "../../rank-result-DHflCNwo.js";
-import { n as CustomFieldType, t as CUSTOM_FIELD_TYPES } from "../../field-formats-BX2FqLle.js";
+import { a as BlockTenantOptions } from "../../block-helpers-CRpAHrp_.js";
+import { 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 CustomFieldType, t as CUSTOM_FIELD_TYPES } from "../../field-formats-CAFNkKSN.js";
+import { t as RankNeighbors } from "../../rank-result-Bwe7igy-.js";
 //#region src/blocks/custom-fields/custom-fields.d.ts
-interface CustomFieldsOptions {
+interface CustomFieldsOptions extends BlockTenantOptions {
   /** `withBlockHooks` hooks around the client's methods. */
   readonly hooks?: NoInfer<BlockHooks<CustomFields>>;
   /** Receives the errors `after` hooks throw. Default: `console`. */
@@ -27,24 +29,43 @@ interface FieldDefinitionDetail extends FieldDefinition {
   readonly type: string;
   readonly required: boolean;
   readonly sensitive: boolean;
+  /**
+   * Whether values are stored as ciphertext under the tenant's Vault key
+   * (`encryptDefinition`). Always `false` without the `field-encryption`
+   * block.
+   */
+  readonly encrypted: boolean;
   /**
    * The rank key, for `reorderDefinition`; absent when definitions aren't
    * ranked.
    */
   readonly rank?: string;
 }
+/** Every method that takes no definition id acts in the block's `tenant`. */
 interface CustomFields {
-  /** One entity's definitions in display order. Needs `custom_fields.read`. */
-  listDefinitions(organizationId: string, entity: string): AsyncResult<FieldDefinitionDetail[]>;
-  saveDefinition(organizationId: string, entity: string, key: string, label: string, type: CustomFieldType, sensitive?: boolean): AsyncResult<FieldDefinition>;
+  /**
+   * One entity's definitions in the tenant, in display order. Needs
+   * `custom_fields.read`.
+   */
+  listDefinitions(entity: string): AsyncResult<FieldDefinitionDetail[]>;
+  /** Adds or updates the definition of `key` on `entity`. */
+  saveDefinition(entity: string, key: string, label: string, type: CustomFieldType, sensitive?: boolean): AsyncResult<FieldDefinition>;
   deleteDefinition(id: string): AsyncResult<boolean>;
+  /**
+   * Stores a `text`, `email` or `url` field's values as ciphertext from now on
+   * and encrypts the ones it has. Needs `custom_fields.manage` and the
+   * `field-encryption` block; there is no way back.
+   */
+  encryptDefinition(id: string): AsyncResult<boolean>;
   /**
    * Moves a definition between the definitions with rank keys `previous` and
    * `next`. Resolves to its new key.
    */
   reorderDefinition(id: string, neighbors: RankNeighbors): AsyncResult<string>;
-  readValues(organizationId: string, subjectType: string, subjectId: string): AsyncResult<unknown>;
-  setValue(organizationId: string, subjectType: string, subjectId: string, definitionId: string, value: string): AsyncResult<FieldDefinition>;
+  /** The custom field values set on `subject`. */
+  readValues(subject: RecordRef): AsyncResult<unknown>;
+  /** Sets one custom field value of `subject`. */
+  setValue(subject: RecordRef, definitionId: string, value: string): AsyncResult<FieldDefinition>;
 }
 export declare function createCustomFields(options: CustomFieldsOptions): CustomFields;
 //#endregion
@@ -54,7 +75,17 @@ type CustomFieldsEvents = {
   readonly "custom_field.saved": SaasEventData;
   readonly "custom_field.deleted": SaasEventData;
   readonly "field_value.set": SaasSubjectEventData;
+  /**
+   * Protected values were read; audit only, with
+   * `blocks.custom-fields.options.auditReads`.
+   */
+  readonly "field_value.viewed": FieldValueReadEventData;
 };
+/** The values of one subject that a `read_field_values` call returned. */
+interface FieldValueReadEventData extends SaasSubjectEventData {
+  /** The ids of the encrypted or sensitive values it returned. */
+  readonly ids: readonly string[];
+}
 /** The `custom-fields` block's event types, for its manifest and `onBlockEvent`. */
 export declare const customFieldsEvents: Events<CustomFieldsEvents>;
 //#endregion

package/dist/blocks/custom-fields/index.js

@@ -1,17 +1,19 @@
-import { t as AsyncResult } from "../../result-DIT_qp4G.js";
+import { t as AsyncResult } from "../../result-ntFBW2p2.js";
 import { n as CUSTOM_FIELD_TYPES } from "../../field-formats-C6QKA3UR.js";
-import { t as customFieldsSqlOptions } from "../../options-vXMBEWSH.js";
+import { t as customFieldsSqlOptions } from "../../options-BjtrC7o6.js";
+import { C as optionalText, D as recordOf, I as textOf, k as recordsOf, o as blockCall } from "../../block-helpers-CtBdjgO4.js";
+import { r as withBlockHooks } from "../../block-hooks-BfxX3682.js";
 import { n as event, t as defineEvents } from "../../event-map-CtPFhcOp.js";
-import { C as optionalText, D as recordOf, I as textOf, k as recordsOf, o as blockCall } from "../../block-helpers-DwE32_gT.js";
-import { r as withBlockHooks } from "../../block-hooks-C1r-R2r0.js";
-import { n as defineBlock } from "../../define-block-B6Gjs57G.js";
-import { t as rankBetweenResult } from "../../rank-result-C6vsw27N.js";
+import { n as defineBlock } from "../../define-block-BGqOO8B3.js";
+import { t as requireOrganization } from "../../block-tenant-DHp7subc.js";
+import { t as rankBetweenResult } from "../../rank-result-BBJIK-k_.js";
 //#region src/blocks/custom-fields/custom-fields.ts
 function createCustomFields(options) {
 	const call = blockCall(options.transport, options.schema, options.mappers);
 	const idOf = (label) => (value) => ({ id: textOf(recordOf(value, label)["id"]) });
+	const tenant = () => requireOrganization(options.tenant);
 	return withBlockHooks({
-		listDefinitions: (organizationId, entity) => call("list_field_definitions", {
+		listDefinitions: (entity) => tenant().andThen((organizationId) => call("list_field_definitions", {
 			tenant: organizationId,
 			entity
 		}, (value) => recordsOf(value, "list_field_definitions").map((row) => {
@@ -24,17 +26,18 @@ function createCustomFields(options) {
 				type: textOf(row["type"]),
 				required: row["required"] === true,
 				sensitive: row["sensitive"] === true,
+				encrypted: row["encrypted"] === true,
 				...rank === void 0 ? {} : { rank }
 			};
-		})),
-		saveDefinition: (organizationId, entity, key, label, type, sensitive) => call("save_field_definition", {
+		}))),
+		saveDefinition: (entity, key, label, type, sensitive) => tenant().andThen((organizationId) => call("save_field_definition", {
 			tenant: organizationId,
 			entity,
 			key,
 			label,
 			type,
 			sensitive: sensitive ?? false
-		}, idOf("save_field_definition")),
+		}, idOf("save_field_definition"))),
 		reorderDefinition: (id, neighbors) => {
 			const key = rankBetweenResult(neighbors);
 			if (!key.ok) return AsyncResult.err(key.error);
@@ -44,18 +47,19 @@ function createCustomFields(options) {
 			}, () => key.data);
 		},
 		deleteDefinition: (id) => call("delete_field_definition", { definition: id }, (value) => value === true),
-		readValues: (organizationId, subjectType, subjectId) => call("read_field_values", {
+		encryptDefinition: (id) => call("encrypt_field_definition", { definition: id }, (value) => value === true),
+		readValues: (subject) => tenant().andThen((organizationId) => call("read_field_values", {
 			tenant: organizationId,
-			subject_type: subjectType,
-			subject_id: subjectId
-		}, (value) => value),
-		setValue: (organizationId, subjectType, subjectId, definitionId, value) => call("set_field_value", {
+			subject_type: subject.type,
+			subject_id: subject.id
+		}, (value) => value)),
+		setValue: (subject, definitionId, value) => tenant().andThen((organizationId) => call("set_field_value", {
 			tenant: organizationId,
-			subject_type: subjectType,
-			subject_id: subjectId,
+			subject_type: subject.type,
+			subject_id: subject.id,
 			definition: definitionId,
 			value
-		}, idOf("set_field_value"))
+		}, idOf("set_field_value")))
 	}, options.hooks, {
 		block: "custom-fields",
 		...options.logger ? { logger: options.logger } : {}
@@ -67,7 +71,8 @@ function createCustomFields(options) {
 const customFieldsEvents = defineEvents({
 	"custom_field.saved": event(),
 	"custom_field.deleted": event(),
-	"field_value.set": event()
+	"field_value.set": event(),
+	"field_value.viewed": event()
 });
 //#endregion
 //#region src/blocks/custom-fields/manifest.ts
@@ -79,7 +84,7 @@ const customFieldsBlock = defineBlock({
 	events: customFieldsEvents,
 	create: createCustomFields,
 	category: "work",
-	recipes: ["custom-fields-editor"]
+	recipes: ["custom-fields-editor", "entity-form"]
 });
 //#endregion
 export { CUSTOM_FIELD_TYPES, createCustomFields, customFieldsBlock, customFieldsEvents };