@open-mercato/core 0.7.1-develop.7193.1.910a5b0a1e → 0.7.1-develop.7195.1.b5efd1d51a

package/dist/helpers/integration/workflowsFixtures.js

@@ -42,8 +42,8 @@ function buildUserTaskDefinitionPayload(timestamp) {
             assignedTo: "admin",
             formSchema: {
               fields: [
-                { name: "approved", type: "boolean", required: true },
-                { name: "comments", type: "string" }
+                { name: "approved", type: "boolean", label: "Approved", required: true },
+                { name: "comments", type: "string", label: "Comments" }
               ]
             }
           }
@@ -68,6 +68,97 @@ function buildUserTaskDefinitionPayload(timestamp) {
     enabled: true
   };
 }
+function buildDryRunIsolationDefinitionPayload(timestamp, suffix = "") {
+  return {
+    workflowId: `qa-wf-dryrun-${timestamp}${suffix}`,
+    workflowName: `QA Dry Run Isolation ${timestamp}${suffix}`,
+    description: "Workflow whose every step has a side effect, for dry-run isolation testing",
+    version: 1,
+    definition: {
+      steps: [
+        { stepId: "start", stepName: "Start", stepType: "START" },
+        { stepId: "notify", stepName: "Notify", stepType: "AUTOMATED" },
+        {
+          stepId: "review",
+          stepName: "Review",
+          stepType: "USER_TASK",
+          userTaskConfig: {
+            assignedTo: ["admin"],
+            formSchema: { fields: [{ name: "approved", type: "boolean", label: "Approved", required: true }] }
+          }
+        },
+        { stepId: "end", stepName: "End", stepType: "END" }
+      ],
+      transitions: [
+        {
+          transitionId: "start-to-notify",
+          fromStepId: "start",
+          toStepId: "notify",
+          trigger: "auto",
+          activities: [
+            {
+              activityId: "send-mail",
+              activityName: "sendMail",
+              activityType: "SEND_EMAIL",
+              config: { to: "qa@example.com", subject: "Dry run isolation probe" }
+            },
+            {
+              activityId: "emit",
+              activityName: "emitProbe",
+              activityType: "EMIT_EVENT",
+              config: { eventName: "workflows.qa.dry_run_probe", payload: { probe: true } }
+            }
+          ]
+        },
+        {
+          transitionId: "notify-to-review",
+          fromStepId: "notify",
+          toStepId: "review",
+          trigger: "auto"
+        },
+        {
+          transitionId: "review-to-end",
+          fromStepId: "review",
+          toStepId: "end",
+          trigger: "auto"
+        }
+      ]
+    },
+    enabled: true
+  };
+}
+function buildDryRunRefusalDefinitionPayload(timestamp, suffix = "") {
+  return {
+    workflowId: `qa-wf-dryrun-refuse-${timestamp}${suffix}`,
+    workflowName: `QA Dry Run Refusal ${timestamp}${suffix}`,
+    version: 1,
+    definition: {
+      steps: [
+        { stepId: "start", stepName: "Start", stepType: "START" },
+        { stepId: "run", stepName: "Run", stepType: "AUTOMATED" },
+        { stepId: "end", stepName: "End", stepType: "END" }
+      ],
+      transitions: [
+        {
+          transitionId: "start-to-run",
+          fromStepId: "start",
+          toStepId: "run",
+          trigger: "auto",
+          activities: [
+            {
+              activityId: "custom",
+              activityName: "customFn",
+              activityType: "EXECUTE_FUNCTION",
+              config: { functionName: "qa.noop" }
+            }
+          ]
+        },
+        { transitionId: "run-to-end", fromStepId: "run", toStepId: "end", trigger: "auto" }
+      ]
+    },
+    enabled: true
+  };
+}
 async function createWorkflowDefinitionFixture(request, token, data) {
   const response = await apiRequest(request, "POST", "/api/workflows/definitions", { token, data });
   const body = await readJsonSafe(response);
@@ -218,11 +309,116 @@ async function getWorkflowInstanceSnapshot(request, token, instanceId) {
 async function pollWorkflowInstance(request, token, instanceId, predicate, options = {}) {
   const timeoutMs = options.timeoutMs ?? 8e3;
   const intervalMs = options.intervalMs ?? 250;
+  const onTimeout = options.onTimeout ?? "throw";
   const deadline = Date.now() + timeoutMs;
   let last = null;
   for (; ; ) {
     last = await getWorkflowInstanceSnapshot(request, token, instanceId);
     if (last && predicate(last)) return last;
+    if (Date.now() >= deadline) {
+      if (onTimeout === "returnLast") return last;
+      const seen = last ? `status=${last.status} currentStepId=${last.currentStepId ?? "null"}` : "the instance was never readable";
+      throw new Error(
+        `[internal] pollWorkflowInstance: instance ${instanceId} did not satisfy the predicate within ${timeoutMs}ms (last seen: ${seen})`
+      );
+    }
+    await new Promise((resolve) => setTimeout(resolve, intervalMs));
+  }
+}
+function buildInspectorUserTaskDefinitionPayload(timestamp, options = {}) {
+  const suffix = options.suffix ?? "";
+  const id = `qa-wf-inspector${suffix}-${timestamp}`;
+  return {
+    workflowId: id,
+    workflowName: `QA Inspector User Task${suffix} ${timestamp}`,
+    description: `Integration test definition ${id}`,
+    version: 1,
+    definition: {
+      steps: [
+        { stepId: "start", stepName: "Start", stepType: "START" },
+        {
+          stepId: "review",
+          stepName: options.stepName ?? "Review",
+          stepType: "USER_TASK",
+          userTaskConfig: options.userTaskConfig ?? {
+            assignedToRoles: ["admin"],
+            formSchema: { properties: { approved: { type: "boolean" } } }
+          }
+        },
+        { stepId: "end", stepName: "End", stepType: "END" }
+      ],
+      transitions: [
+        { transitionId: "start-to-review", fromStepId: "start", toStepId: "review", trigger: "auto" },
+        {
+          transitionId: "review-to-end",
+          fromStepId: "review",
+          toStepId: "end",
+          trigger: options.postTaskTrigger ?? "auto"
+        }
+      ]
+    },
+    enabled: true
+  };
+}
+function buildDecisionUserTaskDefinitionPayload(timestamp, suffix = "") {
+  const id = `qa-wf-decision${suffix}-${timestamp}`;
+  return {
+    workflowId: id,
+    workflowName: `QA Decision User Task${suffix} ${timestamp}`,
+    description: `Integration test definition ${id}`,
+    version: 1,
+    definition: {
+      steps: [
+        { stepId: "start", stepName: "Start", stepType: "START" },
+        {
+          stepId: "review",
+          stepName: "Review",
+          stepType: "USER_TASK",
+          userTaskConfig: {
+            assignedToRoles: ["admin"],
+            formSchema: { properties: { comments: { type: "string" } } },
+            decisions: [
+              { id: "approve", label: "Approve", transitionId: "review-to-approved", style: "primary" },
+              { id: "reject", label: "Reject", transitionId: "review-to-rejected", style: "destructive" }
+            ]
+          }
+        },
+        { stepId: "approved", stepName: "Approved", stepType: "END" },
+        { stepId: "rejected", stepName: "Rejected", stepType: "END" }
+      ],
+      transitions: [
+        { transitionId: "start-to-review", fromStepId: "start", toStepId: "review", trigger: "auto" },
+        { transitionId: "review-to-approved", fromStepId: "review", toStepId: "approved", trigger: "manual" },
+        { transitionId: "review-to-rejected", fromStepId: "review", toStepId: "rejected", trigger: "manual" }
+      ]
+    },
+    enabled: true
+  };
+}
+async function getUserTaskDetail(request, token, taskId) {
+  const response = await apiRequest(
+    request,
+    "GET",
+    `/api/workflows/tasks/${encodeURIComponent(taskId)}`,
+    { token }
+  );
+  if (response.status() !== 200) return null;
+  const body = await readJsonSafe(response);
+  return body?.data ?? null;
+}
+async function listWorkInbox(request, token, query) {
+  const response = await apiRequest(request, "GET", `/api/workflows/work-inbox${query}`, { token });
+  expect(response.status(), `GET /api/workflows/work-inbox${query} should return 200`).toBe(200);
+  return readJsonSafe(response);
+}
+async function pollWorkInbox(request, token, query, predicate, options = {}) {
+  const timeoutMs = options.timeoutMs ?? 8e3;
+  const intervalMs = options.intervalMs ?? 250;
+  const deadline = Date.now() + timeoutMs;
+  let last = null;
+  for (; ; ) {
+    last = await listWorkInbox(request, token, query);
+    if (last && predicate(last)) return last;
     if (Date.now() >= deadline) return last;
     await new Promise((resolve) => setTimeout(resolve, intervalMs));
   }
@@ -251,20 +447,299 @@ async function findInstanceUserTask(request, token, instanceId, options = {}) {
     await new Promise((resolve) => setTimeout(resolve, intervalMs));
   }
 }
+async function registerTaskBindingEntityType(request, token, entityId, label) {
+  const response = await apiRequest(request, "POST", "/api/entities/entities", {
+    token,
+    data: {
+      entityId,
+      label: label ?? entityId,
+      showInSidebar: false,
+      accessRestricted: false
+    }
+  });
+  expect(
+    response.status(),
+    `POST /api/entities/entities should register ${entityId}, got ${response.status()}`
+  ).toBeLessThan(300);
+}
+async function deleteTaskBindingEntityTypeIfExists(request, token, entityId) {
+  if (!entityId) return;
+  await apiRequest(request, "DELETE", "/api/entities/entities", {
+    token,
+    data: { entityId }
+  }).catch(() => void 0);
+}
+function buildAgentOutcomeDefinitionPayload(stamp, signalName) {
+  const id = `qa-wf-outcome-${stamp}`;
+  return {
+    workflowId: id,
+    workflowName: `QA Agent Outcome Workflow ${stamp}`,
+    description: `Integration test definition ${id}`,
+    version: 1,
+    definition: {
+      steps: [
+        { stepId: "start", stepName: "Start", stepType: "START" },
+        {
+          stepId: "agent",
+          stepName: "Assess",
+          stepType: "WAIT_FOR_SIGNAL",
+          signalConfig: { signalName },
+          activities: [
+            {
+              activityId: "assess",
+              activityName: "Assess",
+              activityType: "INVOKE_AGENT",
+              config: { agentId: "qa.assessor", input: {}, onResult: { autoApproveThreshold: 0.8 } }
+            }
+          ]
+        },
+        { stepId: "apply", stepName: "Apply", stepType: "AUTOMATED" },
+        { stepId: "end", stepName: "End", stepType: "END" },
+        { stepId: "rejected_end", stepName: "Rejected", stepType: "END" },
+        { stepId: "guardrail_end", stepName: "Guardrail Blocked", stepType: "END" }
+      ],
+      transitions: [
+        { transitionId: "start-to-agent", fromStepId: "start", toStepId: "agent", trigger: "auto" },
+        { transitionId: "agent-to-apply", fromStepId: "agent", toStepId: "apply", trigger: "auto" },
+        { transitionId: "apply-to-end", fromStepId: "apply", toStepId: "end", trigger: "auto" },
+        {
+          transitionId: "agent-rejected",
+          fromStepId: "agent",
+          toStepId: "rejected_end",
+          trigger: "auto",
+          kind: "outcome",
+          outcomeKind: "rejected"
+        },
+        {
+          transitionId: "agent-guardrail",
+          fromStepId: "agent",
+          toStepId: "guardrail_end",
+          trigger: "auto",
+          kind: "outcome",
+          outcomeKind: "guardrailBlocked"
+        }
+      ]
+    },
+    enabled: true
+  };
+}
+function buildSlaBreachRouteDefinitionPayload(stamp) {
+  const id = `qa-wf-breach-${stamp}`;
+  return {
+    workflowId: id,
+    workflowName: `QA SLA Breach Route Workflow ${stamp}`,
+    description: `Integration test definition ${id}`,
+    version: 1,
+    definition: {
+      steps: [
+        { stepId: "start", stepName: "Start", stepType: "START" },
+        {
+          stepId: "review",
+          stepName: "Review",
+          stepType: "USER_TASK",
+          userTaskConfig: { assignedToRoles: ["admin"], allowedActions: ["complete"] }
+        },
+        { stepId: "escalate", stepName: "Escalate", stepType: "END" },
+        { stepId: "end", stepName: "End", stepType: "END" }
+      ],
+      transitions: [
+        { transitionId: "start-to-review", fromStepId: "start", toStepId: "review", trigger: "auto" },
+        { transitionId: "review-to-end", fromStepId: "review", toStepId: "end", trigger: "auto" },
+        {
+          transitionId: "review-breach",
+          fromStepId: "review",
+          toStepId: "escalate",
+          trigger: "auto",
+          kind: "slaBreach"
+        }
+      ]
+    },
+    enabled: true
+  };
+}
+function buildCompletedRunDefinitionPayload(stamp, suffix = "") {
+  const id = `qa-wf-run${suffix}-${stamp}`;
+  return {
+    workflowId: id,
+    workflowName: `QA Completed Run${suffix} ${stamp}`,
+    description: `Integration test definition ${id}`,
+    version: 1,
+    definition: {
+      steps: [
+        { stepId: "start", stepName: "Start", stepType: "START" },
+        { stepId: "prepare", stepName: "Prepare", stepType: "AUTOMATED" },
+        { stepId: "finish", stepName: "Finish", stepType: "AUTOMATED" },
+        { stepId: "end", stepName: "End", stepType: "END" }
+      ],
+      transitions: [
+        { transitionId: "start-to-prepare", fromStepId: "start", toStepId: "prepare", trigger: "auto" },
+        { transitionId: "prepare-to-finish", fromStepId: "prepare", toStepId: "finish", trigger: "auto" },
+        { transitionId: "finish-to-end", fromStepId: "finish", toStepId: "end", trigger: "auto" }
+      ]
+    },
+    enabled: true
+  };
+}
+function buildFailingStepDefinitionPayload(stamp, options = {}) {
+  const suffix = options.suffix ?? "";
+  const id = `qa-wf-fail${suffix}-${stamp}`;
+  return {
+    workflowId: id,
+    workflowName: `QA Failing Step${suffix} ${stamp}`,
+    description: `Integration test definition ${id}`,
+    version: 1,
+    definition: {
+      steps: [
+        { stepId: "start", stepName: "Start", stepType: "START" },
+        { stepId: "mid", stepName: "Mid", stepType: "AUTOMATED" },
+        {
+          stepId: "boom",
+          stepName: "Boom",
+          stepType: "AUTOMATED",
+          ...options.errorDirective ? { errorDirective: { mode: options.errorDirective } } : {},
+          activities: [
+            {
+              activityId: "boom",
+              activityName: "Boom",
+              activityType: "EXECUTE_FUNCTION",
+              config: { functionName: "qa-nonexistent-function-do-not-register" }
+            }
+          ]
+        },
+        { stepId: "end", stepName: "End", stepType: "END" }
+      ],
+      transitions: [
+        { transitionId: "start-to-mid", fromStepId: "start", toStepId: "mid", trigger: "auto" },
+        { transitionId: "mid-to-boom", fromStepId: "mid", toStepId: "boom", trigger: "auto" },
+        { transitionId: "boom-to-end", fromStepId: "boom", toStepId: "end", trigger: "auto" }
+      ]
+    },
+    enabled: true
+  };
+}
+function buildAgentReviewDeadlineDefinitionPayload(stamp, options) {
+  const suffix = options.suffix ?? "";
+  const id = `qa-wf-review${suffix}-${stamp}`;
+  return {
+    workflowId: id,
+    workflowName: `QA Agent Review Deadline${suffix} ${stamp}`,
+    description: `Integration test definition ${id}`,
+    version: 1,
+    definition: {
+      steps: [
+        { stepId: "start", stepName: "Start", stepType: "START" },
+        {
+          stepId: "agent_review",
+          stepName: "Dispose agent proposal",
+          stepType: "USER_TASK",
+          userTaskConfig: {
+            assignedToRoles: options.assignedToRoles ?? ["admin"],
+            allowedActions: ["complete"],
+            deadline: { duration: options.deadlineDuration },
+            // The USER_TASK vocabulary asking to route. Must be ignored here.
+            onBreach: { action: "route", transitionId: "review-breach" }
+          },
+          activities: [
+            {
+              activityId: "assess",
+              activityName: "Assess",
+              activityType: "INVOKE_AGENT",
+              config: {
+                agentId: "qa.assessor",
+                input: {},
+                onResult: { autoApproveThreshold: 0.8 },
+                review: {
+                  deadline: { duration: options.deadlineDuration },
+                  onBreach: options.onBreach
+                }
+              }
+            }
+          ]
+        },
+        { stepId: "escalate", stepName: "Escalate", stepType: "END" },
+        { stepId: "end", stepName: "End", stepType: "END" }
+      ],
+      transitions: [
+        { transitionId: "start-to-review", fromStepId: "start", toStepId: "agent_review", trigger: "auto" },
+        { transitionId: "review-to-end", fromStepId: "agent_review", toStepId: "end", trigger: "manual" },
+        // The breach route the engine must refuse to follow on an agent step.
+        {
+          transitionId: "review-breach",
+          fromStepId: "agent_review",
+          toStepId: "escalate",
+          trigger: "auto",
+          kind: "slaBreach"
+        }
+      ]
+    },
+    enabled: true
+  };
+}
+async function listWorkflowInstanceEvents(request, token, instanceId, options = {}) {
+  const params = new URLSearchParams({ limit: String(options.limit ?? 100) });
+  if (options.eventType) params.set("eventType", options.eventType);
+  const response = await apiRequest(
+    request,
+    "GET",
+    `/api/workflows/instances/${encodeURIComponent(instanceId)}/events?${params.toString()}`,
+    { token }
+  );
+  expect(response.status(), `GET instance events should return 200 (got ${response.status()})`).toBe(200);
+  const body = await readJsonSafe(response);
+  return body?.data ?? [];
+}
+async function listWorkflowInstanceSteps(request, token, instanceId) {
+  const response = await apiRequest(
+    request,
+    "GET",
+    `/api/workflows/instances/${encodeURIComponent(instanceId)}/steps?limit=100`,
+    { token }
+  );
+  expect(response.status(), `GET instance steps should return 200 (got ${response.status()})`).toBe(200);
+  const body = await readJsonSafe(response);
+  return body?.data ?? [];
+}
+async function getWorkflowFailureQueue(request, token, query = "limit=100") {
+  const response = await apiRequest(
+    request,
+    "GET",
+    `/api/workflows/instances/failure-queue?${query}`,
+    { token }
+  );
+  expect(response.status(), `GET failure-queue should return 200 (got ${response.status()})`).toBe(200);
+  return readJsonSafe(response);
+}
 export {
+  buildAgentOutcomeDefinitionPayload,
+  buildAgentReviewDeadlineDefinitionPayload,
   buildAssignedUserTaskDefinitionPayload,
   buildClaimableUserTaskDefinitionPayload,
+  buildCompletedRunDefinitionPayload,
+  buildDecisionUserTaskDefinitionPayload,
+  buildDryRunIsolationDefinitionPayload,
+  buildDryRunRefusalDefinitionPayload,
+  buildFailingStepDefinitionPayload,
+  buildInspectorUserTaskDefinitionPayload,
   buildManualAdvanceDefinitionPayload,
   buildMinimalDefinitionPayload,
   buildSignalDefinitionPayload,
+  buildSlaBreachRouteDefinitionPayload,
   buildUserTaskDefinitionPayload,
   cancelWorkflowInstanceIfExists,
   createWorkflowDefinitionFixture,
+  deleteTaskBindingEntityTypeIfExists,
   deleteWorkflowDefinitionIfExists,
   findInstanceUserTask,
+  getUserTaskDetail,
+  getWorkflowFailureQueue,
   getWorkflowInstanceSnapshot,
+  listWorkInbox,
+  listWorkflowInstanceEvents,
+  listWorkflowInstanceSteps,
   listWorkflowInstanceTasks,
+  pollWorkInbox,
   pollWorkflowInstance,
+  registerTaskBindingEntityType,
   startWorkflowInstanceFixture
 };
 //# sourceMappingURL=workflowsFixtures.js.map