@open-mercato/core 0.6.7-develop.6676.1.7dad6df292 → 0.6.7-develop.6685.1.77c0a5591b

package/src/modules/workflows/data/validators.ts

@@ -202,6 +202,20 @@ export const activityRetryPolicySchema = z.object({
   maxIntervalMs: z.number().int().min(0),
 })
 
+/**
+ * Config fields each activity executor requires to run (see
+ * `lib/activity-executor.ts`). WAIT is handled separately below because it
+ * takes "duration" OR "until" rather than a fixed key set.
+ */
+const REQUIRED_ACTIVITY_CONFIG_KEYS: Partial<Record<ActivityType, readonly string[]>> = {
+  SEND_EMAIL: ['to', 'subject'],
+  CALL_API: ['endpoint'],
+  CALL_WEBHOOK: ['url'],
+  UPDATE_ENTITY: ['commandId', 'input'],
+  EMIT_EVENT: ['eventName'],
+  EXECUTE_FUNCTION: ['functionName'],
+}
+
 // Activity definition (embedded in transitions)
 export const activityDefinitionSchema = z.object({
   activityId: z.string().min(1).max(100).regex(/^[a-z0-9_-]+$/, 'Activity ID must contain only lowercase letters, numbers, hyphens, and underscores'),
@@ -210,12 +224,49 @@ export const activityDefinitionSchema = z.object({
   config: z.record(z.string(), z.any()),
   async: z.boolean().default(false).optional(), // For Phase 8.3
   retryPolicy: activityRetryPolicySchema.optional(),
-  timeout: z.string().optional(), // ISO 8601 duration
+  /**
+   * Per-activity timeout in milliseconds. This is what the editor writes and
+   * what `executeActivity` reads; it was missing from the schema, so
+   * `z.object()` stripped it on save and UI-configured timeouts silently did
+   * nothing (#4424).
+   */
+  timeoutMs: z.number().int().positive().optional(),
+  /**
+   * @deprecated Use `timeoutMs`. Accepted for definitions already stored with
+   * an ISO 8601 duration string; the executor normalizes it to milliseconds.
+   */
+  timeout: z.string().optional(),
   compensation: z.object({
     activityId: z.string().min(1), // ID of compensation activity
     automatic: z.boolean().default(true).optional() // Auto-trigger on failure
   }).optional(), // Compensation configuration (Phase 8.2)
 }).superRefine((activity, ctx) => {
+  // Config keys each activity executor requires at runtime. Without this, an
+  // activity missing e.g. CALL_API's `endpoint` saved cleanly from the visual
+  // editor and only failed once an instance ran it — the "edit silently
+  // disappeared / nothing told me why" report in #4232 (and the class of bug
+  // #4322 was an instance of). Validating here surfaces the exact missing field
+  // at edit time, since both the editor's save path and the API route parse
+  // through this schema.
+  const requiredConfigKeys = REQUIRED_ACTIVITY_CONFIG_KEYS[activity.activityType]
+  if (requiredConfigKeys) {
+    const config = activity.config || {}
+    for (const key of requiredConfigKeys) {
+      const value = config[key]
+      const isEmpty =
+        value == null ||
+        (typeof value === 'string' && value.trim() === '') ||
+        (key === 'input' && typeof value !== 'object')
+      if (isEmpty) {
+        ctx.addIssue({
+          code: 'custom',
+          path: ['config', key],
+          message: `${activity.activityType} activity requires "${key}"`,
+        })
+      }
+    }
+  }
+
   if (activity.activityType !== 'WAIT') return
   const config = activity.config || {}
   const hasDuration = config.duration != null && config.duration !== ''

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

@@ -80,6 +80,8 @@
   "workflows.activities.async": "Asynchron",
   "workflows.activities.compensation": "Kompensation",
   "workflows.activities.config": "Konfiguration",
+  "workflows.activities.configInvalidJson": "Ungültiges JSON",
+  "workflows.activities.configMustBeObject": "Konfiguration muss ein JSON-Objekt sein",
   "workflows.activities.deleteActivity": "Aktivität löschen",
   "workflows.activities.editActivity": "Aktivität bearbeiten",
   "workflows.activities.plural": "Aktivitäten",

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

@@ -80,6 +80,8 @@
   "workflows.activities.async": "Asynchronous",
   "workflows.activities.compensation": "Compensation",
   "workflows.activities.config": "Configuration",
+  "workflows.activities.configInvalidJson": "Invalid JSON",
+  "workflows.activities.configMustBeObject": "Config must be a JSON object",
   "workflows.activities.deleteActivity": "Delete Activity",
   "workflows.activities.editActivity": "Edit Activity",
   "workflows.activities.plural": "Activities",

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

@@ -80,6 +80,8 @@
   "workflows.activities.async": "Asincrona",
   "workflows.activities.compensation": "Compensacion",
   "workflows.activities.config": "Configuracion",
+  "workflows.activities.configInvalidJson": "JSON no válido",
+  "workflows.activities.configMustBeObject": "La configuración debe ser un objeto JSON",
   "workflows.activities.deleteActivity": "Eliminar actividad",
   "workflows.activities.editActivity": "Editar actividad",
   "workflows.activities.plural": "Actividades",

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",

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

@@ -107,9 +107,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
@@ -332,11 +365,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
+            timeoutMs
           )
         : await executeActivityByType(em, container, activity, context)
 

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.
  *