@sanoma-ai/workflows 0.7.0 → 0.8.0

package/src/worker.ts

@@ -1,23 +1,22 @@
 import { DBOS, type ScheduledWorkflowFn } from "@dbos-inc/dbos-sdk";
-import { randomUUID } from "node:crypto";
 import { awaitApproval } from "./approvals.ts";
 import { buildCtx, decideStart, isInfrastructureError, startHoldOf } from "./call.ts";
 import { dbosStatusesOf } from "./client.ts";
 import { declaredWakeup, type ResolvedConfig, resolveConfig, type SanomaConfig } from "./config.ts";
 import { storedSecrets, watchCredentials } from "./credentials.ts";
-import { claimWakeup, DBOS_DATABASE_OPTIONS, lazyPool, prepareDatabase } from "./db.ts";
+import { type Db, DBOS_DATABASE_OPTIONS, lazyPool, prepareDatabase, stampVersion } from "./db.ts";
 import { deadlineRegistry, type Deadlines, idle, onOwnQueue, type SelfStop, stopWhenIdle } from "./deadlines.ts";
 import type { WorkflowDefinition } from "./define.ts";
 import { credentialsOf, unconfigured, unconfiguredSummary } from "./env.ts";
 import { errorInfo, parseOrThrow, PolicyDeniedError } from "./errors.ts";
 import { entry, ownedLedger, skipped, write, writeFailure } from "./ledger.ts";
-import { dbosLogger, quietIfSandbox, setLogLevel, warn } from "./log.ts";
+import { dbosLogger, info, quietIfSandbox, setLogLevel, warn } from "./log.ts";
 import { lineStartsOf, readSource } from "./ast.ts";
 import { callsOf, outlineWithSource } from "./outline.ts";
 import { currentRun, type Run, type RunArgs, type WorkerState, type WorkflowOutline } from "./run.ts";
 import { applyScheduled, nextScheduledFire, type ScheduledStarter, scheduledStarter } from "./schedules.ts";
 import type { Source } from "./source.ts";
-import { approverLabel, errorMessage, WORKFLOW_ACTION } from "./shared.ts";
+import { approverLabel, CHANGE_WORKFLOW, errorMessage, WORKFLOW_ACTION } from "./shared.ts";
 
 export interface Worker {
   /**
@@ -85,8 +84,8 @@ export interface WorkerOptions {
   /**
    * Given, and with a wakeup declared, the worker stops itself when idle (`stopCheckMs`); without
    * it, nobody would start another, so it never does. Called once the worker has stopped itself, with the deadline it registered with the
-   * wakeup (null for none) and that registration's generation: a supervisor starts a fresh
-   * worker on the next request or wake (`shouldWake`), since a stopped one cannot launch again.
+   * wakeup (null for none): a supervisor starts a fresh worker on the next write or wake, since a
+   * stopped one cannot launch again.
    */
   onStopped?: (stopped: SelfStop) => void;
   /**
@@ -145,6 +144,12 @@ export async function startWorker(config: SanomaConfig, options: WorkerOptions =
     secrets: storedSecrets(() => secrets.db(), "sanoma"),
     workflows: resolved.workflows,
     outlines: new Map([...resolved.workflows].map(([name, wf]) => [name, outlineOf(wf)])),
+    // `registered` is filled below, before any run starts: every name of this config's is registered then.
+    startRun: async (name, runId, args) => {
+      const fn = registered.get(name) as unknown as ((args: RunArgs) => Promise<unknown>) | undefined;
+      if (!fn) throw new Error(`The worker has no workflow "${name}" to start`);
+      return DBOS.startWorkflow(fn, { workflowID: runId })(args);
+    },
     stopped: false,
     deadlines: deadlineRegistry(),
   };
@@ -217,6 +222,8 @@ export async function startWorker(config: SanomaConfig, options: WorkerOptions =
         );
       }
     }
+    // Change runs move to the latest version only: a rollback's worker, unless promoted, leaves them be.
+    if (isLatest) await carryChangeRuns(resolved, () => secrets.db());
     await DBOS.registerQueue(resolved.queueName);
     // The schedules are the latest version's: an older worker leaves them as the newer set them.
     if (isLatest && options.schedules !== false) {
@@ -231,13 +238,10 @@ export async function startWorker(config: SanomaConfig, options: WorkerOptions =
       warn(`the policies do not hold, so every call and start is refused:\n  ${resolved.policyProblems.join("\n  ")}`);
     }
     if (wakeup && options.onStopped) {
-      const owner = randomUUID();
-      await claimWakeup(await secrets.db(), owner);
       const registerId = wakeup.type.wakeup!.register;
       stopRule = stopWhenIdle({
         // The row is one more of the runtime's tables: the secrets' pool, on the same database.
         db: () => secrets.db(),
-        owner,
         wakeup: wakeup.binding ?? wakeup.id,
         // `resolveConfig` checked the operation is the config's (`checkWakeupOps`).
         register: { op: resolved.ops.get(registerId)!, fn: resolved.drivers.get(registerId) },
@@ -286,6 +290,41 @@ function outlineOf(wf: WorkflowDefinition<any, any>): WorkflowOutline {
   return { file: outline.file, lineStarts: lineStartsOf(source!), calls: callsOf(outline.nodes) };
 }
 
+/**
+ * Takes over the unfinished change runs of other versions whose change code is this worker's,
+ * keeping each run's id, history and unread messages: a change's own deploy restarts the worker on
+ * the merged code, a new version, which DBOS would never give the run to. Each is stamped with this
+ * version (`stampVersion`), and a PENDING one queued again on the app's queue (`resumeWorkflows`);
+ * one stopped between the two is PENDING on this version, which DBOS's recovery takes. Not
+ * `rewindWorkflow`, which takes only a cancelled run and deletes its unread messages. It assumes one
+ * live worker per database, as a deploy does: an older one still running such a run runs it on
+ * until it stops. A failure is warned about, and the worker starts.
+ */
+async function carryChangeRuns({ appName, version, changeCode, queueName }: ResolvedConfig, db: () => Promise<Db>) {
+  try {
+    const runs = await DBOS.listWorkflows({
+      workflowName: CHANGE_WORKFLOW,
+      status: ["PENDING", "ENQUEUED"],
+      applicationName: appName,
+      attributes: { changeCode },
+      loadInput: false,
+      loadOutput: false,
+    });
+    const theirs = runs
+      .filter((r) => r.applicationVersion && r.applicationVersion !== version)
+      .map((r) => r.workflowID);
+    if (!theirs.length) return;
+    const carried = await stampVersion(await db(), theirs, version);
+    const pending = carried.filter((r) => r.pending).map((r) => r.id);
+    if (pending.length) await DBOS.resumeWorkflows(pending, { queueName });
+    if (carried.length) {
+      info(`carried ${carried.length} change run(s) onto version ${version}: ${carried.map((r) => r.id).join(", ")}`);
+    }
+  } catch (err) {
+    warn(`carrying the change runs of other versions onto ${version} failed, so they stay there: ${errorMessage(err)}`);
+  }
+}
+
 /**
  * Warns about unfinished runs this worker will never pick up: started on another version of
  * the app, or queued on another queue (such as the single "sanoma" queue before queues were