@open-mercato/core 0.7.1-develop.7193.1.910a5b0a1e → 0.7.1-develop.7194.1.ab4fc81f82

package/dist/modules/workflows/lib/task-entity-types.js

@@ -0,0 +1,36 @@
+import { getEntityIds } from "@open-mercato/shared/lib/encryption/entityIds";
+import { normalizeTaskEntityTypeSpelling, resolveAliasedTaskEntityId } from "./task-entity-aliases.js";
+import {
+  TASK_ENTITY_TYPE_ALIAS_GROUPS,
+  listTaskEntityTypeAliases,
+  normalizeTaskEntityTypeSpelling as normalizeTaskEntityTypeSpelling2,
+  resolveAliasedTaskEntityId as resolveAliasedTaskEntityId2
+} from "./task-entity-aliases.js";
+let registryIdsSource = null;
+let registryIds = /* @__PURE__ */ new Set();
+function knownEntityIds() {
+  const registry = getEntityIds(false);
+  if (registry !== registryIdsSource) {
+    registryIdsSource = registry;
+    registryIds = new Set(
+      Object.values(registry ?? {}).flatMap((moduleEntities) => Object.values(moduleEntities ?? {}))
+    );
+  }
+  return registryIds;
+}
+function normalizeTaskEntityTypeToEntityId(entityType) {
+  if (typeof entityType !== "string") return null;
+  const normalized = normalizeTaskEntityTypeSpelling(entityType);
+  if (!normalized) return null;
+  const aliased = resolveAliasedTaskEntityId(normalized);
+  if (aliased) return aliased;
+  return knownEntityIds().has(normalized) ? normalized : null;
+}
+export {
+  TASK_ENTITY_TYPE_ALIAS_GROUPS,
+  listTaskEntityTypeAliases,
+  normalizeTaskEntityTypeSpelling2 as normalizeTaskEntityTypeSpelling,
+  normalizeTaskEntityTypeToEntityId,
+  resolveAliasedTaskEntityId2 as resolveAliasedTaskEntityId
+};
+//# sourceMappingURL=task-entity-types.js.map

package/dist/modules/workflows/lib/task-entity-types.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../../src/modules/workflows/lib/task-entity-types.ts"],
+  "sourcesContent": ["/**\n * Authored `entityType` \u2192 generated entity id.\n *\n * The bridge between what a task binding carries (free text an author typed)\n * and what the entity-access model is keyed on (`entities.ids.generated.ts`\n * ids, which `ENTITY_ACL_REQUIREMENTS` also keys on). It resolves through the\n * enumerated alias dictionary or through EXACT membership in the entity\n * registry, and refuses everything else.\n *\n * It never guesses. `resolveEntityTableName` pluralizes its way to a table name\n * and logs a warning; doing that here would turn a typo into a plausible-looking\n * grant, which is the opposite of fail-closed. A binding that does not resolve\n * is `null`, and the caller denies.\n *\n * The spellings themselves live in `task-entity-aliases.ts` \u2014 one dictionary,\n * shared with `work-inbox/entity-links.ts`.\n */\n\nimport { getEntityIds } from '@open-mercato/shared/lib/encryption/entityIds'\nimport { normalizeTaskEntityTypeSpelling, resolveAliasedTaskEntityId } from './task-entity-aliases'\n\nexport {\n  TASK_ENTITY_TYPE_ALIAS_GROUPS,\n  listTaskEntityTypeAliases,\n  normalizeTaskEntityTypeSpelling,\n  resolveAliasedTaskEntityId,\n} from './task-entity-aliases'\nexport type { TaskEntityTypeAliasGroup } from './task-entity-aliases'\n\n// The registry is a mutable module singleton (re-registered on HMR), so the\n// derived id set is memoized against the registry's object identity rather than\n// built once and frozen.\nlet registryIdsSource: unknown = null\nlet registryIds: ReadonlySet<string> = new Set<string>()\n\nfunction knownEntityIds(): ReadonlySet<string> {\n  // `false`: an unregistered registry yields an empty set, so every binding\n  // outside the alias table resolves to null and the caller denies. Failing\n  // closed on a missing registry is intended, not a degradation.\n  const registry = getEntityIds(false)\n  if (registry !== registryIdsSource) {\n    registryIdsSource = registry\n    registryIds = new Set(\n      Object.values(registry ?? {}).flatMap((moduleEntities) => Object.values(moduleEntities ?? {})),\n    )\n  }\n  return registryIds\n}\n\n/**\n * The generated entity id an authored binding means, or `null` when nothing\n * enumerated matches it.\n *\n * `null` is a refusal, not a fallback: a typo such as `Custmers:Deal` must hide\n * the task from everyone rather than resolve to something plausible.\n */\nexport function normalizeTaskEntityTypeToEntityId(\n  entityType: string | null | undefined,\n): string | null {\n  if (typeof entityType !== 'string') return null\n  const normalized = normalizeTaskEntityTypeSpelling(entityType)\n  if (!normalized) return null\n  const aliased = resolveAliasedTaskEntityId(normalized)\n  if (aliased) return aliased\n  return knownEntityIds().has(normalized) ? normalized : null\n}\n"],
+  "mappings": "AAkBA,SAAS,oBAAoB;AAC7B,SAAS,iCAAiC,kCAAkC;AAE5E;AAAA,EACE;AAAA,EACA;AAAA,EACA,mCAAAA;AAAA,EACA,8BAAAC;AAAA,OACK;AAMP,IAAI,oBAA6B;AACjC,IAAI,cAAmC,oBAAI,IAAY;AAEvD,SAAS,iBAAsC;AAI7C,QAAM,WAAW,aAAa,KAAK;AACnC,MAAI,aAAa,mBAAmB;AAClC,wBAAoB;AACpB,kBAAc,IAAI;AAAA,MAChB,OAAO,OAAO,YAAY,CAAC,CAAC,EAAE,QAAQ,CAAC,mBAAmB,OAAO,OAAO,kBAAkB,CAAC,CAAC,CAAC;AAAA,IAC/F;AAAA,EACF;AACA,SAAO;AACT;AASO,SAAS,kCACd,YACe;AACf,MAAI,OAAO,eAAe,SAAU,QAAO;AAC3C,QAAM,aAAa,gCAAgC,UAAU;AAC7D,MAAI,CAAC,WAAY,QAAO;AACxB,QAAM,UAAU,2BAA2B,UAAU;AACrD,MAAI,QAAS,QAAO;AACpB,SAAO,eAAe,EAAE,IAAI,UAAU,IAAI,aAAa;AACzD;",
+  "names": ["normalizeTaskEntityTypeSpelling", "resolveAliasedTaskEntityId"]
+}

