@endora-commerce/mod-custom-fields 0.0.0-stage → 0.100.0

package/dist/manifest.d.ts

@@ -0,0 +1,177 @@
+import { type ModuleUninstallHook } from '@endora-commerce/contracts';
+/**
+ * Custom Fields module — manifest (feature 055).
+ *
+ * Owns the entity-agnostic custom-field definition/option registry and the
+ * value-validation service consumed by host modules. Platform-global; values
+ * live on host rows and inherit the host's tenant scope (Principle XI).
+ * Definition/option mutations run through the Command Bus (Principle XIII).
+ */
+export declare const manifest: {
+    id: string;
+    name: string;
+    version: string;
+    dependencies: string[];
+    description?: string | undefined;
+    acknowledgedDependencies?: {
+        moduleId: string;
+        port: string;
+        reason: string;
+    }[] | undefined;
+    nonBindingDependencies?: {
+        moduleId: string;
+        name: string;
+        kind: "contributes-to" | "degrades-without" | "refuses-without";
+        reason: string;
+        whenAbsent?: string | undefined;
+    }[] | undefined;
+    activation?: {
+        settingCode: string;
+        default: boolean;
+    } | {
+        nonDeactivatable: true;
+        reason: string;
+    } | undefined;
+    settings?: {
+        moduleCode: string;
+        groups: {
+            code: string;
+            name: string;
+            salesChannelCodes?: string[] | undefined;
+            isSystemProtected?: boolean | undefined;
+        }[];
+        settings: {
+            code: string;
+            name: string;
+            valueType: "string" | "number" | "boolean" | "json" | "string_list" | "secret" | "credential_ref";
+            defaultValue: unknown;
+            description?: string | undefined;
+            groupCode?: string | undefined;
+            previousDefaultValues?: unknown[] | undefined;
+            salesChannelCodes?: string[] | undefined;
+            enumOptions?: string[] | undefined;
+            configurationType?: string | undefined;
+            hidden?: boolean | undefined;
+        }[];
+    } | undefined;
+    i18n?: {
+        bundlesDir: string;
+    } | undefined;
+    docs?: false | {
+        dir: string;
+    } | undefined;
+    demo?: false | {
+        summary: string;
+        seed: (context: import("@endora-commerce/contracts").ModuleDemoContext<never>) => Promise<import("@endora-commerce/contracts").DemoSeedResult>;
+        reset: (context: import("@endora-commerce/contracts").ModuleDemoContext<never>) => Promise<import("@endora-commerce/contracts").DemoResetResult>;
+        after?: readonly string[] | undefined;
+        package?: string | undefined;
+    } | undefined;
+    actions?: {
+        id: string;
+        labelKey: string;
+        icon: "Plus" | "Sparkles" | "Settings" | "Search" | "Boxes" | "Layers" | "Menu" | "PlusCircle" | "PlusSquare" | "FilePlus" | "FolderPlus" | "Upload" | "FileUp" | "CloudUpload" | "Download" | "FileDown" | "FileText" | "BookOpen" | "Rss" | "Package" | "Tag" | "ShoppingCart" | "Receipt" | "CreditCard" | "Users" | "UserPlus" | "Inbox" | "ListChecks" | "ClipboardList" | "Image" | "Video" | "LayoutDashboard" | "PanelLeft" | "KeyRound" | "ShieldCheck" | "Edit" | "Archive" | "Box" | "Truck" | "CircleDollarSign" | "Activity" | "LineChart" | "Smartphone" | "Webhook" | "Scale" | "PlugZap" | "PercentDiamond" | "Newspaper" | "Languages" | "Eraser" | "Warehouse" | "TrendingDown" | "Bell" | "PackageOpen" | "Building2" | "Store" | "ClipboardCheck";
+        targetRoute: string;
+        keywords: string[];
+        weight: number;
+        descriptionKey?: string | undefined;
+        requiredPermission?: string | undefined;
+    }[] | undefined;
+    permissions?: {
+        code: string;
+        label: string;
+        module?: string | undefined;
+        description?: string | undefined;
+        requires?: string[] | undefined;
+    }[] | undefined;
+    transactionalEmails?: {
+        code: string;
+        name: string;
+        variables: {
+            key: string;
+            label: string;
+            sampleValue?: string | undefined;
+            description?: string | undefined;
+        }[];
+        description?: string | undefined;
+        group?: string | undefined;
+    }[] | undefined;
+    capabilities?: string[] | undefined;
+    exclusiveCapabilities?: {
+        key: string;
+        errorCode: string;
+    }[] | undefined;
+    errorCodes?: {
+        code: string;
+        tokens?: string[] | undefined;
+    }[] | undefined;
+    blocks?: {
+        name: string;
+        labelKey: string;
+        category: string;
+        contexts: ("invoice" | "email" | "cms" | "newsletter")[];
+        fields: Record<string, {
+            type: "number" | "object" | "array" | "text" | "textarea" | "select" | "radio" | "external" | "uuid" | "richtext";
+            label?: string | undefined;
+            required?: boolean | undefined;
+            options?: {
+                label: string;
+                value: string | number;
+            }[] | undefined;
+            refKind?: string | undefined;
+        }>;
+        descriptionKey?: string | undefined;
+        defaultProps?: Record<string, unknown> | undefined;
+        responsiveFields?: string[] | undefined;
+        previewIcon?: string | undefined;
+        weight?: number | undefined;
+    }[] | undefined;
+    blockCategories?: {
+        key: string;
+        titleKey: string;
+        contexts: ("invoice" | "email" | "cms" | "newsletter")[];
+        weight?: number | undefined;
+        visible?: boolean | undefined;
+    }[] | undefined;
+    env?: {
+        name: string;
+        describes: {
+            en: string;
+            pl: string;
+        };
+        requirement: {
+            kind: "required";
+        } | {
+            kind: "requiredWhen";
+            input: string;
+            equals: string;
+        } | {
+            kind: "optional";
+            without: {
+                en: string;
+                pl: string;
+            };
+        };
+        secret: boolean;
+        generable: boolean;
+        owner: {
+            kind: "platform";
+        } | {
+            kind: "application";
+            application: "admin" | "backend" | "storefront";
+        } | {
+            kind: "module";
+            moduleId: string;
+        };
+        consumers: ("admin" | "backend" | "storefront")[];
+        addressOf: "admin" | "backend" | "storefront" | null;
+    }[] | undefined;
+};
+/**
+ * Hard-uninstall cleanup (feature 055). A soft uninstall keeps definitions so a
+ * re-install restores them; a hard uninstall drops all definitions (options
+ * cascade via FK). Host `custom_field_values` columns are owned by their host
+ * modules and removed with them, so nothing dangles either way.
+ */
+export declare const uninstallHook: ModuleUninstallHook;
+//# sourceMappingURL=manifest.d.ts.map

