pg-workflows 0.6.0 → 0.6.1

package/dist/index.js

@@ -195,15 +195,23 @@ async function runMigrations(db) {
         job_id varchar(256)
       );
     `, []);
-    await db.executeSql(`
-      CREATE INDEX workflow_runs_workflow_id_idx ON workflow_runs USING btree (workflow_id);
-    `, []);
     await db.executeSql(`
       CREATE INDEX workflow_runs_created_at_idx ON workflow_runs USING btree (created_at);
+      CREATE INDEX workflow_runs_resource_id_created_at_idx ON workflow_runs USING btree (resource_id, created_at DESC);
+      CREATE INDEX workflow_runs_status_created_at_idx ON workflow_runs USING btree (status, created_at DESC);
+      CREATE INDEX workflow_runs_workflow_id_created_at_idx ON workflow_runs USING btree (workflow_id, created_at DESC);
+      CREATE INDEX workflow_runs_resource_id_workflow_id_created_at_idx ON workflow_runs USING btree (resource_id, workflow_id, created_at DESC);
     `, []);
+  } else {
     await db.executeSql(`
-      CREATE INDEX workflow_runs_resource_id_idx ON workflow_runs USING btree (resource_id);
-    `, []);
+      DROP INDEX IF EXISTS workflow_runs_workflow_id_idx;
+      DROP INDEX IF EXISTS workflow_runs_resource_id_idx;
+      CREATE INDEX IF NOT EXISTS workflow_runs_created_at_idx ON workflow_runs USING btree (created_at);
+      CREATE INDEX IF NOT EXISTS workflow_runs_resource_id_created_at_idx ON workflow_runs USING btree (resource_id, created_at DESC);
+      CREATE INDEX IF NOT EXISTS workflow_runs_status_created_at_idx ON workflow_runs USING btree (status, created_at DESC);
+      CREATE INDEX IF NOT EXISTS workflow_runs_workflow_id_created_at_idx ON workflow_runs USING btree (workflow_id, created_at DESC);
+      CREATE INDEX IF NOT EXISTS workflow_runs_resource_id_workflow_id_created_at_idx ON workflow_runs USING btree (resource_id, workflow_id, created_at DESC);
+      `, []);
   }
 }
 