package/dist/modules/workflows/lib/task-form-registry.js

@@ -0,0 +1,33 @@
+const registry = /* @__PURE__ */ new Map();
+function registerTaskFormRenderer(entry) {
+  if (!entry.formKey) {
+    throw new Error("[internal] Task form renderer requires a formKey");
+  }
+  if (registry.has(entry.formKey)) {
+    throw new Error(`[internal] Task form renderer already registered: ${entry.formKey}`);
+  }
+  registry.set(entry.formKey, entry);
+}
+function getTaskFormRenderer(formKey) {
+  if (!formKey) return null;
+  return registry.get(formKey) ?? null;
+}
+function listTaskFormRenderers() {
+  return Array.from(registry.values());
+}
+function clearTaskFormRenderers() {
+  registry.clear();
+}
+function resolveTaskForm(formKey) {
+  if (!formKey) return { kind: "builtin" };
+  const entry = getTaskFormRenderer(formKey);
+  return entry ? { kind: "registered", entry } : { kind: "missing", formKey };
+}
+export {
+  clearTaskFormRenderers,
+  getTaskFormRenderer,
+  listTaskFormRenderers,
+  registerTaskFormRenderer,
+  resolveTaskForm
+};
+//# sourceMappingURL=task-form-registry.js.map

package/dist/modules/workflows/lib/task-form-registry.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../../src/modules/workflows/lib/task-form-registry.ts"],
+  "sourcesContent": ["/**\n * Workflows Module - External task form renderer registry (#4243)\n *\n * Spec \u00A76.1 \u00A76: *\"**External form** [\u2026] completed as a **renderer registry**\n * keyed by formKey, receiving/returning typed context \u2014 the same mechanism\n * portal rendering (\u00A76.4) and record-page widgets use.\"*\n *\n * Modeled on `registerActivityType` (`lib/activity-registry.ts`), including its\n * purity contract: no React, no MikroORM/EntityManager and no Awilix imports at\n * module scope \u2014 TYPE-ONLY imports \u2014 so the worker and the browser can both\n * load this module. `Renderer` is a component TYPE, which is a type-level\n * reference and never drags React into a server bundle.\n *\n * The registry is a lookup, never a gate: an unknown `formKey` resolves to\n * `null` and the caller degrades to the built-in form with a visible notice.\n * A blank screen is the one outcome this must never produce, so nothing here\n * throws on a miss.\n */\n\nimport type { ComponentType } from 'react'\nimport type { ZodTypeAny } from 'zod'\n\n/**\n * What a renderer receives. Everything a task form could need to render itself\n * without reaching back into the workflows module \u2014 which is what makes the\n * same registry usable from the backoffice, the portal and a record-page\n * widget.\n */\nexport interface TaskFormRendererContext<TValues = Record<string, unknown>> {\n  taskId: string\n  taskName: string\n  /** The key this renderer was resolved under. */\n  formKey: string\n  /** The authored schema, in whichever of the two accepted shapes it was written. */\n  formSchema: unknown\n  /** Records the task is about, as resolved at task-creation time. */\n  entityBindings: unknown[] | null\n  /** Decision buttons the surface will render beside the form. */\n  decisions: { id: string }[]\n  /** Current form values. */\n  values: TValues\n  /** True while a completion is in flight. */\n  disabled: boolean\n  /** Locale of the surrounding surface, for renderers that localize themselves. */\n  locale?: string\n}\n\n/**\n * What a renderer returns: the values the task will be completed with. Called\n * on every change so the host owns the state, exactly as the built-in form does.\n */\nexport type TaskFormRendererChange<TValues = Record<string, unknown>> = (values: TValues) => void\n\nexport interface TaskFormRendererProps<TValues = Record<string, unknown>> {\n  context: TaskFormRendererContext<TValues>\n  onChange: TaskFormRendererChange<TValues>\n}\n\nexport interface TaskFormRendererEntry<TValues = Record<string, unknown>> {\n  formKey: string\n  /** i18n key for the section heading the host renders above the form. */\n  titleKey?: string\n  Renderer: ComponentType<TaskFormRendererProps<TValues>>\n  /** Optional shape of the values handed IN (prefill). */\n  inputSchema?: ZodTypeAny\n  /** Optional shape of the values handed OUT (completion payload). */\n  outputSchema?: ZodTypeAny\n}\n\nconst registry = new Map<string, TaskFormRendererEntry>()\n\n/**\n * Register a renderer for one `formKey`.\n *\n * Duplicate registration throws, mirroring `registerActivityType`: two modules\n * silently fighting over one key is a bug that must surface at load time, not a\n * race whose winner depends on import order.\n */\nexport function registerTaskFormRenderer<TValues>(entry: TaskFormRendererEntry<TValues>): void {\n  if (!entry.formKey) {\n    throw new Error('[internal] Task form renderer requires a formKey')\n  }\n  if (registry.has(entry.formKey)) {\n    throw new Error(`[internal] Task form renderer already registered: ${entry.formKey}`)\n  }\n  registry.set(entry.formKey, entry as TaskFormRendererEntry)\n}\n\n/** Resolve a renderer, or `null` when the key is unknown. Never throws. */\nexport function getTaskFormRenderer(\n  formKey: string | null | undefined\n): TaskFormRendererEntry | null {\n  if (!formKey) return null\n  return registry.get(formKey) ?? null\n}\n\nexport function listTaskFormRenderers(): TaskFormRendererEntry[] {\n  return Array.from(registry.values())\n}\n\n/** Test seam; not part of the module's runtime contract. */\nexport function clearTaskFormRenderers(): void {\n  registry.clear()\n}\n\nexport type TaskFormResolution =\n  | { kind: 'registered'; entry: TaskFormRendererEntry }\n  | { kind: 'builtin' }\n  | { kind: 'missing'; formKey: string }\n\n/**\n * What a task surface should render.\n *\n * `missing` is deliberately distinct from `builtin`: both fall back to the\n * built-in form, but only `missing` means the author asked for a renderer that\n * is not loaded \u2014 which the surface MUST say out loud instead of quietly\n * rendering something else.\n */\nexport function resolveTaskForm(formKey: string | null | undefined): TaskFormResolution {\n  if (!formKey) return { kind: 'builtin' }\n  const entry = getTaskFormRenderer(formKey)\n  return entry ? { kind: 'registered', entry } : { kind: 'missing', formKey }\n}\n"],
+  "mappings": "AAqEA,MAAM,WAAW,oBAAI,IAAmC;AASjD,SAAS,yBAAkC,OAA6C;AAC7F,MAAI,CAAC,MAAM,SAAS;AAClB,UAAM,IAAI,MAAM,kDAAkD;AAAA,EACpE;AACA,MAAI,SAAS,IAAI,MAAM,OAAO,GAAG;AAC/B,UAAM,IAAI,MAAM,qDAAqD,MAAM,OAAO,EAAE;AAAA,EACtF;AACA,WAAS,IAAI,MAAM,SAAS,KAA8B;AAC5D;AAGO,SAAS,oBACd,SAC8B;AAC9B,MAAI,CAAC,QAAS,QAAO;AACrB,SAAO,SAAS,IAAI,OAAO,KAAK;AAClC;AAEO,SAAS,wBAAiD;AAC/D,SAAO,MAAM,KAAK,SAAS,OAAO,CAAC;AACrC;AAGO,SAAS,yBAA+B;AAC7C,WAAS,MAAM;AACjB;AAeO,SAAS,gBAAgB,SAAwD;AACtF,MAAI,CAAC,QAAS,QAAO,EAAE,MAAM,UAAU;AACvC,QAAM,QAAQ,oBAAoB,OAAO;AACzC,SAAO,QAAQ,EAAE,MAAM,cAAc,MAAM,IAAI,EAAE,MAAM,WAAW,QAAQ;AAC5E;",
+  "names": []
+}