package/dist/manifest.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"manifest.d.ts","sourceRoot":"","sources":["../src/manifest.ts"],"names":[],"mappings":"AAAA,OAAO,EAAwB,KAAK,mBAAmB,EAAE,MAAM,4BAA4B,CAAC;AAG5F;;;;;;;GAOG;AACH,eAAO,MAAM,QAAQ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAyGnB,CAAC;AAEH;;;;;GAKG;AACH,eAAO,MAAM,aAAa,EAAE,mBAO3B,CAAC"}

package/dist/manifest.js

@@ -0,0 +1,130 @@
+import { defineModuleManifest } from '@endora-commerce/contracts';
+/**
+ * Custom Fields module — manifest (feature 055).
+ *
+ * Owns the entity-agnostic custom-field definition/option registry and the
+ * value-validation service consumed by host modules. Platform-global; values
+ * live on host rows and inherit the host's tenant scope (Principle XI).
+ * Definition/option mutations run through the Command Bus (Principle XIII).
+ */
+export const manifest = defineModuleManifest({
+    id: 'custom_fields',
+    name: 'Custom Fields',
+    description: 'Entity-agnostic runtime custom fields for core entities.',
+    version: '1.0.0',
+    // `auth` owns the `requireAdmin` port the admin routes are gated by.
+    dependencies: ['auth'],
+    i18n: { bundlesDir: 'i18n' },
+    /**
+     * The `CUSTOM_FIELD_*` family — D-129's remaining sweep, Tier A
+     * (`specs/090-module-owned-error-codes/d129-sweep.md` §5.2, Appendix A;
+     * MR 3).
+     *
+     * All five were declared by `_i18n` until this merge request, not because
+     * anybody judged them the platform's but because the deleted prefix chain
+     * had no rule for them and its last line was `return 'core'`. **D-121 T1
+     * puts them here**: the noun in every one of them is a custom field — its
+     * definition, its key, its option set or a value being written against it —
+     * and this module owns the definition registry, the option rows and the
+     * validation service that decides all five refusals.
+     *
+     * **`CUSTOM_FIELD_VALUE_INVALID` is the one a raise-site count gets wrong,
+     * and it is the reason the family is declared as a family.** Five modules
+     * raise it — `catalog`, `customers`, `orders`, `organizations` and
+     * `quote_requests` — and not one of them decides it: each calls this
+     * module's validation seam over its own host rows and re-answers the
+     * failures it gets back. The judgement, the rules it is made against and the
+     * definitions those rules come from are all here, so T1 puts the code here
+     * and T2's "sole thrower" question never arises. `d129-sweep.md` §2.3 flags
+     * it by name for exactly that reason. `CUSTOM_FIELD_HOST_MANAGED` is the
+     * mirror image: it is raised only here, and it refuses a definition whose
+     * entity type another module manages — the marker is read
+     * entity-agnostically, so the refusal is about this registry rather than
+     * about whichever module happens to be named in it.
+     *
+     * **No sentence moves with them.** None of the five has a sentence in either
+     * language anywhere in the tree; all five were already on
+     * `UNTRANSLATED_ERROR_CODES` under `_i18n` and move to this module's group
+     * there, so the bundle this module already ships gains no key.
+     *
+     * **`tokens` is derived from the raise sites, not from the bundle**
+     * (runbook §5), and there are none to declare. `CUSTOM_FIELD_VALUE_INVALID`
+     * is the one that carries `details`, and it is the Zod-shaped
+     * `{ path, issue }[]` array, which `refusalToken` reads as no token at all
+     * (`packages/platform/src/http/error-envelope.ts`); the other four are bare
+     * `HttpError(status, code, message)`.
+     */
+    errorCodes: [
+        { code: 'CUSTOM_FIELD_DEFINITION_INVALID' },
+        { code: 'CUSTOM_FIELD_HOST_MANAGED' },
+        { code: 'CUSTOM_FIELD_KEY_CONFLICT' },
+        { code: 'CUSTOM_FIELD_NOT_FOUND' },
+        { code: 'CUSTOM_FIELD_VALUE_INVALID' },
+    ],
+    permissions: [
+        { code: 'custom_fields:read', label: 'View custom fields' },
+        { code: 'custom_fields:write', label: 'Manage custom fields (definitions and options)' },
+    ],
+    actions: [
+        {
+            id: 'open-custom-fields',
+            labelKey: 'actions.openCustomFields.label',
+            descriptionKey: 'actions.openCustomFields.description',
+            icon: 'Layers',
+            targetRoute: '/custom-fields',
+            requiredPermission: 'custom_fields:read',
+            keywords: ['custom fields', 'attributes', 'pola', 'niestandardowe'],
+            weight: 240,
+        },
+    ],
+    // Feature 074 (Constitution XVII), test C3 — platform primitive. The flag
+    // used to rest on `organizations` declaring this module; ruling 2 withdraws
+    // a dependent's authority to impose the lock, so the ground is now this
+    // module's own. It is Principle XIV's extensibility mechanism: the answer
+    // the platform gives to "add a field" instead of a bespoke column. Switching
+    // it off does not remove a capability a client chose, it makes the values
+    // already stored against every host entity unreachable.
+    /**
+     * Nothing to demonstrate of its own (feature 113, T224 — contract §1.2).
+     *
+     * The demo shop does have seven product-host custom-field definitions, and
+     * they are not this module's demo data: a product attribute is one of those
+     * definitions paired 1:1 with a `catalog` extension row and written in one
+     * call (feature 061), so it is two modules' rows in one statement and belongs
+     * to whoever owns the instance (§5.1). It is a step of
+     * `backend/src/seeds/demo-composition.ts`, guarded on both modules, and this
+     * module does not declare `catalog` — §2.3's rule that `demo` may not become a
+     * way of acquiring a dependency.
+     *
+     * That is a **correction to §3.3**, which proposed that this module seed the
+     * definitions and `catalog` seed the extensions behind an advisory `after`
+     * edge. `catalog` would then have had to read `custom_field_definitions` to
+     * find the id its extension row references, which §2.2 forbids, so the split
+     * has no implementation.
+     *
+     * `false` rather than absent, because the two are different states: this is a
+     * decision that the module owes nothing, not a module nobody has looked at.
+     */
+    demo: false,
+    activation: {
+        nonDeactivatable: true,
+        reason: 'The platform\'s extensibility mechanism; the custom values already stored against ' +
+            'every host entity become unreachable without it.',
+    },
+});
+/**
+ * Hard-uninstall cleanup (feature 055). A soft uninstall keeps definitions so a
+ * re-install restores them; a hard uninstall drops all definitions (options
+ * cascade via FK). Host `custom_field_values` columns are owned by their host
+ * modules and removed with them, so nothing dangles either way.
+ */
+export const uninstallHook = async (ctx) => {
+    if (!ctx.hard)
+        return;
+    const em = ctx.em;
+    await em
+        .getConnection()
+        .execute('truncate table "custom_field_options", "custom_field_definitions" cascade');
+    ctx.log.info('custom_fields: removed all custom-field definitions on hard uninstall');
+};
+//# sourceMappingURL=manifest.js.map