@@ -241,8 +249,7 @@ async function insertWorkflowRun({
   status,
   input,
   maxRetries,
-  timeoutAt,
-  timeline
+  timeoutAt
 }, db) {
   const runId = generateKSUID("run");
   const now = new Date;
@@ -272,7 +279,7 @@ async function insertWorkflowRun({
     timeoutAt,
     now,
     now,
-    JSON.stringify(timeline ?? {}),
+    "{}",
     0
   ]);
   const insertedRun = result.rows[0];
@@ -300,7 +307,8 @@ async function getWorkflowRun({
 async function updateWorkflowRun({
   runId,
   resourceId,
-  data
+  data,
+  expectedStatuses
 }, db) {
   const now = new Date;
   const updates = ["updated_at = $1"];
@@ -356,10 +364,20 @@ async function updateWorkflowRun({
     values.push(data.jobId);
     paramIndex++;
   }
-  const whereClause = resourceId ? `WHERE id = $${paramIndex} AND resource_id = $${paramIndex + 1}` : `WHERE id = $${paramIndex}`;
   values.push(runId);
+  const idParam = paramIndex;
+  paramIndex++;
   if (resourceId) {
     values.push(resourceId);
+    paramIndex++;
+  }
+  if (expectedStatuses && expectedStatuses.length > 0) {
+    values.push(expectedStatuses);
+    paramIndex++;
+  }
+  let whereClause = resourceId ? `WHERE id = $${idParam} AND resource_id = $${idParam + 1}` : `WHERE id = $${idParam}`;
+  if (expectedStatuses && expectedStatuses.length > 0) {
+    whereClause += ` AND status = ANY($${paramIndex - 1})`;
   }
   const query = `
     UPDATE workflow_runs 
@@ -400,20 +418,28 @@ async function getWorkflowRuns({
     values.push(workflowId);
     paramIndex++;
   }
-  if (startingAfter) {
-    const cursorResult = await db.executeSql("SELECT created_at FROM workflow_runs WHERE id = $1 LIMIT 1", [startingAfter]);
-    if (cursorResult.rows[0]?.created_at) {
-      conditions.push(`created_at < $${paramIndex}`);
-      values.push(typeof cursorResult.rows[0].created_at === "string" ? new Date(cursorResult.rows[0].created_at) : cursorResult.rows[0].created_at);
-      paramIndex++;
+  const cursorIds = [startingAfter, endingBefore].filter(Boolean);
+  if (cursorIds.length > 0) {
+    const cursorResult = await db.executeSql("SELECT id, created_at FROM workflow_runs WHERE id = ANY($1)", [cursorIds]);
+    const cursorMap = new Map;
+    for (const row of cursorResult.rows) {
+      cursorMap.set(row.id, typeof row.created_at === "string" ? new Date(row.created_at) : row.created_at);
     }
-  }
-  if (endingBefore) {
-    const cursorResult = await db.executeSql("SELECT created_at FROM workflow_runs WHERE id = $1 LIMIT 1", [endingBefore]);
-    if (cursorResult.rows[0]?.created_at) {
-      conditions.push(`created_at > $${paramIndex}`);
-      values.push(typeof cursorResult.rows[0].created_at === "string" ? new Date(cursorResult.rows[0].created_at) : cursorResult.rows[0].created_at);
-      paramIndex++;
+    if (startingAfter) {
+      const cursor = cursorMap.get(startingAfter);
+      if (cursor) {
+        conditions.push(`created_at < $${paramIndex}`);
+        values.push(cursor);
+        paramIndex++;
+      }
+    }
+    if (endingBefore) {
+      const cursor = cursorMap.get(endingBefore);
+      if (cursor) {
+        conditions.push(`created_at > $${paramIndex}`);
+        values.push(cursor);
+        paramIndex++;
+      }
     }
   }
   const whereClause = conditions.length > 0 ? `WHERE ${conditions.join(" AND ")}` : "";
@@ -610,8 +636,7 @@ class WorkflowEngine {
         status: "running" /* RUNNING */,
         input,
         maxRetries: options?.retries ?? workflow2.retries ?? 0,
-        timeoutAt,
-        timeline: undefined
+        timeoutAt
       }, _db);
       const job = {
         runId: insertedRun.id,
@@ -642,7 +667,8 @@ class WorkflowEngine {
       data: {
         status: "paused" /* PAUSED */,
         pausedAt: new Date
-      }
+      },
+      expectedStatuses: ["running" /* RUNNING */, "pending" /* PENDING */]
     });
     this.logger.log("Paused workflow run", {
       runId,
@@ -656,6 +682,10 @@ class WorkflowEngine {
     options
   }) {
     await this.checkIfHasStarted();
+    const current = await this.getRun({ runId, resourceId });
+    if (current.status !== "paused" /* PAUSED */) {
+      throw new WorkflowEngineError(`Cannot resume workflow run in '${current.status}' status, must be 'paused'`, current.workflowId, runId);
+    }
     return this.triggerEvent({
       runId,
       resourceId,
@@ -675,8 +705,7 @@ class WorkflowEngine {
       return run;
     }
     const stepId = run.currentStepId;
-    const waitForStepEntry = run.timeline[`${stepId}-wait-for`];
-    const waitForStep = waitForStepEntry && typeof waitForStepEntry === "object" && "waitFor" in waitForStepEntry ? waitForStepEntry : null;
+    const waitForStep = this.getWaitForStepEntry(run.timeline, stepId);
     if (!waitForStep) {
       return run;
     }
@@ -685,18 +714,21 @@ class WorkflowEngine {
       return this.resumeWorkflow({ runId, resourceId });
     }
     if (skipOutput && timeoutEvent) {
-      await this.updateRun({
-        runId,
-        resourceId,
-        data: {
-          timeline: merge(run.timeline, {
-            [stepId]: {
-              output: data ?? {},
-              timestamp: new Date
-            }
-          })
-        }
-      });
+      await withPostgresTransaction(this.db, async (db) => {
+        const freshRun = await this.getRun({ runId, resourceId }, { exclusiveLock: true, db });
+        return this.updateRun({
+          runId,
+          resourceId,
+          data: {
+            timeline: merge(freshRun.timeline, {
+              [stepId]: {
+                output: data ?? {},
+                timestamp: new Date
+              }
+            })
+          }
+        }, { db });
+      }, this.pool);
       return this.triggerEvent({ runId, resourceId, eventName: timeoutEvent });
     }
     if (eventName) {
@@ -717,7 +749,8 @@ class WorkflowEngine {
       resourceId,
       data: {
         status: "cancelled" /* CANCELLED */
-      }
+      },
+      expectedStatuses: ["pending" /* PENDING */, "running" /* RUNNING */, "paused" /* PAUSED */]
     });
     this.logger.log(`cancelled workflow run with id ${runId}`);
     return run;
@@ -742,7 +775,7 @@ class WorkflowEngine {
         data
       }
     };
-    this.boss.send(WORKFLOW_RUN_QUEUE_NAME, job, {
+    await this.boss.send(WORKFLOW_RUN_QUEUE_NAME, job, {
       expireInSeconds: options?.expireInSeconds ?? defaultExpireInSeconds
     });
     this.logger.log(`event ${eventName} sent for workflow run with id ${runId}`);
@@ -758,10 +791,17 @@ class WorkflowEngine {
   async updateRun({
     runId,
     resourceId,
-    data
+    data,
+    expectedStatuses
   }, { db } = {}) {
-    const run = await updateWorkflowRun({ runId, resourceId, data }, db ?? this.db);
+    const run = await updateWorkflowRun({ runId, resourceId, data, expectedStatuses }, db ?? this.db);
     if (!run) {
+      if (expectedStatuses) {
+        const current = await getWorkflowRun({ runId, resourceId }, { db: db ?? this.db });
+        if (current) {
+          throw new WorkflowEngineError(`Cannot update workflow run in '${current.status}' status, expected: ${expectedStatuses.join(", ")}`, current.workflowId, runId);
+        }
+      }
       throw new WorkflowRunNotFoundError(runId);
     }
     return run;
@@ -844,36 +884,40 @@ class WorkflowEngine {
         throw new WorkflowEngineError("Missing current step id", workflowId, runId);
       }
       if (run.status === "paused" /* PAUSED */) {
-        const waitForStepEntry = run.timeline[`${run.currentStepId}-wait-for`];
-        const waitForStep = waitForStepEntry && typeof waitForStepEntry === "object" && "waitFor" in waitForStepEntry ? waitForStepEntry : null;
-        const currentStep = this.getCachedStepEntry(run.timeline, run.currentStepId);
-        const waitFor = waitForStep?.waitFor;
-        const hasCurrentStepOutput = currentStep?.output !== undefined;
-        const eventMatches = waitFor && event?.name && (event.name === waitFor.eventName || event.name === waitFor.timeoutEvent) && !hasCurrentStepOutput;
-        if (eventMatches) {
-          const isTimeout = event?.name === waitFor?.timeoutEvent;
-          const skipOutput = waitFor?.skipOutput;
-          run = await this.updateRun({
-            runId,
-            resourceId: scopedResourceId,
-            data: {
-              status: "running" /* RUNNING */,
-              pausedAt: null,
-              resumedAt: new Date,
-              jobId: job?.id,
-              ...skipOutput ? {} : {
-                timeline: merge(run.timeline, {
-                  [run.currentStepId]: {
-                    output: event?.data ?? {},
-                    ...isTimeout ? { timedOut: true } : {},
-                    timestamp: new Date
-                  }
-                })
+        run = await withPostgresTransaction(this.db, async (db) => {
+          const lockedRun = await this.getRun({ runId, resourceId: scopedResourceId }, { exclusiveLock: true, db });
+          if (lockedRun.status !== "paused" /* PAUSED */) {
+            return lockedRun;
+          }
+          const waitForStep = this.getWaitForStepEntry(lockedRun.timeline, lockedRun.currentStepId);
+          const currentStep = this.getCachedStepEntry(lockedRun.timeline, lockedRun.currentStepId);
+          const waitFor = waitForStep?.waitFor;
+          const hasCurrentStepOutput = currentStep?.output !== undefined;
+          const eventMatches = waitFor && event?.name && (event.name === waitFor.eventName || event.name === waitFor.timeoutEvent) && !hasCurrentStepOutput;
+          if (eventMatches) {
+            const isTimeout = event?.name === waitFor?.timeoutEvent;
+            const skipOutput = waitFor?.skipOutput;
+            return this.updateRun({
+              runId,
+              resourceId: scopedResourceId,
+              data: {
+                status: "running" /* RUNNING */,
+                pausedAt: null,
+                resumedAt: new Date,
+                jobId: job?.id,
+                ...skipOutput ? {} : {
+                  timeline: merge(lockedRun.timeline, {
+                    [lockedRun.currentStepId]: {
+                      output: event?.data ?? {},
+                      ...isTimeout ? { timedOut: true } : {},
+                      timestamp: new Date
+                    }
+                  })
+                }
               }
-            }
-          });
-        } else {
-          run = await this.updateRun({
+            }, { db });
+          }
+          return this.updateRun({
             runId,
             resourceId: scopedResourceId,
             data: {
@@ -882,8 +926,8 @@ class WorkflowEngine {
               resumedAt: new Date,
               jobId: job?.id
             }
-          });
-        }
+          }, { db });
+        }, this.pool);
       }
       const baseStep = {
         run: async (stepId, handler) => {
@@ -1013,6 +1057,10 @@ class WorkflowEngine {
     const stepEntry = timeline[stepId];
     return stepEntry && typeof stepEntry === "object" && "output" in stepEntry ? stepEntry : null;
   }
+  getWaitForStepEntry(timeline, stepId) {
+    const entry = timeline[`${stepId}-wait-for`];
+    return entry && typeof entry === "object" && "waitFor" in entry ? entry : null;
+  }
   async runStep({
     stepId,
     run,
@@ -1054,7 +1102,7 @@ class WorkflowEngine {
           runId: run.id,
           resourceId: run.resourceId ?? undefined,
           data: {
-            timeline: merge(run.timeline, {
+            timeline: merge(persistedRun.timeline, {
               [stepId]: {
                 output,
                 timestamp: new Date
@@ -1098,64 +1146,46 @@ ${error.stack}` : String(error)
     if (cached?.output !== undefined) {
       return cached.timedOut ? undefined : cached.output;
     }
-    const fastForwardConfig = persistedRun.timeline.__fastForward;
-    if (fastForwardConfig && eventName !== PAUSE_EVENT_NAME) {
-      let output = {};
-      if (eventName) {
-        if (typeof fastForwardConfig === "object" && fastForwardConfig !== null && !Array.isArray(fastForwardConfig)) {
-          const mockData = fastForwardConfig[stepId];
-          if (mockData !== undefined) {
-            output = mockData;
-          }
-        }
-      }
-      run = await this.updateRun({
+    const timeoutEvent = timeoutDate ? `__timeout_${stepId}` : undefined;
+    await withPostgresTransaction(this.db, async (db) => {
+      const freshRun = await this.getRun({ runId: run.id, resourceId: run.resourceId ?? undefined }, { exclusiveLock: true, db });
+      return this.updateRun({
         runId: run.id,
         resourceId: run.resourceId ?? undefined,
         data: {
+          status: "paused" /* PAUSED */,
           currentStepId: stepId,
-          timeline: merge(run.timeline, {
-            [stepId]: {
-              output,
+          pausedAt: new Date,
+          timeline: merge(freshRun.timeline, {
+            [`${stepId}-wait-for`]: {
+              waitFor: { eventName, timeoutEvent },
               timestamp: new Date
             }
           })
         }
-      });
-      this.logger.log(`Step ${stepId} fast-forwarded`, {
-        runId: run.id,
-        workflowId: run.workflowId
-      });
-      return output;
-    }
-    const timeoutEvent = timeoutDate ? `__timeout_${stepId}` : undefined;
-    await this.updateRun({
-      runId: run.id,
-      resourceId: run.resourceId ?? undefined,
-      data: {
-        status: "paused" /* PAUSED */,
-        currentStepId: stepId,
-        pausedAt: new Date,
-        timeline: merge(run.timeline, {
-          [`${stepId}-wait-for`]: {
-            waitFor: { eventName, timeoutEvent },
-            timestamp: new Date
-          }
-        })
-      }
-    });
+      }, { db });
+    }, this.pool);
     if (timeoutDate && timeoutEvent) {
-      const job = {
-        runId: run.id,
-        resourceId: run.resourceId ?? undefined,
-        workflowId: run.workflowId,
-        input: run.input,
-        event: { name: timeoutEvent, data: { date: timeoutDate.toISOString() } }
-      };
-      await this.boss.send(WORKFLOW_RUN_QUEUE_NAME, job, {
-        startAfter: timeoutDate.getTime() <= Date.now() ? new Date : timeoutDate,
-        expireInSeconds: defaultExpireInSeconds
-      });
+      try {
+        const job = {
+          runId: run.id,
+          resourceId: run.resourceId ?? undefined,
+          workflowId: run.workflowId,
+          input: run.input,
+          event: { name: timeoutEvent, data: { date: timeoutDate.toISOString() } }
+        };
+        await this.boss.send(WORKFLOW_RUN_QUEUE_NAME, job, {
+          startAfter: timeoutDate.getTime() <= Date.now() ? new Date : timeoutDate,
+          expireInSeconds: defaultExpireInSeconds
+        });
+      } catch (error) {
+        await this.updateRun({
+          runId: run.id,
+          resourceId: run.resourceId ?? undefined,
+          data: { status: "running" /* RUNNING */, pausedAt: null }
+        });
+        throw error;
+      }
     }
     this.logger.log(`Step ${stepId} waiting${eventName ? ` for event "${eventName}"` : ""}${timeoutDate ? ` until ${timeoutDate.toISOString()}` : ""}`, { runId: run.id, workflowId: run.workflowId });
   }
@@ -1180,59 +1210,99 @@ ${error.stack}` : String(error)
     const pollStateEntry = persistedRun.timeline[`${stepId}-poll`];
     const startedAt = pollStateEntry && typeof pollStateEntry === "object" && "startedAt" in pollStateEntry ? new Date(pollStateEntry.startedAt) : new Date;
     if (timeoutMs !== undefined && Date.now() >= startedAt.getTime() + timeoutMs) {
-      await this.updateRun({
+      await withPostgresTransaction(this.db, async (db) => {
+        const freshRun = await this.getRun({ runId: run.id, resourceId: run.resourceId ?? undefined }, { exclusiveLock: true, db });
+        return this.updateRun({
+          runId: run.id,
+          resourceId: run.resourceId ?? undefined,
+          data: {
+            currentStepId: stepId,
+            timeline: merge(freshRun.timeline, {
+              [stepId]: { output: {}, timedOut: true, timestamp: new Date }
+            })
+          }
+        }, { db });
+      }, this.pool);
+      return { timedOut: true };
+    }
+    let result;
+    try {
+      result = await conditionFn();
+    } catch (error) {
+      this.logger.error(`Poll conditionFn for step ${stepId} threw an error, treating as non-match and continuing to poll`, error, { runId: run.id, workflowId: run.workflowId });
+      if (timeoutMs !== undefined && Date.now() >= startedAt.getTime() + timeoutMs) {
+        await withPostgresTransaction(this.db, async (db) => {
+          const freshRun = await this.getRun({ runId: run.id, resourceId: run.resourceId ?? undefined }, { exclusiveLock: true, db });
+          return this.updateRun({
+            runId: run.id,
+            resourceId: run.resourceId ?? undefined,
+            data: {
+              currentStepId: stepId,
+              timeline: merge(freshRun.timeline, {
+                [stepId]: { output: {}, timedOut: true, timestamp: new Date }
+              })
+            }
+          }, { db });
+        }, this.pool);
+        return { timedOut: true };
+      }
+      result = false;
+    }
+    if (result !== false) {
+      await withPostgresTransaction(this.db, async (db) => {
+        const freshRun = await this.getRun({ runId: run.id, resourceId: run.resourceId ?? undefined }, { exclusiveLock: true, db });
+        return this.updateRun({
+          runId: run.id,
+          resourceId: run.resourceId ?? undefined,
+          data: {
+            currentStepId: stepId,
+            timeline: merge(freshRun.timeline, {
+              [stepId]: { output: result, timestamp: new Date }
+            })
+          }
+        }, { db });
+      }, this.pool);
+      return { timedOut: false, data: result };
+    }
+    const pollEvent = `__poll_${stepId}`;
+    await withPostgresTransaction(this.db, async (db) => {
+      const freshRun = await this.getRun({ runId: run.id, resourceId: run.resourceId ?? undefined }, { exclusiveLock: true, db });
+      return this.updateRun({
         runId: run.id,
         resourceId: run.resourceId ?? undefined,
         data: {
+          status: "paused" /* PAUSED */,
           currentStepId: stepId,
-          timeline: merge(persistedRun.timeline, {
-            [stepId]: { output: {}, timedOut: true, timestamp: new Date }
+          pausedAt: new Date,
+          timeline: merge(freshRun.timeline, {
+            [`${stepId}-poll`]: { startedAt: startedAt.toISOString() },
+            [`${stepId}-wait-for`]: {
+              waitFor: { timeoutEvent: pollEvent, skipOutput: true },
+              timestamp: new Date
+            }
           })
         }
+      }, { db });
+    }, this.pool);
+    try {
+      await this.boss.send(WORKFLOW_RUN_QUEUE_NAME, {
+        runId: run.id,
+        resourceId: run.resourceId ?? undefined,
+        workflowId: run.workflowId,
+        input: run.input,
+        event: { name: pollEvent, data: {} }
+      }, {
+        startAfter: new Date(Date.now() + intervalMs),
+        expireInSeconds: defaultExpireInSeconds
       });
-      return { timedOut: true };
-    }
-    const result = await conditionFn();
-    if (result !== false) {
+    } catch (error) {
       await this.updateRun({
         runId: run.id,
         resourceId: run.resourceId ?? undefined,
-        data: {
-          currentStepId: stepId,
-          timeline: merge(persistedRun.timeline, {
-            [stepId]: { output: result, timestamp: new Date }
-          })
-        }
+        data: { status: "running" /* RUNNING */, pausedAt: null }
       });
-      return { timedOut: false, data: result };
+      throw error;
     }
-    const pollEvent = `__poll_${stepId}`;
-    await this.updateRun({
-      runId: run.id,
-      resourceId: run.resourceId ?? undefined,
-      data: {
-        status: "paused" /* PAUSED */,
-        currentStepId: stepId,
-        pausedAt: new Date,
-        timeline: merge(persistedRun.timeline, {
-          [`${stepId}-poll`]: { startedAt: startedAt.toISOString() },
-          [`${stepId}-wait-for`]: {
-            waitFor: { timeoutEvent: pollEvent, skipOutput: true },
-            timestamp: new Date
-          }
-        })
-      }
-    });
-    await this.boss.send(WORKFLOW_RUN_QUEUE_NAME, {
-      runId: run.id,
-      resourceId: run.resourceId ?? undefined,
-      workflowId: run.workflowId,
-      input: run.input,
-      event: { name: pollEvent, data: {} }
-    }, {
-      startAfter: new Date(Date.now() + intervalMs),
-      expireInSeconds: defaultExpireInSeconds
-    });
     this.logger.log(`Step ${stepId} polling every ${intervalMs}ms...`, {
       runId: run.id,
       workflowId: run.workflowId
@@ -1286,5 +1356,5 @@ export {
   StepType
 };
 
-//# debugId=3C42BBABB5FBDC4364756E2164756E21
+//# debugId=0EF998205E7ED0B464756E2164756E21
 //# sourceMappingURL=index.js.map