@cascade-flow/backend-postgres 0.2.8 → 0.2.9

package/dist/index.js

@@ -5080,6 +5080,31 @@ class DatabaseClient {
       client.release();
     }
   }
+  async loadStepEventsForProjection(workflowSlug, runId) {
+    const client = await this.pool.connect();
+    try {
+      const query = `
+        SELECT event_data, event_id, step_id
+        FROM ${this.schema}.step_events
+        WHERE workflow_slug = $1 AND run_id = $2
+          AND type NOT IN ('LogEntry', 'StepHeartbeat', 'StepRetrying')
+        ORDER BY timestamp_us ASC, event_id ASC
+      `;
+      const result = await client.query(query, [workflowSlug, runId]);
+      const eventsByStep = new Map;
+      for (const row of result.rows) {
+        const stepId = row.step_id;
+        const event = { ...row.event_data, eventId: row.event_id };
+        if (!eventsByStep.has(stepId)) {
+          eventsByStep.set(stepId, []);
+        }
+        eventsByStep.get(stepId).push(event);
+      }
+      return eventsByStep;
+    } finally {
+      client.release();
+    }
+  }
   async claimScheduledStep(workflowSlug, runId, stepId, workerId, eventToWrite) {
     const client = await this.pool.connect();
     try {
@@ -5451,6 +5476,253 @@ class DatabaseClient {
       client.release();
     }
   }
+  async getQueueDepthAggregation(workflowSlug) {
+    const client = await this.pool.connect();
+    try {
+      const result = await client.query(`WITH
+        -- Get the latest workflow event per run to determine run status
+        run_status AS (
+          SELECT DISTINCT ON (workflow_slug, run_id)
+            workflow_slug,
+            run_id,
+            type,
+            timestamp_us AS created_at
+          FROM ${this.schema}.workflow_events
+          WHERE ($1::text IS NULL OR workflow_slug = $1)
+          ORDER BY workflow_slug, run_id, timestamp_us DESC, event_id DESC
+        ),
+        -- Filter to only active (pending/running) runs
+        active_runs AS (
+          SELECT
+            workflow_slug,
+            run_id,
+            CASE WHEN type IN ('RunSubmitted', 'WorkflowRetryStarted') THEN 'pending' ELSE 'running' END AS status,
+            created_at
+          FROM run_status
+          WHERE type IN ('RunSubmitted', 'WorkflowRetryStarted', 'WorkflowStarted', 'WorkflowResumed')
+        ),
+        -- Get latest step event per step (excluding LogEntry which doesn't change state)
+        latest_step_events AS (
+          SELECT DISTINCT ON (se.workflow_slug, se.run_id, se.step_id)
+            se.type,
+            se.available_at_us
+          FROM ${this.schema}.step_events se
+          INNER JOIN active_runs ar
+            ON ar.workflow_slug = se.workflow_slug
+            AND ar.run_id = se.run_id
+            AND ar.status = 'running'
+          WHERE se.type != 'LogEntry'
+          ORDER BY se.workflow_slug, se.run_id, se.step_id, se.timestamp_us DESC, se.event_id DESC
+        ),
+        -- Aggregate step counts
+        step_counts AS (
+          SELECT
+            COUNT(*) FILTER (WHERE type IN ('StepScheduled', 'StepReclaimed')) AS scheduled_steps,
+            COUNT(*) FILTER (WHERE type IN ('StepStarted', 'StepHeartbeat')) AS running_steps,
+            MIN(available_at_us) FILTER (WHERE type IN ('StepScheduled', 'StepReclaimed')) AS oldest_scheduled_step_us
+          FROM latest_step_events
+        ),
+        -- Aggregate run counts
+        run_counts AS (
+          SELECT
+            COUNT(*) FILTER (WHERE status = 'pending') AS pending_runs,
+            COUNT(*) FILTER (WHERE status = 'running') AS running_runs,
+            MIN(created_at) FILTER (WHERE status = 'pending') AS oldest_pending_run_us
+          FROM active_runs
+        )
+        SELECT
+          COALESCE(rc.pending_runs, 0) AS pending_runs,
+          COALESCE(rc.running_runs, 0) AS running_runs,
+          COALESCE(sc.scheduled_steps, 0) AS scheduled_steps,
+          COALESCE(sc.running_steps, 0) AS running_steps,
+          sc.oldest_scheduled_step_us,
+          rc.oldest_pending_run_us
+        FROM run_counts rc, step_counts sc`, [workflowSlug ?? null]);
+      const row = result.rows[0];
+      return {
+        pendingRuns: parseInt(row?.pending_runs ?? "0", 10),
+        runningRuns: parseInt(row?.running_runs ?? "0", 10),
+        scheduledSteps: parseInt(row?.scheduled_steps ?? "0", 10),
+        runningSteps: parseInt(row?.running_steps ?? "0", 10),
+        oldestScheduledStepUs: row?.oldest_scheduled_step_us ? parseInt(row.oldest_scheduled_step_us, 10) : null,
+        oldestPendingRunUs: row?.oldest_pending_run_us ? parseInt(row.oldest_pending_run_us, 10) : null
+      };
+    } finally {
+      client.release();
+    }
+  }
+  async listRunsFiltered(options) {
+    const client = await this.pool.connect();
+    try {
+      const statusToEvents = {
+        pending: ["RunSubmitted", "WorkflowRetryStarted"],
+        running: ["WorkflowStarted", "WorkflowResumed"],
+        completed: ["WorkflowCompleted"],
+        failed: ["WorkflowFailed"],
+        cancelled: ["WorkflowCancelled"]
+      };
+      let eventTypeFilter = null;
+      if (options?.status && options.status.length > 0) {
+        eventTypeFilter = options.status.flatMap((s) => statusToEvents[s] || []);
+      }
+      const result = await client.query(`WITH
+        -- Get first event (RunSubmitted) for each run to get createdAt and tags
+        run_submitted AS (
+          SELECT DISTINCT ON (workflow_slug, run_id)
+            workflow_slug,
+            run_id,
+            timestamp_us AS created_at,
+            event_data->'tags' AS tags
+          FROM ${this.schema}.workflow_events
+          WHERE type = 'RunSubmitted'
+            AND ($1::text IS NULL OR workflow_slug = $1)
+          ORDER BY workflow_slug, run_id, timestamp_us ASC
+        ),
+        -- Get latest status-determining event for each run
+        latest_status AS (
+          SELECT DISTINCT ON (workflow_slug, run_id)
+            workflow_slug,
+            run_id,
+            CASE
+              WHEN type IN ('RunSubmitted', 'WorkflowRetryStarted') THEN 'pending'
+              WHEN type IN ('WorkflowStarted', 'WorkflowResumed') THEN 'running'
+              WHEN type = 'WorkflowCompleted' THEN 'completed'
+              WHEN type = 'WorkflowFailed' THEN 'failed'
+              WHEN type = 'WorkflowCancelled' THEN 'cancelled'
+            END AS status,
+            type
+          FROM ${this.schema}.workflow_events
+          WHERE ($1::text IS NULL OR workflow_slug = $1)
+          ORDER BY workflow_slug, run_id, timestamp_us DESC, event_id DESC
+        )
+        SELECT
+          ls.workflow_slug,
+          ls.run_id,
+          ls.status,
+          rs.created_at,
+          rs.tags
+        FROM latest_status ls
+        JOIN run_submitted rs ON ls.workflow_slug = rs.workflow_slug AND ls.run_id = rs.run_id
+        WHERE ($2::text[] IS NULL OR ls.type = ANY($2))
+        ORDER BY rs.created_at DESC
+        LIMIT $3`, [
+        options?.workflowSlug ?? null,
+        eventTypeFilter,
+        options?.limit ?? null
+      ]);
+      return result.rows.map((row) => ({
+        workflowSlug: row.workflow_slug,
+        runId: row.run_id,
+        status: row.status,
+        createdAt: parseInt(row.created_at, 10),
+        tags: row.tags
+      }));
+    } finally {
+      client.release();
+    }
+  }
+  async loadWorkflowEventsForRuns(runs) {
+    if (runs.length === 0) {
+      return new Map;
+    }
+    const client = await this.pool.connect();
+    try {
+      const values = [];
+      const valuePlaceholders = [];
+      runs.forEach((run, i) => {
+        values.push(run.workflowSlug, run.runId);
+        valuePlaceholders.push(`($${i * 2 + 1}, $${i * 2 + 2})`);
+      });
+      const result = await client.query(`SELECT workflow_slug, run_id, event_data, event_id
+         FROM ${this.schema}.workflow_events
+         WHERE (workflow_slug, run_id) IN (VALUES ${valuePlaceholders.join(", ")})
+         ORDER BY workflow_slug, run_id, timestamp_us ASC, event_id ASC`, values);
+      const eventsByRun = new Map;
+      for (const row of result.rows) {
+        const key = `${row.workflow_slug}:${row.run_id}`;
+        const events = eventsByRun.get(key) || [];
+        events.push({ ...row.event_data, eventId: row.event_id });
+        eventsByRun.set(key, events);
+      }
+      return eventsByRun;
+    } finally {
+      client.release();
+    }
+  }
+  async getQueueDepthByWorkflowAggregation() {
+    const client = await this.pool.connect();
+    try {
+      const result = await client.query(`WITH
+        -- Get the latest workflow event per run to determine run status
+        run_status AS (
+          SELECT DISTINCT ON (workflow_slug, run_id)
+            workflow_slug,
+            run_id,
+            type,
+            timestamp_us AS created_at
+          FROM ${this.schema}.workflow_events
+          ORDER BY workflow_slug, run_id, timestamp_us DESC, event_id DESC
+        ),
+        -- Filter to only active (pending/running) runs
+        active_runs AS (
+          SELECT
+            workflow_slug,
+            run_id,
+            CASE WHEN type IN ('RunSubmitted', 'WorkflowRetryStarted') THEN 'pending' ELSE 'running' END AS status,
+            created_at
+          FROM run_status
+          WHERE type IN ('RunSubmitted', 'WorkflowRetryStarted', 'WorkflowStarted', 'WorkflowResumed')
+        ),
+        -- Get latest step event per step (excluding LogEntry)
+        latest_step_events AS (
+          SELECT DISTINCT ON (se.workflow_slug, se.run_id, se.step_id)
+            se.workflow_slug,
+            se.type,
+            se.available_at_us
+          FROM ${this.schema}.step_events se
+          INNER JOIN active_runs ar
+            ON ar.workflow_slug = se.workflow_slug
+            AND ar.run_id = se.run_id
+            AND ar.status = 'running'
+          WHERE se.type != 'LogEntry'
+          ORDER BY se.workflow_slug, se.run_id, se.step_id, se.timestamp_us DESC, se.event_id DESC
+        ),
+        -- Aggregate step counts by workflow
+        step_counts_by_workflow AS (
+          SELECT
+            workflow_slug,
+            COUNT(*) FILTER (WHERE type IN ('StepScheduled', 'StepReclaimed')) AS scheduled_steps,
+            MIN(available_at_us) FILTER (WHERE type IN ('StepScheduled', 'StepReclaimed')) AS oldest_scheduled_us
+          FROM latest_step_events
+          GROUP BY workflow_slug
+        ),
+        -- Aggregate run counts by workflow
+        run_counts_by_workflow AS (
+          SELECT
+            workflow_slug,
+            COUNT(*) FILTER (WHERE status = 'pending') AS pending_runs,
+            MIN(created_at) FILTER (WHERE status = 'pending') AS oldest_pending_run_us
+          FROM active_runs
+          GROUP BY workflow_slug
+        )
+        SELECT
+          COALESCE(r.workflow_slug, s.workflow_slug) AS workflow_slug,
+          COALESCE(r.pending_runs, 0) AS pending_runs,
+          COALESCE(s.scheduled_steps, 0) AS scheduled_steps,
+          LEAST(r.oldest_pending_run_us, s.oldest_scheduled_us) AS oldest_pending_item_us
+        FROM run_counts_by_workflow r
+        FULL OUTER JOIN step_counts_by_workflow s ON r.workflow_slug = s.workflow_slug
+        WHERE COALESCE(r.pending_runs, 0) > 0 OR COALESCE(s.scheduled_steps, 0) > 0`);
+      return result.rows.map((row) => ({
+        workflowSlug: row.workflow_slug,
+        pendingRuns: parseInt(row.pending_runs, 10),
+        scheduledSteps: parseInt(row.scheduled_steps, 10),
+        oldestPendingItemUs: row.oldest_pending_item_us ? parseInt(row.oldest_pending_item_us, 10) : null
+      }));
+    } finally {
+      client.release();
+    }
+  }
 }
 function createPool(connectionString) {
   return new Pool2({ connectionString });
@@ -5729,6 +6001,60 @@ async function migration005_addWorkflowVersioning(pool, schema) {
     client.release();
   }
 }
