@bratsos/workflow-engine 0.0.11 → 0.2.0

package/dist/chunk-NYKMT46J.js

@@ -0,0 +1,1143 @@
+import { createLogger } from './chunk-MUWP5SF2.js';
+import { StaleVersionError } from './chunk-SPXBCZLB.js';
+
+// src/persistence/prisma/ai-logger.ts
+var logger = createLogger("AICallLogger");
+var PrismaAICallLogger = class {
+  constructor(prisma) {
+    this.prisma = prisma;
+  }
+  /**
+   * Log a single AI call (fire and forget)
+   * Does not await - logs asynchronously to avoid blocking AI operations
+   */
+  logCall(call) {
+    this.prisma.aICall.create({
+      data: {
+        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
+      }
+    }).catch(
+      (error) => logger.error("Failed to persist AI call:", error)
+    );
+  }
+  /**
+   * Log batch results (for recording batch API results)
+   */
+  async logBatchResults(batchId, results) {
+    await this.prisma.aICall.createMany({
+      data: results.map((call) => ({
+        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,
+          batchId
+        }
+      }))
+    });
+  }
+  /**
+   * Get aggregated stats for a topic prefix
+   */
+  async getStats(topicPrefix) {
+    const calls = await this.prisma.aICall.findMany({
+      where: {
+        topic: { startsWith: topicPrefix }
+      },
+      select: {
+        modelKey: true,
+        inputTokens: true,
+        outputTokens: true,
+        cost: true
+      }
+    });
+    const perModel = {};
+    for (const call of calls) {
+      if (!perModel[call.modelKey]) {
+        perModel[call.modelKey] = {
+          calls: 0,
+          inputTokens: 0,
+          outputTokens: 0,
+          cost: 0
+        };
+      }
+      perModel[call.modelKey].calls++;
+      perModel[call.modelKey].inputTokens += call.inputTokens;
+      perModel[call.modelKey].outputTokens += call.outputTokens;
+      perModel[call.modelKey].cost += call.cost;
+    }
+    return {
+      totalCalls: calls.length,
+      totalInputTokens: calls.reduce(
+        (sum, c) => sum + c.inputTokens,
+        0
+      ),
+      totalOutputTokens: calls.reduce(
+        (sum, c) => sum + c.outputTokens,
+        0
+      ),
+      totalCost: calls.reduce(
+        (sum, c) => sum + c.cost,
+        0
+      ),
+      perModel
+    };
+  }
+  /**
+   * Check if batch results are already recorded
+   */
+  async isRecorded(batchId) {
+    const existing = await this.prisma.aICall.findFirst({
+      where: {
+        metadata: {
+          path: ["batchId"],
+          equals: batchId
+        }
+      },
+      select: { id: true }
+    });
+    return existing !== null;
+  }
+};
+function createPrismaAICallLogger(prisma) {
+  return new PrismaAICallLogger(prisma);
+}
+
+// src/persistence/prisma/enum-compat.ts
+function createEnumHelper(prisma) {
+  const resolveEnum = (enumName, value) => {
+    try {
+      const enumObj = prisma.$Enums?.[enumName];
+      if (enumObj && value in enumObj) {
+        return enumObj[value];
+      }
+    } catch {
+    }
+    return value;
+  };
+  return {
+    status: (value) => resolveEnum("Status", value),
+    artifactType: (value) => resolveEnum("ArtifactType", value),
+    logLevel: (value) => resolveEnum("LogLevel", value)
+  };
+}
+
+// src/persistence/prisma/job-queue.ts
+var logger2 = createLogger("JobQueue");
+var PrismaJobQueue = class {
+  workerId;
+  prisma;
+  enums;
+  databaseType;
+  constructor(prisma, options = {}) {
+    this.prisma = prisma;
+    this.workerId = options.workerId || `worker-${process.pid}-${Date.now()}`;
+    this.enums = createEnumHelper(prisma);
+    this.databaseType = options.databaseType ?? "postgresql";
+  }
+  /**
+   * Add a new job to the queue
+   */
+  async enqueue(options) {
+    const job = await this.prisma.jobQueue.create({
+      data: {
+        workflowRunId: options.workflowRunId,
+        stageId: options.stageId,
+        priority: options.priority ?? 5,
+        payload: {
+          ...options.payload,
+          _workflowId: options.workflowId
+        },
+        status: this.enums.status("PENDING"),
+        nextPollAt: options.scheduledFor
+      }
+    });
+    logger2.debug(
+      `Enqueued job ${job.id} for stage ${options.stageId} (run: ${options.workflowRunId})`
+    );
+    return job.id;
+  }
+  /**
+   * Enqueue multiple stages in parallel (same execution group)
+   */
+  async enqueueParallel(jobs) {
+    if (jobs.length === 0) return [];
+    const results = await this.prisma.$transaction(
+      jobs.map(
+        (job) => this.prisma.jobQueue.create({
+          data: {
+            workflowRunId: job.workflowRunId,
+            stageId: job.stageId,
+            priority: job.priority ?? 5,
+            payload: { ...job.payload, _workflowId: job.workflowId },
+            status: this.enums.status("PENDING")
+          }
+        })
+      )
+    );
+    return results.map((r) => r.id);
+  }
+  /**
+   * Atomically dequeue the next available job
+   * Uses FOR UPDATE SKIP LOCKED (PostgreSQL) or optimistic locking (SQLite)
+   */
+  async dequeue() {
+    if (this.databaseType === "sqlite") {
+      return this.dequeueSqlite();
+    }
+    return this.dequeuePostgres();
+  }
+  /**
+   * PostgreSQL implementation using FOR UPDATE SKIP LOCKED for safe concurrency
+   */
+  async dequeuePostgres() {
+    try {
+      const result = await this.prisma.$queryRaw`
+        UPDATE "job_queue"
+        SET
+          status = 'RUNNING',
+          "workerId" = ${this.workerId},
+          "lockedAt" = NOW(),
+          "startedAt" = NOW(),
+          attempt = attempt + 1
+        WHERE id = (
+          SELECT id FROM "job_queue"
+          WHERE status = 'PENDING'
+            AND ("nextPollAt" IS NULL OR "nextPollAt" <= NOW())
+          ORDER BY priority DESC, "createdAt" ASC
+          LIMIT 1
+          FOR UPDATE SKIP LOCKED
+        )
+        RETURNING id, "workflowRunId", "stageId", priority, attempt, "maxAttempts", payload
+      `;
+      if (result.length === 0) {
+        return null;
+      }
+      const job = result[0];
+      logger2.debug(
+        `Dequeued job ${job.id} (stage: ${job.stageId}, attempt: ${job.attempt})`
+      );
+      const payload = job.payload;
+      const { _workflowId, ...rest } = payload;
+      return {
+        jobId: job.id,
+        workflowRunId: job.workflowRunId,
+        workflowId: _workflowId ?? "",
+        stageId: job.stageId,
+        priority: job.priority,
+        attempt: job.attempt,
+        maxAttempts: job.maxAttempts,
+        payload: rest
+      };
+    } catch (error) {
+      logger2.error("Error dequeuing job:", error);
+      return null;
+    }
+  }
+  /**
+   * SQLite implementation using optimistic locking.
+   * SQLite doesn't support FOR UPDATE SKIP LOCKED, so we use a two-step approach:
+   * 1. Find a PENDING job
+   * 2. Atomically update it (only succeeds if still PENDING)
+   * 3. If another worker claimed it, retry
+   */
+  async dequeueSqlite() {
+    try {
+      const now = /* @__PURE__ */ new Date();
+      const job = await this.prisma.jobQueue.findFirst({
+        where: {
+          status: this.enums.status("PENDING"),
+          OR: [{ nextPollAt: null }, { nextPollAt: { lte: now } }]
+        },
+        orderBy: [{ priority: "desc" }, { createdAt: "asc" }]
+      });
+      if (!job) {
+        return null;
+      }
+      const result = await this.prisma.jobQueue.updateMany({
+        where: {
+          id: job.id,
+          status: this.enums.status("PENDING")
+          // Optimistic lock
+        },
+        data: {
+          status: this.enums.status("RUNNING"),
+          workerId: this.workerId,
+          lockedAt: now,
+          startedAt: now,
+          attempt: { increment: 1 }
+        }
+      });
+      if (result.count === 0) {
+        return this.dequeueSqlite();
+      }
+      const claimedJob = await this.prisma.jobQueue.findUnique({
+        where: { id: job.id }
+      });
+      if (!claimedJob) {
+        return null;
+      }
+      logger2.debug(
+        `Dequeued job ${claimedJob.id} (stage: ${claimedJob.stageId}, attempt: ${claimedJob.attempt})`
+      );
+      const claimedPayload = claimedJob.payload;
+      const { _workflowId: claimedWfId, ...claimedRest } = claimedPayload;
+      return {
+        jobId: claimedJob.id,
+        workflowRunId: claimedJob.workflowRunId,
+        workflowId: claimedWfId ?? "",
+        stageId: claimedJob.stageId,
+        priority: claimedJob.priority,
+        attempt: claimedJob.attempt,
+        maxAttempts: claimedJob.maxAttempts,
+        payload: claimedRest
+      };
+    } catch (error) {
+      logger2.error("Error dequeuing job:", error);
+      return null;
+    }
+  }
+  /**
+   * Mark job as completed
+   */
+  async complete(jobId) {
+    await this.prisma.jobQueue.update({
+      where: { id: jobId },
+      data: {
+        status: this.enums.status("COMPLETED"),
+        completedAt: /* @__PURE__ */ new Date()
+      }
+    });
+    logger2.debug(`Job ${jobId} completed`);
+  }
+  /**
+   * Mark job as suspended (for async-batch)
+   */
+  async suspend(jobId, nextPollAt) {
+    await this.prisma.jobQueue.update({
+      where: { id: jobId },
+      data: {
+        status: this.enums.status("SUSPENDED"),
+        nextPollAt,
+        workerId: null,
+        lockedAt: null
+      }
+    });
+    logger2.debug(`Job ${jobId} suspended until ${nextPollAt.toISOString()}`);
+  }
+  /**
+   * Mark job as failed
+   */
+  async fail(jobId, error, shouldRetry = false) {
+    const job = await this.prisma.jobQueue.findUnique({
+      where: { id: jobId },
+      select: { attempt: true, maxAttempts: true }
+    });
+    if (shouldRetry && job && job.attempt < job.maxAttempts) {
+      const backoffMs = 2 ** job.attempt * 1e3;
+      const nextPollAt = new Date(Date.now() + backoffMs);
+      await this.prisma.jobQueue.update({
+        where: { id: jobId },
+        data: {
+          status: this.enums.status("PENDING"),
+          lastError: error,
+          workerId: null,
+          lockedAt: null,
+          nextPollAt
+        }
+      });
+      logger2.debug(`Job ${jobId} failed, will retry in ${backoffMs}ms`);
+    } else {
+      await this.prisma.jobQueue.update({
+        where: { id: jobId },
+        data: {
+          status: this.enums.status("FAILED"),
+          completedAt: /* @__PURE__ */ new Date(),
+          lastError: error
+        }
+      });
+      logger2.debug(`Job ${jobId} failed permanently: ${error}`);
+    }
+  }
+  /**
+   * Get suspended jobs that are ready to be checked
+   */
+  async getSuspendedJobsReadyToPoll() {
+    const jobs = await this.prisma.jobQueue.findMany({
+      where: {
+        status: this.enums.status("SUSPENDED"),
+        nextPollAt: { lte: /* @__PURE__ */ new Date() }
+      },
+      select: {
+        id: true,
+        workflowRunId: true,
+        stageId: true
+      }
+    });
+    return jobs.map(
+      (j) => ({
+        jobId: j.id,
+        workflowRunId: j.workflowRunId,
+        stageId: j.stageId
+      })
+    );
+  }
+  /**
+   * Release stale locks (for crashed workers)
+   */
+  async releaseStaleJobs(staleThresholdMs = 3e5) {
+    const thresholdDate = new Date(Date.now() - staleThresholdMs);
+    const result = await this.prisma.jobQueue.updateMany({
+      where: {
+        status: this.enums.status("RUNNING"),
+        lockedAt: { lt: thresholdDate }
+      },
+      data: {
+        status: this.enums.status("PENDING"),
+        workerId: null,
+        lockedAt: null
+      }
+    });
+    if (result.count > 0) {
+      logger2.debug(
+        `Released ${result.count} stale jobs (locked before ${thresholdDate.toISOString()})`
+      );
+    }
+    return result.count;
+  }
+};
+function createPrismaJobQueue(prisma, optionsOrWorkerId) {
+  const options = typeof optionsOrWorkerId === "string" ? { workerId: optionsOrWorkerId } : optionsOrWorkerId ?? {};
+  return new PrismaJobQueue(prisma, options);
+}
+
+// src/persistence/prisma/persistence.ts
+var IDEMPOTENCY_IN_PROGRESS_MARKER = {
+  __workflowEngineState: "in_progress"
+};
+function isInProgressResult(result) {
+  if (!result || typeof result !== "object") return false;
+  return result.__workflowEngineState === "in_progress";
+}
+var PrismaWorkflowPersistence = class _PrismaWorkflowPersistence {
+  constructor(prisma, options = {}) {
+    this.prisma = prisma;
+    this.enums = createEnumHelper(prisma);
+    this.databaseType = options.databaseType ?? "postgresql";
+  }
+  enums;
+  databaseType;
+  async withTransaction(fn) {
+    if (typeof this.prisma.$transaction !== "function") {
+      return fn(this);
+    }
+    return this.prisma.$transaction(async (tx) => {
+      const txPersistence = new _PrismaWorkflowPersistence(tx, {
+        databaseType: this.databaseType
+      });
+      return fn(txPersistence);
+    });
+  }
+  // ============================================================================
+  // WorkflowRun Operations
+  // ============================================================================
+  async createRun(data) {
+    const run = await this.prisma.workflowRun.create({
+      data: {
+        id: data.id,
+        workflowId: data.workflowId,
+        workflowName: data.workflowName,
+        workflowType: data.workflowType,
+        input: data.input,
+        config: data.config ?? {},
+        priority: data.priority ?? 5,
+        // Spread metadata for domain-specific fields (certificateId, etc.)
+        ...data.metadata ?? {}
+      }
+    });
+    return this.mapWorkflowRun(run);
+  }
+  async updateRun(id, data) {
+    const updateData = this.buildRunUpdateData(data);
+    if (data.expectedVersion === void 0) {
+      await this.prisma.workflowRun.update({
+        where: { id },
+        data: updateData
+      });
+      return;
+    }
+    const result = await this.prisma.workflowRun.updateMany({
+      where: { id, version: data.expectedVersion },
+      data: {
+        ...updateData,
+        version: { increment: 1 }
+      }
+    });
+    if (result.count === 0) {
+      const current = await this.prisma.workflowRun.findUnique({
+        where: { id },
+        select: { version: true }
+      });
+      throw new StaleVersionError(
+        "WorkflowRun",
+        id,
+        data.expectedVersion,
+        current?.version ?? -1
+      );
+    }
+  }
+  async getRun(id) {
+    const run = await this.prisma.workflowRun.findUnique({ where: { id } });
+    return run ? this.mapWorkflowRun(run) : null;
+  }
+  async getRunStatus(id) {
+    const run = await this.prisma.workflowRun.findUnique({
+      where: { id },
+      select: { status: true }
+    });
+    return run?.status ?? null;
+  }
+  async getRunsByStatus(status) {
+    const runs = await this.prisma.workflowRun.findMany({
+      where: { status: this.enums.status(status) },
+      orderBy: { createdAt: "asc" }
+    });
+    return runs.map((run) => this.mapWorkflowRun(run));
+  }
+  async claimPendingRun(id) {
+    const result = await this.prisma.workflowRun.updateMany({
+      where: {
+        id,
+        status: this.enums.status("PENDING")
+      },
+      data: {
+        status: this.enums.status("RUNNING"),
+        startedAt: /* @__PURE__ */ new Date()
+      }
+    });
+    return result.count > 0;
+  }
+  async claimNextPendingRun() {
+    if (this.databaseType === "sqlite") {
+      return this.claimNextPendingRunSqlite();
+    }
+    return this.claimNextPendingRunPostgres();
+  }
+  /**
+   * PostgreSQL implementation using FOR UPDATE SKIP LOCKED for zero-contention claiming.
+   * This atomically:
+   * 1. Finds the highest priority PENDING run (FIFO within same priority)
+   * 2. Locks it exclusively (other workers skip locked rows)
+   * 3. Updates it to RUNNING
+   * 4. Returns the claimed run
+   */
+  async claimNextPendingRunPostgres() {
+    const results = await this.prisma.$queryRaw`
+      WITH claimed AS (
+        SELECT id
+        FROM "workflow_runs"
+        WHERE status = ${this.enums.status("PENDING")}
+        ORDER BY priority DESC, "createdAt" ASC
+        LIMIT 1
+        FOR UPDATE SKIP LOCKED
+      )
+      UPDATE "workflow_runs"
+      SET status = ${this.enums.status("RUNNING")},
+          "startedAt" = NOW(),
+          "updatedAt" = NOW()
+      FROM claimed
+      WHERE "workflow_runs".id = claimed.id
+      RETURNING "workflow_runs".*
+    `;
+    if (results.length === 0) {
+      return null;
+    }
+    return this.mapWorkflowRun(results[0]);
+  }
+  /**
+   * SQLite implementation using optimistic locking.
+   * SQLite doesn't support FOR UPDATE SKIP LOCKED, so we use a two-step approach:
+   * 1. Find a PENDING run
+   * 2. Atomically update it (only succeeds if still PENDING)
+   * 3. If another worker claimed it, retry
+   */
+  async claimNextPendingRunSqlite() {
+    const run = await this.prisma.workflowRun.findFirst({
+      where: { status: this.enums.status("PENDING") },
+      orderBy: [{ priority: "desc" }, { createdAt: "asc" }]
+    });
+    if (!run) {
+      return null;
+    }
+    const result = await this.prisma.workflowRun.updateMany({
+      where: {
+        id: run.id,
+        status: this.enums.status("PENDING")
+        // Optimistic lock
+      },
+      data: {
+        status: this.enums.status("RUNNING"),
+        startedAt: /* @__PURE__ */ new Date(),
+        updatedAt: /* @__PURE__ */ new Date()
+      }
+    });
+    if (result.count === 0) {
+      return this.claimNextPendingRunSqlite();
+    }
+    const claimedRun = await this.prisma.workflowRun.findUnique({
+      where: { id: run.id }
+    });
+    return claimedRun ? this.mapWorkflowRun(claimedRun) : null;
+  }
+  // ============================================================================
+  // WorkflowStage Operations
+  // ============================================================================
+  async createStage(data) {
+    const stage = await this.prisma.workflowStage.create({
+      data: {
+        workflowRunId: data.workflowRunId,
+        stageId: data.stageId,
+        stageName: data.stageName,
+        stageNumber: data.stageNumber,
+        executionGroup: data.executionGroup,
+        status: data.status ? this.enums.status(data.status) : this.enums.status("PENDING"),
+        startedAt: data.startedAt,
+        config: data.config,
+        inputData: data.inputData
+      }
+    });
+    return this.mapWorkflowStage(stage);
+  }
+  async upsertStage(data) {
+    const stage = await this.prisma.workflowStage.upsert({
+      where: {
+        workflowRunId_stageId: {
+          workflowRunId: data.workflowRunId,
+          stageId: data.stageId
+        }
+      },
+      create: {
+        workflowRunId: data.create.workflowRunId,
+        stageId: data.create.stageId,
+        stageName: data.create.stageName,
+        stageNumber: data.create.stageNumber,
+        executionGroup: data.create.executionGroup,
+        status: data.create.status ? this.enums.status(data.create.status) : this.enums.status("RUNNING"),
+        startedAt: data.create.startedAt ?? /* @__PURE__ */ new Date(),
+        config: data.create.config,
+        inputData: data.create.inputData
+      },
+      update: {
+        status: data.update.status ? this.enums.status(data.update.status) : void 0,
+        startedAt: data.update.startedAt
+      }
+    });
+    return this.mapWorkflowStage(stage);
+  }
+  async updateStage(id, data) {
+    const updateData = this.buildStageUpdateData(data);
+    if (data.expectedVersion === void 0) {
+      await this.prisma.workflowStage.update({
+        where: { id },
+        data: updateData
+      });
+      return;
+    }
+    const result = await this.prisma.workflowStage.updateMany({
+      where: { id, version: data.expectedVersion },
+      data: {
+        ...updateData,
+        version: { increment: 1 }
+      }
+    });
+    if (result.count === 0) {
+      const current = await this.prisma.workflowStage.findUnique({
+        where: { id },
+        select: { version: true }
+      });
+      throw new StaleVersionError(
+        "WorkflowStage",
+        id,
+        data.expectedVersion,
+        current?.version ?? -1
+      );
+    }
+  }
+  async updateStageByRunAndStageId(workflowRunId, stageId, data) {
+    const updateData = this.buildStageUpdateData(data);
+    if (data.expectedVersion === void 0) {
+      await this.prisma.workflowStage.update({
+        where: {
+          workflowRunId_stageId: { workflowRunId, stageId }
+        },
+        data: updateData
+      });
+      return;
+    }
+    const result = await this.prisma.workflowStage.updateMany({
+      where: {
+        workflowRunId,
+        stageId,
+        version: data.expectedVersion
+      },
+      data: {
+        ...updateData,
+        version: { increment: 1 }
+      }
+    });
+    if (result.count === 0) {
+      const current = await this.prisma.workflowStage.findFirst({
+        where: { workflowRunId, stageId },
+        select: { id: true, version: true }
+      });
+      throw new StaleVersionError(
+        "WorkflowStage",
+        current?.id ?? `${workflowRunId}/${stageId}`,
+        data.expectedVersion,
+        current?.version ?? -1
+      );
+    }
+  }
+  buildRunUpdateData(data) {
+    return {
+      status: data.status ? this.enums.status(data.status) : void 0,
+      startedAt: data.startedAt,
+      completedAt: data.completedAt,
+      duration: data.duration,
+      output: data.output,
+      totalCost: data.totalCost,
+      totalTokens: data.totalTokens
+    };
+  }
+  buildStageUpdateData(data) {
+    return {
+      status: data.status ? this.enums.status(data.status) : void 0,
+      startedAt: data.startedAt,
+      completedAt: data.completedAt,
+      duration: data.duration,
+      outputData: data.outputData,
+      config: data.config,
+      suspendedState: data.suspendedState,
+      resumeData: data.resumeData,
+      nextPollAt: data.nextPollAt,
+      pollInterval: data.pollInterval,
+      maxWaitUntil: data.maxWaitUntil,
+      metrics: data.metrics,
+      embeddingInfo: data.embeddingInfo,
+      errorMessage: data.errorMessage
+    };
+  }
+  async getStage(runId, stageId) {
+    const stage = await this.prisma.workflowStage.findUnique({
+      where: {
+        workflowRunId_stageId: { workflowRunId: runId, stageId }
+      }
+    });
+    return stage ? this.mapWorkflowStage(stage) : null;
+  }
+  async getStageById(id) {
+    const stage = await this.prisma.workflowStage.findUnique({ where: { id } });
+    return stage ? this.mapWorkflowStage(stage) : null;
+  }
+  async getStagesByRun(runId, options) {
+    const stages = await this.prisma.workflowStage.findMany({
+      where: {
+        workflowRunId: runId,
+        ...options?.status && { status: this.enums.status(options.status) }
+      },
+      orderBy: { executionGroup: options?.orderBy ?? "asc" }
+    });
+    return stages.map((s) => this.mapWorkflowStage(s));
+  }
+  async getSuspendedStages(beforeDate) {
+    const stages = await this.prisma.workflowStage.findMany({
+      where: {
+        status: this.enums.status("SUSPENDED"),
+        nextPollAt: { lte: beforeDate }
+      },
+      include: {
+        workflowRun: { select: { workflowType: true } }
+      }
+    });
+    return stages.map((s) => this.mapWorkflowStage(s));
+  }
+  async getFirstSuspendedStageReadyToResume(runId) {
+    const stage = await this.prisma.workflowStage.findFirst({
+      where: {
+        workflowRunId: runId,
+        status: this.enums.status("SUSPENDED"),
+        nextPollAt: null
+        // Ready to resume (poll cleared by orchestrator)
+      },
+      orderBy: { executionGroup: "asc" }
+    });
+    return stage ? this.mapWorkflowStage(stage) : null;
+  }
+  async getFirstFailedStage(runId) {
+    const stage = await this.prisma.workflowStage.findFirst({
+      where: {
+        workflowRunId: runId,
+        status: this.enums.status("FAILED")
+      },
+      orderBy: { executionGroup: "desc" }
+    });
+    return stage ? this.mapWorkflowStage(stage) : null;
+  }
+  async getLastCompletedStage(runId) {
+    const stage = await this.prisma.workflowStage.findFirst({
+      where: {
+        workflowRunId: runId,
+        status: this.enums.status("COMPLETED")
+      },
+      orderBy: { executionGroup: "desc" }
+    });
+    return stage ? this.mapWorkflowStage(stage) : null;
+  }
+  async getLastCompletedStageBefore(runId, executionGroup) {
+    const stage = await this.prisma.workflowStage.findFirst({
+      where: {
+        workflowRunId: runId,
+        status: this.enums.status("COMPLETED"),
+        executionGroup: { lt: executionGroup }
+      },
+      orderBy: { executionGroup: "desc" }
+    });
+    return stage ? this.mapWorkflowStage(stage) : null;
+  }
+  async deleteStage(id) {
+    await this.prisma.workflowStage.delete({ where: { id } });
+  }
+  // ============================================================================
+  // WorkflowLog Operations
+  // ============================================================================
+  async createLog(data) {
+    await this.prisma.workflowLog.create({
+      data: {
+        workflowRunId: data.workflowRunId,
+        workflowStageId: data.workflowStageId,
+        level: this.enums.logLevel(data.level),
+        message: data.message,
+        metadata: data.metadata
+      }
+    });
+  }
+  // ============================================================================
+  // WorkflowArtifact Operations
+  // ============================================================================
+  async saveArtifact(data) {
+    await this.prisma.workflowArtifact.upsert({
+      where: {
+        workflowRunId_key: {
+          workflowRunId: data.workflowRunId,
+          key: data.key
+        }
+      },
+      create: {
+        workflowRunId: data.workflowRunId,
+        workflowStageId: data.workflowStageId,
+        key: data.key,
+        type: this.enums.artifactType(data.type),
+        data: data.data,
+        size: data.size,
+        metadata: data.metadata
+      },
+      update: {
+        data: data.data,
+        size: data.size,
+        metadata: data.metadata
+      }
+    });
+  }
+  async loadArtifact(runId, key) {
+    const artifact = await this.prisma.workflowArtifact.findUnique({
+      where: {
+        workflowRunId_key: { workflowRunId: runId, key }
+      }
+    });
+    return artifact?.data;
+  }
+  async hasArtifact(runId, key) {
+    const artifact = await this.prisma.workflowArtifact.findUnique({
+      where: {
+        workflowRunId_key: { workflowRunId: runId, key }
+      },
+      select: { id: true }
+    });
+    return artifact !== null;
+  }
+  async deleteArtifact(runId, key) {
+    await this.prisma.workflowArtifact.delete({
+      where: {
+        workflowRunId_key: { workflowRunId: runId, key }
+      }
+    });
+  }
+  async listArtifacts(runId) {
+    const artifacts = await this.prisma.workflowArtifact.findMany({
+      where: { workflowRunId: runId }
+    });
+    return artifacts.map(
+      (a) => this.mapWorkflowArtifact(a)
+    );
+  }
+  async getStageIdForArtifact(runId, stageId) {
+    const stage = await this.prisma.workflowStage.findUnique({
+      where: {
+        workflowRunId_stageId: { workflowRunId: runId, stageId }
+      },
+      select: { id: true }
+    });
+    return stage?.id ?? null;
+  }
+  // ============================================================================
+  // Stage Output Convenience Methods
+  // ============================================================================
+  async saveStageOutput(runId, workflowType, stageId, output) {
+    const key = `workflow-v2/${workflowType}/${runId}/${stageId}/output.json`;
+    const json = JSON.stringify(output);
+    const size = Buffer.byteLength(json, "utf8");
+    const workflowStageId = await this.getStageIdForArtifact(runId, stageId);
+    await this.prisma.workflowArtifact.upsert({
+      where: {
+        workflowRunId_key: { workflowRunId: runId, key }
+      },
+      update: {
+        data: output,
+        size,
+        workflowStageId
+      },
+      create: {
+        workflowRunId: runId,
+        workflowStageId,
+        key,
+        type: this.enums.artifactType("STAGE_OUTPUT"),
+        data: output,
+        size
+      }
+    });
+    return key;
+  }
+  // ============================================================================
+  // Outbox Operations
+  // ============================================================================
+  async appendOutboxEvents(events) {
+    if (events.length === 0) return;
+    const byRun = /* @__PURE__ */ new Map();
+    for (const event of events) {
+      const list = byRun.get(event.workflowRunId) ?? [];
+      list.push(event);
+      byRun.set(event.workflowRunId, list);
+    }
+    const rows = [];
+    for (const [workflowRunId, runEvents] of byRun) {
+      if (this.databaseType === "postgresql" && typeof this.prisma.$executeRaw === "function") {
+        await this.prisma.$executeRaw`
+          SELECT pg_advisory_xact_lock(hashtext(${workflowRunId}))
+        `;
+      }
+      const maxResult = await this.prisma.outboxEvent.aggregate({
+        where: { workflowRunId },
+        _max: { sequence: true }
+      });
+      let seq = maxResult._max.sequence ?? 0;
+      for (const event of runEvents) {
+        seq++;
+        rows.push({
+          workflowRunId: event.workflowRunId,
+          sequence: seq,
+          eventType: event.eventType,
+          payload: event.payload,
+          causationId: event.causationId,
+          occurredAt: event.occurredAt
+        });
+      }
+    }
+    await this.prisma.outboxEvent.createMany({ data: rows });
+  }
+  async getUnpublishedOutboxEvents(limit) {
+    const effectiveLimit = limit ?? 100;
+    const records = await this.prisma.outboxEvent.findMany({
+      where: { publishedAt: null, dlqAt: null },
+      orderBy: [{ workflowRunId: "asc" }, { sequence: "asc" }],
+      take: effectiveLimit
+    });
+    return records.map((r) => this.mapOutboxEvent(r));
+  }
+  async markOutboxEventsPublished(ids) {
+    if (ids.length === 0) return;
+    await this.prisma.outboxEvent.updateMany({
+      where: { id: { in: ids } },
+      data: { publishedAt: /* @__PURE__ */ new Date() }
+    });
+  }
+  // ============================================================================
+  // Outbox DLQ Operations
+  // ============================================================================
+  async incrementOutboxRetryCount(id) {
+    const record = await this.prisma.outboxEvent.update({
+      where: { id },
+      data: { retryCount: { increment: 1 } },
+      select: { retryCount: true }
+    });
+    return record.retryCount;
+  }
+  async moveOutboxEventToDLQ(id) {
+    await this.prisma.outboxEvent.update({
+      where: { id },
+      data: { dlqAt: /* @__PURE__ */ new Date() }
+    });
+  }
+  async replayDLQEvents(maxEvents) {
+    const dlqEvents = await this.prisma.outboxEvent.findMany({
+      where: { dlqAt: { not: null } },
+      take: maxEvents,
+      select: { id: true }
+    });
+    if (dlqEvents.length === 0) return 0;
+    const result = await this.prisma.outboxEvent.updateMany({
+      where: { id: { in: dlqEvents.map((e) => e.id) } },
+      data: { dlqAt: null, retryCount: 0 }
+    });
+    return result.count;
+  }
+  // ============================================================================
+  // Idempotency Operations
+  // ============================================================================
+  async acquireIdempotencyKey(key, commandType) {
+    try {
+      await this.prisma.idempotencyKey.create({
+        data: {
+          key,
+          commandType,
+          result: IDEMPOTENCY_IN_PROGRESS_MARKER
+        }
+      });
+      return { status: "acquired" };
+    } catch (error) {
+      if (error?.code !== "P2002") {
+        throw error;
+      }
+    }
+    const existing = await this.prisma.idempotencyKey.findUnique({
+      where: { key_commandType: { key, commandType } },
+      select: { result: true }
+    });
+    if (!existing || isInProgressResult(existing.result)) {
+      return { status: "in_progress" };
+    }
+    return { status: "replay", result: existing.result };
+  }
+  async completeIdempotencyKey(key, commandType, result) {
+    await this.prisma.idempotencyKey.update({
+      where: { key_commandType: { key, commandType } },
+      data: { result }
+    });
+  }
+  async releaseIdempotencyKey(key, commandType) {
+    await this.prisma.idempotencyKey.deleteMany({
+      where: { key, commandType }
+    });
+  }
+  // ============================================================================
+  // Type Mappers
+  // ============================================================================
+  mapWorkflowRun(run) {
+    return {
+      id: run.id,
+      createdAt: run.createdAt,
+      updatedAt: run.updatedAt,
+      workflowId: run.workflowId,
+      workflowName: run.workflowName,
+      workflowType: run.workflowType,
+      status: run.status,
+      startedAt: run.startedAt,
+      completedAt: run.completedAt,
+      duration: run.duration,
+      input: run.input,
+      output: run.output,
+      config: run.config,
+      totalCost: run.totalCost,
+      totalTokens: run.totalTokens,
+      priority: run.priority,
+      version: run.version ?? 0
+    };
+  }
+  mapWorkflowStage(stage) {
+    return {
+      id: stage.id,
+      createdAt: stage.createdAt,
+      updatedAt: stage.updatedAt,
+      workflowRunId: stage.workflowRunId,
+      stageId: stage.stageId,
+      stageName: stage.stageName,
+      stageNumber: stage.stageNumber,
+      executionGroup: stage.executionGroup,
+      status: stage.status,
+      startedAt: stage.startedAt,
+      completedAt: stage.completedAt,
+      duration: stage.duration,
+      inputData: stage.inputData,
+      outputData: stage.outputData,
+      config: stage.config,
+      suspendedState: stage.suspendedState,
+      resumeData: stage.resumeData,
+      nextPollAt: stage.nextPollAt,
+      pollInterval: stage.pollInterval,
+      maxWaitUntil: stage.maxWaitUntil,
+      metrics: stage.metrics,
+      embeddingInfo: stage.embeddingInfo,
+      errorMessage: stage.errorMessage,
+      version: stage.version ?? 0
+    };
+  }
+  mapOutboxEvent(record) {
+    return {
+      id: record.id,
+      workflowRunId: record.workflowRunId,
+      sequence: record.sequence,
+      eventType: record.eventType,
+      payload: record.payload,
+      causationId: record.causationId,
+      occurredAt: record.occurredAt,
+      publishedAt: record.publishedAt,
+      retryCount: record.retryCount,
+      dlqAt: record.dlqAt
+    };
+  }
+  mapWorkflowArtifact(artifact) {
+    return {
+      id: artifact.id,
+      createdAt: artifact.createdAt,
+      updatedAt: artifact.updatedAt,
+      workflowRunId: artifact.workflowRunId,
+      workflowStageId: artifact.workflowStageId,
+      key: artifact.key,
+      type: artifact.type,
+      data: artifact.data,
+      size: artifact.size,
+      metadata: artifact.metadata
+    };
+  }
+};
+function createPrismaWorkflowPersistence(prisma, options) {
+  return new PrismaWorkflowPersistence(prisma, options);
+}
+
+export { PrismaAICallLogger, PrismaJobQueue, PrismaWorkflowPersistence, createEnumHelper, createPrismaAICallLogger, createPrismaJobQueue, createPrismaWorkflowPersistence };
+//# sourceMappingURL=chunk-NYKMT46J.js.map
+//# sourceMappingURL=chunk-NYKMT46J.js.map