@bratsos/workflow-engine 0.0.11 → 0.1.0

package/dist/testing/index.js

@@ -0,0 +1,777 @@
+import { randomUUID } from 'crypto';
+
+// src/testing/in-memory-ai-logger.ts
+var InMemoryAICallLogger = class {
+  calls = /* @__PURE__ */ new Map();
+  recordedBatches = /* @__PURE__ */ new Set();
+  // ============================================================================
+  // Core Operations
+  // ============================================================================
+  /**
+   * Log a single AI call (fire and forget)
+   */
+  logCall(call) {
+    const id = randomUUID();
+    const record = {
+      id,
+      createdAt: /* @__PURE__ */ new Date(),
+      topic: call.topic,
+      callType: call.callType,
+      modelKey: call.modelKey,
+      modelId: call.modelId,
+      prompt: call.prompt,
+      response: call.response,
+      inputTokens: call.inputTokens,
+      outputTokens: call.outputTokens,
+      cost: call.cost,
+      metadata: call.metadata ?? null
+    };
+    this.calls.set(id, record);
+  }
+  /**
+   * Log batch results (for recording batch API results)
+   */
+  async logBatchResults(batchId, results) {
+    this.recordedBatches.add(batchId);
+    for (const result of results) {
+      this.logCall({
+        ...result,
+        metadata: {
+          ...result.metadata,
+          batchId
+        }
+      });
+    }
+  }
+  /**
+   * Get aggregated stats for a topic prefix
+   */
+  async getStats(topicPrefix) {
+    const matchingCalls = Array.from(this.calls.values()).filter(
+      (call) => call.topic.startsWith(topicPrefix)
+    );
+    const stats = {
+      totalCalls: matchingCalls.length,
+      totalInputTokens: 0,
+      totalOutputTokens: 0,
+      totalCost: 0,
+      perModel: {}
+    };
+    for (const call of matchingCalls) {
+      stats.totalInputTokens += call.inputTokens;
+      stats.totalOutputTokens += call.outputTokens;
+      stats.totalCost += call.cost;
+      if (!stats.perModel[call.modelKey]) {
+        stats.perModel[call.modelKey] = {
+          calls: 0,
+          inputTokens: 0,
+          outputTokens: 0,
+          cost: 0
+        };
+      }
+      stats.perModel[call.modelKey].calls++;
+      stats.perModel[call.modelKey].inputTokens += call.inputTokens;
+      stats.perModel[call.modelKey].outputTokens += call.outputTokens;
+      stats.perModel[call.modelKey].cost += call.cost;
+    }
+    return stats;
+  }
+  /**
+   * Check if batch results are already recorded
+   */
+  async isRecorded(batchId) {
+    return this.recordedBatches.has(batchId);
+  }
+  // ============================================================================
+  // Test Helpers
+  // ============================================================================
+  /**
+   * Clear all data - useful between tests
+   */
+  clear() {
+    this.calls.clear();
+    this.recordedBatches.clear();
+  }
+  /**
+   * Get all calls for inspection
+   */
+  getAllCalls() {
+    return Array.from(this.calls.values()).map((c) => ({ ...c }));
+  }
+  /**
+   * Get calls by topic for inspection
+   */
+  getCallsByTopic(topic) {
+    return Array.from(this.calls.values()).filter((c) => c.topic === topic).map((c) => ({ ...c }));
+  }
+  /**
+   * Get calls by topic prefix for inspection
+   */
+  getCallsByTopicPrefix(prefix) {
+    return Array.from(this.calls.values()).filter((c) => c.topic.startsWith(prefix)).map((c) => ({ ...c }));
+  }
+  /**
+   * Get calls by model for inspection
+   */
+  getCallsByModel(modelKey) {
+    return Array.from(this.calls.values()).filter((c) => c.modelKey === modelKey).map((c) => ({ ...c }));
+  }
+  /**
+   * Get calls by call type for inspection
+   */
+  getCallsByType(callType) {
+    return Array.from(this.calls.values()).filter((c) => c.callType === callType).map((c) => ({ ...c }));
+  }
+  /**
+   * Get total cost across all calls
+   */
+  getTotalCost() {
+    let total = 0;
+    for (const call of this.calls.values()) {
+      total += call.cost;
+    }
+    return total;
+  }
+  /**
+   * Get total tokens across all calls
+   */
+  getTotalTokens() {
+    let input = 0;
+    let output = 0;
+    for (const call of this.calls.values()) {
+      input += call.inputTokens;
+      output += call.outputTokens;
+    }
+    return { input, output };
+  }
+  /**
+   * Get call count
+   */
+  getCallCount() {
+    return this.calls.size;
+  }
+  /**
+   * Get all recorded batch IDs
+   */
+  getRecordedBatchIds() {
+    return Array.from(this.recordedBatches);
+  }
+  /**
+   * Get the last call made (useful for assertions)
+   */
+  getLastCall() {
+    const calls = Array.from(this.calls.values());
+    if (calls.length === 0) return null;
+    calls.sort((a, b) => b.createdAt.getTime() - a.createdAt.getTime());
+    return { ...calls[0] };
+  }
+  /**
+   * Assert a call was made with specific properties
+   */
+  hasCallMatching(predicate) {
+    return Array.from(this.calls.values()).some(predicate);
+  }
+};
+var InMemoryJobQueue = class {
+  jobs = /* @__PURE__ */ new Map();
+  workerId;
+  defaultMaxAttempts = 3;
+  constructor(workerId) {
+    this.workerId = workerId ?? `worker-${randomUUID().slice(0, 8)}`;
+  }
+  // ============================================================================
+  // Core Operations
+  // ============================================================================
+  async enqueue(options) {
+    const now = /* @__PURE__ */ new Date();
+    const id = randomUUID();
+    const job = {
+      id,
+      createdAt: now,
+      updatedAt: now,
+      workflowRunId: options.workflowRunId,
+      stageId: options.stageId,
+      status: "PENDING",
+      priority: options.priority ?? 5,
+      workerId: null,
+      lockedAt: null,
+      startedAt: null,
+      completedAt: null,
+      attempt: 1,
+      maxAttempts: this.defaultMaxAttempts,
+      lastError: null,
+      nextPollAt: options.scheduledFor ?? null,
+      payload: options.payload ?? {}
+    };
+    this.jobs.set(id, job);
+    return id;
+  }
+  async enqueueParallel(jobs) {
+    const ids = [];
+    for (const job of jobs) {
+      const id = await this.enqueue(job);
+      ids.push(id);
+    }
+    return ids;
+  }
+  async dequeue() {
+    const now = /* @__PURE__ */ new Date();
+    const pendingJobs = Array.from(this.jobs.values()).filter(
+      (j) => j.status === "PENDING" && (j.nextPollAt === null || j.nextPollAt <= now)
+    ).sort((a, b) => {
+      if (b.priority !== a.priority) {
+        return b.priority - a.priority;
+      }
+      return a.createdAt.getTime() - b.createdAt.getTime();
+    });
+    if (pendingJobs.length === 0) {
+      return null;
+    }
+    const job = pendingJobs[0];
+    const updated = {
+      ...job,
+      status: "RUNNING",
+      workerId: this.workerId,
+      lockedAt: now,
+      startedAt: now,
+      updatedAt: now
+    };
+    this.jobs.set(job.id, updated);
+    return {
+      jobId: job.id,
+      workflowRunId: job.workflowRunId,
+      stageId: job.stageId,
+      priority: job.priority,
+      attempt: job.attempt,
+      payload: job.payload
+    };
+  }
+  async complete(jobId) {
+    const job = this.jobs.get(jobId);
+    if (!job) {
+      throw new Error(`Job not found: ${jobId}`);
+    }
+    const now = /* @__PURE__ */ new Date();
+    const updated = {
+      ...job,
+      status: "COMPLETED",
+      completedAt: now,
+      updatedAt: now
+    };
+    this.jobs.set(jobId, updated);
+  }
+  async suspend(jobId, nextPollAt) {
+    const job = this.jobs.get(jobId);
+    if (!job) {
+      throw new Error(`Job not found: ${jobId}`);
+    }
+    const updated = {
+      ...job,
+      status: "SUSPENDED",
+      nextPollAt,
+      workerId: null,
+      lockedAt: null,
+      updatedAt: /* @__PURE__ */ new Date()
+    };
+    this.jobs.set(jobId, updated);
+  }
+  async fail(jobId, error, shouldRetry = true) {
+    const job = this.jobs.get(jobId);
+    if (!job) {
+      throw new Error(`Job not found: ${jobId}`);
+    }
+    const now = /* @__PURE__ */ new Date();
+    if (shouldRetry && job.attempt < job.maxAttempts) {
+      const updated = {
+        ...job,
+        status: "PENDING",
+        attempt: job.attempt + 1,
+        lastError: error,
+        workerId: null,
+        lockedAt: null,
+        updatedAt: now
+      };
+      this.jobs.set(jobId, updated);
+    } else {
+      const updated = {
+        ...job,
+        status: "FAILED",
+        lastError: error,
+        completedAt: now,
+        updatedAt: now
+      };
+      this.jobs.set(jobId, updated);
+    }
+  }
+  async getSuspendedJobsReadyToPoll() {
+    const now = /* @__PURE__ */ new Date();
+    return Array.from(this.jobs.values()).filter(
+      (j) => j.status === "SUSPENDED" && j.nextPollAt && j.nextPollAt <= now
+    ).map((j) => ({
+      jobId: j.id,
+      stageId: j.stageId,
+      workflowRunId: j.workflowRunId
+    }));
+  }
+  async releaseStaleJobs(staleThresholdMs = 6e4) {
+    const now = /* @__PURE__ */ new Date();
+    const threshold = new Date(now.getTime() - staleThresholdMs);
+    let released = 0;
+    for (const job of this.jobs.values()) {
+      if (job.status === "RUNNING" && job.lockedAt && job.lockedAt < threshold) {
+        const updated = {
+          ...job,
+          status: "PENDING",
+          workerId: null,
+          lockedAt: null,
+          updatedAt: now
+        };
+        this.jobs.set(job.id, updated);
+        released++;
+      }
+    }
+    return released;
+  }
+  // ============================================================================
+  // Test Helpers
+  // ============================================================================
+  /**
+   * Clear all jobs - useful between tests
+   */
+  clear() {
+    this.jobs.clear();
+  }
+  /**
+   * Get all jobs for inspection
+   */
+  getAllJobs() {
+    return Array.from(this.jobs.values()).map((j) => ({ ...j }));
+  }
+  /**
+   * Get jobs by status for inspection
+   */
+  getJobsByStatus(status) {
+    return Array.from(this.jobs.values()).filter((j) => j.status === status).map((j) => ({ ...j }));
+  }
+  /**
+   * Get a specific job by ID
+   */
+  getJob(jobId) {
+    const job = this.jobs.get(jobId);
+    return job ? { ...job } : null;
+  }
+  /**
+   * Get the worker ID for this queue instance
+   */
+  getWorkerId() {
+    return this.workerId;
+  }
+  /**
+   * Set max attempts for new jobs
+   */
+  setDefaultMaxAttempts(maxAttempts) {
+    this.defaultMaxAttempts = maxAttempts;
+  }
+  /**
+   * Simulate a worker crash by releasing a job's lock without completing it
+   */
+  simulateCrash(jobId) {
+    const job = this.jobs.get(jobId);
+    if (job && job.status === "RUNNING") ;
+  }
+  /**
+   * Move a suspended job back to pending (for manual resume testing)
+   */
+  resumeJob(jobId) {
+    const job = this.jobs.get(jobId);
+    if (job && job.status === "SUSPENDED") {
+      const updated = {
+        ...job,
+        status: "PENDING",
+        nextPollAt: null,
+        updatedAt: /* @__PURE__ */ new Date()
+      };
+      this.jobs.set(jobId, updated);
+    }
+  }
+  /**
+   * Set lockedAt for testing stale job scenarios
+   */
+  setJobLockedAt(jobId, lockedAt) {
+    const job = this.jobs.get(jobId);
+    if (job) {
+      const updated = {
+        ...job,
+        lockedAt
+      };
+      this.jobs.set(jobId, updated);
+    }
+  }
+  /**
+   * Set nextPollAt for testing suspended job polling
+   */
+  setJobNextPollAt(jobId, nextPollAt) {
+    const job = this.jobs.get(jobId);
+    if (job) {
+      const updated = {
+        ...job,
+        nextPollAt
+      };
+      this.jobs.set(jobId, updated);
+    }
+  }
+};
+var InMemoryWorkflowPersistence = class {
+  runs = /* @__PURE__ */ new Map();
+  stages = /* @__PURE__ */ new Map();
+  logs = /* @__PURE__ */ new Map();
+  artifacts = /* @__PURE__ */ new Map();
+  // Helper to generate composite keys for stages
+  stageKey(runId, stageId) {
+    return `${runId}:${stageId}`;
+  }
+  // Helper to generate composite keys for artifacts
+  artifactKey(runId, key) {
+    return `${runId}:${key}`;
+  }
+  // ============================================================================
+  // WorkflowRun Operations
+  // ============================================================================
+  async createRun(data) {
+    const now = /* @__PURE__ */ new Date();
+    const record = {
+      id: data.id ?? randomUUID(),
+      createdAt: now,
+      updatedAt: now,
+      workflowId: data.workflowId,
+      workflowName: data.workflowName,
+      workflowType: data.workflowType,
+      status: "PENDING",
+      startedAt: null,
+      completedAt: null,
+      duration: null,
+      input: data.input,
+      output: null,
+      config: data.config ?? {},
+      totalCost: 0,
+      totalTokens: 0,
+      priority: data.priority ?? 5
+    };
+    this.runs.set(record.id, record);
+    return { ...record };
+  }
+  async updateRun(id, data) {
+    const run = this.runs.get(id);
+    if (!run) {
+      throw new Error(`WorkflowRun not found: ${id}`);
+    }
+    const updated = {
+      ...run,
+      ...data,
+      updatedAt: /* @__PURE__ */ new Date()
+    };
+    this.runs.set(id, updated);
+  }
+  async getRun(id) {
+    const run = this.runs.get(id);
+    return run ? { ...run } : null;
+  }
+  async getRunStatus(id) {
+    const run = this.runs.get(id);
+    return run?.status ?? null;
+  }
+  async getRunsByStatus(status) {
+    return Array.from(this.runs.values()).filter((run) => run.status === status).map((run) => ({ ...run }));
+  }
+  async claimPendingRun(id) {
+    const run = this.runs.get(id);
+    if (!run || run.status !== "PENDING") {
+      return false;
+    }
+    const updated = {
+      ...run,
+      status: "RUNNING",
+      startedAt: /* @__PURE__ */ new Date(),
+      updatedAt: /* @__PURE__ */ new Date()
+    };
+    this.runs.set(id, updated);
+    return true;
+  }
+  async claimNextPendingRun() {
+    const pendingRuns = Array.from(this.runs.values()).filter((run) => run.status === "PENDING").sort((a, b) => {
+      if (a.priority !== b.priority) {
+        return b.priority - a.priority;
+      }
+      return a.createdAt.getTime() - b.createdAt.getTime();
+    });
+    if (pendingRuns.length === 0) {
+      return null;
+    }
+    const runToClaim = pendingRuns[0];
+    const currentRun = this.runs.get(runToClaim.id);
+    if (!currentRun || currentRun.status !== "PENDING") {
+      return this.claimNextPendingRun();
+    }
+    const claimed = {
+      ...currentRun,
+      status: "RUNNING",
+      startedAt: /* @__PURE__ */ new Date(),
+      updatedAt: /* @__PURE__ */ new Date()
+    };
+    this.runs.set(claimed.id, claimed);
+    return { ...claimed };
+  }
+  // ============================================================================
+  // WorkflowStage Operations
+  // ============================================================================
+  async createStage(data) {
+    const now = /* @__PURE__ */ new Date();
+    const id = randomUUID();
+    const record = {
+      id,
+      createdAt: now,
+      updatedAt: now,
+      workflowRunId: data.workflowRunId,
+      stageId: data.stageId,
+      stageName: data.stageName,
+      stageNumber: data.stageNumber,
+      executionGroup: data.executionGroup,
+      status: data.status ?? "PENDING",
+      startedAt: data.startedAt ?? null,
+      completedAt: null,
+      duration: null,
+      inputData: data.inputData ?? null,
+      outputData: null,
+      config: data.config ?? null,
+      suspendedState: null,
+      resumeData: null,
+      nextPollAt: null,
+      pollInterval: null,
+      maxWaitUntil: null,
+      metrics: null,
+      embeddingInfo: null,
+      errorMessage: null
+    };
+    this.stages.set(id, record);
+    this.stages.set(this.stageKey(data.workflowRunId, data.stageId), record);
+    return { ...record };
+  }
+  async upsertStage(data) {
+    const key = this.stageKey(data.workflowRunId, data.stageId);
+    const existing = this.stages.get(key);
+    if (existing) {
+      const updated = {
+        ...existing,
+        ...data.update,
+        updatedAt: /* @__PURE__ */ new Date()
+      };
+      this.stages.set(existing.id, updated);
+      this.stages.set(key, updated);
+      return { ...updated };
+    } else {
+      return this.createStage(data.create);
+    }
+  }
+  async updateStage(id, data) {
+    const stage = this.stages.get(id);
+    if (!stage) {
+      throw new Error(`WorkflowStage not found: ${id}`);
+    }
+    const updated = {
+      ...stage,
+      ...data,
+      updatedAt: /* @__PURE__ */ new Date()
+    };
+    this.stages.set(id, updated);
+    this.stages.set(this.stageKey(stage.workflowRunId, stage.stageId), updated);
+  }
+  async updateStageByRunAndStageId(workflowRunId, stageId, data) {
+    const key = this.stageKey(workflowRunId, stageId);
+    const stage = this.stages.get(key);
+    if (!stage) {
+      throw new Error(`WorkflowStage not found: ${workflowRunId}/${stageId}`);
+    }
+    const updated = {
+      ...stage,
+      ...data,
+      updatedAt: /* @__PURE__ */ new Date()
+    };
+    this.stages.set(stage.id, updated);
+    this.stages.set(key, updated);
+  }
+  async getStage(runId, stageId) {
+    const key = this.stageKey(runId, stageId);
+    const stage = this.stages.get(key);
+    return stage ? { ...stage } : null;
+  }
+  async getStageById(id) {
+    const stage = this.stages.get(id);
+    return stage ? { ...stage } : null;
+  }
+  async getStagesByRun(runId, options) {
+    const seenIds = /* @__PURE__ */ new Set();
+    let stages = Array.from(this.stages.values()).filter((s) => {
+      if (s.workflowRunId !== runId) return false;
+      if (seenIds.has(s.id)) return false;
+      seenIds.add(s.id);
+      return true;
+    });
+    if (options?.status) {
+      stages = stages.filter((s) => s.status === options.status);
+    }
+    stages.sort((a, b) => {
+      const diff = a.stageNumber - b.stageNumber;
+      return options?.orderBy === "desc" ? -diff : diff;
+    });
+    return stages.map((s) => ({ ...s }));
+  }
+  async getSuspendedStages(beforeDate) {
+    return Array.from(this.stages.values()).filter(
+      (s) => s.status === "SUSPENDED" && s.nextPollAt && s.nextPollAt <= beforeDate && this.stages.get(s.id) === s
+    ).map((s) => ({ ...s }));
+  }
+  async getFirstSuspendedStageReadyToResume(runId) {
+    const stages = await this.getStagesByRun(runId, { status: "SUSPENDED" });
+    const now = /* @__PURE__ */ new Date();
+    const ready = stages.find((s) => s.nextPollAt && s.nextPollAt <= now);
+    return ready ?? null;
+  }
+  async getFirstFailedStage(runId) {
+    const stages = await this.getStagesByRun(runId, { status: "FAILED" });
+    return stages[0] ?? null;
+  }
+  async getLastCompletedStage(runId) {
+    const stages = await this.getStagesByRun(runId, {
+      status: "COMPLETED",
+      orderBy: "desc"
+    });
+    return stages[0] ?? null;
+  }
+  async getLastCompletedStageBefore(runId, executionGroup) {
+    const stages = await this.getStagesByRun(runId, {
+      status: "COMPLETED",
+      orderBy: "desc"
+    });
+    const before = stages.filter((s) => s.executionGroup < executionGroup);
+    return before[0] ?? null;
+  }
+  async deleteStage(id) {
+    const stage = this.stages.get(id);
+    if (stage) {
+      this.stages.delete(id);
+      this.stages.delete(this.stageKey(stage.workflowRunId, stage.stageId));
+    }
+  }
+  // ============================================================================
+  // WorkflowLog Operations
+  // ============================================================================
+  async createLog(data) {
+    const record = {
+      id: randomUUID(),
+      createdAt: /* @__PURE__ */ new Date(),
+      workflowRunId: data.workflowRunId ?? null,
+      workflowStageId: data.workflowStageId ?? null,
+      level: data.level,
+      message: data.message,
+      metadata: data.metadata ?? null
+    };
+    this.logs.set(record.id, record);
+  }
+  // ============================================================================
+  // WorkflowArtifact Operations
+  // ============================================================================
+  async saveArtifact(data) {
+    const now = /* @__PURE__ */ new Date();
+    const key = this.artifactKey(data.workflowRunId, data.key);
+    const existing = this.artifacts.get(key);
+    const record = {
+      id: existing?.id ?? randomUUID(),
+      createdAt: existing?.createdAt ?? now,
+      updatedAt: now,
+      workflowRunId: data.workflowRunId,
+      workflowStageId: data.workflowStageId ?? null,
+      key: data.key,
+      type: data.type,
+      data: data.data,
+      size: data.size,
+      metadata: data.metadata ?? null
+    };
+    this.artifacts.set(key, record);
+  }
+  async loadArtifact(runId, key) {
+    const artifact = this.artifacts.get(this.artifactKey(runId, key));
+    if (!artifact) {
+      throw new Error(`Artifact not found: ${runId}/${key}`);
+    }
+    return artifact.data;
+  }
+  async hasArtifact(runId, key) {
+    return this.artifacts.has(this.artifactKey(runId, key));
+  }
+  async deleteArtifact(runId, key) {
+    this.artifacts.delete(this.artifactKey(runId, key));
+  }
+  async listArtifacts(runId) {
+    return Array.from(this.artifacts.values()).filter((a) => a.workflowRunId === runId).map((a) => ({ ...a }));
+  }
+  async getStageIdForArtifact(runId, stageId) {
+    const stage = await this.getStage(runId, stageId);
+    return stage?.id ?? null;
+  }
+  // ============================================================================
+  // Stage Output Convenience Method
+  // ============================================================================
+  async saveStageOutput(runId, workflowType, stageId, output) {
+    const key = `workflow-v2/${workflowType}/${runId}/${stageId}/output.json`;
+    const stageDbId = await this.getStageIdForArtifact(runId, stageId);
+    await this.saveArtifact({
+      workflowRunId: runId,
+      workflowStageId: stageDbId ?? void 0,
+      key,
+      type: "STAGE_OUTPUT",
+      data: output,
+      size: JSON.stringify(output).length
+    });
+    return key;
+  }
+  // ============================================================================
+  // Test Helpers
+  // ============================================================================
+  /**
+   * Clear all data - useful between tests
+   */
+  clear() {
+    this.runs.clear();
+    this.stages.clear();
+    this.logs.clear();
+    this.artifacts.clear();
+  }
+  /**
+   * Get all runs for inspection
+   */
+  getAllRuns() {
+    return Array.from(this.runs.values()).map((r) => ({ ...r }));
+  }
+  /**
+   * Get all stages for inspection
+   */
+  getAllStages() {
+    return Array.from(this.stages.values()).filter((s) => this.stages.get(s.id) === s).map((s) => ({ ...s }));
+  }
+  /**
+   * Get all logs for inspection
+   */
+  getAllLogs() {
+    return Array.from(this.logs.values()).map((l) => ({ ...l }));
+  }
+  /**
+   * Get all artifacts for inspection
+   */
+  getAllArtifacts() {
+    return Array.from(this.artifacts.values()).map((a) => ({ ...a }));
+  }
+};
+
+export { InMemoryAICallLogger, InMemoryJobQueue, InMemoryWorkflowPersistence };
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map