+async function migration006_addDescIndexes(pool, schema) {
+  const client = await pool.connect();
+  try {
+    await client.query(`
+      CREATE INDEX IF NOT EXISTS idx_workflow_events_latest
+      ON ${schema}.workflow_events (workflow_slug, run_id, timestamp_us DESC, event_id DESC)
+    `);
+    await client.query(`
+      CREATE INDEX IF NOT EXISTS idx_step_events_latest
+      ON ${schema}.step_events (workflow_slug, run_id, step_id, timestamp_us DESC, event_id DESC)
+    `);
+    await client.query(`
+      CREATE INDEX IF NOT EXISTS idx_workflow_events_by_type
+      ON ${schema}.workflow_events (type, workflow_slug, run_id, timestamp_us ASC)
+    `);
+    console.log("[Migration 006] Optimized query indexes added successfully");
+  } catch (error) {
+    console.error("[Migration 006] Error adding DESC indexes:", error);
+    throw error;
+  } finally {
+    client.release();
+  }
+}
+async function migration007_addWorkerIndexes(pool, schema) {
+  const client = await pool.connect();
+  try {
+    await client.query(`
+      CREATE INDEX IF NOT EXISTS idx_step_events_scheduled_status
+      ON ${schema}.step_events (type, workflow_slug, run_id, step_id, timestamp_us DESC, event_id DESC)
+      WHERE type IN ('StepScheduled', 'StepReclaimed', 'StepRetrying')
+    `);
+    await client.query(`
+      CREATE INDEX IF NOT EXISTS idx_step_events_heartbeat_status
+      ON ${schema}.step_events (type, workflow_slug, run_id, step_id, timestamp_us DESC, event_id DESC)
+      WHERE type IN ('StepStarted', 'StepHeartbeat')
+    `);
+    await client.query(`
+      CREATE INDEX IF NOT EXISTS idx_workflow_events_active_types
+      ON ${schema}.workflow_events (type)
+      WHERE type IN ('RunSubmitted', 'WorkflowStarted', 'WorkflowResumed')
+    `);
+    await client.query(`
+      CREATE INDEX IF NOT EXISTS idx_step_events_active_types
+      ON ${schema}.step_events (type)
+      WHERE type IN ('StepScheduled', 'StepStarted', 'StepReclaimed', 'StepRetrying')
+    `);
+    console.log("[Migration 007] Worker loop indexes added successfully");
+  } catch (error) {
+    console.error("[Migration 007] Error adding worker indexes:", error);
+    throw error;
+  } finally {
+    client.release();
+  }
+}
 async function runMigrations(pool, schema = "cascadeflow") {
   console.log(`[Migrations] Starting database migrations in schema '${schema}'...`);
   try {
@@ -5738,6 +6064,8 @@ async function runMigrations(pool, schema = "cascadeflow") {
     await migration003_createIndexes(pool, schema);
     await migration004_addErrorFingerprints(pool, schema);
     await migration005_addWorkflowVersioning(pool, schema);
+    await migration006_addDescIndexes(pool, schema);
+    await migration007_addWorkerIndexes(pool, schema);
     console.log("[Migrations] All migrations completed successfully");
   } catch (error) {
     console.error("[Migrations] Migration failed:", error);
@@ -5761,6 +6089,20 @@ class PostgresBackend extends Backend {
     await runMigrations(this.db.getPool(), this.db.getSchema());
     this.initialized = true;
   }
+  async backendReady() {
+    try {
+      const client = await this.db.getPool().connect();
+      try {
+        await client.query("SELECT 1");
+        return true;
+      } finally {
+        client.release();
+      }
+    } catch (error) {
+      console.error("Backend health check failed:", error);
+      return false;
+    }
+  }
   generateRunId() {
     return `run_${Date.now()}_${Math.random().toString(36).substring(2, 15)}`;
   }
@@ -5824,6 +6166,9 @@ class PostgresBackend extends Backend {
       return this.db.loadAllRunEvents(workflowSlug, runId);
     }
   }
+  async loadStepEventsForProjection(workflowSlug, runId) {
+    return this.db.loadStepEventsForProjection(workflowSlug, runId);
+  }
   async copyEntireRun(workflowSlug, sourceRunId, targetRunId) {
     await this.copyEntireRunWithClient(workflowSlug, sourceRunId, targetRunId, this.db.getPool());
   }
@@ -6054,8 +6399,7 @@ class PostgresBackend extends Backend {
     await this.db.appendEvent("step_events", event);
   }
   async saveStepComplete(workflowSlug, runId, stepId, output, metadata, exportOutput = false) {
-    const events = await this.loadEvents(workflowSlug, runId, { category: "step", stepId });
-    const attemptNumber = getCurrentAttemptNumber(events);
+    const attemptNumber = metadata.attemptNumber;
     if (attemptNumber === 0) {
       throw new Error(`Cannot complete step that hasn't started: ${stepId}`);
     }
@@ -6194,6 +6538,40 @@ class PostgresBackend extends Backend {
     };
     await this.db.appendEvent("step_events", event);
   }
+  async saveStepCheckpoint(workflowSlug, runId, stepId, checkpoint) {
+    const now = getMicrosecondTimestamp();
+    const event = {
+      category: "step",
+      type: "StepCheckpoint",
+      eventId: this.generateEventId(now),
+      timestampUs: now,
+      workflowSlug,
+      runId,
+      stepId,
+      name: checkpoint.name,
+      sequenceNumber: checkpoint.sequenceNumber,
+      attemptNumber: checkpoint.attemptNumber,
+      data: checkpoint.data
+    };
+    await this.db.appendEvent("step_events", event);
+  }
+  async saveStepCheckpointFailed(workflowSlug, runId, stepId, checkpoint) {
+    const now = getMicrosecondTimestamp();
+    const event = {
+      category: "step",
+      type: "StepCheckpointFailed",
+      eventId: this.generateEventId(now),
+      timestampUs: now,
+      workflowSlug,
+      runId,
+      stepId,
+      name: checkpoint.name,
+      sequenceNumber: checkpoint.sequenceNumber,
+      attemptNumber: checkpoint.attemptNumber,
+      error: checkpoint.error
+    };
+    await this.db.appendEvent("step_events", event);
+  }
   async saveStepHeartbeat(workflowSlug, runId, stepId, workerId, attemptNumber) {
     const now = getMicrosecondTimestamp();
     const event = {
@@ -6403,35 +6781,39 @@ class PostgresBackend extends Backend {
     return { runId, isNew: true };
   }
   async listRuns(options) {
+    const filteredRuns = await this.db.listRunsFiltered({
+      workflowSlug: options?.workflowSlug,
+      status: options?.status,
+      limit: options?.tags?.length ? undefined : options?.limit
+    });
+    let runsToLoad = filteredRuns;
+    if (options?.tags && options.tags.length > 0) {
+      runsToLoad = filteredRuns.filter((run) => {
+        const runTags = run.tags || [];
+        return options.tags.every((tag) => runTags.includes(tag));
+      });
+      if (options?.limit) {
+        runsToLoad = runsToLoad.slice(0, options.limit);
+      }
+    }
+    if (runsToLoad.length === 0) {
+      return [];
+    }
+    const eventsByRun = await this.db.loadWorkflowEventsForRuns(runsToLoad.map((r) => ({ workflowSlug: r.workflowSlug, runId: r.runId })));
     const allRuns = [];
-    const workflows = options?.workflowSlug ? [options.workflowSlug] : await this.db.listActiveWorkflows();
-    for (const workflowSlug of workflows) {
-      const runIds = await this.db.listRunIds(workflowSlug);
-      for (const runId of runIds) {
-        try {
-          const events = await this.db.loadAllRunEvents(workflowSlug, runId);
-          if (events.length === 0)
-            continue;
-          const workflowEvents = events.filter((e) => e.category === "workflow");
-          const state = projectRunStateFromEvents(workflowEvents, workflowSlug);
-          if (options?.status && options.status.length > 0) {
-            if (!options.status.includes(state.status))
-              continue;
-          }
-          if (options?.tags && options.tags.length > 0) {
-            const stateTags = state.tags || [];
-            const hasAllTags = options.tags.every((tag) => stateTags.includes(tag));
-            if (!hasAllTags)
-              continue;
-          }
-          allRuns.push(state);
-        } catch {
-          continue;
-        }
+    for (const run of runsToLoad) {
+      const key = `${run.workflowSlug}:${run.runId}`;
+      const events = eventsByRun.get(key);
+      if (!events || events.length === 0)
+        continue;
+      try {
+        const state = projectRunStateFromEvents(events, run.workflowSlug);
+        allRuns.push(state);
+      } catch {
+        continue;
       }
     }
-    allRuns.sort((a, b) => b.createdAt - a.createdAt);
-    return options?.limit ? allRuns.slice(0, options.limit) : allRuns;
+    return allRuns;
   }
   async cancelRun(runId, reason) {
     const allWorkflows = await this.db.listActiveWorkflows();
@@ -6461,8 +6843,7 @@ class PostgresBackend extends Backend {
     for (const workflowSlug of allWorkflows) {
       const runIds = await this.db.listRunIds(workflowSlug);
       if (runIds.includes(runId)) {
-        const events = await this.db.loadAllRunEvents(workflowSlug, runId);
-        const workflowEvents = events.filter((e) => e.category === "workflow");
+        const workflowEvents = await this.loadEvents(workflowSlug, runId, { category: "workflow" });
         return projectRunStateFromEvents(workflowEvents, workflowSlug);
       }
     }
@@ -6907,113 +7288,34 @@ class PostgresBackend extends Backend {
     return computeThroughput(stepEvents, workflowEvents, timeRangeUs, options?.workflowSlug);
   }
   async getQueueDepth(options) {
-    const runs = await this.listRuns({
-      workflowSlug: options?.workflowSlug,
-      status: ["pending", "running"]
-    });
-    let pendingRuns = 0;
-    let runningRuns = 0;
-    let scheduledSteps = 0;
-    let runningSteps = 0;
-    let oldestScheduledStepUs;
-    let oldestPendingRunUs;
-    for (const run of runs) {
-      if (run.status === "pending") {
-        pendingRuns++;
-        if (!oldestPendingRunUs || run.createdAt < oldestPendingRunUs) {
-          oldestPendingRunUs = run.createdAt;
-        }
-      } else if (run.status === "running") {
-        runningRuns++;
-        try {
-          const stepEvents = await this.loadEvents(run.workflowSlug, run.runId, {
-            category: "step"
-          });
-          const eventsByStep = new Map;
-          for (const event of stepEvents) {
-            const events = eventsByStep.get(event.stepId) || [];
-            events.push(event);
-            eventsByStep.set(event.stepId, events);
-          }
-          for (const [stepId, events] of eventsByStep.entries()) {
-            const state = projectStepState(events, run.workflowSlug);
-            if (state.status === "scheduled") {
-              scheduledSteps++;
-              if (state.availableAt && (!oldestScheduledStepUs || state.availableAt < oldestScheduledStepUs)) {
-                oldestScheduledStepUs = state.availableAt;
-              }
-            } else if (state.status === "running") {
-              runningSteps++;
-            }
-          }
-        } catch (error) {
-          continue;
-        }
-      }
-    }
+    const result = await this.db.getQueueDepthAggregation(options?.workflowSlug);
     return {
       workflowSlug: options?.workflowSlug,
-      pendingRuns,
-      runningRuns,
-      scheduledSteps,
-      runningSteps,
-      oldestScheduledStepUs,
-      oldestPendingRunUs
+      pendingRuns: result.pendingRuns,
+      runningRuns: result.runningRuns,
+      scheduledSteps: result.scheduledSteps,
+      runningSteps: result.runningSteps,
+      oldestScheduledStepUs: result.oldestScheduledStepUs ?? undefined,
+      oldestPendingRunUs: result.oldestPendingRunUs ?? undefined
     };
   }
   async getQueueDepthByWorkflow() {
-    const runs = await this.listRuns({ status: ["pending", "running"] });
-    const workflowMap = new Map;
-    for (const run of runs) {
-      const existing = workflowMap.get(run.workflowSlug) || {
-        pendingRuns: 0,
-        scheduledSteps: 0
-      };
-      if (run.status === "pending") {
-        existing.pendingRuns++;
-        if (!existing.oldestPendingItemUs || run.createdAt < existing.oldestPendingItemUs) {
-          existing.oldestPendingItemUs = run.createdAt;
-        }
-      } else if (run.status === "running") {
-        try {
-          const stepEvents = await this.loadEvents(run.workflowSlug, run.runId, {
-            category: "step"
-          });
-          const eventsByStep = new Map;
-          for (const event of stepEvents) {
-            const events = eventsByStep.get(event.stepId) || [];
-            events.push(event);
-            eventsByStep.set(event.stepId, events);
-          }
-          for (const [stepId, events] of eventsByStep.entries()) {
-            const state = projectStepState(events, run.workflowSlug);
-            if (state.status === "scheduled") {
-              existing.scheduledSteps++;
-              if (state.availableAt && (!existing.oldestPendingItemUs || state.availableAt < existing.oldestPendingItemUs)) {
-                existing.oldestPendingItemUs = state.availableAt;
-              }
-            }
-          }
-        } catch (error) {
-          continue;
-        }
-      }
-      workflowMap.set(run.workflowSlug, existing);
-    }
-    const allMetadata = await this.listWorkflowMetadata();
+    const [aggregation, allMetadata] = await Promise.all([
+      this.db.getQueueDepthByWorkflowAggregation(),
+      this.listWorkflowMetadata()
+    ]);
     const metadataMap = new Map(allMetadata.map((m) => [m.slug, m]));
-    const result = Array.from(workflowMap.entries()).map(([workflowSlug, data]) => ({
-      workflowSlug,
-      workflowName: metadataMap.get(workflowSlug)?.name,
-      pendingRuns: data.pendingRuns,
-      scheduledSteps: data.scheduledSteps,
-      oldestPendingItemUs: data.oldestPendingItemUs
-    })).filter((item) => item.pendingRuns > 0 || item.scheduledSteps > 0).sort((a, b) => {
+    return aggregation.map((item) => ({
+      workflowSlug: item.workflowSlug,
+      workflowName: metadataMap.get(item.workflowSlug)?.name,
+      pendingRuns: item.pendingRuns,
+      scheduledSteps: item.scheduledSteps,
+      oldestPendingItemUs: item.oldestPendingItemUs ?? undefined
+    })).sort((a, b) => {
       const aTotal = a.pendingRuns + a.scheduledSteps;
       const bTotal = b.pendingRuns + b.scheduledSteps;
       return bTotal - aTotal;
     });
-    return result;
   }
   async getSuccessRate(options) {
     const { stepEvents, workflowEvents } = await this.loadEventsForAnalytics(options);
@@ -7066,4 +7368,4 @@ export {
   PostgresBackend
 };
 
-//# debugId=53B1DE663ECDB0B364756E2164756E21
+//# debugId=E1D15906F1E05F4664756E2164756E21