@ai-matrx/records 0.8.0 → 0.11.0

package/dist/react/index.cjs

@@ -64,6 +64,11 @@ __export(react_exports, {
   measureKey: () => measureKey,
   ok: () => ok,
   publicFormPath: () => publicFormPath,
+  useEntityFieldMutation: () => useEntityFieldMutation,
+  useEntityFieldRights: () => useEntityFieldRights,
+  useEntityFields: () => useEntityFields,
+  useEntityRecord: () => useEntityRecord,
+  useEntityTable: () => useEntityTable,
   useFieldMutation: () => useFieldMutation,
   useFields: () => useFields,
   useMergeField: () => useMergeField,
@@ -1672,6 +1677,24 @@ var DOORS = {
   fieldDeclare: "field_declare",
   fieldUpdate: "field_update",
   fieldRetire: "field_retire",
+  // CUSTOM FIELDS ON A STANDARD BUSINESS TABLE. Every door above is keyed by a
+  // custom Table's uuid, and a standard table has no Table record - so until
+  // 2026-09-20 `custom.applicable_fields(org, 'party', null)` answered `22P02
+  // invalid input syntax for uuid` and there was no other way in. These are
+  // keyed by the REGISTRY TOKEN instead, and they are one set for all 643
+  // tables the registry types Entity or Detail. The three value doors are
+  // SECURITY INVOKER in the database on purpose: the standard table's own
+  // row-level security is what decides who may read and write its rows, and a
+  // definer wrapper would replace it with a second access system.
+  entityTable: "entity_table",
+  entityFields: "entity_fields",
+  entityFieldDeclare: "entity_field_declare",
+  entityFieldUpdate: "entity_field_update",
+  entityFieldRetire: "entity_field_retire",
+  entityFieldRights: "entity_field_rights",
+  entityRecordRead: "entity_record_read",
+  entityValueWrite: "entity_value_write",
+  entityRecordsFind: "entity_records_find",
   tableCapacity: "table_capacity",
   tableStorage: "table_storage",
   promoteTable: "promote_table",
@@ -1778,6 +1801,23 @@ var DOORS = {
   workSlotRelease: "work_slot_release",
   workSlotHolds: "work_slot_holds",
   workSlotExpire: "work_slot_expire",
+  // THE WORK LAYER'S OWN DOORS (lane WORK-DOORS, 2026-09-20). Until this lane
+  // all nineteen `custom.work_*` functions were SECURITY INVOKER with no client
+  // grant: REC-69, REC-70 and REC-71 were live in the store and unreachable
+  // from a browser. These are the verbs a person actually uses.
+  workPerson: "work_person",
+  workAssign: "work_assign",
+  workRecordStates: "work_record_states",
+  workSetState: "work_set_state",
+  workList: "work_list",
+  workTemplates: "work_templates",
+  /** THE ONE QUEUE: assignments, approvals and the agent's proposals together. */
+  workInbox: "work_inbox",
+  workApprovalApprovers: "work_approval_approvers",
+  workApprovalRequest: "work_approval_request",
+  workApprovalMayDecide: "work_approval_may_decide",
+  workApprovalDecide: "work_approval_decide",
+  workApprovalRead: "work_approval_read",
   // Declared here BECAUSE they do not exist yet: naming them is what makes the
   // absence visible to `pnpm check:store-registry` and to the suite.
   metadataSearch: "metadata_search",
@@ -2203,6 +2243,88 @@ function createRecordsClient(config) {
         "fieldDeclare"
       );
     },
+    async entityTable({ token }) {
+      const answer = await callDoor(
+        DOORS.entityTable,
+        { p_token: token },
+        "entityTable"
+      );
+      if (!answer.ok) return err(answer.error);
+      const row = Array.isArray(answer.data) ? answer.data[0] : answer.data;
+      if (!row) {
+        return err({
+          code: "not_found",
+          message: `The registry answered nothing for the table "${token}".`,
+          hint: "REC-33: a standard table is named by its registry token. Nothing was read."
+        });
+      }
+      return ok(row);
+    },
+    async entityFields({ token }) {
+      const rows = await callDoor(
+        DOORS.entityFields,
+        { p_organization_id: org, p_token: token },
+        "entityFields"
+      );
+      if (!rows.ok) return err(rows.error);
+      return ok((rows.data ?? []).map((row) => ({ id: row.id, ...row.data })));
+    },
+    async entityFieldDeclare({ token, spec }) {
+      return callDoor(
+        DOORS.entityFieldDeclare,
+        { p_organization_id: org, p_token: token, p_spec: spec },
+        "entityFieldDeclare"
+      );
+    },
+    async entityFieldUpdate({ field_id, patch }) {
+      return callDoor(
+        DOORS.entityFieldUpdate,
+        { p_organization_id: org, p_field_id: field_id, p_patch: patch },
+        "entityFieldUpdate"
+      );
+    },
+    async entityFieldRetire({ field_id }) {
+      return callDoor(
+        DOORS.entityFieldRetire,
+        { p_organization_id: org, p_field_id: field_id },
+        "entityFieldRetire"
+      );
+    },
+    async entityFieldRights({ token }) {
+      return callDoor(
+        DOORS.entityFieldRights,
+        { p_organization_id: org, p_token: token },
+        "entityFieldRights"
+      );
+    },
+    async entityRecordRead({ token, record_id }) {
+      return callDoor(
+        DOORS.entityRecordRead,
+        { p_organization_id: org, p_token: token, p_record_id: record_id },
+        "entityRecordRead"
+      );
+    },
+    async entityValueWrite({ token, record_id, patch }) {
+      return callDoor(
+        DOORS.entityValueWrite,
+        { p_organization_id: org, p_token: token, p_record_id: record_id, p_patch: patch },
+        "entityValueWrite"
+      );
+    },
+    async entityRecordsFind({ token, key, value, limit, offset }) {
+      return callDoor(
+        DOORS.entityRecordsFind,
+        {
+          p_organization_id: org,
+          p_token: token,
+          p_key: key,
+          p_value: value === void 0 ? null : value,
+          ...limit === void 0 ? {} : { p_limit: limit },
+          ...offset === void 0 ? {} : { p_offset: offset }
+        },
+        "entityRecordsFind"
+      );
+    },
     async fieldUpdate({ field_id, patch }) {
       return callDoor(
         DOORS.fieldUpdate,
@@ -2620,6 +2742,128 @@ function createRecordsClient(config) {
         "workSlotExpire"
       );
     },
+    // ── the work layer a person actually uses ────────────────────────────
+    async workInbox(args) {
+      return callDoor(
+        DOORS.workInbox,
+        {
+          p_organization_id: org,
+          p_limit: args?.limit ?? 50,
+          p_offset: args?.offset ?? 0,
+          p_include_decided: args?.includeDecided ?? false
+        },
+        "workInbox"
+      );
+    },
+    async workList(args) {
+      return callDoor(
+        DOORS.workList,
+        {
+          p_organization_id: org,
+          p_flavour: args?.flavour ?? "mine",
+          p_include_finished: args?.includeFinished ?? false,
+          p_limit: args?.limit ?? 100,
+          p_offset: args?.offset ?? 0
+        },
+        "workList"
+      );
+    },
+    async workAssign({ record_id, user_id = null, dueDate = null, clearDue = false }) {
+      return callDoor(
+        DOORS.workAssign,
+        {
+          p_organization_id: org,
+          p_record_id: record_id,
+          p_assignee_user_id: user_id,
+          p_due_date: dueDate,
+          p_clear_due: clearDue
+        },
+        "workAssign"
+      );
+    },
+    async workRecordStates({ record_id }) {
+      return callDoor(
+        DOORS.workRecordStates,
+        { p_organization_id: org, p_record_id: record_id },
+        "workRecordStates"
+      );
+    },
+    async workSetState({ record_id, state_id }) {
+      return callDoor(
+        DOORS.workSetState,
+        { p_organization_id: org, p_record_id: record_id, p_state_id: state_id },
+        "workSetState"
+      );
+    },
+    async workPerson({ user_id, create = true }) {
+      return callDoor(
+        DOORS.workPerson,
+        { p_organization_id: org, p_user_id: user_id, p_create: create },
+        "workPerson"
+      );
+    },
+    async workTemplates(args) {
+      return callDoor(
+        DOORS.workTemplates,
+        { p_organization_id: org, p_limit: args?.limit ?? 100 },
+        "workTemplates"
+      );
+    },
+    async workApprovalApprovers({ subject_id, approver_id = null }) {
+      return callDoor(
+        DOORS.workApprovalApprovers,
+        { p_organization_id: org, p_subject_id: subject_id, p_approver_id: approver_id },
+        "workApprovalApprovers"
+      );
+    },
+    async workApprovalRequest({
+      subject_id,
+      change,
+      note = null,
+      approver_id = null,
+      origin = "person",
+      conversation_id = null
+    }) {
+      return callDoor(
+        DOORS.workApprovalRequest,
+        {
+          p_organization_id: org,
+          p_subject_id: subject_id,
+          p_change: change,
+          p_note: note,
+          p_approver_id: approver_id,
+          p_origin: origin,
+          p_conversation_id: conversation_id
+        },
+        "workApprovalRequest"
+      );
+    },
+    async workApprovalMayDecide({ approval_id }) {
+      return callDoor(
+        DOORS.workApprovalMayDecide,
+        { p_organization_id: org, p_approval_id: approval_id },
+        "workApprovalMayDecide"
+      );
+    },
+    async workApprovalDecide({ approval_id, approve, note = null }) {
+      return callDoor(
+        DOORS.workApprovalDecide,
+        {
+          p_organization_id: org,
+          p_approval_id: approval_id,
+          p_approve: approve,
+          p_note: note
+        },
+        "workApprovalDecide"
+      );
+    },
+    async workApprovalRead({ approval_id }) {
+      return callDoor(
+        DOORS.workApprovalRead,
+        { p_organization_id: org, p_approval_id: approval_id },
+        "workApprovalRead"
+      );
+    },
     // ── the trust doors ──────────────────────────────────────────────────
     async isExternalPrincipal(args) {
       return trustDoor(
@@ -2946,6 +3190,72 @@ function useRecordMutation() {
     [client, run, saving, error, conflict]
   );
 }
+function useEntityFields(token) {
+  return useAsync(
+    (client) => token ? client.entityFields({ token }) : Promise.resolve({ ok: true, data: [] }),
+    [token]
+  );
+}
+function useEntityRecord(token, recordId) {
+  return useAsync(
+    (client) => token && recordId ? client.entityRecordRead({ token, record_id: recordId }) : Promise.resolve({ ok: true, data: null }),
+    [token, recordId]
+  );
+}
+function useEntityTable(token) {
+  return useAsync(
+    (client) => token ? client.entityTable({ token }) : Promise.resolve({ ok: true, data: null }),
+    [token]
+  );
+}
+function useEntityFieldRights(token) {
+  return useAsync(
+    (client) => token ? client.entityFieldRights({ token }) : Promise.resolve({ ok: true, data: null }),
+    [token]
+  );
+}
+function useEntityFieldMutation() {
+  const client = useRecordsClient();
+  const [saving, setSaving] = (0, import_react2.useState)(false);
+  const [error, setError] = (0, import_react2.useState)(null);
+  const run = (0, import_react2.useCallback)(
+    async (call, whenRefused) => {
+      setSaving(true);
+      setError(null);
+      try {
+        const result = await call();
+        if (result.ok) return result.data;
+        setError(result.error);
+        return whenRefused;
+      } finally {
+        setSaving(false);
+      }
+    },
+    []
+  );
+  return (0, import_react2.useMemo)(
+    () => ({
+      declare: (args) => run(() => client.entityFieldDeclare({ token: args.token, spec: args.spec }), null),
+      update: (args) => run(
+        () => client.entityFieldUpdate({ field_id: args.field_id, patch: args.patch }),
+        null
+      ),
+      retire: (args) => run(() => client.entityFieldRetire({ field_id: args.field_id }), null),
+      write: (args) => run(
+        () => client.entityValueWrite({
+          token: args.token,
+          record_id: args.record_id,
+          patch: args.patch
+        }),
+        null
+      ),
+      saving,
+      error,
+      clearError: () => setError(null)
+    }),
+    [client, run, saving, error]
+  );
+}
 function useFieldMutation() {
   const client = useRecordsClient();
   const [saving, setSaving] = (0, import_react2.useState)(false);