@contractspec/lib.contracts-spec 2.0.0

package/dist/workflow/context.js

@@ -0,0 +1,247 @@
+// @bun
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __moduleCache = /* @__PURE__ */ new WeakMap;
+var __toCommonJS = (from) => {
+  var entry = __moduleCache.get(from), desc;
+  if (entry)
+    return entry;
+  entry = __defProp({}, "__esModule", { value: true });
+  if (from && typeof from === "object" || typeof from === "function")
+    __getOwnPropNames(from).map((key) => !__hasOwnProp.call(entry, key) && __defProp(entry, key, {
+      get: () => from[key],
+      enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+    }));
+  __moduleCache.set(from, entry);
+  return entry;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, {
+      get: all[name],
+      enumerable: true,
+      configurable: true,
+      set: (newValue) => all[name] = () => newValue
+    });
+};
+var __esm = (fn, res) => () => (fn && (res = fn(fn = 0)), res);
+var __require = import.meta.require;
+
+// src/workflow/context.ts
+class WorkflowContextError extends Error {
+  errorType;
+  workflowId;
+  details;
+  constructor(type, workflowId, message, details) {
+    super(message);
+    this.name = "WorkflowContextError";
+    this.errorType = type;
+    this.workflowId = workflowId;
+    this.details = details;
+  }
+}
+
+class WorkflowContextImpl {
+  state;
+  spec;
+  constructor(state, spec) {
+    this.state = state;
+    this.spec = spec;
+  }
+  get workflowId() {
+    return this.state.workflowId;
+  }
+  get workflowKey() {
+    return this.state.workflowName;
+  }
+  get workflowVersion() {
+    return this.state.workflowVersion;
+  }
+  get currentStep() {
+    return this.state.currentStep;
+  }
+  get status() {
+    return this.state.status;
+  }
+  get data() {
+    return this.state.data;
+  }
+  get history() {
+    return this.state.history;
+  }
+  getState() {
+    return this.state;
+  }
+  getData(key) {
+    return this.state.data[key];
+  }
+  isTerminal() {
+    return this.state.status === "completed" || this.state.status === "failed" || this.state.status === "cancelled";
+  }
+  isRunning() {
+    return this.state.status === "running";
+  }
+  getCurrentStepDef() {
+    return this.spec.definition.steps.find((s) => s.id === this.state.currentStep);
+  }
+  getRetryCount(stepId) {
+    const id = stepId ?? this.state.currentStep;
+    return this.state.retryCounts?.[id] ?? 0;
+  }
+  canTransition(toStepId) {
+    const transitions = this.spec.definition.transitions.filter((t) => t.from === this.state.currentStep && t.to === toStepId);
+    return transitions.length > 0;
+  }
+  getAvailableTransitions() {
+    return this.spec.definition.transitions.filter((t) => t.from === this.state.currentStep).map((t) => ({
+      from: t.from,
+      to: t.to,
+      label: t.label,
+      condition: t.condition
+    }));
+  }
+  hasNextStep() {
+    return this.spec.definition.transitions.some((t) => t.from === this.state.currentStep);
+  }
+  getRemainingTime(slaKey) {
+    const sla = this.spec.definition.sla;
+    if (!sla)
+      return null;
+    const now = Date.now();
+    if (slaKey === "totalDuration") {
+      if (!sla.totalDurationMs)
+        return null;
+      const elapsed2 = now - this.state.createdAt.getTime();
+      return Math.max(0, sla.totalDurationMs - elapsed2);
+    }
+    const stepLimit = sla.stepDurationMs?.[slaKey];
+    if (!stepLimit)
+      return null;
+    const stepExecution = this.state.history.find((h) => h.stepId === slaKey && h.status === "running");
+    if (!stepExecution)
+      return stepLimit;
+    const elapsed = now - stepExecution.startedAt.getTime();
+    return Math.max(0, stepLimit - elapsed);
+  }
+  isSlaViolated(slaKey) {
+    const remaining = this.getRemainingTime(slaKey);
+    return remaining !== null && remaining <= 0;
+  }
+  getAllSlaStatuses() {
+    const sla = this.spec.definition.sla;
+    if (!sla)
+      return [];
+    const statuses = [];
+    const now = Date.now();
+    if (sla.totalDurationMs) {
+      const elapsed = now - this.state.createdAt.getTime();
+      const remaining = Math.max(0, sla.totalDurationMs - elapsed);
+      statuses.push({
+        key: "totalDuration",
+        type: "workflow",
+        limitMs: sla.totalDurationMs,
+        elapsedMs: elapsed,
+        remainingMs: remaining,
+        violated: remaining <= 0,
+        percentUsed: elapsed / sla.totalDurationMs * 100
+      });
+    }
+    if (sla.stepDurationMs) {
+      for (const [stepId, limitMs] of Object.entries(sla.stepDurationMs)) {
+        const stepExecution = this.state.history.find((h) => h.stepId === stepId && h.status === "running");
+        const elapsed = stepExecution ? now - stepExecution.startedAt.getTime() : 0;
+        const remaining = Math.max(0, limitMs - elapsed);
+        statuses.push({
+          key: stepId,
+          type: "step",
+          stepId,
+          limitMs,
+          elapsedMs: elapsed,
+          remainingMs: remaining,
+          violated: stepExecution !== undefined && remaining <= 0,
+          percentUsed: elapsed / limitMs * 100
+        });
+      }
+    }
+    return statuses;
+  }
+  hasCompensation() {
+    return this.spec.definition.compensation !== undefined;
+  }
+  getCompensableSteps() {
+    const compensation = this.spec.definition.compensation;
+    if (!compensation)
+      return [];
+    return compensation.steps.map((s) => s.stepId);
+  }
+  getEvents() {
+    const events = [];
+    for (const execution of this.state.history) {
+      events.push({
+        timestamp: execution.startedAt,
+        type: "step_started",
+        stepId: execution.stepId,
+        input: execution.input
+      });
+      if (execution.completedAt) {
+        if (execution.status === "completed") {
+          events.push({
+            timestamp: execution.completedAt,
+            type: "step_completed",
+            stepId: execution.stepId,
+            output: execution.output
+          });
+        } else if (execution.status === "failed") {
+          events.push({
+            timestamp: execution.completedAt,
+            type: "step_failed",
+            stepId: execution.stepId,
+            error: execution.error
+          });
+        }
+      }
+    }
+    events.sort((a, b) => a.timestamp.getTime() - b.timestamp.getTime());
+    return events;
+  }
+}
+function createWorkflowContext(state, spec) {
+  return new WorkflowContextImpl(state, spec);
+}
+function calculateWorkflowProgress(ctx) {
+  const state = ctx.getState();
+  const completedSteps = new Set(state.history.filter((h) => h.status === "completed").map((h) => h.stepId));
+  const _totalSteps = completedSteps.size + (ctx.isTerminal() ? 0 : 1);
+  if (ctx.status === "completed")
+    return 100;
+  if (ctx.status === "failed" || ctx.status === "cancelled") {
+    return completedSteps.size > 0 ? Math.min(99, completedSteps.size * 20) : 0;
+  }
+  return Math.min(99, completedSteps.size * 20);
+}
+function getWorkflowDuration(ctx) {
+  const state = ctx.getState();
+  const endTime = ctx.isTerminal() ? state.updatedAt.getTime() : Date.now();
+  return endTime - state.createdAt.getTime();
+}
+function getAverageStepDuration(ctx) {
+  const completedSteps = ctx.history.filter((h) => h.status === "completed" && h.completedAt);
+  if (completedSteps.length === 0)
+    return 0;
+  const totalDuration = completedSteps.reduce((sum, step) => {
+    if (!step.completedAt)
+      return sum;
+    const duration = step.completedAt.getTime() - step.startedAt.getTime();
+    return sum + duration;
+  }, 0);
+  return totalDuration / completedSteps.length;
+}
+export {
+  getWorkflowDuration,
+  getAverageStepDuration,
+  createWorkflowContext,
+  calculateWorkflowProgress,
+  WorkflowContextError
+};

