@open-mercato/core 0.6.7 → 0.6.8-develop.6875.1.871a4afc94

package/src/modules/workflows/i18n/pl.json

@@ -80,6 +80,8 @@
   "workflows.activities.async": "Asynchroniczne",
   "workflows.activities.compensation": "Kompensacja",
   "workflows.activities.config": "Konfiguracja",
+  "workflows.activities.configInvalidJson": "Nieprawidłowy JSON",
+  "workflows.activities.configMustBeObject": "Konfiguracja musi być obiektem JSON",
   "workflows.activities.deleteActivity": "Usuń Działanie",
   "workflows.activities.editActivity": "Edytuj Działanie",
   "workflows.activities.plural": "Działania",
@@ -933,6 +935,7 @@
   "workflows.orderApproval.decisionLabel": "Decyzja",
   "workflows.orderApproval.groupDescription": "Przejrzyj i zatwierdź lub odrzuć to zamówienie.",
   "workflows.orderApproval.groupLabel": "Zatwierdzanie zamówienia",
+  "workflows.orderApproval.missingOrderId": "Nie można rozpocząć procesu zatwierdzania, zanim zamówienie się nie wczyta.",
   "workflows.orderApproval.missingStatuses": "Brakuje wpisów statusów zamówienia. Upewnij się, że istnieją statusy pending_approval, approved i rejected.",
   "workflows.orderApproval.noWorkflowActive": "Brak aktywnego przepływu zatwierdzania dla tego zamówienia.",
   "workflows.orderApproval.pendingDescription": "To zamówienie wymaga zatwierdzenia przed realizacją.",

package/src/modules/workflows/lib/activity-executor.ts

@@ -22,7 +22,6 @@ import {
   type HostLookup,
 } from '@open-mercato/shared/lib/url-safety'
 import { parseBooleanWithDefault } from '@open-mercato/shared/lib/boolean'
-import { hasAllFeatures } from '@open-mercato/shared/security/features'
 import { callWebhookConfigSchema } from '../data/validators'
 import { WorkflowActivityJob, WORKFLOW_ACTIVITIES_QUEUE_NAME } from './activity-queue-types'
 import { logWorkflowEvent } from './event-logger'
@@ -107,9 +106,42 @@ export interface ActivityDefinition {
   async?: boolean // Flag to execute activity asynchronously via queue
   retryPolicy?: RetryPolicy
   timeoutMs?: number
+  /**
+   * @deprecated Use `timeoutMs`. Legacy ISO 8601 duration string accepted by
+   * the definition schema before #4424; normalized by `resolveActivityTimeoutMs`.
+   */
+  timeout?: string
   compensate?: boolean // Flag to execute compensation on failure
 }
 