package/dist/modules/workflows/lib/task-form-schema.js

@@ -0,0 +1,75 @@
+function readAuthoredFields(formSchema) {
+  if (!formSchema || typeof formSchema !== "object") return null;
+  const fields = formSchema.fields;
+  if (!Array.isArray(fields)) return null;
+  return fields.filter(
+    (field) => !!field && typeof field === "object" && typeof field.name === "string"
+  );
+}
+function readJsonSchema(formSchema) {
+  if (!formSchema || typeof formSchema !== "object") return null;
+  const schema = formSchema;
+  if (!schema.properties || typeof schema.properties !== "object") return null;
+  return formSchema;
+}
+function authoredTypeToJsonSchemaField(field) {
+  const options = Array.isArray(field.options) ? field.options.filter((option) => typeof option === "string") : null;
+  const base = {
+    title: field.label ?? field.name,
+    ...field.placeholder ? { description: field.placeholder } : {}
+  };
+  if (options?.length) return { ...base, type: "string", enum: options };
+  switch (field.type) {
+    case "number":
+      return { ...base, type: "number" };
+    case "integer":
+      return { ...base, type: "integer" };
+    case "checkbox":
+    case "boolean":
+      return { ...base, type: "boolean" };
+    case "email":
+      return { ...base, type: "string", format: "email" };
+    case "url":
+      return { ...base, type: "string", format: "uri" };
+    case "date":
+      return { ...base, type: "string", format: "date" };
+    case "time":
+      return { ...base, type: "string", format: "time" };
+    case "datetime-local":
+      return { ...base, type: "string", format: "date-time" };
+    case "textarea":
+      return { ...base, type: "string", maxLength: 2e3 };
+    default:
+      return { ...base, type: "string" };
+  }
+}
+function normalizeTaskFormSchema(formSchema) {
+  const authored = readAuthoredFields(formSchema);
+  if (authored) {
+    if (!authored.length) return null;
+    const properties = {};
+    const required = [];
+    for (const field of authored) {
+      properties[field.name] = authoredTypeToJsonSchemaField(field);
+      if (field.required === true) required.push(field.name);
+    }
+    return { type: "object", properties, ...required.length ? { required } : {} };
+  }
+  const jsonSchema = readJsonSchema(formSchema);
+  if (!jsonSchema) return null;
+  return Object.keys(jsonSchema.properties ?? {}).length ? jsonSchema : null;
+}
+function readRequiredFormFields(formSchema) {
+  const normalized = normalizeTaskFormSchema(formSchema);
+  return normalized?.required ?? [];
+}
+function countTaskFormFields(formSchema) {
+  const normalized = normalizeTaskFormSchema(formSchema);
+  return normalized ? Object.keys(normalized.properties ?? {}).length : 0;
+}
+export {
+  countTaskFormFields,
+  normalizeTaskFormSchema,
+  readRequiredFormFields
+};
+//# sourceMappingURL=task-form-schema.js.map

