@entifix/next-shell 0.1.0-0

package/dist/lib/crud/entity-crud-form.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"entity-crud-form.d.ts","sourceRoot":"","sources":["../../../src/lib/crud/entity-crud-form.tsx"],"names":[],"mappings":"AAEA,OAAO,EACL,KAAK,YAAY,EACjB,KAAK,MAAM,EACX,KAAK,iBAAiB,EACtB,KAAK,oBAAoB,EAE1B,MAAM,eAAe,CAAC;AAEvB,OAAO,EACL,KAAK,gBAAgB,EAEtB,MAAM,4BAA4B,CAAC;AAGpC,OAAO,KAAK,EACV,gBAAgB,EAChB,oBAAoB,EACrB,MAAM,6BAA6B,CAAC;AAIrC,MAAM,WAAW,mBAAmB,CAAC,OAAO,SAAS,MAAM;IACzD,QAAQ,CAAC,iBAAiB,EAAE,iBAAiB,CAAC,OAAO,CAAC,CAAC;IACvD,QAAQ,CAAC,UAAU,EAAE,gBAAgB,CAAC;IACtC,QAAQ,CAAC,YAAY,EAAE,SAAS,MAAM,EAAE,CAAC;IACzC,QAAQ,CAAC,KAAK,EAAE,SAAS,oBAAoB,EAAE,CAAC;IAChD,mEAAmE;IACnE,QAAQ,CAAC,MAAM,CAAC,EAAE,OAAO,CAAC;IAC1B,QAAQ,CAAC,SAAS,CAAC,EAAE,OAAO,CAAC;IAC7B,QAAQ,CAAC,QAAQ,CAAC,EAAE,OAAO,CAAC;IAC5B,QAAQ,CAAC,UAAU,CAAC,EAAE,OAAO,CAAC;IAC9B,QAAQ,CAAC,KAAK,CAAC,EAAE,YAAY,CAAC;IAC9B,QAAQ,CAAC,MAAM,EAAE,CAAC,MAAM,EAAE,OAAO,KAAK,IAAI,CAAC;IAC3C,6DAA6D;IAC7D,QAAQ,CAAC,QAAQ,CAAC,EAAE,MAAM,IAAI,CAAC;IAC/B,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC;IAC1B;;;OAGG;IACH,QAAQ,CAAC,KAAK,CAAC,EAAE,gBAAgB,CAAC;IAClC;;;;OAIG;IACH,QAAQ,CAAC,cAAc,CAAC,EAAE,oBAAoB,CAAC;IAC/C,sEAAsE;IACtE,QAAQ,CAAC,SAAS,CAAC,EAAE,CAAC,GAAG,EAAE,MAAM,KAAK,IAAI,CAAC;CAC5C;AAED;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,cAAc,CAAC,OAAO,SAAS,MAAM,EAAE,EACrD,iBAAiB,EACjB,UAAU,EACV,YAAY,EACZ,KAAK,EACL,MAAM,EACN,SAAiB,EACjB,QAAgB,EAChB,UAAkB,EAClB,KAAK,EACL,MAAM,EACN,QAAQ,EACR,QAAQ,EACR,KAAK,EACL,cAAc,EACd,SAAS,GACV,EAAE,mBAAmB,CAAC,OAAO,CAAC,+BAuH9B"}

package/dist/lib/crud/entity-crud-form.js