package/dist/manifest.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"manifest.js","sourceRoot":"","sources":["../src/manifest.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,oBAAoB,EAA4B,MAAM,4BAA4B,CAAC;AAG5F;;;;;;;GAOG;AACH,MAAM,CAAC,MAAM,QAAQ,GAAG,oBAAoB,CAAC;IAC3C,EAAE,EAAE,eAAe;IACnB,IAAI,EAAE,eAAe;IACrB,WAAW,EAAE,0DAA0D;IACvE,OAAO,EAAE,OAAO;IAChB,qEAAqE;IACrE,YAAY,EAAE,CAAC,MAAM,CAAC;IACtB,IAAI,EAAE,EAAE,UAAU,EAAE,MAAM,EAAE;IAC5B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OAsCG;IACH,UAAU,EAAE;QACV,EAAE,IAAI,EAAE,iCAAiC,EAAE;QAC3C,EAAE,IAAI,EAAE,2BAA2B,EAAE;QACrC,EAAE,IAAI,EAAE,2BAA2B,EAAE;QACrC,EAAE,IAAI,EAAE,wBAAwB,EAAE;QAClC,EAAE,IAAI,EAAE,4BAA4B,EAAE;KACvC;IACD,WAAW,EAAE;QACX,EAAE,IAAI,EAAE,oBAAoB,EAAE,KAAK,EAAE,oBAAoB,EAAE;QAC3D,EAAE,IAAI,EAAE,qBAAqB,EAAE,KAAK,EAAE,gDAAgD,EAAE;KACzF;IACD,OAAO,EAAE;QACP;YACE,EAAE,EAAE,oBAAoB;YACxB,QAAQ,EAAE,gCAAgC;YAC1C,cAAc,EAAE,sCAAsC;YACtD,IAAI,EAAE,QAAQ;YACd,WAAW,EAAE,gBAAgB;YAC7B,kBAAkB,EAAE,oBAAoB;YACxC,QAAQ,EAAE,CAAC,eAAe,EAAE,YAAY,EAAE,MAAM,EAAE,gBAAgB,CAAC;YACnE,MAAM,EAAE,GAAG;SACZ;KACF;IACD,0EAA0E;IAC1E,4EAA4E;IAC5E,wEAAwE;IACxE,0EAA0E;IAC1E,6EAA6E;IAC7E,0EAA0E;IAC1E,wDAAwD;IACxD;;;;;;;;;;;;;;;;;;;;OAoBG;IACH,IAAI,EAAE,KAAK;IACX,UAAU,EAAE;QACV,gBAAgB,EAAE,IAAI;QACtB,MAAM,EACJ,oFAAoF;YACpF,kDAAkD;KACrD;CACF,CAAC,CAAC;AAEH;;;;;GAKG;AACH,MAAM,CAAC,MAAM,aAAa,GAAwB,KAAK,EAAE,GAAG,EAAE,EAAE;IAC9D,IAAI,CAAC,GAAG,CAAC,IAAI;QAAE,OAAO;IACtB,MAAM,EAAE,GAAG,GAAG,CAAC,EAAmB,CAAC;IACnC,MAAM,EAAE;SACL,aAAa,EAAE;SACf,OAAO,CAAC,2EAA2E,CAAC,CAAC;IACxF,GAAG,CAAC,GAAG,CAAC,IAAI,CAAC,uEAAuE,CAAC,CAAC;AACxF,CAAC,CAAC"}