package/dist/modules/workflows/lib/task-form-schema.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../../src/modules/workflows/lib/task-form-schema.ts"],
+  "sourcesContent": ["/**\n * Workflows Module - Task form schema normalization (pure)\n *\n * `userTaskConfigSchema.formSchema` has always accepted TWO shapes:\n *\n *   - `{ properties, required }` \u2014 JSON Schema;\n *   - `{ fields: [{ name, type, label, required, options }] }` \u2014 the authoring\n *     shape the Studio's form-field editor writes (`lib/nodeFormTransforms.ts`).\n *\n * Only the first was ever read. The task page renders `formSchema.properties`,\n * and `validateFormData` checked `formSchema.required` \u2014 so a task authored in\n * the visual editor rendered NO fields and validated NOTHING, however many its\n * author marked mandatory.\n *\n * This module is the one place the two shapes are reconciled: every reader goes\n * through `normalizeTaskFormSchema` and every required-field check through\n * `readRequiredFormFields`, so they cannot drift apart again. The mapping is the\n * exact inverse of `mapJsonSchemaTypeToFieldType`, which is what makes the\n * editor round trip.\n *\n * PURE: no ORM, DI, React or registry imports \u2014 the browser renderer and the\n * server-side completion path both load it.\n */\n\nimport type { JsonSchema, JsonSchemaField } from '../data/types'\n\ninterface AuthoredFormField {\n  name: string\n  type?: string\n  label?: string\n  required?: boolean\n  options?: unknown[]\n  placeholder?: string\n  defaultValue?: unknown\n}\n\nfunction readAuthoredFields(formSchema: unknown): AuthoredFormField[] | null {\n  if (!formSchema || typeof formSchema !== 'object') return null\n  const fields = (formSchema as { fields?: unknown }).fields\n  if (!Array.isArray(fields)) return null\n  return fields.filter(\n    (field): field is AuthoredFormField =>\n      !!field && typeof field === 'object' && typeof (field as { name?: unknown }).name === 'string'\n  )\n}\n\nfunction readJsonSchema(formSchema: unknown): JsonSchema | null {\n  if (!formSchema || typeof formSchema !== 'object') return null\n  const schema = formSchema as { properties?: unknown; required?: unknown }\n  if (!schema.properties || typeof schema.properties !== 'object') return null\n  return formSchema as JsonSchema\n}\n\n/** Inverse of the editor's `mapJsonSchemaTypeToFieldType`. */\nfunction authoredTypeToJsonSchemaField(field: AuthoredFormField): JsonSchemaField {\n  const options = Array.isArray(field.options)\n    ? field.options.filter((option): option is string => typeof option === 'string')\n    : null\n\n  const base: JsonSchemaField = {\n    title: field.label ?? field.name,\n    ...(field.placeholder ? { description: field.placeholder } : {}),\n  }\n\n  if (options?.length) return { ...base, type: 'string', enum: options }\n\n  switch (field.type) {\n    case 'number':\n      return { ...base, type: 'number' }\n    case 'integer':\n      return { ...base, type: 'integer' }\n    case 'checkbox':\n    case 'boolean':\n      return { ...base, type: 'boolean' }\n    case 'email':\n      return { ...base, type: 'string', format: 'email' }\n    case 'url':\n      return { ...base, type: 'string', format: 'uri' }\n    case 'date':\n      return { ...base, type: 'string', format: 'date' }\n    case 'time':\n      return { ...base, type: 'string', format: 'time' }\n    case 'datetime-local':\n      return { ...base, type: 'string', format: 'date-time' }\n    case 'textarea':\n      return { ...base, type: 'string', maxLength: 2000 }\n    default:\n      return { ...base, type: 'string' }\n  }\n}\n\n/**\n * Present either authored shape as the JSON-Schema shape the renderer walks.\n * Returns `null` when the schema declares no fields at all, which is what the\n * \"this task has no form\" branch keys off.\n */\nexport function normalizeTaskFormSchema(formSchema: unknown): JsonSchema | null {\n  const authored = readAuthoredFields(formSchema)\n  if (authored) {\n    if (!authored.length) return null\n    const properties: Record<string, JsonSchemaField> = {}\n    const required: string[] = []\n    for (const field of authored) {\n      properties[field.name] = authoredTypeToJsonSchemaField(field)\n      if (field.required === true) required.push(field.name)\n    }\n    return { type: 'object', properties, ...(required.length ? { required } : {}) }\n  }\n\n  const jsonSchema = readJsonSchema(formSchema)\n  if (!jsonSchema) return null\n  return Object.keys(jsonSchema.properties ?? {}).length ? jsonSchema : null\n}\n\n/**\n * Names of the fields a form schema declares as required, in EITHER shape.\n * The authoring shape carries a per-field `required: true`; JSON Schema carries\n * a `required` array.\n */\nexport function readRequiredFormFields(formSchema: unknown): string[] {\n  const normalized = normalizeTaskFormSchema(formSchema)\n  return normalized?.required ?? []\n}\n\n/** How many fields the schema declares, in either shape. */\nexport function countTaskFormFields(formSchema: unknown): number {\n  const normalized = normalizeTaskFormSchema(formSchema)\n  return normalized ? Object.keys(normalized.properties ?? {}).length : 0\n}\n"],
+  "mappings": "AAoCA,SAAS,mBAAmB,YAAiD;AAC3E,MAAI,CAAC,cAAc,OAAO,eAAe,SAAU,QAAO;AAC1D,QAAM,SAAU,WAAoC;AACpD,MAAI,CAAC,MAAM,QAAQ,MAAM,EAAG,QAAO;AACnC,SAAO,OAAO;AAAA,IACZ,CAAC,UACC,CAAC,CAAC,SAAS,OAAO,UAAU,YAAY,OAAQ,MAA6B,SAAS;AAAA,EAC1F;AACF;AAEA,SAAS,eAAe,YAAwC;AAC9D,MAAI,CAAC,cAAc,OAAO,eAAe,SAAU,QAAO;AAC1D,QAAM,SAAS;AACf,MAAI,CAAC,OAAO,cAAc,OAAO,OAAO,eAAe,SAAU,QAAO;AACxE,SAAO;AACT;AAGA,SAAS,8BAA8B,OAA2C;AAChF,QAAM,UAAU,MAAM,QAAQ,MAAM,OAAO,IACvC,MAAM,QAAQ,OAAO,CAAC,WAA6B,OAAO,WAAW,QAAQ,IAC7E;AAEJ,QAAM,OAAwB;AAAA,IAC5B,OAAO,MAAM,SAAS,MAAM;AAAA,IAC5B,GAAI,MAAM,cAAc,EAAE,aAAa,MAAM,YAAY,IAAI,CAAC;AAAA,EAChE;AAEA,MAAI,SAAS,OAAQ,QAAO,EAAE,GAAG,MAAM,MAAM,UAAU,MAAM,QAAQ;AAErE,UAAQ,MAAM,MAAM;AAAA,IAClB,KAAK;AACH,aAAO,EAAE,GAAG,MAAM,MAAM,SAAS;AAAA,IACnC,KAAK;AACH,aAAO,EAAE,GAAG,MAAM,MAAM,UAAU;AAAA,IACpC,KAAK;AAAA,IACL,KAAK;AACH,aAAO,EAAE,GAAG,MAAM,MAAM,UAAU;AAAA,IACpC,KAAK;AACH,aAAO,EAAE,GAAG,MAAM,MAAM,UAAU,QAAQ,QAAQ;AAAA,IACpD,KAAK;AACH,aAAO,EAAE,GAAG,MAAM,MAAM,UAAU,QAAQ,MAAM;AAAA,IAClD,KAAK;AACH,aAAO,EAAE,GAAG,MAAM,MAAM,UAAU,QAAQ,OAAO;AAAA,IACnD,KAAK;AACH,aAAO,EAAE,GAAG,MAAM,MAAM,UAAU,QAAQ,OAAO;AAAA,IACnD,KAAK;AACH,aAAO,EAAE,GAAG,MAAM,MAAM,UAAU,QAAQ,YAAY;AAAA,IACxD,KAAK;AACH,aAAO,EAAE,GAAG,MAAM,MAAM,UAAU,WAAW,IAAK;AAAA,IACpD;AACE,aAAO,EAAE,GAAG,MAAM,MAAM,SAAS;AAAA,EACrC;AACF;AAOO,SAAS,wBAAwB,YAAwC;AAC9E,QAAM,WAAW,mBAAmB,UAAU;AAC9C,MAAI,UAAU;AACZ,QAAI,CAAC,SAAS,OAAQ,QAAO;AAC7B,UAAM,aAA8C,CAAC;AACrD,UAAM,WAAqB,CAAC;AAC5B,eAAW,SAAS,UAAU;AAC5B,iBAAW,MAAM,IAAI,IAAI,8BAA8B,KAAK;AAC5D,UAAI,MAAM,aAAa,KAAM,UAAS,KAAK,MAAM,IAAI;AAAA,IACvD;AACA,WAAO,EAAE,MAAM,UAAU,YAAY,GAAI,SAAS,SAAS,EAAE,SAAS,IAAI,CAAC,EAAG;AAAA,EAChF;AAEA,QAAM,aAAa,eAAe,UAAU;AAC5C,MAAI,CAAC,WAAY,QAAO;AACxB,SAAO,OAAO,KAAK,WAAW,cAAc,CAAC,CAAC,EAAE,SAAS,aAAa;AACxE;AAOO,SAAS,uBAAuB,YAA+B;AACpE,QAAM,aAAa,wBAAwB,UAAU;AACrD,SAAO,YAAY,YAAY,CAAC;AAClC;AAGO,SAAS,oBAAoB,YAA6B;AAC/D,QAAM,aAAa,wBAAwB,UAAU;AACrD,SAAO,aAAa,OAAO,KAAK,WAAW,cAAc,CAAC,CAAC,EAAE,SAAS;AACxE;",
+  "names": []
+}

