@contractspec/example.workflow-system 1.57.0 → 1.59.0

package/dist/instance/instance.handler.js

@@ -1,94 +1,357 @@
-import { mockDataStore } from "../shared/mock-data.js";
-import { buildStateMachineDefinition, createStateMachineEngine } from "../state-machine/index.js";
-import { createApprovalRequests } from "../approval/approval.handler.js";
+// @bun
+// src/shared/mock-data.ts
+var mockDataStore = {
+  workflows: new Map,
+  steps: new Map,
+  instances: new Map,
+  approvals: new Map,
+  stepExecutions: new Map
+};
 
-//#region src/instance/instance.handler.ts
+// src/state-machine/index.ts
+class BasicStateMachineEngine {
+  canTransition(definition, state, action, context) {
+    if (state.status !== "RUNNING" && state.status !== "WAITING") {
+      return {
+        allowed: false,
+        reason: `Workflow is ${state.status}, cannot transition`
+      };
+    }
+    const currentStep = definition.steps[state.currentStepKey];
+    if (!currentStep) {
+      return {
+        allowed: false,
+        reason: `Step ${state.currentStepKey} not found`
+      };
+    }
+    const transition = currentStep.transitions[action];
+    if (!transition) {
+      return {
+        allowed: false,
+        reason: `Action ${action} not available in step ${state.currentStepKey}`
+      };
+    }
+    if (currentStep.allowedRoles && currentStep.allowedRoles.length > 0) {
+      const hasRole = currentStep.allowedRoles.some((role) => context.userRoles.includes(role));
+      if (!hasRole) {
+        return {
+          allowed: false,
+          reason: `User lacks required role for this action`
+        };
+      }
+    }
+    if (typeof transition === "object" && transition.allowedRoles && transition.allowedRoles.length > 0) {
+      const hasRole = transition.allowedRoles.some((role) => context.userRoles.includes(role));
+      if (!hasRole) {
+        return {
+          allowed: false,
+          reason: `User lacks required role for action ${action}`
+        };
+      }
+    }
+    return { allowed: true };
+  }
+  getAvailableActions(definition, state, context) {
+    if (state.status !== "RUNNING" && state.status !== "WAITING") {
+      return [];
+    }
+    const currentStep = definition.steps[state.currentStepKey];
+    if (!currentStep) {
+      return [];
+    }
+    return Object.keys(currentStep.transitions).filter((action) => {
+      const result = this.canTransition(definition, state, action, context);
+      return result.allowed;
+    });
+  }
+  transition(definition, state, action, context) {
+    const validation = this.canTransition(definition, state, action, context);
+    if (!validation.allowed) {
+      return {
+        success: false,
+        previousStepKey: state.currentStepKey,
+        currentStepKey: state.currentStepKey,
+        status: state.status,
+        error: validation.reason
+      };
+    }
+    const currentStep = definition.steps[state.currentStepKey];
+    if (!currentStep) {
+      return {
+        success: false,
+        previousStepKey: state.currentStepKey,
+        currentStepKey: state.currentStepKey,
+        status: state.status,
+        error: `Current step ${state.currentStepKey} not found`
+      };
+    }
+    const transition = currentStep.transitions[action];
+    if (!transition) {
+      return {
+        success: false,
+        previousStepKey: state.currentStepKey,
+        currentStepKey: state.currentStepKey,
+        status: state.status,
+        error: `Transition for action ${action} not found`
+      };
+    }
+    const targetStepKey = typeof transition === "string" ? transition : transition.targetStepKey;
+    const targetStep = definition.steps[targetStepKey];
+    if (!targetStep) {
+      return {
+        success: false,
+        previousStepKey: state.currentStepKey,
+        currentStepKey: state.currentStepKey,
+        status: state.status,
+        error: `Target step ${targetStepKey} not found`
+      };
+    }
+    let newStatus = "RUNNING";
+    if (targetStep.type === "END") {
+      newStatus = "COMPLETED";
+    } else if (targetStep.type === "APPROVAL" || targetStep.type === "WAIT") {
+      newStatus = "WAITING";
+    }
+    return {
+      success: true,
+      previousStepKey: state.currentStepKey,
+      currentStepKey: targetStepKey,
+      status: newStatus
+    };
+  }
+  evaluateCondition(expression, contextData) {
+    try {
+      const match = expression.match(/^(\w+)\s*(>=|<=|>|<|===|!==|==|!=)\s*(.+)$/);
+      if (match) {
+        const [, prop, operator, value] = match;
+        if (!prop || !operator || value === undefined) {
+          return false;
+        }
+        const propValue = contextData[prop];
+        const compareValue = JSON.parse(value);
+        switch (operator) {
+          case ">":
+            return Number(propValue) > Number(compareValue);
+          case "<":
+            return Number(propValue) < Number(compareValue);
+          case ">=":
+            return Number(propValue) >= Number(compareValue);
+          case "<=":
+            return Number(propValue) <= Number(compareValue);
+          case "===":
+          case "==":
+            return propValue === compareValue;
+          case "!==":
+          case "!=":
+            return propValue !== compareValue;
+        }
+      }
+      if (expression in contextData) {
+        return Boolean(contextData[expression]);
+      }
+      return false;
+    } catch {
+      return false;
+    }
+  }
+}
+function createStateMachineEngine() {
+  return new BasicStateMachineEngine;
+}
+function buildStateMachineDefinition(workflow, steps) {
+  const stepMap = {};
+  for (const step of steps) {
+    stepMap[step.key] = {
+      key: step.key,
+      name: step.name,
+      type: step.type,
+      transitions: step.transitions,
+      approvalMode: step.approvalMode,
+      allowedRoles: step.approverRoles,
+      timeoutSeconds: step.timeoutSeconds,
+      conditionExpression: step.conditionExpression
+    };
+  }
+  const startStep = steps.find((s) => s.type === "START");
+  const initialStepKey = startStep?.key ?? steps[0]?.key ?? "";
+  return {
+    key: workflow.key,
+    name: workflow.name,
+    version: workflow.version,
+    initialStepKey,
+    steps: stepMap
+  };
+}
+function createInitialState(definition, contextData = {}) {
+  return {
+    currentStepKey: definition.initialStepKey,
+    status: "RUNNING",
+    contextData,
+    history: []
+  };
+}
+
+// src/approval/approval.handler.ts
+async function createApprovalRequests(instance, step, _context) {
+  const now = new Date;
+  for (let i = 0;i < step.approverRoles.length; i++) {
+    const role = step.approverRoles[i];
+    const id = `approval_${Date.now()}_${i}`;
+    const request = {
+      id,
+      workflowInstanceId: instance.id,
+      stepExecutionId: `exec_${instance.id}_${step.id}`,
+      approverId: `user_${role}`,
+      approverRole: role,
+      title: `Approval required for ${step.name}`,
+      description: step.description,
+      status: "PENDING",
+      contextSnapshot: instance.contextData,
+      sequenceOrder: i,
+      createdAt: now,
+      updatedAt: now
+    };
+    mockDataStore.approvals.set(id, request);
+  }
+}
+async function handleSubmitDecision(input, context) {
+  const request = mockDataStore.approvals.get(input.requestId);
+  if (!request) {
+    throw new Error(`Approval request ${input.requestId} not found`);
+  }
+  if (request.approverId !== context.userId && !context.userRoles.includes(request.approverRole ?? "")) {
+    throw new Error("User is not authorized to make this decision");
+  }
+  const now = new Date;
+  request.decision = input.decision;
+  request.decisionComment = input.comment;
+  request.decidedAt = now;
+  request.updatedAt = now;
+  if (input.decision === "APPROVE") {
+    request.status = "APPROVED";
+    await handleTransitionWorkflow({
+      instanceId: request.workflowInstanceId,
+      action: "approve",
+      data: input.data,
+      comment: input.comment
+    }, context);
+  } else if (input.decision === "REJECT") {
+    request.status = "REJECTED";
+    await handleTransitionWorkflow({
+      instanceId: request.workflowInstanceId,
+      action: "reject",
+      data: input.data,
+      comment: input.comment
+    }, context);
+  }
+  return request;
+}
+async function handleListMyApprovals(input, context) {
+  let requests = Array.from(mockDataStore.approvals.values()).filter((r) => r.approverId === context.userId || context.userRoles.includes(r.approverRole ?? ""));
+  const pendingCount = requests.filter((r) => r.status === "PENDING").length;
+  if (input.status) {
+    requests = requests.filter((r) => r.status === input.status);
+  }
+  const total = requests.length;
+  const offset = input.offset ?? 0;
+  const limit = input.limit ?? 20;
+  requests = requests.sort((a, b) => b.createdAt.getTime() - a.createdAt.getTime()).slice(offset, offset + limit);
+  return { requests, total, pendingCount };
+}
+
+// src/instance/instance.handler.ts
 async function handleStartWorkflow(input, context) {
-	const workflow = Array.from(mockDataStore.workflows.values()).find((w) => w.key === input.workflowKey && w.status === "ACTIVE" && w.organizationId === context.organizationId);
-	if (!workflow) throw new Error(`Active workflow ${input.workflowKey} not found`);
-	const id = `inst_${Date.now()}`;
-	const now = /* @__PURE__ */ new Date();
-	const instance = {
-		id,
-		workflowDefinitionId: workflow.id,
-		referenceId: input.referenceId,
-		referenceType: input.referenceType,
-		status: "RUNNING",
-		currentStepId: workflow.initialStepId,
-		contextData: input.contextData ?? {},
-		triggeredBy: context.userId,
-		organizationId: context.organizationId,
-		priority: input.priority ?? 0,
-		dueAt: input.dueAt,
-		createdAt: now,
-		updatedAt: now,
-		startedAt: now
-	};
-	mockDataStore.instances.set(id, instance);
-	if (workflow.initialStepId) {
-		const firstStep = mockDataStore.steps.get(workflow.initialStepId);
-		if (firstStep?.type === "APPROVAL") {
-			instance.status = "WAITING";
-			await createApprovalRequests(instance, firstStep, context);
-		}
-	}
-	return instance;
+  const workflow = Array.from(mockDataStore.workflows.values()).find((w) => w.key === input.workflowKey && w.status === "ACTIVE" && w.organizationId === context.organizationId);
+  if (!workflow) {
+    throw new Error(`Active workflow ${input.workflowKey} not found`);
+  }
+  const id = `inst_${Date.now()}`;
+  const now = new Date;
+  const instance = {
+    id,
+    workflowDefinitionId: workflow.id,
+    referenceId: input.referenceId,
+    referenceType: input.referenceType,
+    status: "RUNNING",
+    currentStepId: workflow.initialStepId,
+    contextData: input.contextData ?? {},
+    triggeredBy: context.userId,
+    organizationId: context.organizationId,
+    priority: input.priority ?? 0,
+    dueAt: input.dueAt,
+    createdAt: now,
+    updatedAt: now,
+    startedAt: now
+  };
+  mockDataStore.instances.set(id, instance);
+  if (workflow.initialStepId) {
+    const firstStep = mockDataStore.steps.get(workflow.initialStepId);
+    if (firstStep?.type === "APPROVAL") {
+      instance.status = "WAITING";
+      await createApprovalRequests(instance, firstStep, context);
+    }
+  }
+  return instance;
 }
 async function handleTransitionWorkflow(input, context) {
-	const instance = mockDataStore.instances.get(input.instanceId);
-	if (!instance) throw new Error(`Instance ${input.instanceId} not found`);
-	const workflow = mockDataStore.workflows.get(instance.workflowDefinitionId);
-	if (!workflow) throw new Error(`Workflow ${instance.workflowDefinitionId} not found`);
-	const steps = Array.from(mockDataStore.steps.values()).filter((s) => s.workflowDefinitionId === workflow.id);
-	const definition = buildStateMachineDefinition({
-		key: workflow.key,
-		name: workflow.name,
-		version: workflow.version,
-		initialStepId: workflow.initialStepId ?? null
-	}, steps);
-	const currentStep = steps.find((s) => s.id === instance.currentStepId);
-	const state = {
-		currentStepKey: currentStep?.key ?? "",
-		status: instance.status,
-		contextData: instance.contextData,
-		history: []
-	};
-	const transitionContext = {
-		userId: context.userId,
-		userRoles: context.userRoles,
-		data: input.data
-	};
-	const result = createStateMachineEngine().transition(definition, state, input.action, transitionContext);
-	if (!result.success) return {
-		success: false,
-		instance,
-		message: result.error
-	};
-	const previousStepKey = currentStep?.key;
-	const newStep = steps.find((s) => s.key === result.currentStepKey);
-	instance.currentStepId = newStep?.id;
-	instance.status = result.status;
-	instance.contextData = {
-		...instance.contextData,
-		...input.data
-	};
-	instance.updatedAt = /* @__PURE__ */ new Date();
-	if (result.status === "COMPLETED") {
-		instance.completedAt = /* @__PURE__ */ new Date();
-		instance.outcome = input.action;
-	}
-	if (newStep?.type === "APPROVAL") {
-		instance.status = "WAITING";
-		await createApprovalRequests(instance, newStep, context);
-	}
-	return {
-		success: true,
-		instance,
-		previousStepKey,
-		currentStepKey: result.currentStepKey ?? void 0
-	};
+  const instance = mockDataStore.instances.get(input.instanceId);
+  if (!instance) {
+    throw new Error(`Instance ${input.instanceId} not found`);
+  }
+  const workflow = mockDataStore.workflows.get(instance.workflowDefinitionId);
+  if (!workflow) {
+    throw new Error(`Workflow ${instance.workflowDefinitionId} not found`);
+  }
+  const steps = Array.from(mockDataStore.steps.values()).filter((s) => s.workflowDefinitionId === workflow.id);
+  const definition = buildStateMachineDefinition({
+    key: workflow.key,
+    name: workflow.name,
+    version: workflow.version,
+    initialStepId: workflow.initialStepId ?? null
+  }, steps);
+  const currentStep = steps.find((s) => s.id === instance.currentStepId);
+  const state = {
+    currentStepKey: currentStep?.key ?? "",
+    status: instance.status,
+    contextData: instance.contextData,
+    history: []
+  };
+  const transitionContext = {
+    userId: context.userId,
+    userRoles: context.userRoles,
+    data: input.data
+  };
+  const engine = createStateMachineEngine();
+  const result = engine.transition(definition, state, input.action, transitionContext);
+  if (!result.success) {
+    return {
+      success: false,
+      instance,
+      message: result.error
+    };
+  }
+  const previousStepKey = currentStep?.key;
+  const newStep = steps.find((s) => s.key === result.currentStepKey);
+  instance.currentStepId = newStep?.id;
+  instance.status = result.status;
+  instance.contextData = { ...instance.contextData, ...input.data };
+  instance.updatedAt = new Date;
+  if (result.status === "COMPLETED") {
+    instance.completedAt = new Date;
+    instance.outcome = input.action;
+  }
+  if (newStep?.type === "APPROVAL") {
+    instance.status = "WAITING";
+    await createApprovalRequests(instance, newStep, context);
+  }
+  return {
+    success: true,
+    instance,
+    previousStepKey,
+    currentStepKey: result.currentStepKey ?? undefined
+  };
 }
-
-//#endregion
-export { handleStartWorkflow, handleTransitionWorkflow };
-//# sourceMappingURL=instance.handler.js.map
+export {
+  handleTransitionWorkflow,
+  handleStartWorkflow
+};