package/dist/migrations/20260718T200338_custom_fields_init.d.ts

@@ -0,0 +1,20 @@
+import { Migration } from '@mikro-orm/migrations';
+/**
+ * Feature 055 — Custom Fields Layer (init).
+ *
+ * Creates the two entity-agnostic module tables:
+ *   - `custom_field_definitions` — operator-defined typed fields per host
+ *     entity type (unique `(entity_type, key)`), with per-locale label +
+ *     fallback, value type, required flag, ordering, and an opaque `config`
+ *     JSONB for host-capability opt-in the generic core never interprets.
+ *   - `custom_field_options` — select/multiselect option lists (unique
+ *     `(definition_id, value)`, FK ON DELETE CASCADE).
+ *
+ * The per-host `custom_field_values` JSONB columns are added additively by the
+ * host modules (migrations 092–096). `product_attributes` is untouched (FR-011).
+ */
+export declare class Migration20260718T200338CustomFieldsInit extends Migration {
+    up(): Promise<void>;
+    down(): Promise<void>;
+}
+//# sourceMappingURL=20260718T200338_custom_fields_init.d.ts.map

package/dist/migrations/20260718T200338_custom_fields_init.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"20260718T200338_custom_fields_init.d.ts","sourceRoot":"","sources":["../../src/migrations/20260718T200338_custom_fields_init.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAE,MAAM,uBAAuB,CAAC;AAElD;;;;;;;;;;;;;GAaG;AACH,qBAAa,wCAAyC,SAAQ,SAAS;IACtD,EAAE,IAAI,OAAO,CAAC,IAAI,CAAC;IAkDnB,IAAI,IAAI,OAAO,CAAC,IAAI,CAAC;CAIrC"}

package/dist/migrations/20260718T200338_custom_fields_init.js