package/dist/modules/workflows/lib/task-handler.js

@@ -6,6 +6,13 @@ import {
 } from "../data/entities.js";
 import { executeWorkflow } from "./workflow-executor.js";
 import { findDefinitionForInstance } from "./find-definition.js";
+import {
+  findTaskDecision,
+  findTaskDecisionTransition,
+  withRecordedDecision
+} from "./task-decisions.js";
+import { loadTaskDecisionContext } from "./task-decision-context.js";
+import { readRequiredFormFields } from "./task-form-schema.js";
 import * as stepHandler from "./step-handler.js";
 import * as transitionHandler from "./transition-handler.js";
 import { createLogger } from "@open-mercato/shared/lib/logger";
@@ -19,9 +26,11 @@ class UserTaskError extends Error {
   }
 }
 async function completeUserTask(em, container, options) {
-  const { taskId, formData, userId, comments } = options;
+  const { taskId, formData, userId, comments, decisionId, scope } = options;
   const task = await em.findOne(UserTask, {
     id: taskId,
+    tenantId: scope.tenantId,
+    organizationId: scope.organizationId,
     status: { $in: ["PENDING", "IN_PROGRESS"] }
   });
   if (!task) {
@@ -31,6 +40,14 @@ async function completeUserTask(em, container, options) {
       { taskId }
     );
   }
+  const claimant = task.claimedBy ?? task.assignedTo;
+  if (claimant && claimant !== userId) {
+    throw new UserTaskError(
+      "Task is assigned to another user",
+      "TASK_ASSIGNED_TO_ANOTHER_USER",
+      { taskId, assignedTo: claimant }
+    );
+  }
   if (task.formSchema) {
     try {
       validateFormData(formData, task.formSchema);
@@ -42,9 +59,18 @@ async function completeUserTask(em, container, options) {
       );
     }
   }
+  const chosenDecision = decisionId ? findTaskDecision((await loadTaskDecisionContext(em, task)).decisions, decisionId) : null;
+  if (decisionId && !chosenDecision) {
+    throw new UserTaskError(
+      "Unknown decision for this task",
+      "UNKNOWN_DECISION",
+      { taskId, decisionId }
+    );
+  }
+  const completionData = withRecordedDecision(formData, chosenDecision?.id);
   const now = /* @__PURE__ */ new Date();
   task.status = "COMPLETED";
-  task.formData = formData;
+  task.formData = completionData;
   task.completedBy = userId;
   task.completedAt = now;
   task.comments = comments || null;
@@ -64,7 +90,13 @@ async function completeUserTask(em, container, options) {
       stepInstanceId: task.stepInstanceId,
       branchInstanceId: task.branchInstanceId,
       eventType: "USER_TASK_COMPLETED",
-      eventData: { taskId: task.id, taskName: task.taskName, completedBy: userId, formData },
+      eventData: {
+        taskId: task.id,
+        taskName: task.taskName,
+        completedBy: userId,
+        formData: completionData,
+        ...chosenDecision ? { decisionId: chosenDecision.id } : {}
+      },
       userId,
       tenantId: instance.tenantId,
       organizationId: instance.organizationId
@@ -75,9 +107,9 @@ async function completeUserTask(em, container, options) {
       branchInstanceId: task.branchInstanceId,
       tenantId: instance.tenantId,
       organizationId: instance.organizationId,
-      contextMerge: formData,
+      contextMerge: completionData,
       exitStepInstanceId: task.stepInstanceId,
-      exitOutput: { userTaskId: task.id, formData }
+      exitOutput: { userTaskId: task.id, formData: completionData }
     });
     if (resumed) {
       await executeWorkflow(em, container, instance.id, { userId });
@@ -86,7 +118,7 @@ async function completeUserTask(em, container, options) {
   }
   instance.context = {
     ...instance.context,
-    ...formData
+    ...completionData
   };
   instance.updatedAt = now;
   await logWorkflowEvent(em, {
@@ -97,7 +129,8 @@ async function completeUserTask(em, container, options) {
       taskId: task.id,
       taskName: task.taskName,
       completedBy: userId,
-      formData
+      formData: completionData,
+      ...chosenDecision ? { decisionId: chosenDecision.id } : {}
     },
     userId,
     tenantId: instance.tenantId,
@@ -108,7 +141,7 @@ async function completeUserTask(em, container, options) {
     status: "ACTIVE"
   });
   if (stepInstance) {
-    await stepHandler.exitStep(em, stepInstance, { userTaskId: task.id, formData });
+    await stepHandler.exitStep(em, stepInstance, { userTaskId: task.id, formData: completionData });
   }
   const currentStepId = instance.currentStepId;
   const definition = await findDefinitionForInstance(em, instance);
@@ -119,35 +152,59 @@ async function completeUserTask(em, container, options) {
       { definitionId: instance.definitionId }
     );
   }
-  const autoTransitions = (definition.definition.transitions || []).filter(
-    (t) => t.fromStepId === currentStepId && t.trigger === "auto"
-  );
-  if (autoTransitions.length === 0) {
-    return;
-  }
   const transitionContext = {
     workflowContext: instance.context,
     userId
   };
-  const validTransitions = await transitionHandler.findValidTransitions(
-    em,
-    instance,
-    currentStepId,
-    transitionContext
-  );
-  const firstValidTransition = validTransitions.find((t) => t.isValid);
-  if (!firstValidTransition || !firstValidTransition.transition) {
+  const decisionTransition = chosenDecision ? findTaskDecisionTransition(
+    definition.definition.transitions || [],
+    chosenDecision.transitionId,
+    currentStepId
+  ) : null;
+  if (chosenDecision && !decisionTransition) {
+    logger.warn("Task decision route not found on the current step; falling back to auto routing", {
+      component: "task-handler",
+      taskId: task.id,
+      decisionId: chosenDecision.id,
+      transitionId: chosenDecision.transitionId,
+      currentStepId
+    });
+  }
+  let selectedTransition = decisionTransition ?? null;
+  let targetStepId = selectedTransition?.toStepId ?? null;
+  if (!targetStepId) {
+    const autoTransitions = (definition.definition.transitions || []).filter(
+      (t) => t.fromStepId === currentStepId && t.trigger === "auto"
+    );
+    if (autoTransitions.length === 0) {
+      return;
+    }
+    const validTransitions = await transitionHandler.findValidTransitions(
+      em,
+      instance,
+      currentStepId,
+      transitionContext
+    );
+    const firstValidTransition = validTransitions.find((t) => t.isValid);
+    if (!firstValidTransition || !firstValidTransition.transition) {
+      instance.status = "RUNNING";
+      await em.flush();
+      return;
+    }
+    targetStepId = firstValidTransition.transition.toStepId;
+    selectedTransition = firstValidTransition.transition;
+  }
+  if (instance.status === "PAUSED") {
     instance.status = "RUNNING";
     await em.flush();
-    return;
   }
   const transitionResult = await transitionHandler.executeTransition(
     em,
     container,
     instance,
     currentStepId,
-    firstValidTransition.transition.toStepId,
-    transitionContext
+    targetStepId,
+    { ...transitionContext, transitionId: selectedTransition?.transitionId }
   );
   if (!transitionResult.success) {
     logger.error("Transition failed", { component: "task-handler", err: transitionResult.error });
@@ -155,9 +212,16 @@ async function completeUserTask(em, container, options) {
   }
   await executeWorkflow(em, container, instance.id, { userId });
 }
-async function claimUserTask(em, taskId, userId) {
+function hasRoleOverlap(taskRoles, callerRoleNames) {
+  if (callerRoleNames.length === 0) return false;
+  const held = new Set(callerRoleNames);
+  return taskRoles.some((role) => held.has(role));
+}
+async function claimUserTask(em, taskId, userId, scope, callerRoleNames) {
   const task = await em.findOne(UserTask, {
     id: taskId,
+    tenantId: scope.tenantId,
+    organizationId: scope.organizationId,
     status: "PENDING"
   });
   if (!task) {
@@ -181,7 +245,37 @@ async function claimUserTask(em, taskId, userId) {
       { taskId }
     );
   }
+  if (!hasRoleOverlap(task.assignedToRoles, callerRoleNames)) {
+    throw new UserTaskError(
+      "Task not found or already claimed",
+      "TASK_NOT_FOUND",
+      { taskId }
+    );
+  }
   const now = /* @__PURE__ */ new Date();
+  const claimed = await em.nativeUpdate(
+    UserTask,
+    {
+      id: taskId,
+      tenantId: scope.tenantId,
+      organizationId: scope.organizationId,
+      status: "PENDING",
+      claimedBy: null
+    },
+    {
+      claimedBy: userId,
+      claimedAt: now,
+      status: "IN_PROGRESS",
+      updatedAt: now
+    }
+  );
+  if (claimed === 0) {
+    throw new UserTaskError(
+      "Task not found or already claimed",
+      "TASK_NOT_FOUND",
+      { taskId }
+    );
+  }
   task.claimedBy = userId;
   task.claimedAt = now;
   task.status = "IN_PROGRESS";
@@ -204,6 +298,132 @@ async function claimUserTask(em, taskId, userId) {
     });
   }
 }
+async function releaseUserTask(em, taskId, userId, scope) {
+  const task = await em.findOne(UserTask, {
+    id: taskId,
+    tenantId: scope.tenantId,
+    organizationId: scope.organizationId,
+    status: "IN_PROGRESS"
+  });
+  if (!task) {
+    throw new UserTaskError(
+      "Task not found or not claimed",
+      "TASK_NOT_FOUND",
+      { taskId }
+    );
+  }
+  if (task.claimedBy !== userId) {
+    throw new UserTaskError(
+      "Task is claimed by another user",
+      "TASK_ASSIGNED_TO_ANOTHER_USER",
+      { taskId, claimedBy: task.claimedBy }
+    );
+  }
+  const now = /* @__PURE__ */ new Date();
+  const released = await em.nativeUpdate(
+    UserTask,
+    {
+      id: taskId,
+      tenantId: scope.tenantId,
+      organizationId: scope.organizationId,
+      status: "IN_PROGRESS",
+      claimedBy: userId
+    },
+    {
+      claimedBy: null,
+      claimedAt: null,
+      status: "PENDING",
+      updatedAt: now
+    }
+  );
+  if (released === 0) {
+    throw new UserTaskError(
+      "Task not found or not claimed",
+      "TASK_NOT_FOUND",
+      { taskId }
+    );
+  }
+  task.claimedBy = null;
+  task.claimedAt = null;
+  task.status = "PENDING";
+  task.updatedAt = now;
+  await em.flush();
+  const instance = await em.findOne(WorkflowInstance, task.workflowInstanceId);
+  if (instance) {
+    await logWorkflowEvent(em, {
+      workflowInstanceId: instance.id,
+      stepInstanceId: task.stepInstanceId,
+      eventType: "USER_TASK_RELEASED",
+      eventData: {
+        taskId: task.id,
+        taskName: task.taskName,
+        releasedBy: userId
+      },
+      userId,
+      tenantId: instance.tenantId,
+      organizationId: instance.organizationId
+    });
+  }
+}
+const REASSIGNABLE_STATUSES = ["PENDING", "IN_PROGRESS"];
+async function reassignUserTask(em, options) {
+  const { taskId, userId, target, reason, scope } = options;
+  const task = await em.findOne(UserTask, {
+    id: taskId,
+    tenantId: scope.tenantId,
+    organizationId: scope.organizationId
+  });
+  if (!task) {
+    throw new UserTaskError("Task not found", "TASK_NOT_FOUND", { taskId });
+  }
+  if (!REASSIGNABLE_STATUSES.includes(task.status)) {
+    throw new UserTaskError(
+      "Task is no longer open and cannot be reassigned",
+      "TASK_NOT_REASSIGNABLE",
+      { taskId, status: task.status }
+    );
+  }
+  const assignedTo = target.assignedTo ?? null;
+  const assignedToRoles = target.assignedToRoles && target.assignedToRoles.length > 0 ? [...target.assignedToRoles] : null;
+  const previous = {
+    assignedTo: task.assignedTo ?? null,
+    assignedToRoles: task.assignedToRoles ?? null,
+    claimedBy: task.claimedBy ?? null
+  };
+  const now = /* @__PURE__ */ new Date();
+  task.assignedTo = assignedTo;
+  task.assigneeKind = "user";
+  task.assignedToRoles = assignedToRoles;
+  task.claimedBy = null;
+  task.claimedAt = null;
+  if (task.status === "IN_PROGRESS") task.status = "PENDING";
+  task.reassignedBy = userId;
+  task.reassignedAt = now;
+  task.reassignReason = reason ?? null;
+  task.updatedAt = now;
+  await em.flush();
+  const instance = await em.findOne(WorkflowInstance, task.workflowInstanceId);
+  if (instance) {
+    await logWorkflowEvent(em, {
+      workflowInstanceId: instance.id,
+      stepInstanceId: task.stepInstanceId,
+      branchInstanceId: task.branchInstanceId ?? null,
+      eventType: "USER_TASK_REASSIGNED",
+      eventData: {
+        taskId: task.id,
+        taskName: task.taskName,
+        reassignedBy: userId,
+        reason: reason ?? null,
+        from: previous,
+        to: { assignedTo, assignedToRoles }
+      },
+      userId,
+      tenantId: instance.tenantId,
+      organizationId: instance.organizationId
+    });
+  }
+  return task;
+}
 async function logWorkflowEvent(em, event) {
   const workflowEvent = em.create(WorkflowEvent, {
     ...event,
@@ -213,11 +433,7 @@ async function logWorkflowEvent(em, event) {
   return workflowEvent;
 }
 function validateFormData(formData, formSchema) {
-  if (!formSchema || !formSchema.properties) {
-    return;
-  }
-  const requiredFields = formSchema.required || [];
-  for (const field of requiredFields) {
+  for (const field of readRequiredFormFields(formSchema)) {
     if (!(field in formData) || formData[field] === null || formData[field] === void 0) {
       throw new Error(`Required field missing: ${field}`);
     }
@@ -226,6 +442,9 @@ function validateFormData(formData, formSchema) {
 export {
   UserTaskError,
   claimUserTask,
-  completeUserTask
+  completeUserTask,
+  reassignUserTask,
+  releaseUserTask,
+  validateFormData
 };
 //# sourceMappingURL=task-handler.js.map