@@ -0,0 +1,133 @@
+'use client';
+import { _ as _extends } from "@swc/helpers/_/_extends";
+import { jsx as _jsx } from "react/jsx-runtime";
+import { reconstructEntity } from '@entifix/core';
+import { EntityField, EntityForm, useT } from '@entifix/react-controls';
+import { useEntityForm } from '@entifix/react-integration';
+import { useEffect, useMemo } from 'react';
+import { useEntityAffordances } from './use-entity-affordances.js';
+import { useEntityLinkSources } from './use-entity-link-sources.js';
+/**
+ * The generated create/update form. A thin wrapper over the agnostic
+ * {@link EntityForm}: every field, label and validation rule comes from the
+ * entity's own accessor metadata, and `reconstructEntity` derives the submit
+ * rebuild from that same metadata — so nothing here is per-entity but the
+ * constructor, the catalog key and the hidden-field list.
+ *
+ * A hidden member still round-trips. `code` is assigned by the create
+ * transaction and never shown, but it is a plain writable member, so the rebuild
+ * picks it out of the seeded draft; dropping it from the rendered fields is not
+ * dropping it from the draft.
+ *
+ * `useEntityForm` owns the draft and seeds it once, so the page keys this
+ * component by the record id to reseed when the record arrives.
+ */ export function EntityCrudForm({ entityConstructor, catalogKey, hiddenFields, links, entity, isLoading = false, isSaving = false, isDeleting = false, error, onSave, onDelete, backHref, draft, metadataSource, onUseCase }) {
+    const et = useT('entity');
+    const ct = useT('controls');
+    // `controls` copy, resolved here and handed down. The integration package
+    // owns the validation *rules* and this shell owns the sentences, because a
+    // sideways import between the two `entifix:react` packages is what the
+    // boundary rule forbids.
+    const validationMessages = useMemo(()=>{
+        const say = (failure)=>(field)=>ct(`validation.${failure}`, {
+                    field
+                });
+        return {
+            required: say('required'),
+            number: say('number'),
+            date: say('date'),
+            option: say('option')
+        };
+    }, [
+        ct
+    ]);
+    const form = useEntityForm({
+        entityConstructor,
+        entity,
+        validationMessages,
+        draft,
+        onSubmit: (values)=>onSave(reconstructEntity(entityConstructor, values, {
+                existing: entity
+            }))
+    });
+    const linkSources = useEntityLinkSources(links, {
+        values: form.values,
+        selection: form.links
+    });
+    // Refill the relation sidecar from the ids the draft did keep.
+    //
+    // A draft is JSON, so it holds ids and nothing else; the instances behind them
+    // die with the page. Each picker already resolves its id — that is how a
+    // restored draft shows a brand's name instead of its key — so the instance is
+    // in hand and only has to be handed back. Without this, a member declared
+    // `linkSerialization: 'embedded'` reaches `applyEntityLinks` with an id and no
+    // target, which it refuses rather than writing the wrong wire shape.
+    //
+    // `hydrateLink`, not `setLink`: this is a lookup landing, not a pick, so it
+    // must leave the draft — and the form's dirty flag — alone.
+    const { links: selection, hydrateLink } = form;
+    useEffect(()=>{
+        for (const [field, source] of Object.entries(linkSources)){
+            const resolved = source.selected.entity;
+            if (resolved !== undefined && selection[field] === undefined) {
+                hydrateLink(field, resolved);
+            }
+        }
+    }, [
+        linkSources,
+        selection,
+        hydrateLink
+    ]);
+    const affordances = useEntityAffordances(entityConstructor, metadataSource);
+    /**
+   * May this caller write the record in front of them?
+   *
+   * The **same authority that withholds Save**, applied one step earlier.
+   * Absent metadata keeps the pre-ADR-0026 behaviour, so an un-migrated call
+   * site is untouched; present metadata is authoritative, because it is what
+   * the service already decided.
+   *
+   * ⚠️ Without this the form rendered inputs nobody could submit. Measured on
+   * the stock surface: `stock-item` answers `["read"]` — no role holds
+   * `stock-item:write` and there is no save route — so Save was correctly
+   * absent while `onHand` and `reserved` still rendered as **enabled number
+   * inputs**. A vendor could type a new quantity into the very field ADR 0010
+   * forbids writing, and nothing would happen and nothing would say why.
+   *
+   * A create is exempt: there is no record yet, so there is nothing to read and
+   * a `read` mode would render an empty form with no way to fill it.
+   */ const mayWrite = entity === undefined || affordances.metadata === undefined || affordances.metadata.actions.includes('write');
+    return /*#__PURE__*/ _jsx(EntityForm, _extends({
+        entityConstructor: entityConstructor,
+        entity: entity,
+        // Driven by the served descriptor rather than fixed: `edit` for a caller
+        // who may write, `read` for one who may not. Passing it at all is what
+        // suppresses the built-in Ver/Editar toggle, which would otherwise offer
+        // a way back into inputs the service will refuse.
+        mode: mayWrite ? 'edit' : 'read',
+        values: form.values,
+        onFieldChange: form.setField,
+        linkSources: linkSources,
+        onLinkChange: form.setLink,
+        errors: form.errors,
+        formError: form.formError,
+        onSubmit: form.submit,
+        onDelete: onDelete
+    }, affordances, {
+        onUseCase: onUseCase,
+        isLoading: isLoading,
+        isSaving: isSaving,
+        isDeleting: isDeleting,
+        error: error,
+        backHref: backHref,
+        // `entity` is undefined until the record lands, so testing it alone
+        // titled a loading edit form "New" and then relabelled it (#139).
+        title: et(entity || isLoading ? `${catalogKey}.form.editTitle` : `${catalogKey}.form.newTitle`),
+        children: hiddenFields.map((field)=>/*#__PURE__*/ _jsx(EntityField, {
+                field: field,
+                hidden: true
+            }, field))
+    }));
+}
+
+//# sourceMappingURL=entity-crud-form.js.map

