@open-mercato/core 0.6.8-develop.6908.1.4792c7717e → 0.6.8-develop.6910.1.560e304de2

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

@@ -26,6 +26,7 @@ import { callWebhookConfigSchema } from '../data/validators'
 import { WorkflowActivityJob, WORKFLOW_ACTIVITIES_QUEUE_NAME } from './activity-queue-types'
 import { logWorkflowEvent } from './event-logger'
 import { parseDuration } from './duration'
+import { resolveActivityTimeoutMs } from './activityTimeoutFields'
 import { getWorkflowSafeCommand } from './workflow-safe-commands'
 
 export { isPrivateUrl } from '@open-mercato/shared/lib/network'
@@ -114,33 +115,7 @@ export interface ActivityDefinition {
   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 { resolveActivityTimeoutMs }
 
 export interface RetryPolicy {
   maxAttempts: number
@@ -1494,6 +1469,11 @@ function sleep(ms: number): Promise<void> {
 
 /**
  * Execute a promise with timeout
+ *
+ * Only CALL_API and CALL_WEBHOOK honour the abort signal today — they forward
+ * it to `fetch`. SEND_EMAIL, EMIT_EVENT, UPDATE_ENTITY and EXECUTE_FUNCTION
+ * still run to completion after the timeout has been recorded. Tracked in
+ * #5148.
  */
 async function executeWithTimeout<T>(
   executor: (signal: AbortSignal) => Promise<T>,

package/src/modules/workflows/lib/activityTimeoutFields.ts

@@ -0,0 +1,75 @@
+import { toTimeoutMs } from './duration'
+
+/**
+ * The two timeout fields an activity definition can carry.
+ *
+ * `timeoutMs` is canonical and is what `resolveActivityTimeoutMs` prefers;
+ * `timeout` is the deprecated alias that stored definitions and the CrudForm
+ * activity editor still write. A timeout input must own both fields — read
+ * them merged and write both on every edit — otherwise the box shows the
+ * executor's effective timeout while changing only half of the pair, and the
+ * user's edit is silently discarded.
+ */
+export type ActivityTimeoutFields = {
+  timeout?: string
+  timeoutMs?: number
+}
+
+/**
+ * Effective timeout for an activity, in milliseconds.
+ *
+ * The editors and the executor both speak `timeoutMs`, but the definition
+ * schema historically accepted only a `timeout` string — so stored definitions
+ * can carry either. Prefer `timeoutMs`; fall back to `toTimeoutMs`, which
+ * reads both a duration string ("PT30S", "5m") and a plain millisecond string
+ * ("30000") — the CrudForm activity editor writes the latter, and its own
+ * placeholder tells the user to. A malformed value is ignored rather than
+ * thrown mid-execution (an unparseable timeout must not fail an activity that
+ * would otherwise succeed). Returns undefined when no usable timeout is
+ * configured (#4424).
+ *
+ * `activity-executor` re-exports this so its import path stays stable; it
+ * lives here so the editors can assert the round-trip without pulling in the
+ * server-only executor.
+ */
+export function resolveActivityTimeoutMs(activity: ActivityTimeoutFields): number | undefined {
+  if (typeof activity.timeoutMs === 'number' && activity.timeoutMs > 0) {
+    return activity.timeoutMs
+  }
+  return toTimeoutMs(activity.timeout)
+}
+
+/**
+ * Text shown by a timeout input that accepts duration strings as well as
+ * milliseconds (the CrudForm activity editor, whose placeholder reads
+ * "PT30S or 30000").
+ */
+export function durationTimeoutInputValue(activity: ActivityTimeoutFields): string {
+  if (activity.timeout) return activity.timeout
+  return activity.timeoutMs != null ? String(activity.timeoutMs) : ''
+}
+
+/** Value shown by a millisecond-only timeout input (the two visual editors). */
+export function millisecondTimeoutInputValue(activity: ActivityTimeoutFields): number | '' {
+  return activity.timeoutMs ?? toTimeoutMs(activity.timeout) ?? ''
+}
+
+/**
+ * Fields to merge into an activity after a duration-accepting input changed.
+ *
+ * The raw text stays in the deprecated alias so a partially typed duration
+ * survives the re-render, and `timeoutMs` carries whatever the executor can
+ * actually use — undefined while the text is incomplete or unusable.
+ */
+export function durationTimeoutPatch(raw: string): ActivityTimeoutFields {
+  return { timeout: raw || undefined, timeoutMs: toTimeoutMs(raw) }
+}
+
+/**
+ * Fields to merge into an activity after a millisecond-only input changed.
+ * The deprecated alias is dropped, so clearing the box clears the timeout and
+ * stored definitions migrate off `timeout` as they are edited.
+ */
+export function millisecondTimeoutPatch(raw: string): ActivityTimeoutFields {
+  return { timeout: undefined, timeoutMs: toTimeoutMs(raw) }
+}

package/src/modules/workflows/lib/duration.ts

@@ -49,3 +49,40 @@ export function parseDuration(duration: string): number {
 
   throw new Error(`Invalid duration format: ${duration}`)
 }
+
+/**
+ * Normalize a timeout value to milliseconds
+ *
+ * Accepts every shape the activity editors and stored definitions carry:
+ * - a millisecond number (30000)
+ * - a millisecond string ("30000") — what the CrudForm activity editor writes,
+ *   and what its own placeholder ("PT30S or 30000") tells the user to type
+ * - a duration string ("PT30S", "5m")
+ *
+ * Returns undefined for an absent or unusable value rather than throwing, so a
+ * malformed timeout never fails an activity that would otherwise succeed.
+ *
+ * @param value - Raw timeout value
+ * @returns Milliseconds, or undefined when the value is absent or unusable
+ */
+export function toTimeoutMs(value: unknown): number | undefined {
+  if (typeof value === 'number') {
+    return Number.isFinite(value) && value > 0 ? value : undefined
+  }
+  if (typeof value !== 'string') return undefined
+
+  const trimmed = value.trim()
+  if (!trimmed) return undefined
+
+  if (/^\d+$/.test(trimmed)) {
+    const milliseconds = Number(trimmed)
+    return milliseconds > 0 ? milliseconds : undefined
+  }
+
+  try {
+    const milliseconds = parseDuration(trimmed)
+    return Number.isFinite(milliseconds) && milliseconds > 0 ? milliseconds : undefined
+  } catch {
+    return undefined
+  }
+}