@@ -0,0 +1,60 @@
+import { Migration } from '@mikro-orm/migrations';
+/**
+ * Feature 055 — Custom Fields Layer (init).
+ *
+ * Creates the two entity-agnostic module tables:
+ *   - `custom_field_definitions` — operator-defined typed fields per host
+ *     entity type (unique `(entity_type, key)`), with per-locale label +
+ *     fallback, value type, required flag, ordering, and an opaque `config`
+ *     JSONB for host-capability opt-in the generic core never interprets.
+ *   - `custom_field_options` — select/multiselect option lists (unique
+ *     `(definition_id, value)`, FK ON DELETE CASCADE).
+ *
+ * The per-host `custom_field_values` JSONB columns are added additively by the
+ * host modules (migrations 092–096). `product_attributes` is untouched (FR-011).
+ */
+export class Migration20260718T200338CustomFieldsInit extends Migration {
+    async up() {
+        this.addSql(`
+      create table "custom_field_definitions" (
+        "id" uuid not null,
+        "entity_type" varchar(32) not null,
+        "key" varchar(64) not null,
+        "label" jsonb not null default '{}',
+        "label_default" varchar(200) not null,
+        "value_type" varchar(16) not null,
+        "required" boolean not null default false,
+        "sort_order" int not null default 0,
+        "config" jsonb not null default '{}',
+        "created_at" timestamptz not null,
+        "updated_at" timestamptz not null,
+        constraint "custom_field_definitions_pkey" primary key ("id")
+      );
+    `);
+        this.addSql(`alter table "custom_field_definitions" add constraint "custom_field_definitions_entity_key_unique" unique ("entity_type", "key");`);
+        this.addSql(`create index "custom_field_definitions_entity_type_idx" on "custom_field_definitions" ("entity_type");`);
+        this.addSql(`
+      create table "custom_field_options" (
+        "id" uuid not null,
+        "definition_id" uuid not null,
+        "value" varchar(200) not null,
+        "label" jsonb not null default '{}',
+        "label_default" varchar(200) not null,
+        "is_default" boolean not null default false,
+        "sort_order" int not null default 0,
+        "created_at" timestamptz not null,
+        "updated_at" timestamptz not null,
+        constraint "custom_field_options_pkey" primary key ("id")
+      );
+    `);
+        this.addSql(`alter table "custom_field_options" add constraint "custom_field_options_definition_value_unique" unique ("definition_id", "value");`);
+        this.addSql(`create index "custom_field_options_definition_idx" on "custom_field_options" ("definition_id");`);
+        this.addSql(`alter table "custom_field_options" add constraint "custom_field_options_definition_fk" ` +
+            `foreign key ("definition_id") references "custom_field_definitions" ("id") on delete cascade;`);
+    }
+    async down() {
+        this.addSql(`drop table if exists "custom_field_options" cascade;`);
+        this.addSql(`drop table if exists "custom_field_definitions" cascade;`);
+    }
+}
+//# sourceMappingURL=20260718T200338_custom_fields_init.js.map

package/dist/migrations/20260718T200338_custom_fields_init.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"20260718T200338_custom_fields_init.js","sourceRoot":"","sources":["../../src/migrations/20260718T200338_custom_fields_init.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAE,MAAM,uBAAuB,CAAC;AAElD;;;;;;;;;;;;;GAaG;AACH,MAAM,OAAO,wCAAyC,SAAQ,SAAS;IAC5D,KAAK,CAAC,EAAE;QACf,IAAI,CAAC,MAAM,CAAC;;;;;;;;;;;;;;;KAeX,CAAC,CAAC;QACH,IAAI,CAAC,MAAM,CACT,mIAAmI,CACpI,CAAC;QACF,IAAI,CAAC,MAAM,CACT,wGAAwG,CACzG,CAAC;QAEF,IAAI,CAAC,MAAM,CAAC;;;;;;;;;;;;;KAaX,CAAC,CAAC;QACH,IAAI,CAAC,MAAM,CACT,qIAAqI,CACtI,CAAC;QACF,IAAI,CAAC,MAAM,CACT,iGAAiG,CAClG,CAAC;QACF,IAAI,CAAC,MAAM,CACT,yFAAyF;YACvF,+FAA+F,CAClG,CAAC;IACJ,CAAC;IAEQ,KAAK,CAAC,IAAI;QACjB,IAAI,CAAC,MAAM,CAAC,sDAAsD,CAAC,CAAC;QACpE,IAAI,CAAC,MAAM,CAAC,0DAA0D,CAAC,CAAC;IAC1E,CAAC;CACF"}

package/dist/migrations/index.d.ts

@@ -0,0 +1,27 @@
+/**
+ * The `./migrations` subpath — every migration class this module owns, as one
+ * ordered `migrations` array.
+ *
+ * The array is what the platform reads when this module is **installed**:
+ * `src/packages/package-runtime.ts` takes `exported['migrations']` and refuses
+ * the package outright when it is absent (D-168).
+ *
+ * Listed in ascending timestamp, which is the order of this module's own
+ * migrations and of nothing else (feature 081): a manifest `dependencies` array
+ * is the only thing ordering this block against another module's.
+ *
+ * The **named** exports stay beside the array, and the asymmetry with
+ * `./backend` — which publishes an array and no named class (D-168) — is
+ * deliberate. `db/migrations-registry.generated.ts` imports each class by name
+ * from this specifier, and a migration class name is contract in a way an entity
+ * class name is not: `mikro_orm_migrations` persists it, so it is a string every
+ * already-migrated database holds.
+ *
+ * A class that is in neither the array nor the barrel is a migration that does
+ * not run: `migration:pending` reports nothing pending and the first symptom is
+ * a query against a table nobody created.
+ */
+import { Migration20260718T200338CustomFieldsInit } from './20260718T200338_custom_fields_init.js';
+export declare const migrations: (typeof Migration20260718T200338CustomFieldsInit)[];
+export { Migration20260718T200338CustomFieldsInit, };
+//# sourceMappingURL=index.d.ts.map