+/**
+ * Effective timeout for an activity, in milliseconds.
+ *
+ * The editor and this executor both speak `timeoutMs`, but the definition
+ * schema historically accepted only an ISO 8601 `timeout` string — so stored
+ * definitions can carry either. Prefer `timeoutMs`; fall back to parsing
+ * `timeout`, ignoring a malformed value rather than throwing mid-execution
+ * (an unparseable timeout must not fail an activity that would otherwise
+ * succeed). Returns undefined when no usable timeout is configured (#4424).
+ */
+export function resolveActivityTimeoutMs(activity: {
+  timeoutMs?: number
+  timeout?: string
+}): number | undefined {
+  if (typeof activity.timeoutMs === 'number' && activity.timeoutMs > 0) {
+    return activity.timeoutMs
+  }
+  if (typeof activity.timeout === 'string' && activity.timeout.trim().length > 0) {
+    try {
+      const parsed = parseDuration(activity.timeout.trim())
+      if (Number.isFinite(parsed) && parsed > 0) return parsed
+    } catch {
+      return undefined
+    }
+  }
+  return undefined
+}
+
 export interface RetryPolicy {
   maxAttempts: number
   initialIntervalMs: number
@@ -130,27 +162,29 @@ export interface ActivityContext {
 }
 
 type RbacFeatureResolver = {
-  getGrantedFeatures: (
+  userHasAllFeatures: (
     userId: string,
+    required: string[],
     opts: { tenantId: string | null; organizationId: string | null }
-  ) => Promise<string[]>
+  ) => Promise<boolean>
 }
 
-async function resolveWorkflowUserFeatures(
+async function workflowUserHasAllFeatures(
   container: AwilixContainer,
   userId: string,
+  required: readonly string[],
   tenantId: string | null,
   organizationId: string | null
-): Promise<string[]> {
+): Promise<boolean> {
   try {
     const rbac = container.resolve('rbacService') as RbacFeatureResolver | undefined
-    if (rbac?.getGrantedFeatures) {
-      return await rbac.getGrantedFeatures(userId, { tenantId, organizationId })
+    if (rbac?.userHasAllFeatures) {
+      return await rbac.userHasAllFeatures(userId, [...required], { tenantId, organizationId })
     }
   } catch {
     // Fail closed below when the workflow executor cannot prove the actor's grants.
   }
-  return []
+  return false
 }
 
 export interface ActivityExecutionResult {
@@ -332,11 +366,13 @@ export async function executeActivity(
     try {
       const startTime = Date.now()
 
-      // Execute with timeout if specified
-      const result = activity.timeoutMs
+      // Execute with timeout if specified (timeoutMs, or a legacy ISO 8601
+      // `timeout` string normalized to ms — see resolveActivityTimeoutMs).
+      const timeoutMs = resolveActivityTimeoutMs(activity)
+      const result = timeoutMs
         ? await executeWithTimeout(
-            () => executeActivityByType(em, container, activity, context),
-            activity.timeoutMs
+            (signal) => executeActivityByType(em, container, activity, context, signal),
+            timeoutMs
           )
         : await executeActivityByType(em, container, activity, context)
 
@@ -475,7 +511,8 @@ async function executeActivityByType(
   em: EntityManager,
   container: AwilixContainer,
   activity: ActivityDefinition,
-  context: ActivityContext
+  context: ActivityContext,
+  signal?: AbortSignal
 ): Promise<any> {
   // Interpolate config variables from context (including workflow metadata)
   const interpolatedConfig = interpolateVariables(activity.config, context.workflowContext, context.workflowInstance)
@@ -485,7 +522,7 @@ async function executeActivityByType(
       return await executeSendEmail(interpolatedConfig, context, container)
 
     case 'CALL_API':
-      return await executeCallApi(em, interpolatedConfig, context, container)
+      return await executeCallApi(em, interpolatedConfig, context, container, signal)
 
     case 'EMIT_EVENT':
       return await executeEmitEvent(interpolatedConfig, context, container)
@@ -494,7 +531,7 @@ async function executeActivityByType(
       return await executeUpdateEntity(em, interpolatedConfig, context, container)
 
     case 'CALL_WEBHOOK':
-      return await executeCallWebhook(interpolatedConfig, context)
+      return await executeCallWebhook(interpolatedConfig, context, { signal })
 
     case 'EXECUTE_FUNCTION':
       return await executeFunction(interpolatedConfig, context, container)
@@ -566,6 +603,17 @@ export async function executeEmitEvent(
     throw new Error('EMIT_EVENT requires "eventName" field')
   }
 
+  // Emissions are fire-and-forget and no subscriber validates the payload shape,
+  // so an unresolved `{{context.x}}` here is even quieter than on the command
+  // path — it ships the literal template to every consumer. Fail loudly instead.
+  const unresolvedPayloadKeys = findUnresolvedTemplateKeys(payload)
+  if (unresolvedPayloadKeys.length > 0) {
+    throw new Error(
+      `EMIT_EVENT payload contains unresolved template variables for: ${unresolvedPayloadKeys.join(', ')}. ` +
+        `Check that the workflow context provides these keys.`
+    )
+  }
+
   // Get event bus from container
   const eventBus = container.resolve<{ emitEvent: (event: string, payload: unknown, options?: unknown) => Promise<unknown> | unknown }>('eventBus')
 
@@ -592,6 +640,23 @@ export async function executeEmitEvent(
   return { emitted: true, eventName, payload: enrichedPayload }
 }
 
+const UNRESOLVED_TEMPLATE_PATTERN = /\{\{[^}]+\}\}/
+
+function findUnresolvedTemplateKeys(value: unknown, path = ''): string[] {
+  if (typeof value === 'string') {
+    return UNRESOLVED_TEMPLATE_PATTERN.test(value) ? [path] : []
+  }
+  if (Array.isArray(value)) {
+    return value.flatMap((item, index) => findUnresolvedTemplateKeys(item, `${path}[${index}]`))
+  }
+  if (value && typeof value === 'object') {
+    return Object.entries(value).flatMap(([key, nested]) =>
+      findUnresolvedTemplateKeys(nested, path ? `${path}.${key}` : key)
+    )
+  }
+  return []
+}
+
 /**
  * UPDATE_ENTITY activity handler
  *
@@ -614,11 +679,14 @@ export async function executeEmitEvent(
  *   "commandId": "sales.orders.update",
  *   "statusDictionary": "sales.order_status",
  *   "input": {
- *     "id": "{{context.id}}",
+ *     "id": "{{context.orderId}}",
  *     "statusValue": "pending_approval"
  *   }
  * }
  * ```
+ *
+ * Every `{{...}}` reference in `input` must resolve against the workflow context —
+ * an unresolved reference is rejected rather than forwarded to the command bus.
  */
 export async function executeUpdateEntity(
   em: EntityManager,
@@ -646,13 +714,14 @@ export async function executeUpdateEntity(
     throw new Error('UPDATE_ENTITY requires an authenticated workflow user')
   }
 
-  const userFeatures = await resolveWorkflowUserFeatures(
+  const authorized = await workflowUserHasAllFeatures(
     container,
     actorUserId,
+    workflowSafeCommand.requiredFeatures,
     context.workflowInstance.tenantId,
     context.workflowInstance.organizationId
   )
-  if (!hasAllFeatures(userFeatures, workflowSafeCommand.requiredFeatures)) {
+  if (!authorized) {
     throw new Error('UPDATE_ENTITY command is not authorized')
   }
 
@@ -663,6 +732,14 @@ export async function executeUpdateEntity(
     throw new Error('CommandBus not available in container')
   }
 
+  const unresolvedKeys = findUnresolvedTemplateKeys(input)
+  if (unresolvedKeys.length > 0) {
+    throw new Error(
+      `UPDATE_ENTITY input contains unresolved template variables for: ${unresolvedKeys.join(', ')}. ` +
+        `Check that the workflow context provides these keys.`
+    )
+  }
+
   // Prepare final input, resolving statusValue if provided
   let finalInput = { ...input }
 
@@ -1419,19 +1496,21 @@ function sleep(ms: number): Promise<void> {
  * Execute a promise with timeout
  */
 async function executeWithTimeout<T>(
-  executor: () => Promise<T>,
+  executor: (signal: AbortSignal) => Promise<T>,
   timeoutMs: number
 ): Promise<T> {
   let timeoutId: NodeJS.Timeout
+  const abortController = new AbortController()
 
   const timeoutPromise = new Promise<never>((_, reject) => {
     timeoutId = setTimeout(() => {
+      abortController.abort()
       reject(new Error(`Activity execution timeout after ${timeoutMs}ms`))
     }, timeoutMs)
   })
 
   try {
-    return await Promise.race([executor(), timeoutPromise])
+    return await Promise.race([executor(abortController.signal), timeoutPromise])
   } finally {
     clearTimeout(timeoutId!)
   }

package/src/modules/workflows/lib/format-validation-error.ts

@@ -8,6 +8,66 @@ type ApiErrorBody = {
   details?: ZodIssueLite[]
 }
 
+// Collection segments in a definition path, mapped to the label an operator
+// recognizes from the editor. Indexes are rendered 1-based.
+const COLLECTION_LABELS: Record<string, string> = {
+  steps: 'step',
+  transitions: 'transition',
+  activities: 'activity',
+  triggers: 'trigger',
+  preConditions: 'pre-condition',
+}
+
+/**
+ * Turn a raw Zod path into something an operator can act on:
+ * `steps.2.activities.0.config.endpoint` → `step 3 › activity 1 › config.endpoint`.
+ *
+ * The raw dotted path reads as internal JSON and gives no hint which node to
+ * open in the visual editor (#4232).
+ */
+export function humanizeDefinitionIssuePath(path: ReadonlyArray<PropertyKey>): string {
+  if (!path.length) return 'definition'
+  const parts: string[] = []
+  let pending: string | null = null
+
+  for (const rawSegment of path) {
+    // Zod types issue paths as PropertyKey; symbols can't appear in JSON data
+    // but narrow defensively rather than casting.
+    const segment = typeof rawSegment === 'symbol' ? rawSegment.toString() : rawSegment
+    if (typeof segment === 'number') {
+      parts.push(pending ? `${pending} ${segment + 1}` : `#${segment + 1}`)
+      pending = null
+      continue
+    }
+    const label = COLLECTION_LABELS[segment]
+    if (label) {
+      if (pending) parts.push(pending)
+      pending = label
+      continue
+    }
+    if (pending) {
+      parts.push(pending)
+      pending = null
+    }
+    parts.push(segment)
+  }
+  if (pending) parts.push(pending)
+
+  const [head, ...rest] = parts
+  if (!rest.length) return head
+  // Keep trailing field names dotted (config.endpoint), collections chevroned.
+  const grouped: string[] = [head]
+  for (const part of rest) {
+    const isIndexed = /\s\d+$/.test(part) || part.startsWith('#')
+    if (!isIndexed && grouped.length > 0 && !/\s\d+$/.test(grouped[grouped.length - 1]) && !grouped[grouped.length - 1].startsWith('#')) {
+      grouped[grouped.length - 1] = `${grouped[grouped.length - 1]}.${part}`
+      continue
+    }
+    grouped.push(part)
+  }
+  return grouped.join(' › ')
+}
+
 /**
  * Format an API validation error body into a user-readable message.
  *

package/src/modules/workflows/widgets/injection/order-approval/context-keys.ts

@@ -0,0 +1,18 @@
+/**
+ * The context keys the order-approval widget seeds when it starts the
+ * `sales.order-approval` workflow. The workflow definition interpolates
+ * `{{context.<key>}}` against exactly this set, and `interpolateVariables()`
+ * silently returns the original string when a key is missing — so the two must
+ * not drift. Both the widget and the contract test import this list, which is
+ * what makes the drift a type error rather than a runtime surprise (issue #4334).
+ */
+export const ORDER_APPROVAL_CONTEXT_KEYS = [
+  'orderId',
+  'pendingApprovalStatusId',
+  'approvedStatusId',
+  'rejectedStatusId',
+] as const
+
+export type OrderApprovalContextKey = (typeof ORDER_APPROVAL_CONTEXT_KEYS)[number]
+
+export type OrderApprovalInitialContext = Record<OrderApprovalContextKey, string>

package/src/modules/workflows/widgets/injection/order-approval/widget.client.tsx

@@ -10,6 +10,8 @@ import { Spinner } from '@open-mercato/ui/primitives/spinner'
 import { Textarea } from '@open-mercato/ui/primitives/textarea'
 import { Badge } from '@open-mercato/ui/primitives/badge'
 import { emitSalesDocumentDataRefresh } from '@open-mercato/core/modules/sales/lib/frontend/documentDataEvents'
+import { fetchAllDictionaryEntries } from '@open-mercato/core/modules/dictionaries/lib/fetchAllEntries'
+import type { OrderApprovalInitialContext } from './context-keys'
 
 type OrderRecord = {
   id: string
@@ -165,12 +167,18 @@ export default function OrderApprovalWidget({ data }: InjectionWidgetComponentPr
   // Fetch order status dictionary entries using the dictionary ID
   const { data: statusEntriesData } = useQuery({
     queryKey: ['dictionary-entries', orderStatusDictionaryId],
-    queryFn: async () => {
+    queryFn: async (): Promise<{ items: DictionaryEntry[] }> => {
       if (!orderStatusDictionaryId) return { items: [] }
-      const result = await apiCall<{ items: DictionaryEntry[] }>(
-        `/api/dictionaries/${orderStatusDictionaryId}/entries`
-      )
-      return result.ok ? result.result : { items: [] }
+      const result = await fetchAllDictionaryEntries(orderStatusDictionaryId)
+      if (!result.ok) return { items: [] }
+      const items = result.items.flatMap((entry) => {
+        const id = typeof entry.id === 'string' ? entry.id : null
+        const value = typeof entry.value === 'string' ? entry.value : null
+        if (!id || !value) return []
+        const label = typeof entry.label === 'string' && entry.label.trim().length ? entry.label : value
+        return [{ id, value, label }]
+      })
+      return { items }
     },
     enabled: Boolean(orderStatusDictionaryId),
     staleTime: 60_000,
@@ -192,20 +200,28 @@ export default function OrderApprovalWidget({ data }: InjectionWidgetComponentPr
       const approvedStatusId = findStatusId('approved')
       const rejectedStatusId = findStatusId('rejected')
 
+      if (!orderId) {
+        throw new Error(t('workflows.orderApproval.missingOrderId', 'Cannot start the approval workflow before the order has loaded.'))
+      }
+
       if (!pendingApprovalStatusId || !approvedStatusId || !rejectedStatusId) {
         throw new Error(t('workflows.orderApproval.missingStatuses', 'Missing order status entries. Please ensure pending_approval, approved, and rejected statuses exist in the sales.order_status dictionary.'))
       }
 
+      // Typed against the shared key list so a definition that references a new
+      // {{context.*}} key cannot compile until this seed provides it.
+      const initialContext: OrderApprovalInitialContext = {
+        orderId,
+        pendingApprovalStatusId,
+        approvedStatusId,
+        rejectedStatusId,
+      }
+
       const result = await apiCall<{ data: WorkflowInstance }>('/api/workflows/instances', {
         method: 'POST',
         body: JSON.stringify({
           workflowId: WORKFLOW_ID,
-          initialContext: {
-            orderId,
-            pendingApprovalStatusId,
-            approvedStatusId,
-            rejectedStatusId,
-          },
+          initialContext,
           metadata: {
             entityType: 'SalesOrder',
             entityId: orderId,