package/dist/workflow/context.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/workflow/expression.d.ts

@@ -0,0 +1,6 @@
+export interface ExpressionContext {
+    data: Record<string, unknown>;
+    input?: unknown;
+    output?: unknown;
+}
+export declare function evaluateExpression(expression: string | undefined, ctx: ExpressionContext): boolean;

package/dist/workflow/expression.js

@@ -0,0 +1,157 @@
+// @bun
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __moduleCache = /* @__PURE__ */ new WeakMap;
+var __toCommonJS = (from) => {
+  var entry = __moduleCache.get(from), desc;
+  if (entry)
+    return entry;
+  entry = __defProp({}, "__esModule", { value: true });
+  if (from && typeof from === "object" || typeof from === "function")
+    __getOwnPropNames(from).map((key) => !__hasOwnProp.call(entry, key) && __defProp(entry, key, {
+      get: () => from[key],
+      enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+    }));
+  __moduleCache.set(from, entry);
+  return entry;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, {
+      get: all[name],
+      enumerable: true,
+      configurable: true,
+      set: (newValue) => all[name] = () => newValue
+    });
+};
+var __esm = (fn, res) => () => (fn && (res = fn(fn = 0)), res);
+var __require = import.meta.require;
+
+// src/workflow/expression.ts
+function evaluateExpression(expression, ctx) {
+  if (!expression)
+    return true;
+  const trimmed = expression.trim();
+  if (!trimmed)
+    return true;
+  const orParts = splitByOperator(trimmed, "||");
+  if (orParts.length > 1)
+    return orParts.some((part) => evaluateExpression(part, ctx));
+  const andParts = splitByOperator(trimmed, "&&");
+  if (andParts.length > 1)
+    return andParts.every((part) => evaluateExpression(part, ctx));
+  return evaluateSingle(trimmed, ctx);
+}
+function evaluateSingle(expr, ctx) {
+  const trimmed = expr.trim();
+  if (!trimmed)
+    return true;
+  if (trimmed.startsWith("!"))
+    return !evaluateSingle(trimmed.slice(1), ctx);
+  const comparisonMatch = trimmed.match(/^(data|input|output)\.([A-Za-z0-9_.[\]]+)\s*(===|==|!==|!=|>=|<=|>|<)\s*(.+)$/);
+  if (comparisonMatch) {
+    const [, root, path, operator, rawRight] = comparisonMatch;
+    const left = resolveRoot(root, ctx, path);
+    const right = parseLiteral(rawRight);
+    return compare(left, right, operator);
+  }
+  const truthyMatch = trimmed.match(/^(data|input|output)\.([A-Za-z0-9_.[\]]+)$/);
+  if (truthyMatch) {
+    const [, root, path] = truthyMatch;
+    const value = resolveRoot(root, ctx, path);
+    return Boolean(value);
+  }
+  const literal = parseLiteral(trimmed);
+  return Boolean(literal);
+}
+function compare(left, right, operator) {
+  switch (operator) {
+    case "===":
+    case "==":
+      return left === right;
+    case "!==":
+    case "!=":
+      return left !== right;
+    case ">":
+      return Number(left) > Number(right);
+    case ">=":
+      return Number(left) >= Number(right);
+    case "<":
+      return Number(left) < Number(right);
+    case "<=":
+      return Number(left) <= Number(right);
+    default:
+      return false;
+  }
+}
+function parseLiteral(value) {
+  const trimmed = (value ?? "").trim();
+  if (trimmed.startsWith('"') && trimmed.endsWith('"') || trimmed.startsWith("'") && trimmed.endsWith("'"))
+    return trimmed.slice(1, -1);
+  if (/^-?\d+(\.\d+)?$/.test(trimmed))
+    return Number(trimmed);
+  if (/^true$/i.test(trimmed))
+    return true;
+  if (/^false$/i.test(trimmed))
+    return false;
+  if (/^null$/i.test(trimmed))
+    return null;
+  if (/^undefined$/i.test(trimmed))
+    return;
+  return trimmed;
+}
+function resolveRoot(root, ctx, path) {
+  const source = root === "data" ? ctx.data : root === "input" ? ctx.input : ctx.output;
+  return resolvePath(source, path);
+}
+function resolvePath(source, path) {
+  if (source == null)
+    return;
+  if (!path)
+    return source;
+  const segments = path.replace(/\[(\d+)\]/g, ".$1").split(".").filter(Boolean);
+  let current = source;
+  for (const segment of segments) {
+    if (current == null)
+      return;
+    current = current[segment];
+  }
+  return current;
+}
+function splitByOperator(expr, operator) {
+  const parts = [];
+  let buffer = "";
+  let inSingleQuote = false;
+  let inDoubleQuote = false;
+  for (let i = 0;i < expr.length; i++) {
+    const char = expr[i];
+    if (!char)
+      continue;
+    const next = expr.slice(i, i + operator.length);
+    if (char === "'" && !inDoubleQuote) {
+      inSingleQuote = !inSingleQuote;
+      buffer += char;
+      continue;
+    }
+    if (char === '"' && !inSingleQuote) {
+      inDoubleQuote = !inDoubleQuote;
+      buffer += char;
+      continue;
+    }
+    if (!inSingleQuote && !inDoubleQuote && next === operator) {
+      parts.push(buffer.trim());
+      buffer = "";
+      i += operator.length - 1;
+      continue;
+    }
+    buffer += char;
+  }
+  if (buffer.trim().length)
+    parts.push(buffer.trim());
+  return parts;
+}
+export {
+  evaluateExpression
+};

package/dist/workflow/expression.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/workflow/index.d.ts

@@ -0,0 +1,13 @@
+export * from './spec';
+export * from './validation';
+export * from './state';
+export * from './runner';
+export * from './expression';
+export * from './adapters';
+export * from './context';
+export * from './sla-monitor';
+import type { WorkflowSpec } from './spec';
+/**
+ * Helper to define a Workflow.
+ */
+export declare const defineWorkflow: (spec: WorkflowSpec) => WorkflowSpec;