package/dist/lib/crud/entity-crud-form.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/lib/crud/entity-crud-form.tsx"],"sourcesContent":["'use client';\n\nimport {\n  type EntifixError,\n  type Entity,\n  type EntityConstructor,\n  type EntityMetadataSource,\n  reconstructEntity,\n} from '@entifix/core';\nimport { EntityField, EntityForm, useT } from '@entifix/react-controls';\nimport {\n  type EntityDraftStore,\n  useEntityForm,\n} from '@entifix/react-integration';\nimport { useEffect, useMemo } from 'react';\n\nimport type {\n  EntityCatalogKey,\n  EntityCrudLinkSource,\n} from './make-entity-crud.types.js';\nimport { useEntityAffordances } from './use-entity-affordances.js';\nimport { useEntityLinkSources } from './use-entity-link-sources.js';\n\nexport interface EntityCrudFormProps<TEntity extends Entity> {\n  readonly entityConstructor: EntityConstructor<TEntity>;\n  readonly catalogKey: EntityCatalogKey;\n  readonly hiddenFields: readonly string[];\n  readonly links: readonly EntityCrudLinkSource[];\n  /** The record being edited; `undefined` means this is a create. */\n  readonly entity?: TEntity;\n  readonly isLoading?: boolean;\n  readonly isSaving?: boolean;\n  readonly isDeleting?: boolean;\n  readonly error?: EntifixError;\n  readonly onSave: (entity: TEntity) => void;\n  /** Omitted for a create — there is nothing to delete yet. */\n  readonly onDelete?: () => void;\n  readonly backHref: string;\n  /**\n   * Where to autosave this form's draft. Omitted by a route host, which is what\n   * keeps a plain route ephemeral; the workspace tab host supplies one.\n   */\n  readonly draft?: EntityDraftStore;\n  /**\n   * Where this caller's affordances come from. Absent keeps the pre-ADR-0026\n   * behaviour: Save and Delete render unconditionally and no declared verb\n   * appears — which is what every generated catalog did before it existed.\n   */\n  readonly metadataSource?: EntityMetadataSource;\n  /** Runs a declared `entity`-bound verb on this record, by its key. */\n  readonly onUseCase?: (key: string) => void;\n}\n\n/**\n * The generated create/update form. A thin wrapper over the agnostic\n * {@link EntityForm}: every field, label and validation rule comes from the\n * entity's own accessor metadata, and `reconstructEntity` derives the submit\n * rebuild from that same metadata — so nothing here is per-entity but the\n * constructor, the catalog key and the hidden-field list.\n *\n * A hidden member still round-trips. `code` is assigned by the create\n * transaction and never shown, but it is a plain writable member, so the rebuild\n * picks it out of the seeded draft; dropping it from the rendered fields is not\n * dropping it from the draft.\n *\n * `useEntityForm` owns the draft and seeds it once, so the page keys this\n * component by the record id to reseed when the record arrives.\n */\nexport function EntityCrudForm<TEntity extends Entity>({\n  entityConstructor,\n  catalogKey,\n  hiddenFields,\n  links,\n  entity,\n  isLoading = false,\n  isSaving = false,\n  isDeleting = false,\n  error,\n  onSave,\n  onDelete,\n  backHref,\n  draft,\n  metadataSource,\n  onUseCase,\n}: EntityCrudFormProps<TEntity>) {\n  const et = useT('entity');\n  const ct = useT('controls');\n\n  // `controls` copy, resolved here and handed down. The integration package\n  // owns the validation *rules* and this shell owns the sentences, because a\n  // sideways import between the two `entifix:react` packages is what the\n  // boundary rule forbids.\n  const validationMessages = useMemo(() => {\n    const say =\n      (failure: 'required' | 'number' | 'date' | 'option') => (field: string) =>\n        ct(`validation.${failure}`, { field });\n    return {\n      required: say('required'),\n      number: say('number'),\n      date: say('date'),\n      option: say('option'),\n    };\n  }, [ct]);\n\n  const form = useEntityForm<TEntity>({\n    entityConstructor,\n    entity,\n    validationMessages,\n    draft,\n    onSubmit: values =>\n      onSave(\n        reconstructEntity(entityConstructor, values, { existing: entity }),\n      ),\n  });\n\n  const linkSources = useEntityLinkSources(links, {\n    values: form.values,\n    selection: form.links,\n  });\n\n  // Refill the relation sidecar from the ids the draft did keep.\n  //\n  // A draft is JSON, so it holds ids and nothing else; the instances behind them\n  // die with the page. Each picker already resolves its id — that is how a\n  // restored draft shows a brand's name instead of its key — so the instance is\n  // in hand and only has to be handed back. Without this, a member declared\n  // `linkSerialization: 'embedded'` reaches `applyEntityLinks` with an id and no\n  // target, which it refuses rather than writing the wrong wire shape.\n  //\n  // `hydrateLink`, not `setLink`: this is a lookup landing, not a pick, so it\n  // must leave the draft — and the form's dirty flag — alone.\n  const { links: selection, hydrateLink } = form;\n  useEffect(() => {\n    for (const [field, source] of Object.entries(linkSources)) {\n      const resolved = source.selected.entity;\n      if (resolved !== undefined && selection[field] === undefined) {\n        hydrateLink(field, resolved);\n      }\n    }\n  }, [linkSources, selection, hydrateLink]);\n\n  const affordances = useEntityAffordances(entityConstructor, metadataSource);\n\n  /**\n   * May this caller write the record in front of them?\n   *\n   * The **same authority that withholds Save**, applied one step earlier.\n   * Absent metadata keeps the pre-ADR-0026 behaviour, so an un-migrated call\n   * site is untouched; present metadata is authoritative, because it is what\n   * the service already decided.\n   *\n   * ⚠️ Without this the form rendered inputs nobody could submit. Measured on\n   * the stock surface: `stock-item` answers `[\"read\"]` — no role holds\n   * `stock-item:write` and there is no save route — so Save was correctly\n   * absent while `onHand` and `reserved` still rendered as **enabled number\n   * inputs**. A vendor could type a new quantity into the very field ADR 0010\n   * forbids writing, and nothing would happen and nothing would say why.\n   *\n   * A create is exempt: there is no record yet, so there is nothing to read and\n   * a `read` mode would render an empty form with no way to fill it.\n   */\n  const mayWrite =\n    entity === undefined ||\n    affordances.metadata === undefined ||\n    affordances.metadata.actions.includes('write');\n\n  return (\n    <EntityForm<TEntity>\n      entityConstructor={entityConstructor}\n      entity={entity}\n      // Driven by the served descriptor rather than fixed: `edit` for a caller\n      // who may write, `read` for one who may not. Passing it at all is what\n      // suppresses the built-in Ver/Editar toggle, which would otherwise offer\n      // a way back into inputs the service will refuse.\n      mode={mayWrite ? 'edit' : 'read'}\n      values={form.values}\n      onFieldChange={form.setField}\n      linkSources={linkSources}\n      onLinkChange={form.setLink}\n      errors={form.errors}\n      formError={form.formError}\n      onSubmit={form.submit}\n      onDelete={onDelete}\n      {...affordances}\n      onUseCase={onUseCase}\n      isLoading={isLoading}\n      isSaving={isSaving}\n      isDeleting={isDeleting}\n      error={error}\n      backHref={backHref}\n      // `entity` is undefined until the record lands, so testing it alone\n      // titled a loading edit form \"New\" and then relabelled it (#139).\n      title={et(\n        entity || isLoading\n          ? `${catalogKey}.form.editTitle`\n          : `${catalogKey}.form.newTitle`,\n      )}\n    >\n      {hiddenFields.map(field => (\n        <EntityField<TEntity> key={field} field={field} hidden />\n      ))}\n    </EntityForm>\n  );\n}\n"],"names":["reconstructEntity","EntityField","EntityForm","useT","useEntityForm","useEffect","useMemo","useEntityAffordances","useEntityLinkSources","EntityCrudForm","entityConstructor","catalogKey","hiddenFields","links","entity","isLoading","isSaving","isDeleting","error","onSave","onDelete","backHref","draft","metadataSource","onUseCase","et","ct","validationMessages","say","failure","field","required","number","date","option","form","onSubmit","values","existing","linkSources","selection","hydrateLink","source","Object","entries","resolved","selected","undefined","affordances","mayWrite","metadata","actions","includes","mode","onFieldChange","setField","onLinkChange","setLink","errors","formError","submit","title","map","hidden"],"mappings":"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"}

package/dist/lib/crud/hand-off-write.d.ts

@@ -0,0 +1,35 @@
+import type { PendingTransactionStore } from '@entifix/transactions';
+export interface HandOffWriteOptions {
+    /** The saved record's id — the transaction id, for a tracked create. */
+    readonly id: string;
+    /** The record as the browser built it, shown until the service confirms. */
+    readonly record: unknown;
+    readonly pending: PendingTransactionStore;
+    /** The draft the write was composed in, if it had one. */
+    readonly draft?: {
+        clear(): void;
+    };
+}
+/**
+ * What happens to a draft once its write has been handed over.
+ *
+ * A transactional create resolves at the `202`, **before** the write is
+ * durable, so the save adapter has already announced it and the id is in the
+ * pending set ([ADR 0043](../../../../../../docs/adr/0043-the-optimistic-mutation-contract.md)).
+ * Handing the record over *is* the question: the returned entity is otherwise
+ * indistinguishable from a plain REST create, and asking `entries.some(...)`
+ * beforehand would read a set captured before the `await` that announced it.
+ *
+ * ⚠️ A **still-pending write keeps its draft**. The write has not committed, and
+ * a failure minutes from now would otherwise have destroyed the operator's only
+ * copy of what they typed. Only a plain, committed write spends it.
+ *
+ * It lives here rather than inside `makeEntityCrud` because it is not the
+ * generator's rule — it is the rule for every screen that writes. A wizard's
+ * Finalizar performs the same three steps, and a second copy of them is where
+ * one of the two would eventually stop keeping the draft.
+ *
+ * @returns whether the write is still in flight.
+ */
+export declare function handOffWrite({ id, record, pending, draft, }: HandOffWriteOptions): boolean;
+//# sourceMappingURL=hand-off-write.d.ts.map

package/dist/lib/crud/hand-off-write.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"hand-off-write.d.ts","sourceRoot":"","sources":["../../../src/lib/crud/hand-off-write.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,uBAAuB,EAAE,MAAM,uBAAuB,CAAC;AAErE,MAAM,WAAW,mBAAmB;IAClC,wEAAwE;IACxE,QAAQ,CAAC,EAAE,EAAE,MAAM,CAAC;IACpB,4EAA4E;IAC5E,QAAQ,CAAC,MAAM,EAAE,OAAO,CAAC;IACzB,QAAQ,CAAC,OAAO,EAAE,uBAAuB,CAAC;IAC1C,0DAA0D;IAC1D,QAAQ,CAAC,KAAK,CAAC,EAAE;QAAE,KAAK,IAAI,IAAI,CAAA;KAAE,CAAC;CACpC;AAED;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,wBAAgB,YAAY,CAAC,EAC3B,EAAE,EACF,MAAM,EACN,OAAO,EACP,KAAK,GACN,EAAE,mBAAmB,GAAG,OAAO,CAK/B"}

package/dist/lib/crud/hand-off-write.js

@@ -0,0 +1,27 @@
+/**
+ * What happens to a draft once its write has been handed over.
+ *
+ * A transactional create resolves at the `202`, **before** the write is
+ * durable, so the save adapter has already announced it and the id is in the
+ * pending set ([ADR 0043](../../../../../../docs/adr/0043-the-optimistic-mutation-contract.md)).
+ * Handing the record over *is* the question: the returned entity is otherwise
+ * indistinguishable from a plain REST create, and asking `entries.some(...)`
+ * beforehand would read a set captured before the `await` that announced it.
+ *
+ * ⚠️ A **still-pending write keeps its draft**. The write has not committed, and
+ * a failure minutes from now would otherwise have destroyed the operator's only
+ * copy of what they typed. Only a plain, committed write spends it.
+ *
+ * It lives here rather than inside `makeEntityCrud` because it is not the
+ * generator's rule — it is the rule for every screen that writes. A wizard's
+ * Finalizar performs the same three steps, and a second copy of them is where
+ * one of the two would eventually stop keeping the draft.
+ *
+ * @returns whether the write is still in flight.
+ */ export function handOffWrite({ id, record, pending, draft }) {
+    if (pending.attach(id, record)) return true;
+    draft == null ? void 0 : draft.clear();
+    return false;
+}
+
+//# sourceMappingURL=hand-off-write.js.map

package/dist/lib/crud/hand-off-write.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/lib/crud/hand-off-write.ts"],"sourcesContent":["import type { PendingTransactionStore } from '@entifix/transactions';\n\nexport interface HandOffWriteOptions {\n  /** The saved record's id — the transaction id, for a tracked create. */\n  readonly id: string;\n  /** The record as the browser built it, shown until the service confirms. */\n  readonly record: unknown;\n  readonly pending: PendingTransactionStore;\n  /** The draft the write was composed in, if it had one. */\n  readonly draft?: { clear(): void };\n}\n\n/**\n * What happens to a draft once its write has been handed over.\n *\n * A transactional create resolves at the `202`, **before** the write is\n * durable, so the save adapter has already announced it and the id is in the\n * pending set ([ADR 0043](../../../../../../docs/adr/0043-the-optimistic-mutation-contract.md)).\n * Handing the record over *is* the question: the returned entity is otherwise\n * indistinguishable from a plain REST create, and asking `entries.some(...)`\n * beforehand would read a set captured before the `await` that announced it.\n *\n * ⚠️ A **still-pending write keeps its draft**. The write has not committed, and\n * a failure minutes from now would otherwise have destroyed the operator's only\n * copy of what they typed. Only a plain, committed write spends it.\n *\n * It lives here rather than inside `makeEntityCrud` because it is not the\n * generator's rule — it is the rule for every screen that writes. A wizard's\n * Finalizar performs the same three steps, and a second copy of them is where\n * one of the two would eventually stop keeping the draft.\n *\n * @returns whether the write is still in flight.\n */\nexport function handOffWrite({\n  id,\n  record,\n  pending,\n  draft,\n}: HandOffWriteOptions): boolean {\n  if (pending.attach(id, record)) return true;\n\n  draft?.clear();\n  return false;\n}\n"],"names":["handOffWrite","id","record","pending","draft","attach","clear"],"mappings":"AAYA;;;;;;;;;;;;;;;;;;;;CAoBC,GACD,OAAO,SAASA,aAAa,EAC3BC,EAAE,EACFC,MAAM,EACNC,OAAO,EACPC,KAAK,EACe;IACpB,IAAID,QAAQE,MAAM,CAACJ,IAAIC,SAAS,OAAO;IAEvCE,yBAAAA,MAAOE,KAAK;IACZ,OAAO;AACT"}

package/dist/lib/crud/index.d.ts

@@ -0,0 +1,9 @@
+export * from './entity-crud-form.js';
+export * from './hand-off-write.js';
+export * from './make-entity-crud.js';
+export * from './make-entity-crud.types.js';
+export * from './slug.js';
+export * from './use-entity-affordances.js';
+export * from './use-entity-bulk.js';
+export * from './use-entity-link-sources.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/lib/crud/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/lib/crud/index.ts"],"names":[],"mappings":"AAAA,cAAc,uBAAuB,CAAC;AACtC,cAAc,qBAAqB,CAAC;AACpC,cAAc,uBAAuB,CAAC;AACtC,cAAc,6BAA6B,CAAC;AAC5C,cAAc,WAAW,CAAC;AAC1B,cAAc,6BAA6B,CAAC;AAC5C,cAAc,sBAAsB,CAAC;AACrC,cAAc,8BAA8B,CAAC"}

package/dist/lib/crud/index.js

@@ -0,0 +1,10 @@
+export * from './entity-crud-form.js';
+export * from './hand-off-write.js';
+export * from './make-entity-crud.js';
+export * from './make-entity-crud.types.js';
+export * from './slug.js';
+export * from './use-entity-affordances.js';
+export * from './use-entity-bulk.js';
+export * from './use-entity-link-sources.js';
+
+//# sourceMappingURL=index.js.map

package/dist/lib/crud/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/lib/crud/index.ts"],"sourcesContent":["export * from './entity-crud-form.js';\nexport * from './hand-off-write.js';\nexport * from './make-entity-crud.js';\nexport * from './make-entity-crud.types.js';\nexport * from './slug.js';\nexport * from './use-entity-affordances.js';\nexport * from './use-entity-bulk.js';\nexport * from './use-entity-link-sources.js';\n"],"names":[],"mappings":"AAAA,cAAc,wBAAwB;AACtC,cAAc,sBAAsB;AACpC,cAAc,wBAAwB;AACtC,cAAc,8BAA8B;AAC5C,cAAc,YAAY;AAC1B,cAAc,8BAA8B;AAC5C,cAAc,uBAAuB;AACrC,cAAc,+BAA+B"}

package/dist/lib/crud/make-entity-crud.d.ts

@@ -0,0 +1,28 @@
+import { type ConfigurationRepositoryTag, type EntityRepositoryTag } from '@entifix/business';
+import { type Entity, type EntityConstructor } from '@entifix/core';
+import type { TransactionSink } from '@entifix/transactions';
+import { TransactionSinkTag } from '@entifix/transactions';
+import { Context } from 'effect';
+import type { EntityCrud, EntityCrudOptions } from './make-entity-crud.types.js';
+/**
+ * What the generated pages' use-cases run against.
+ *
+ * Exported because a hand-built screen needs the same three: a wizard reads
+ * records, resolves pickers and writes through exactly these ports, and
+ * rebuilding the union at each such call site is how one of them ends up
+ * missing `TransactionSinkTag` and quietly losing its optimistic treatment.
+ */
+export type CrudContext = EntityRepositoryTag | ConfigurationRepositoryTag | TransactionSinkTag;
+/**
+ * Merges the configuration adapter with one repository adapter into the context
+ * the use-cases run against.
+ *
+ * The casts are the price of naming adapters by key: `AdapterKey` narrows which
+ * names may be *offered*, but TypeScript will not carry that narrowing through
+ * an index access on a generic record. The alternative is every call site
+ * passing two `Context` values per entity — the duplication this factory exists
+ * to remove.
+ */
+export declare function mergeCrudContext<TAdapters>(adapters: TAdapters, configuration: keyof TAdapters, repository: keyof TAdapters, sink: TransactionSink): Context.Context<CrudContext>;
+export declare function makeEntityCrud<TEntity extends Entity, TAdapters>(entityConstructor: EntityConstructor<TEntity>, options: EntityCrudOptions<TAdapters, TEntity>): EntityCrud<TEntity>;
+//# sourceMappingURL=make-entity-crud.d.ts.map

package/dist/lib/crud/make-entity-crud.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"make-entity-crud.d.ts","sourceRoot":"","sources":["../../../src/lib/crud/make-entity-crud.tsx"],"names":[],"mappings":"AAEA,OAAO,EACL,KAAK,0BAA0B,EAE/B,KAAK,mBAAmB,EAIzB,MAAM,mBAAmB,CAAC;AAC3B,OAAO,EAKL,KAAK,MAAM,EACX,KAAK,iBAAiB,EAGvB,MAAM,eAAe,CAAC;AAQvB,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,uBAAuB,CAAC;AAC7D,OAAO,EAAE,kBAAkB,EAAE,MAAM,uBAAuB,CAAC;AAE3D,OAAO,EAAE,OAAO,EAAE,MAAM,QAAQ,CAAC;AAYjC,OAAO,KAAK,EACV,UAAU,EAEV,iBAAiB,EAElB,MAAM,6BAA6B,CAAC;AASrC;;;;;;;GAOG;AACH,MAAM,MAAM,WAAW,GACrB,mBAAmB,GAAG,0BAA0B,GAAG,kBAAkB,CAAC;AAExE;;;;;;;;;GASG;AACH,wBAAgB,gBAAgB,CAAC,SAAS,EACxC,QAAQ,EAAE,SAAS,EACnB,aAAa,EAAE,MAAM,SAAS,EAC9B,UAAU,EAAE,MAAM,SAAS,EAC3B,IAAI,EAAE,eAAe,GACpB,OAAO,CAAC,OAAO,CAAC,WAAW,CAAC,CAS9B;AAwCD,wBAAgB,cAAc,CAAC,OAAO,SAAS,MAAM,EAAE,SAAS,EAC9D,iBAAiB,EAAE,iBAAiB,CAAC,OAAO,CAAC,EAC7C,OAAO,EAAE,iBAAiB,CAAC,SAAS,EAAE,OAAO,CAAC,GAC7C,UAAU,CAAC,OAAO,CAAC,CAyUrB"}