package/dist/migrations/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/migrations/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;GAsBG;AAEH,OAAO,EAAE,wCAAwC,EAAE,MAAM,yCAAyC,CAAC;AAEnG,eAAO,MAAM,UAAU,qDAEtB,CAAC;AAEF,OAAO,EACL,wCAAwC,GACzC,CAAC"}

package/dist/migrations/index.js

@@ -0,0 +1,29 @@
+/**
+ * The `./migrations` subpath — every migration class this module owns, as one
+ * ordered `migrations` array.
+ *
+ * The array is what the platform reads when this module is **installed**:
+ * `src/packages/package-runtime.ts` takes `exported['migrations']` and refuses
+ * the package outright when it is absent (D-168).
+ *
+ * Listed in ascending timestamp, which is the order of this module's own
+ * migrations and of nothing else (feature 081): a manifest `dependencies` array
+ * is the only thing ordering this block against another module's.
+ *
+ * The **named** exports stay beside the array, and the asymmetry with
+ * `./backend` — which publishes an array and no named class (D-168) — is
+ * deliberate. `db/migrations-registry.generated.ts` imports each class by name
+ * from this specifier, and a migration class name is contract in a way an entity
+ * class name is not: `mikro_orm_migrations` persists it, so it is a string every
+ * already-migrated database holds.
+ *
+ * A class that is in neither the array nor the barrel is a migration that does
+ * not run: `migration:pending` reports nothing pending and the first symptom is
+ * a query against a table nobody created.
+ */
+import { Migration20260718T200338CustomFieldsInit } from './20260718T200338_custom_fields_init.js';
+export const migrations = [
+    Migration20260718T200338CustomFieldsInit,
+];
+export { Migration20260718T200338CustomFieldsInit, };
+//# sourceMappingURL=index.js.map

package/dist/migrations/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/migrations/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;GAsBG;AAEH,OAAO,EAAE,wCAAwC,EAAE,MAAM,yCAAyC,CAAC;AAEnG,MAAM,CAAC,MAAM,UAAU,GAAG;IACxB,wCAAwC;CACzC,CAAC;AAEF,OAAO,EACL,wCAAwC,GACzC,CAAC"}

package/dist/ports/index.d.ts

