@cascade-flow/backend-postgres 0.2.5 → 0.2.8

package/dist/index.js

@@ -4744,6 +4744,7 @@ import {
   projectRunStateFromEvents,
   extractLogsFromEvents,
   getCurrentAttemptNumber,
+  getVersionIdFromEvents,
   getMicrosecondTimestamp,
   computeErrorAnalysis,
   computeRetryAnalysis,
@@ -4773,6 +4774,10 @@ var esm_default = import_lib.default;
 
 // src/db.ts
 var { Pool: Pool2 } = esm_default;
+function stripEventIdFromJson(event) {
+  const { eventId, ...eventWithoutId } = event;
+  return eventWithoutId;
+}
 
 class DatabaseClient {
   pool;
@@ -4807,9 +4812,18 @@ class DatabaseClient {
         } else if ("workflowAttemptNumber" in we) {
           workflowAttemptNumber = we.workflowAttemptNumber;
         }
-        if (we.type === "WorkflowStarted") {
+        if (we.type === "WorkflowStarted" || we.type === "WorkflowResumed") {
           versionId = we.versionId;
         }
+        if (versionId === null) {
+          const versionResult = await client.query(`SELECT version_id FROM ${this.schema}.workflow_events
+             WHERE workflow_slug = $1 AND run_id = $2
+             AND type IN ('WorkflowStarted', 'RunSubmitted')
+             AND version_id IS NOT NULL
+             ORDER BY timestamp_us DESC, event_id DESC
+             LIMIT 1`, [we.workflowSlug, we.runId]);
+          versionId = versionResult.rows[0]?.version_id ?? null;
+        }
         await client.query(`INSERT INTO ${this.schema}.workflow_events (
           event_id, workflow_slug, run_id, timestamp_us, category, type, event_data,
           workflow_attempt_number, available_at_us, priority, timeout_us, idempotency_key, version_id
@@ -4821,7 +4835,7 @@ class DatabaseClient {
           we.timestampUs,
           we.category,
           we.type,
-          JSON.stringify(event),
+          JSON.stringify(stripEventIdFromJson(event)),
           workflowAttemptNumber,
           availableAtUs,
           priority,
@@ -4860,7 +4874,10 @@ class DatabaseClient {
           errorStackPortableHash = se.errorFingerprints.stackPortableHash;
         }
         const versionResult = await client.query(`SELECT version_id FROM ${this.schema}.workflow_events
-           WHERE workflow_slug = $1 AND run_id = $2 AND version_id IS NOT NULL
+           WHERE workflow_slug = $1 AND run_id = $2
+           AND type IN ('WorkflowStarted', 'RunSubmitted')
+           AND version_id IS NOT NULL
+           ORDER BY timestamp_us DESC, event_id DESC
            LIMIT 1`, [se.workflowSlug, se.runId]);
         const versionId = versionResult.rows[0]?.version_id ?? null;
         await client.query(`INSERT INTO ${this.schema}.step_events (
@@ -4877,7 +4894,7 @@ class DatabaseClient {
           se.timestampUs,
           se.category,
           se.type,
-          JSON.stringify(event),
+          JSON.stringify(stripEventIdFromJson(event)),
           workerId,
           attemptNumber,
           availableAtUs,
@@ -4915,6 +4932,15 @@ class DatabaseClient {
       if (we.type === "WorkflowStarted") {
         versionId = we.versionId;
       }
+      if (versionId === null) {
+        const versionResult = await client.query(`SELECT version_id FROM ${this.schema}.workflow_events
+           WHERE workflow_slug = $1 AND run_id = $2
+           AND type IN ('WorkflowStarted', 'RunSubmitted')
+           AND version_id IS NOT NULL
+           ORDER BY timestamp_us DESC, event_id DESC
+           LIMIT 1`, [we.workflowSlug, we.runId]);
+        versionId = versionResult.rows[0]?.version_id ?? null;
+      }
       await client.query(`INSERT INTO ${this.schema}.workflow_events (
           event_id, workflow_slug, run_id, timestamp_us, category, type, event_data,
           workflow_attempt_number, available_at_us, priority, timeout_us, idempotency_key, version_id
@@ -4926,7 +4952,7 @@ class DatabaseClient {
         we.timestampUs,
         we.category,
         we.type,
-        JSON.stringify(event),
+        JSON.stringify(stripEventIdFromJson(event)),
         workflowAttemptNumber,
         availableAtUs,
         priority,
@@ -4965,7 +4991,10 @@ class DatabaseClient {
         errorStackPortableHash = se.errorFingerprints.stackPortableHash;
       }
       const versionResult = await client.query(`SELECT version_id FROM ${this.schema}.workflow_events
-         WHERE workflow_slug = $1 AND run_id = $2 AND version_id IS NOT NULL
+         WHERE workflow_slug = $1 AND run_id = $2
+         AND type IN ('WorkflowStarted', 'RunSubmitted')
+         AND version_id IS NOT NULL
+         ORDER BY timestamp_us DESC, event_id DESC
          LIMIT 1`, [se.workflowSlug, se.runId]);
       const versionId = versionResult.rows[0]?.version_id ?? null;
       await client.query(`INSERT INTO ${this.schema}.step_events (
@@ -4982,7 +5011,7 @@ class DatabaseClient {
         se.timestampUs,
         se.category,
         se.type,
-        JSON.stringify(event),
+        JSON.stringify(stripEventIdFromJson(event)),
         workerId,
         attemptNumber,
         availableAtUs,
@@ -5024,12 +5053,12 @@ class DatabaseClient {
       }
       const whereClause = conditions.length > 0 ? `WHERE ${conditions.join(" AND ")}` : "";
       const query = `
-      SELECT event_data FROM ${this.schema}.${table}
+      SELECT event_data, event_id FROM ${this.schema}.${table}
       ${whereClause}
       ORDER BY timestamp_us ASC, event_id ASC
     `;
       const result = await client.query(query, values);
-      return result.rows.map((row) => row.event_data);
+      return result.rows.map((row) => ({ ...row.event_data, eventId: row.event_id }));
     } finally {
       client.release();
     }
@@ -5046,7 +5075,7 @@ class DatabaseClient {
       ORDER BY timestamp_us ASC, event_id ASC
     `;
       const result = await client.query(query, [workflowSlug, runId]);
-      return result.rows.map((row) => row.event_data);
+      return result.rows.map((row) => ({ ...row.event_data, eventId: row.event_id }));
     } finally {
       client.release();
     }
@@ -5090,13 +5119,20 @@ class DatabaseClient {
         errorStackNormalizedHash = eventToWrite.errorFingerprints.stackNormalizedHash;
         errorStackPortableHash = eventToWrite.errorFingerprints.stackPortableHash;
       }
+      const versionResult = await client.query(`SELECT version_id FROM ${this.schema}.workflow_events
+         WHERE workflow_slug = $1 AND run_id = $2
+         AND type IN ('WorkflowStarted', 'RunSubmitted')
+         AND version_id IS NOT NULL
+         ORDER BY timestamp_us DESC, event_id DESC
+         LIMIT 1`, [eventToWrite.workflowSlug, eventToWrite.runId]);
+      const versionId = versionResult.rows[0]?.version_id ?? null;
       await client.query(`INSERT INTO ${this.schema}.step_events (
           event_id, workflow_slug, run_id, step_id, timestamp_us, category, type, event_data,
           worker_id, attempt_number, available_at_us, export_output,
           error_name_hash, error_message_hash, error_stack_exact_hash,
-          error_stack_normalized_hash, error_stack_portable_hash
+          error_stack_normalized_hash, error_stack_portable_hash, version_id
         )
-         VALUES ($1, $2, $3, $4, $5, $6, $7, $8, $9, $10, $11, $12, $13, $14, $15, $16, $17)`, [
+         VALUES ($1, $2, $3, $4, $5, $6, $7, $8, $9, $10, $11, $12, $13, $14, $15, $16, $17, $18)`, [
         eventToWrite.eventId,
         eventToWrite.workflowSlug,
         eventToWrite.runId,
@@ -5104,7 +5140,7 @@ class DatabaseClient {
         eventToWrite.timestampUs,
         eventToWrite.category,
         eventToWrite.type,
-        JSON.stringify(eventToWrite),
+        JSON.stringify(stripEventIdFromJson(eventToWrite)),
         workerId2,
         attemptNumber,
         null,
@@ -5113,7 +5149,8 @@ class DatabaseClient {
         errorMessageHash,
         errorStackExactHash,
         errorStackNormalizedHash,
-        errorStackPortableHash
+        errorStackPortableHash,
+        versionId
       ]);
       await client.query("COMMIT");
       return true;
@@ -5309,6 +5346,59 @@ class DatabaseClient {
       client.release();
     }
   }
+  async getWorkflowVersion(workflowSlug, versionId) {
+    const client = await this.pool.connect();
+    try {
+      const result = await client.query(`WITH numbered_versions AS (
+          SELECT *,
+            ROW_NUMBER() OVER (PARTITION BY workflow_slug ORDER BY created_at ASC) as version_number
+          FROM ${this.schema}.workflow_versions
+          WHERE workflow_slug = $1
+        )
+        SELECT * FROM numbered_versions WHERE version_id = $2`, [workflowSlug, versionId]);
+      if (result.rows.length === 0)
+        return null;
+      return result.rows[0];
+    } finally {
+      client.release();
+    }
+  }
+  async getCurrentWorkflowVersion(workflowSlug) {
+    const client = await this.pool.connect();
+    try {
+      const result = await client.query(`WITH numbered_versions AS (
+          SELECT *,
+            ROW_NUMBER() OVER (PARTITION BY workflow_slug ORDER BY created_at ASC) as version_number
+          FROM ${this.schema}.workflow_versions
+          WHERE workflow_slug = $1
+        )
+        SELECT * FROM numbered_versions
+        ORDER BY created_at DESC
+        LIMIT 1`, [workflowSlug]);
+      if (result.rows.length === 0)
+        return null;
+      return result.rows[0];
+    } finally {
+      client.release();
+    }
+  }
+  async listWorkflowVersions(workflowSlug, limit) {
+    const client = await this.pool.connect();
+    try {
+      const result = await client.query(`WITH numbered_versions AS (
+          SELECT *,
+            ROW_NUMBER() OVER (PARTITION BY workflow_slug ORDER BY created_at ASC) as version_number
+          FROM ${this.schema}.workflow_versions
+          WHERE workflow_slug = $1
+        )
+        SELECT * FROM numbered_versions
+        ORDER BY created_at DESC
+        LIMIT $2`, [workflowSlug, limit]);
+      return result.rows;
+    } finally {
+      client.release();
+    }
+  }
   async saveIdempotencyKey(hash, runId) {
     const client = await this.pool.connect();
     try {
@@ -5734,6 +5824,200 @@ class PostgresBackend extends Backend {
       return this.db.loadAllRunEvents(workflowSlug, runId);
     }
   }
+  async copyEntireRun(workflowSlug, sourceRunId, targetRunId) {
+    await this.copyEntireRunWithClient(workflowSlug, sourceRunId, targetRunId, this.db.getPool());
+  }
+  async copyEntireRunWithClient(workflowSlug, sourceRunId, targetRunId, client) {
+    const schema = this.db.getSchema();
+    await client.query(`INSERT INTO ${schema}.workflow_events (
+         event_id, workflow_slug, run_id, timestamp_us, category, type, event_data, created_at,
+         workflow_attempt_number, available_at_us, priority, timeout_us, idempotency_key, version_id
+       )
+       SELECT
+         gen_random_uuid()::text,
+         workflow_slug,
+         $2,
+         timestamp_us,
+         category,
+         type,
+         jsonb_set(event_data, '{runId}', to_jsonb($2::text)),
+         created_at,
+         workflow_attempt_number,
+         available_at_us,
+         priority,
+         timeout_us,
+         idempotency_key,
+         version_id
+       FROM ${schema}.workflow_events
+       WHERE workflow_slug = $1 AND run_id = $3`, [workflowSlug, targetRunId, sourceRunId]);
+    await client.query(`INSERT INTO ${schema}.step_events (
+         event_id, workflow_slug, run_id, step_id, timestamp_us, category, type, event_data, created_at,
+         worker_id, attempt_number, available_at_us, export_output,
+         error_name_hash, error_message_hash, error_stack_exact_hash, error_stack_normalized_hash, error_stack_portable_hash,
+         version_id
+       )
+       SELECT
+         gen_random_uuid()::text,
+         workflow_slug,
+         $2,
+         step_id,
+         timestamp_us,
+         category,
+         type,
+         jsonb_set(event_data, '{runId}', to_jsonb($2::text)),
+         created_at,
+         worker_id,
+         attempt_number,
+         available_at_us,
+         export_output,
+         error_name_hash,
+         error_message_hash,
+         error_stack_exact_hash,
+         error_stack_normalized_hash,
+         error_stack_portable_hash,
+         version_id
+       FROM ${schema}.step_events
+       WHERE workflow_slug = $1 AND run_id = $3`, [workflowSlug, targetRunId, sourceRunId]);
+  }
+  async deleteStepEvents(workflowSlug, runId, stepIds) {
+    await this.deleteStepEventsWithClient(workflowSlug, runId, stepIds, this.db.getPool());
+  }
+  async deleteStepEventsWithClient(workflowSlug, runId, stepIds, client) {
+    if (stepIds.size === 0)
+      return;
+    const schema = this.db.getSchema();
+    const stepIdsArray = Array.from(stepIds);
+    await client.query(`DELETE FROM ${schema}.step_events
+       WHERE workflow_slug = $1 AND run_id = $2 AND step_id = ANY($3)`, [workflowSlug, runId, stepIdsArray]);
+  }
+  async deleteWorkflowTerminalEvents(workflowSlug, runId) {
+    await this.deleteWorkflowTerminalEventsWithClient(workflowSlug, runId, this.db.getPool());
+  }
+  async deleteWorkflowTerminalEventsWithClient(workflowSlug, runId, client) {
+    const schema = this.db.getSchema();
+    await client.query(`DELETE FROM ${schema}.workflow_events
+       WHERE workflow_slug = $1
+         AND run_id = $2
+         AND type IN ('WorkflowCompleted', 'WorkflowFailed', 'WorkflowCancelled')`, [workflowSlug, runId]);
+  }
+  async copyWorkflowEvents(workflowSlug, sourceRunId, targetRunId, excludeTerminal) {
+    const pool = this.db.getPool();
+    const schema = this.db.getSchema();
+    const terminalFilter = excludeTerminal ? `AND type NOT IN ('WorkflowCompleted', 'WorkflowFailed', 'WorkflowCancelled')` : "";
+    await pool.query(`INSERT INTO ${schema}.workflow_events (
+         event_id, workflow_slug, run_id, timestamp_us, category, type, event_data, created_at,
+         workflow_attempt_number, available_at_us, priority, timeout_us, idempotency_key, version_id
+       )
+       SELECT
+         gen_random_uuid()::text,
+         workflow_slug,
+         $3,
+         timestamp_us,
+         category,
+         type,
+         jsonb_set(event_data, '{runId}', to_jsonb($3::text)),
+         created_at,
+         workflow_attempt_number,
+         available_at_us,
+         priority,
+         timeout_us,
+         idempotency_key,
+         version_id
+       FROM ${schema}.workflow_events
+       WHERE workflow_slug = $1
+         AND run_id = $2
+         ${terminalFilter}`, [workflowSlug, sourceRunId, targetRunId]);
+  }
+  async copyStepEvents(workflowSlug, sourceRunId, targetRunId, includeStepIds) {
+    const pool = this.db.getPool();
+    const schema = this.db.getSchema();
+    const stepIdsArray = Array.from(includeStepIds);
+    if (stepIdsArray.length === 0)
+      return;
+    await pool.query(`INSERT INTO ${schema}.step_events (
+         event_id, workflow_slug, run_id, step_id, timestamp_us, category, type, event_data, created_at,
+         worker_id, attempt_number, available_at_us, export_output,
+         error_name_hash, error_message_hash, error_stack_exact_hash, error_stack_normalized_hash, error_stack_portable_hash,
+         version_id
+       )
+       SELECT
+         gen_random_uuid()::text,
+         workflow_slug,
+         $3,
+         step_id,
+         timestamp_us,
+         category,
+         type,
+         jsonb_set(event_data, '{runId}', to_jsonb($3::text)),
+         created_at,
+         worker_id,
+         attempt_number,
+         available_at_us,
+         export_output,
+         error_name_hash,
+         error_message_hash,
+         error_stack_exact_hash,
+         error_stack_normalized_hash,
+         error_stack_portable_hash,
+         version_id
+       FROM ${schema}.step_events
+       WHERE workflow_slug = $1
+         AND run_id = $2
+         AND step_id = ANY($4)`, [workflowSlug, sourceRunId, targetRunId, stepIdsArray]);
+  }
+  async rerunFrom(params) {
+    const parentRun = await this.getRun(params.parentRunId);
+    if (!parentRun) {
+      throw new Error(`Parent run "${params.parentRunId}" not found`);
+    }
+    const dependents = await this.calculateDependents(parentRun.workflowSlug, params.fromStepId);
+    const rerunStepIds = new Set([params.fromStepId, ...dependents]);
+    const newRunId = getMicrosecondTimestamp().toString();
+    const pool = this.db.getPool();
+    const client = await pool.connect();
+    try {
+      await client.query("BEGIN");
+      await this.copyEntireRunWithClient(parentRun.workflowSlug, params.parentRunId, newRunId, client);
+      await this.deleteStepEventsWithClient(parentRun.workflowSlug, newRunId, rerunStepIds, client);
+      await this.deleteWorkflowTerminalEventsWithClient(parentRun.workflowSlug, newRunId, client);
+      await client.query("COMMIT");
+    } catch (error) {
+      await client.query("ROLLBACK");
+      throw error;
+    } finally {
+      client.release();
+    }
+    const currentVersion = await this.getCurrentWorkflowVersion(parentRun.workflowSlug);
+    if (!currentVersion) {
+      throw new Error(`Workflow ${parentRun.workflowSlug} not registered. Please ensure the worker has started and registered workflows.`);
+    }
+    const parentWorkflowEvents = await this.loadEvents(parentRun.workflowSlug, params.parentRunId, {
+      category: "workflow"
+    });
+    const parentVersionId = getVersionIdFromEvents(parentWorkflowEvents);
+    const timestamp = getMicrosecondTimestamp();
+    await this.appendEvent(parentRun.workflowSlug, newRunId, {
+      category: "workflow",
+      type: "WorkflowRerunFromStep",
+      eventId: this.generateEventId(timestamp),
+      timestampUs: timestamp,
+      workflowSlug: parentRun.workflowSlug,
+      runId: newRunId,
+      parentRunId: params.parentRunId,
+      rerunFromStepId: params.fromStepId,
+      rerunStepIds: Array.from(rerunStepIds),
+      versionId: currentVersion.versionId,
+      parentVersionId
+    });
+    await this.submitRun({
+      workflowSlug: parentRun.workflowSlug,
+      runId: newRunId,
+      input: params.input
+    });
+    return {
+      runId: newRunId
+    };
+  }
   async saveStepScheduled(workflowSlug, runId, stepId, metadata) {
     const now = getMicrosecondTimestamp();
     const event = {
@@ -6025,6 +6309,7 @@ class PostgresBackend extends Backend {
       timestampUs: timestamp,
       workflowSlug,
       runId,
+      versionId: metadata.versionId,
       originalRunId: metadata.originalRunId,
       resumedSteps: metadata.resumedSteps,
       pendingSteps: metadata.pendingSteps
@@ -6327,20 +6612,17 @@ class PostgresBackend extends Backend {
     ]);
   }
   async getWorkflowVersion(workflowSlug, versionId) {
-    const result = await this.db.getPool().query(`
-      SELECT * FROM ${this.db.getSchema()}.workflow_versions
-      WHERE workflow_slug = $1 AND version_id = $2
-    `, [workflowSlug, versionId]);
-    if (result.rows.length === 0)
+    const row = await this.db.getWorkflowVersion(workflowSlug, versionId);
+    if (!row)
       return null;
-    const row = result.rows[0];
     return {
       workflowSlug: row.workflow_slug,
       versionId: row.version_id,
+      versionNumber: parseInt(row.version_number.toString(), 10),
       createdAt: Math.floor(new Date(row.created_at).getTime() * 1000),
       stepManifest: row.step_manifest,
       totalSteps: row.total_steps,
-      git: row.git_commit ? {
+      git: row.git_commit && row.git_dirty !== null && row.git_branch !== null ? {
         commit: row.git_commit,
         dirty: row.git_dirty,
         branch: row.git_branch
@@ -6348,22 +6630,17 @@ class PostgresBackend extends Backend {
     };
   }
   async getCurrentWorkflowVersion(workflowSlug) {
-    const result = await this.db.getPool().query(`
-      SELECT * FROM ${this.db.getSchema()}.workflow_versions
-      WHERE workflow_slug = $1
-      ORDER BY created_at DESC
-      LIMIT 1
-    `, [workflowSlug]);
-    if (result.rows.length === 0)
+    const row = await this.db.getCurrentWorkflowVersion(workflowSlug);
+    if (!row)
       return null;
-    const row = result.rows[0];
     return {
       workflowSlug: row.workflow_slug,
       versionId: row.version_id,
+      versionNumber: parseInt(row.version_number.toString(), 10),
       createdAt: Math.floor(new Date(row.created_at).getTime() * 1000),
       stepManifest: row.step_manifest,
       totalSteps: row.total_steps,
-      git: row.git_commit ? {
+      git: row.git_commit && row.git_dirty !== null && row.git_branch !== null ? {
         commit: row.git_commit,
         dirty: row.git_dirty,
         branch: row.git_branch
@@ -6372,19 +6649,15 @@ class PostgresBackend extends Backend {
   }
   async listWorkflowVersions(workflowSlug, options) {
     const limit = options?.limit ?? 100;
-    const result = await this.db.getPool().query(`
-      SELECT * FROM ${this.db.getSchema()}.workflow_versions
-      WHERE workflow_slug = $1
-      ORDER BY created_at DESC
-      LIMIT $2
-    `, [workflowSlug, limit]);
-    return result.rows.map((row) => ({
+    const rows = await this.db.listWorkflowVersions(workflowSlug, limit);
+    return rows.map((row) => ({
       workflowSlug: row.workflow_slug,
       versionId: row.version_id,
+      versionNumber: parseInt(row.version_number.toString(), 10),
       createdAt: Math.floor(new Date(row.created_at).getTime() * 1000),
       stepManifest: row.step_manifest,
       totalSteps: row.total_steps,
-      git: row.git_commit ? {
+      git: row.git_commit && row.git_dirty !== null && row.git_branch !== null ? {
         commit: row.git_commit,
         dirty: row.git_dirty,
         branch: row.git_branch
@@ -6399,7 +6672,7 @@ class PostgresBackend extends Backend {
     const startUs = options?.startUs ?? now - 24 * 60 * 60 * 1000 * 1000;
     const endUs = options?.endUs ?? now;
     let stepQuery = `
-      SELECT event_data
+      SELECT event_data, event_id
       FROM ${this.db.getSchema()}.step_events
       WHERE timestamp_us >= $1 AND timestamp_us <= $2
     `;
@@ -6423,7 +6696,7 @@ class PostgresBackend extends Backend {
     }
     stepQuery += ` ORDER BY timestamp_us ASC`;
     let workflowQuery = `
-      SELECT event_data
+      SELECT event_data, event_id
       FROM ${this.db.getSchema()}.workflow_events
       WHERE timestamp_us >= $1 AND timestamp_us <= $2
     `;
@@ -6445,8 +6718,8 @@ class PostgresBackend extends Backend {
       this.db.getPool().query(stepQuery, stepParams),
       options?.stepId ? Promise.resolve({ rows: [] }) : this.db.getPool().query(workflowQuery, workflowParams)
     ]);
-    const stepEvents = stepResult.rows.map((row) => row.event_data);
-    const workflowEvents = workflowResult.rows.map((row) => row.event_data);
+    const stepEvents = stepResult.rows.map((row) => ({ ...row.event_data, eventId: row.event_id }));
+    const workflowEvents = workflowResult.rows.map((row) => ({ ...row.event_data, eventId: row.event_id }));
     return { stepEvents, workflowEvents };
   }
   async getErrorAnalysis(options) {
@@ -6793,4 +7066,4 @@ export {
   PostgresBackend
 };
 
-//# debugId=D60A61AD3A02516564756E2164756E21
+//# debugId=53B1DE663ECDB0B364756E2164756E21