package/dist/lib/crud/make-entity-crud.js

@@ -0,0 +1,318 @@
+'use client';
+import { _ as _extends } from "@swc/helpers/_/_extends";
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { deleteUCFactory, getUCFactory, loadUCFactory, saveUCFactory } from '@entifix/business';
+import { describeEntityColumns, EntifixBuildError, EntifixLogicError, envelopeEntityName, extractMetaEntity } from '@entifix/core';
+import { EntityTable, useCasesForSurface } from '@entifix/react-controls';
+import { entityQueryScope, useDataLoading, useEntityMutation, useEntityRecord } from '@entifix/react-integration';
+import { TransactionSinkTag } from '@entifix/transactions';
+import { useQueryClient } from '@tanstack/react-query';
+import { Context } from 'effect';
+import { useParams, useRouter } from 'next/navigation';
+import { useState } from 'react';
+import { useLocaleHref } from '../i18n/index.js';
+import { pendingFor, pendingRecordsFor, usePendingTransactions } from '../workspace/pending-transactions.js';
+import { EntityCrudForm } from './entity-crud-form.js';
+import { handOffWrite } from './hand-off-write.js';
+import { PendingNotice } from './pending-notice.js';
+import { CATALOG_NEW_SLUG, slugToEntityId } from './slug.js';
+import { useEntityAffordances } from './use-entity-affordances.js';
+import { useEntityBulk } from './use-entity-bulk.js';
+/** What a picker defaults to reading off its target. */ const TARGET_NAME_PROPERTY = 'name';
+/**
+ * Merges the configuration adapter with one repository adapter into the context
+ * the use-cases run against.
+ *
+ * The casts are the price of naming adapters by key: `AdapterKey` narrows which
+ * names may be *offered*, but TypeScript will not carry that narrowing through
+ * an index access on a generic record. The alternative is every call site
+ * passing two `Context` values per entity — the duplication this factory exists
+ * to remove.
+ */ export function mergeCrudContext(adapters, configuration, repository, sink) {
+    return Context.add(Context.merge(adapters[configuration], adapters[repository]), TransactionSinkTag, sink);
+}
+/**
+ * Builds the list page and the single-record page for one entity.
+ *
+ * Every catalog entity used to cost ~10 files and ~300 lines whose only variable
+ * was a class name: two organisms with a `.types.ts` each, two client pages, two
+ * route files. The route files stay (Next needs a module per path); everything
+ * between them is derived from the entity's own metadata, so a new reference
+ * entity is this call plus a nav entry.
+ *
+ * Two things are checked here rather than at the call site, because both fail
+ * silently otherwise. The catalog key must be the entity's own `@entity({ key })`
+ * — they are the same string by convention, and a drifted one titles the form
+ * after a different entity in a way only a reader of both catalogs would catch.
+ * And a `links` entry must name a real member — a picker aimed at nothing renders
+ * identically to a read-only field.
+ *
+ * **Serves compile-time `@entity()` classes only.** Operator reference data ships
+ * with the code, so making this spec-driven would trade type safety for nothing;
+ * a vendor-authored `EntitySpecification` renders through a separate path
+ * (ADR 0014).
+ */ /**
+ * A rejected verb, as something the form's error slot can render.
+ *
+ * `useErrorMessage` resolves `details.code` through the shared `errors`
+ * catalog, so a shell that throws an `EntifixError` carrying one gets its
+ * translated sentence; anything else — a network failure, a thrown string —
+ * keeps its message rather than being relabelled with a code it never had.
+ */ function asEntifixError(failure) {
+    return failure instanceof EntifixLogicError || failure instanceof EntifixBuildError ? failure : new EntifixLogicError(failure instanceof Error ? failure.message : String(failure));
+}
+export function makeEntityCrud(entityConstructor, options) {
+    const { useAdapters, basePath, catalogKey, repository, configuration, hiddenFields = [], columns, toolbar, links = [], metadataSource, runBulkUseCase, runUseCase } = options;
+    const meta = extractMetaEntity(entityConstructor);
+    if (meta.key !== catalogKey) {
+        throw new EntifixBuildError(`${entityConstructor.name} declares key "${String(meta.key)}" but was given catalog key "${catalogKey}"`);
+    }
+    // Read off `@entity()` rather than rebuilt from `catalogKey`. Both spellings
+    // produce the same string today, and that is exactly the problem: a second
+    // place that knows how an entity's catalog subtree is laid out is a second
+    // place to fix when one moves. `MetaEntityOptions` makes them optional, so an
+    // entity that never declared them fails here — where a screen is generated —
+    // rather than on the render that first tries to title a tab with `undefined`.
+    const { labelKey: entityLabelKey, pluralKey: entityPluralKey } = meta;
+    if (entityLabelKey === undefined || entityPluralKey === undefined) {
+        throw new EntifixBuildError(`${entityConstructor.name} must declare labelKey and pluralKey on @entity() to be generated`);
+    }
+    // Computed once: a descriptor is a property of the class, so nothing about it
+    // depends on the record being edited. `linkLabelProperty`/`linkSearchProperty`
+    // are overridden here because a scalar foreign key's `@accessor()` cannot name
+    // the target's members — it may not import the target at all.
+    // The wire name, which is also what a pending entry records and what
+    // `entityQueryScopeFor` keys on — one derivation, so a notice and an
+    // invalidation can never disagree about which entity they mean.
+    const entityName = envelopeEntityName(entityConstructor);
+    const descriptors = describeEntityColumns(entityConstructor);
+    const linkPlans = links.map((link)=>{
+        var _link_labelProperty, _link_searchProperty;
+        const descriptor = descriptors.find((entry)=>entry.name === link.field);
+        if (descriptor === undefined) {
+            throw new EntifixBuildError(`${entityConstructor.name} has no member "${link.field}" for a link source`);
+        }
+        return _extends({}, link, {
+            descriptor: _extends({}, descriptor, {
+                linkLabelProperty: (_link_labelProperty = link.labelProperty) != null ? _link_labelProperty : TARGET_NAME_PROPERTY,
+                linkSearchProperty: (_link_searchProperty = link.searchProperty) != null ? _link_searchProperty : TARGET_NAME_PROPERTY
+            })
+        });
+    });
+    function ListPage() {
+        var _affordances_metadata, _affordances_metadata1;
+        const adapters = useAdapters();
+        // Outside a `PendingTransactionsProvider` this watches nothing, so a host
+        // that has not mounted one behaves exactly as it did before.
+        const pending = usePendingTransactions();
+        // Every internal href carries the locale. An unprefixed one still resolves —
+        // the middleware redirects it — but the visitor pays a round trip per click.
+        const withLocale = useLocaleHref();
+        const queryClient = useQueryClient();
+        const scope = entityQueryScope(entityConstructor);
+        const affordances = useEntityAffordances(entityConstructor, metadataSource);
+        // Records this browser has created but the service has not finished
+        // writing. Prepended below rather than patched into the cache, which a
+        // refetch would undo.
+        const optimistic = pendingRecordsFor(pending, entityName);
+        const pager = useDataLoading({
+            uc: loadUCFactory(),
+            ctx: mergeCrudContext(adapters, configuration, repository, pending),
+            // Scoped rather than left to the per-instance fallback, which is correct
+            // but unshared: with the entity's own scope one invalidation refreshes
+            // every page and filter of it, which is what a bulk run needs — and it is
+            // the same prefix `useReactiveInvalidation`already targets, so a generated
+            // list now also refreshes on a reactive change event.
+            queryKey: scope
+        });
+        // Only when this caller may actually run something over a selection.
+        //
+        // Measured live: an `admin` holds `catalog-reference:*:read` and no
+        // `retire`, so the service filters the verb out of `$metadata` — but the
+        // selection column still rendered, offering a set that no action could be
+        // taken on. A checkbox that can lead nowhere is worse than no checkbox: it
+        // reads as a permission the user does not have.
+        //
+        // Decided from the served document rather than from the runner, because
+        // the runner is a property of the *shell* (it knows the route) and the
+        // grant is a property of the *caller*. The column therefore appears when
+        // the document lands, which is the asynchrony ADR 0026 already accepts for
+        // every action surface.
+        const canRunBulk = useCasesForSurface('bulk-bar', (_affordances_metadata = affordances.metadata) == null ? void 0 : _affordances_metadata.useCases).length > 0;
+        const bulk = useEntityBulk({
+            run: canRunBulk ? runBulkUseCase : undefined,
+            // A bulk write changed the rows underneath the listing, so the page is
+            // re-read; the selection deliberately survives it (#121 — "the selection
+            // is still there afterwards"), because the operator's next act is usually
+            // to retry the failures or run a second verb on the same rows.
+            onCompleted: ()=>{
+                void queryClient.invalidateQueries({
+                    queryKey: scope
+                });
+            }
+        });
+        // What a row's overflow menu runs, and the one place the list reports a
+        // verb that failed.
+        //
+        // ⚠️ **A row verb and the form's are the same runner with different
+        // arguments.** `EntityTable` hands back the whole record, because that is
+        // what it has; `runUseCase` takes an id, because that is what a route needs
+        // (#216). The list has no error slot of its own, so a failure lands in the
+        // table's own error region — the same one a failed page read uses.
+        const [useCaseError, setUseCaseError] = useState(undefined);
+        // Called unconditionally and the *result* gated, the way the surfaces are
+        // read in `EntityForm`: the name begins with `use`, so short-circuiting it
+        // reads to `react-hooks/rules-of-hooks` as a conditional hook.
+        const rowUseCases = useCasesForSurface('row-menu', (_affordances_metadata1 = affordances.metadata) == null ? void 0 : _affordances_metadata1.useCases);
+        const canRunRowUseCase = runUseCase !== undefined && rowUseCases.length > 0;
+        const handleRowUseCase = canRunRowUseCase ? (key, item)=>{
+            if (item.id == null) return;
+            setUseCaseError(undefined);
+            void runUseCase(key, item.id).then(()=>queryClient.invalidateQueries({
+                    queryKey: scope
+                }), (failure)=>setUseCaseError(asEntifixError(failure)));
+        } : undefined;
+        return /*#__PURE__*/ _jsxs("div", {
+            className: "flex flex-col gap-s",
+            children: [
+                /*#__PURE__*/ _jsx(PendingNotice, {
+                    entries: pendingFor(pending, entityName),
+                    onDismiss: pending.dismiss
+                }),
+                /*#__PURE__*/ _jsxs(EntityTable, _extends({
+                    entityConstructor: entityConstructor
+                }, pager, {
+                    items: [
+                        ...optimistic,
+                        ...pager.items
+                    ],
+                    totalItems: pager.totalItems + optimistic.length,
+                    hrefFor: (id)=>withLocale(`${basePath}/${String(id)}`),
+                    newHref: withLocale(`${basePath}/${CATALOG_NEW_SLUG}`)
+                }, affordances, bulk.tableProps, {
+                    onUseCase: handleRowUseCase,
+                    error: useCaseError != null ? useCaseError : pager.error,
+                    children: [
+                        columns,
+                        toolbar
+                    ]
+                }))
+            ]
+        });
+    }
+    /**
+   * Dual-host: as a route it reads its slug from the URL and returns to the list
+   * on save; in a workspace tab it takes the slug and the post-save action as
+   * props.
+   */ function SingleViewPage({ slug, onSaved, onDeleted, draft } = {}) {
+        var _ref, _ref1;
+        const adapters = useAdapters();
+        const pending = usePendingTransactions();
+        const router = useRouter();
+        const withLocale = useLocaleHref();
+        const params = useParams();
+        // A verb's failure is this page's, not the record fetch's or the mutation's,
+        // so it needs a slot of its own to reach the form's error area.
+        const [useCaseError, setUseCaseError] = useState(undefined);
+        const id = slugToEntityId(slug != null ? slug : params.slug);
+        const ctx = mergeCrudContext(adapters, configuration, repository, pending);
+        const { entity, isLoading, error: loadError, reload } = useEntityRecord({
+            uc: getUCFactory(),
+            ctx,
+            id
+        });
+        const { save, remove, isSaving, isDeleting, error: writeError } = useEntityMutation({
+            saveUc: saveUCFactory(),
+            deleteUc: deleteUCFactory(),
+            ctx
+        });
+        // Rebuilt inline on every render on purpose: `useEntityLinkSource` holds
+        // these in a ref and keeps them out of its query keys, precisely so a caller
+        // does not have to memoise them.
+        const linkSources = linkPlans.map((plan)=>({
+                field: plan.field,
+                descriptor: plan.descriptor,
+                config: {
+                    entityConstructor: plan.entityConstructor,
+                    loadUc: loadUCFactory(),
+                    getUc: getUCFactory(),
+                    ctx: mergeCrudContext(adapters, configuration, plan.repository, pending)
+                }
+            }));
+        const afterSave = onSaved != null ? onSaved : ()=>router.push(withLocale(basePath));
+        const afterDelete = onDeleted != null ? onDeleted : ()=>router.push(withLocale(basePath));
+        // The draft is spent once the write *commits*, and only here is that known:
+        // `useEntityForm` neither fetches nor saves, so it cannot clear its own.
+        // A failed mutation deliberately keeps the draft — the edit is still the
+        // user's only copy of what they typed.
+        const handleSave = async (next)=>{
+            const saved = await save(next);
+            if (saved === undefined) return;
+            // ⚠️ Deliberately *not* a `setQueriesData` patch. The list refetches on
+            // mount — precisely when the operator arrives, having just been navigated
+            // here — and the server legitimately does not hold the record yet, so the
+            // refetch would replace the patched page and the row would vanish a
+            // moment after appearing. The pending set outlives refetches.
+            handOffWrite({
+                id: String(saved.id),
+                record: saved,
+                pending,
+                draft
+            });
+            afterSave();
+        };
+        const handleDelete = async ()=>{
+            if (await remove(id)) {
+                draft == null ? void 0 : draft.clear();
+                afterDelete();
+            }
+        };
+        /**
+     * An `entity`-bound verb, on the record being shown.
+     *
+     * It **reloads** rather than patching what it has: the service decides the
+     * resulting state — a `publish` may land on `published` from four different
+     * places — and a client that assumed the new value would show the wrong one
+     * the first time the rule changed. `id == null` means the create form,
+     * where there is no record to act on and the form renders no verbs anyway.
+     *
+     * ⚠️ The rejection is **caught and shown**, never left to the promise.
+     * `EntityForm`'s `onUseCase` returns `void`, so an uncaught rejection here
+     * reaches the console and nothing else — measured on an offering refusing
+     * `unpublish` from `draft`: the service answered `409` with a coded body,
+     * the record correctly did not move, and the operator saw a button that
+     * appeared to do nothing at all.
+     */ const handleUseCase = runUseCase === undefined || id == null ? undefined : (key)=>{
+            setUseCaseError(undefined);
+            void runUseCase(key, id).then(()=>reload(), (failure)=>setUseCaseError(asEntifixError(failure)));
+        };
+        return /*#__PURE__*/ _jsx(EntityCrudForm, {
+            entityConstructor: entityConstructor,
+            catalogKey: catalogKey,
+            metadataSource: metadataSource,
+            hiddenFields: hiddenFields,
+            links: linkSources,
+            entity: entity,
+            isLoading: isLoading,
+            isSaving: isSaving,
+            isDeleting: isDeleting,
+            error: (_ref = loadError != null ? loadError : writeError) != null ? _ref : useCaseError,
+            onSave: handleSave,
+            onDelete: id == null ? undefined : handleDelete,
+            onUseCase: handleUseCase,
+            backHref: withLocale(basePath),
+            draft: draft
+        }, String((_ref1 = entity == null ? void 0 : entity.id) != null ? _ref1 : CATALOG_NEW_SLUG));
+    }
+    return {
+        entityConstructor,
+        entityKey: catalogKey,
+        entityLabelKey,
+        entityPluralKey,
+        basePath,
+        ListPage,
+        SingleViewPage
+    };
+}
+
+//# sourceMappingURL=make-entity-crud.js.map