@@ -0,0 +1,123 @@
+/**
+ * The port interfaces `custom_fields` publishes, and **nothing that exists at
+ * runtime** (feature 080, T053(b); D-169, D-171).
+ *
+ * `tsc` compiles this file to `export {};`. That is the property D-171 makes
+ * the boundary decision on — *a subpath is contract surface iff the module it
+ * resolves to exports no runtime binding* — and it is why this declaration has
+ * its own file rather than sitting on top of `custom-field-definition.service.ts`,
+ * which exports the service class and an error class beside it. A consumer
+ * naming that file names the owner's implementation, whatever `import type`
+ * erases; a consumer naming this one names a declaration and can name nothing
+ * else.
+ *
+ * **This is not yet a supported specifier and the ledger still counts it.**
+ * `custom_fields` is not a workspace package, so there is no `exports` map for
+ * this to be a subpath of, and `check:module-boundary` reads `catalog`'s
+ * relative import exactly as it read the old one — D-171 says so in as many
+ * words: `resolveModulePackage` returns `null` for any specifier starting with
+ * `.`, so an unconverted reach has no subpath for the exemption to apply to,
+ * and reaching the exempt state takes three separable edits (package the owner,
+ * publish the interface, rewrite the specifier). This file is the second of
+ * those three, taken early because it is the one that does not need the module
+ * to move: when `custom_fields` is packaged, this directory becomes the
+ * package's `./ports` and the consumer's edit is one specifier.
+ *
+ * No entity class leaves by this door, type-only included (D-168).
+ */
+import type { EntityManager } from '@mikro-orm/postgresql';
+import type { CreateCustomFieldDefinitionRequest, CustomFieldDefinitionRecord, CustomFieldOptionDto, CustomFieldOptionRecord, SupportedEntityType, UpdateCustomFieldDefinitionRequest } from '@endora-commerce/contracts';
+/**
+ * Container name: `customFieldDefinitionService`. Owner: `custom_fields`.
+ *
+ * Transactional apply seam for host modules (feature 061,
+ * contracts/custom-fields-product-host.md §3). Every `apply*` call runs inside
+ * the CALLER's transactional EM (a host Command's `run({ em })`), performs the
+ * same invariants as the public CRUD, and does NO command dispatch, NO audit
+ * (the host command audits the composite operation), and NO cache publish.
+ * The caller MUST invoke {@link CustomFieldDefinitionApplyApi.publishInvalidate}
+ * after its transaction commits.
+ *
+ * **Which transaction it runs in, said on this side too** (D-77). The caller's:
+ * a host Command's `run({ em })`, the same `EntityManager` the host writes its
+ * own row on. That is not a convenience — `fk_product_attributes_custom_field_definition`
+ * is `on delete restrict` with a `unique` on the same column, so the child
+ * insert must see its parent inside one transaction, and a second transaction
+ * cannot satisfy a foreign key against a row it cannot see. The seam is
+ * therefore permanent, declared, and named on both sides; what would retire it
+ * is F4's package entry points, or dropping the constraint.
+ *
+ * **The `EntityManager` is a required parameter on every `apply*` method and
+ * never an optional one** (D-169). Open Mercato's `transactionalEm?` is
+ * optional on the context *and* in the handler, so a caller may hand a
+ * transaction to a handler that ignores it and receive a silently non-atomic
+ * write. Do not relax this to match it.
+ *
+ * **This shape may not live in `@endora-commerce/contracts`**, which is the whole
+ * reason it is declared here: `admin` and `storefront` both compile that
+ * package, so it holds zero `@mikro-orm` imports and FR-034 keeps it that way.
+ * The qualifying test D-171 states is not *"is this a real published port"* but
+ * *"does this signature stop the interface living in `packages/contracts`"*,
+ * and seven of these eight methods do.
+ *
+ * **The returns are published records, not live entities** (D-77's first
+ * narrowing). A host reads `id`, `sortOrder`, `labelDefault` and the rest off
+ * what comes back; handing it a managed entity also handed it the ability to
+ * mutate a definition outside the seam, and the ability to persist that change
+ * on the transaction it happens to be holding.
+ *
+ * **The definition *read* is not here** and is not a seventh `apply*`. It is
+ * `CustomFieldDefinitionReadPort.getById` in `@endora-commerce/contracts`, under the
+ * container name `customFieldDefinitionReadPort`: a read handed an
+ * `EntityManager` is a write seam re-opened to serve a read (D-169), and until
+ * T053(b) this interface was where `catalog` got it, typed as a record and
+ * answered with the owner's two managed entities.
+ *
+ * **Owner off:** the seam fails closed — resolving this port throws
+ * `ModuleDisabledError` and the call answers 503 `MODULE_DISABLED`, so nothing
+ * half-executes. Whether `custom_fields` has an off state at all is its
+ * manifest's `activation` to say, not this line's: a module declaring
+ * `nonDeactivatable` never enters one.
+ */
+export interface CustomFieldDefinitionApplyApi {
+    applyCreate(em: EntityManager, input: CreateCustomFieldDefinitionRequest): Promise<CustomFieldDefinitionRecord>;
+    applyUpdate(em: EntityManager, id: string, patch: UpdateCustomFieldDefinitionRequest): Promise<CustomFieldDefinitionRecord>;
+    applyDelete(em: EntityManager, id: string): Promise<void>;
+    /**
+     * Rename a definition's key — the one path by which a key changes after
+     * create, and **not** an edit: {@link applyUpdate}'s patch omits `key`
+     * deliberately, because every host stores its values under the key and an
+     * ordinary rename would orphan them (`specs/134-paid-module-extraction/`
+     * research D12).
+     *
+     * The caller is expected to rename the host's values **in the same
+     * transaction** — for `product`, through `catalog`'s value-key seam on
+     * `@endora-commerce/mod-catalog/ports` — and to call
+     * {@link publishInvalidate} after it commits.
+     *
+     * `expectedKey` is the key the caller planned from: a definition whose key
+     * has moved since is refused (`key_changed`) rather than renamed from a
+     * state the caller never saw. A key held by another definition of the same
+     * entity type is refused (`duplicate_key`), and so is one outside the key
+     * grammar (`invalid_key`). Flushes before it returns, so a two-phase rename
+     * (park every key, then move it) runs its statements in the order written.
+     */
+    applyRenameKey(em: EntityManager, id: string, expectedKey: string, newKey: string): Promise<CustomFieldDefinitionRecord>;
+    applyCreateOption(em: EntityManager, definitionId: string, input: CustomFieldOptionDto): Promise<CustomFieldOptionRecord>;
+    applyUpdateOption(em: EntityManager, definitionId: string, optionId: string, patch: Partial<Pick<CustomFieldOptionDto, 'label' | 'labelDefault' | 'isDefault' | 'sortOrder'>>): Promise<CustomFieldOptionRecord>;
+    applyDeleteOption(em: EntityManager, definitionId: string, optionId: string): Promise<void>;
+    /**
+     * Post-commit responsibility of the caller, and the one method here that
+     * takes no `EntityManager` — by construction, since it must run **after** the
+     * caller's transaction commits.
+     *
+     * It stays on the apply seam rather than moving to the read port with
+     * `getById`, because it is a step of this seam's protocol and not a question
+     * anybody else has: D-97.1 refused to publish the cache mechanism to
+     * consumers at all, and answers the reader's real question with
+     * `CustomFieldDefinitionReadPort.listForEntityFresh` instead. Only a caller
+     * that has just written through `apply*` owes this call.
+     */
+    publishInvalidate(entityType: SupportedEntityType): Promise<void>;
+}
+//# sourceMappingURL=index.d.ts.map

package/dist/ports/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/ports/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AACH,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,uBAAuB,CAAC;AAC3D,OAAO,KAAK,EACV,kCAAkC,EAClC,2BAA2B,EAC3B,oBAAoB,EACpB,uBAAuB,EACvB,mBAAmB,EACnB,kCAAkC,EACnC,MAAM,4BAA4B,CAAC;AAEpC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAmDG;AACH,MAAM,WAAW,6BAA6B;IAC5C,WAAW,CACT,EAAE,EAAE,aAAa,EACjB,KAAK,EAAE,kCAAkC,GACxC,OAAO,CAAC,2BAA2B,CAAC,CAAC;IACxC,WAAW,CACT,EAAE,EAAE,aAAa,EACjB,EAAE,EAAE,MAAM,EACV,KAAK,EAAE,kCAAkC,GACxC,OAAO,CAAC,2BAA2B,CAAC,CAAC;IACxC,WAAW,CAAC,EAAE,EAAE,aAAa,EAAE,EAAE,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;IAC1D;;;;;;;;;;;;;;;;;;OAkBG;IACH,cAAc,CACZ,EAAE,EAAE,aAAa,EACjB,EAAE,EAAE,MAAM,EACV,WAAW,EAAE,MAAM,EACnB,MAAM,EAAE,MAAM,GACb,OAAO,CAAC,2BAA2B,CAAC,CAAC;IACxC,iBAAiB,CACf,EAAE,EAAE,aAAa,EACjB,YAAY,EAAE,MAAM,EACpB,KAAK,EAAE,oBAAoB,GAC1B,OAAO,CAAC,uBAAuB,CAAC,CAAC;IACpC,iBAAiB,CACf,EAAE,EAAE,aAAa,EACjB,YAAY,EAAE,MAAM,EACpB,QAAQ,EAAE,MAAM,EAChB,KAAK,EAAE,OAAO,CAAC,IAAI,CAAC,oBAAoB,EAAE,OAAO,GAAG,cAAc,GAAG,WAAW,GAAG,WAAW,CAAC,CAAC,GAC/F,OAAO,CAAC,uBAAuB,CAAC,CAAC;IACpC,iBAAiB,CAAC,EAAE,EAAE,aAAa,EAAE,YAAY,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;IAC5F;;;;;;;;;;;OAWG;IACH,iBAAiB,CAAC,UAAU,EAAE,mBAAmB,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;CACnE"}

package/dist/ports/index.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=index.js.map

package/dist/ports/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/ports/index.ts"],"names":[],"mappings":""}

package/i18n/en.json

@@ -0,0 +1,15 @@
+{
+  "customFields.title": "Custom Fields",
+  "customFields.description": "Define runtime typed fields on core entities without a code change or migration.",
+  "customFields.entity.category": "Category",
+  "customFields.entity.order": "Order",
+  "customFields.entity.organization": "Organization",
+  "customFields.entity.customer": "Customer",
+  "customFields.entity.quoteRequest": "Quote request",
+  "customFields.entity.product": "Product",
+  "customFields.managedBy.catalogAttributes": "Managed on Catalog → Attributes",
+  "customFields.managedBy.notice": "Definitions for this entity type are managed by another module and are read-only here.",
+  "actions.openCustomFields.label": "Custom fields",
+  "actions.openCustomFields.description": "Define runtime fields on core entities.",
+  "nav.customFields.label": "Custom Fields"
+}

package/i18n/pl.json

@@ -0,0 +1,15 @@
+{
+  "customFields.title": "Pola niestandardowe",
+  "customFields.description": "Definiuj typowane pola na kluczowych encjach bez zmiany kodu i migracji.",
+  "customFields.entity.category": "Kategoria",
+  "customFields.entity.order": "Zamówienie",
+  "customFields.entity.organization": "Organizacja",
+  "customFields.entity.customer": "Klient",
+  "customFields.entity.quoteRequest": "Zapytanie ofertowe",
+  "customFields.entity.product": "Produkt",
+  "customFields.managedBy.catalogAttributes": "Zarządzane w Katalog → Atrybuty",
+  "customFields.managedBy.notice": "Definicje dla tego typu encji są zarządzane przez inny moduł i są tutaj tylko do odczytu.",
+  "actions.openCustomFields.label": "Pola niestandardowe",
+  "actions.openCustomFields.description": "Definiuj pola na kluczowych encjach.",
+  "nav.customFields.label": "Pola niestandardowe"
+}