@voyantjs/workflows-orchestrator-node 0.107.5 → 0.107.6

package/src/node-selfhost-deps.ts

@@ -0,0 +1,495 @@
+import { createServer } from "node:http"
+import { resolve as resolvePath } from "node:path"
+import { handleStepRequest } from "@voyantjs/workflows/handler"
+import { createInMemoryRateLimiter } from "@voyantjs/workflows/rate-limit"
+import {
+  createInMemoryRunStore,
+  type RunRecord,
+  resume,
+  resumeDueAlarms,
+  type StepHandler,
+  trigger,
+} from "@voyantjs/workflows-orchestrator"
+import { createChunkBus } from "./dashboard-chunks.js"
+import { startServer } from "./dashboard-http-server.js"
+import { renderMetrics } from "./dashboard-metrics.js"
+import {
+  assertReadableDirectory,
+  assertReadableFile,
+  findDashboardDir,
+} from "./dashboard-static.js"
+import type {
+  HealthReport,
+  NodeSelfHostServerOptions,
+  ServeDeps,
+  ServeHandle,
+} from "./dashboard-types.js"
+import { loadEntryFile } from "./entry-loader.js"
+import { durationToMs, generateLocalRunId } from "./local-runtime.js"
+import { createDefaultWakeupLeaseOwner, localTenantMeta } from "./node-selfhost-defaults.js"
+import {
+  mergeTags,
+  requireExternalResumeFromStep,
+  requireExternalSeedResults,
+} from "./node-selfhost-resume-input.js"
+import { nodeStepRunner } from "./node-step-runner.js"
+import { createPersistentWakeupManager } from "./persistent-wakeup-manager.js"
+import { createPostgresConnection } from "./postgres.js"
+import { createPostgresSnapshotRunStore } from "./postgres-snapshot-run-store.js"
+import { createPostgresWakeupStore } from "./postgres-wakeup-store.js"
+import { buildResumeJournal, buildSeededResumeJournal } from "./resume-run.js"
+import { recordToSnapshot, snapshotToRecord } from "./run-record-snapshot.js"
+import { createScheduler, type SchedulerHandle, type ScheduleSource } from "./scheduler.js"
+import { createFsSnapshotRunStore, type StoredRun } from "./snapshot-run-store.js"
+import { createFsWakeupStore } from "./wakeup-store.js"
+
+type WorkflowRegistryModule = Pick<
+  typeof import("@voyantjs/workflows"),
+  "__resetRegistry" | "__listRegisteredWorkflows"
+>
+
+export async function startNodeSelfHostServer(
+  opts: NodeSelfHostServerOptions,
+): Promise<ServeHandle> {
+  const deps = await createNodeSelfHostDeps(opts)
+  return startServer(
+    {
+      port: opts.port ?? 3232,
+      host: opts.host ?? "127.0.0.1",
+    },
+    deps,
+  )
+}
+
+export async function createNodeSelfHostDeps(
+  opts: Pick<
+    NodeSelfHostServerOptions,
+    | "entryFile"
+    | "staticDir"
+    | "cacheBustEntry"
+    | "services"
+    | "store"
+    | "databaseUrl"
+    | "wakeupPollIntervalMs"
+    | "wakeupLeaseMs"
+    | "wakeupLeaseOwner"
+  >,
+): Promise<ServeDeps> {
+  let staticDir = opts.staticDir
+  if (!staticDir) staticDir = await findDashboardDir(process.cwd())
+  if (!staticDir && typeof import.meta.url === "string") {
+    const here = resolvePath(new URL(".", import.meta.url).pathname)
+    staticDir = await findDashboardDir(here)
+  }
+  if (staticDir) {
+    await assertReadableDirectory(staticDir, "dashboard static dir")
+  }
+
+  const databaseUrl = opts.databaseUrl ?? process.env.DATABASE_URL
+  const pg = databaseUrl ? createPostgresConnection({ databaseUrl }) : undefined
+  const store =
+    opts.store ?? (pg ? createPostgresSnapshotRunStore({ db: pg.db }) : createFsSnapshotRunStore())
+  const wfMod: WorkflowRegistryModule = await import("@voyantjs/workflows")
+  wfMod.__resetRegistry()
+
+  const entryAbs = resolvePath(process.cwd(), opts.entryFile)
+  await assertReadableFile(entryAbs, "workflow entry")
+  await loadEntryFile(entryAbs, { cacheBust: opts.cacheBustEntry })
+
+  const _handlerMod = await import("@voyantjs/workflows/handler")
+  const rateLimiter = createInMemoryRateLimiter()
+  const chunkBus = createChunkBus()
+
+  const stepHandler: StepHandler = async (req, stepOpts) =>
+    handleStepRequest(req, { rateLimiter, nodeStepRunner, services: opts.services }, stepOpts)
+
+  const wakeupStore = pg ? createPostgresWakeupStore({ db: pg.db }) : createFsWakeupStore()
+  const leaseOwner = opts.wakeupLeaseOwner ?? createDefaultWakeupLeaseOwner()
+
+  const listWorkflows = () =>
+    wfMod.__listRegisteredWorkflows().map((workflow) => ({
+      id: workflow.id,
+      description: workflow.config.description,
+    }))
+  const registeredWorkflows = listWorkflows()
+  if (registeredWorkflows.length === 0) {
+    throw new Error(
+      "voyant workflows selfhost: workflow entry registered no workflows. " +
+        `Check "${entryAbs}" and ensure it calls workflow(...).`,
+    )
+  }
+
+  const healthCheck = (): HealthReport => ({
+    ok: true,
+    service: "voyant-workflows-selfhost",
+  })
+
+  const readinessCheck = async (): Promise<HealthReport> => {
+    const checks: Record<string, "ok" | "error"> = {
+      workflowEntry: "ok",
+    }
+    const details: Record<string, unknown> = {}
+
+    if (pg) {
+      try {
+        await pg.pool.query("select 1")
+        checks.database = "ok"
+      } catch (err) {
+        checks.database = "error"
+        details.database = err instanceof Error ? err.message : String(err)
+      }
+    }
+
+    return {
+      ok: Object.values(checks).every((status) => status === "ok"),
+      service: "voyant-workflows-selfhost",
+      checks,
+      details: Object.keys(details).length > 0 ? details : undefined,
+    }
+  }
+
+  const collectMetrics = async (): Promise<string> => {
+    const runs = await store.list()
+    const wakeups = await wakeupStore.list()
+    const runsByStatus = runs.reduce<Record<string, number>>((acc, run) => {
+      acc[run.status] = (acc[run.status] ?? 0) + 1
+      return acc
+    }, {})
+    return renderMetrics({
+      workflowsRegistered: listWorkflows().length,
+      schedulesRegistered: listSchedules ? listSchedules().length : 0,
+      runsTotal: runs.length,
+      wakeupsTotal: wakeups.length,
+      runsByStatus,
+      generatedAtMs: Date.now(),
+    })
+  }
+
+  const wakeupManager = createPersistentWakeupManager({
+    wakeupStore,
+    listRuns: () => store.list(),
+    getRun: (runId) => store.get(runId),
+    saveRun: async (stored) => {
+      if (!store.update) {
+        throw new Error("snapshot run store does not support update")
+      }
+      return store.update(stored)
+    },
+    toRecord: (stored) => snapshotToRecord(stored),
+    fromRecord: (record, base) => recordToSnapshot(record, base),
+    handler: stepHandler,
+    onStreamChunk: ({ runId, chunk }) => chunkBus.publish({ runId, chunk }),
+    logger: (level, message, data) => {
+      const error =
+        typeof data === "object" && data !== null && "error" in data ? data.error : undefined
+      const details = error ? `: ${String(error)}` : ""
+      if (level === "error") console.error(`[voyant] ${message}${details}`)
+      else console.warn(`[voyant] ${message}${details}`)
+    },
+    createRunStore: createInMemoryRunStore,
+    resumeDueAlarmsImpl: resumeDueAlarms,
+    leaseOwner,
+    intervalMs: opts.wakeupPollIntervalMs,
+    leaseMs: opts.wakeupLeaseMs,
+  })
+
+  const cancelRun: ServeDeps["cancelRun"] = async ({ runId }) => {
+    const existing = await store.get(runId)
+    if (!existing) return { ok: false, message: `run "${runId}" not found`, exitCode: 1 }
+    if (existing.status !== "waiting") {
+      return {
+        ok: false,
+        message: `run "${runId}" is not parked (status: ${existing.status})`,
+        exitCode: 2,
+      }
+    }
+    if (!store.update) {
+      return { ok: false, message: "snapshot run store does not support update", exitCode: 1 }
+    }
+    const now = Date.now()
+    const updated: StoredRun = {
+      ...existing,
+      status: "cancelled",
+      completedAt: now,
+      durationMs: now - existing.startedAt,
+      result: {
+        ...existing.result,
+        status: "cancelled",
+        cancelledAt: now,
+      },
+    }
+    const saved = await store.update(updated)
+    await wakeupManager.clear(runId)
+    return { ok: true, saved }
+  }
+
+  const triggerRun: ServeDeps["triggerRun"] = async ({
+    workflowId,
+    input,
+    runId,
+    tags,
+    triggeredByUserId,
+  }) => {
+    const workflow = wfMod.__listRegisteredWorkflows().find((entry) => entry.id === workflowId)
+    if (!workflow) {
+      return {
+        ok: false,
+        message: `workflow "${workflowId}" is not registered in ${entryAbs}.`,
+        exitCode: 2,
+      }
+    }
+    const nextRunId = runId ?? generateLocalRunId()
+    const memStore = createInMemoryRunStore()
+    let record: RunRecord
+    try {
+      record = await trigger(
+        {
+          runId: nextRunId,
+          workflowId,
+          workflowVersion: "local",
+          input,
+          tenantMeta: localTenantMeta,
+          tags,
+          triggeredBy:
+            triggeredByUserId === undefined || triggeredByUserId === null
+              ? { kind: "api" }
+              : { kind: "api", actor: triggeredByUserId },
+          timeoutMs: durationToMs(workflow.config.timeout),
+        },
+        {
+          store: memStore,
+          handler: stepHandler,
+          onStreamChunk: (chunk) => chunkBus.publish({ runId: nextRunId, chunk }),
+        },
+      )
+    } catch (err) {
+      return {
+        ok: false,
+        message: err instanceof Error ? err.message : String(err),
+        exitCode: 1,
+      }
+    }
+    if (!store.update) {
+      return { ok: false, message: "snapshot run store does not support update", exitCode: 1 }
+    }
+    const stored = recordToSnapshot(record)
+    stored.entryFile = entryAbs
+    const saved = await store.update(stored)
+    await wakeupManager.syncStoredRun(saved)
+    return { ok: true, saved }
+  }
+
+  const resumeRun: ServeDeps["resumeRun"] = async ({
+    parentRunId,
+    workflowId: requestedWorkflowId,
+    input,
+    resumeFromStep,
+    seedResults,
+    runId,
+    tags,
+    triggeredByUserId,
+  }) => {
+    const existing = await store.get(parentRunId)
+    let parent: RunRecord | undefined
+    if (existing) {
+      try {
+        parent = snapshotToRecord(existing)
+      } catch (err) {
+        return {
+          ok: false,
+          message: err instanceof Error ? err.message : String(err),
+          exitCode: 1,
+        }
+      }
+    } else if (!requestedWorkflowId) {
+      return {
+        ok: false,
+        message:
+          `parent run "${parentRunId}" not found; pass workflowId, resumeFromStep, ` +
+          "and seedResults to resume from an external workflow-runs parent",
+        exitCode: 1,
+      }
+    }
+
+    const workflowId = parent?.workflowId ?? requestedWorkflowId!
+    const workflow = wfMod.__listRegisteredWorkflows().find((entry) => entry.id === workflowId)
+    if (!workflow) {
+      return {
+        ok: false,
+        message: `workflow "${workflowId}" is not registered in ${entryAbs}.`,
+        exitCode: 2,
+      }
+    }
+
+    let resumeSeed: ReturnType<typeof buildResumeJournal>
+    try {
+      resumeSeed = parent
+        ? buildResumeJournal({
+            parent,
+            resumeFromStep,
+            seedResults,
+          })
+        : buildSeededResumeJournal({
+            parentRunId,
+            resumeFromStep: requireExternalResumeFromStep(resumeFromStep),
+            seedResults: requireExternalSeedResults(seedResults),
+          })
+    } catch (err) {
+      return {
+        ok: false,
+        message: err instanceof Error ? err.message : String(err),
+        exitCode: 2,
+      }
+    }
+
+    const memStore = createInMemoryRunStore()
+    const nextRunId = runId ?? generateLocalRunId()
+    let record: RunRecord
+    try {
+      record = await trigger(
+        {
+          runId: nextRunId,
+          workflowId,
+          workflowVersion: parent?.workflowVersion ?? "local",
+          input: input === undefined ? parent?.input : input,
+          tenantMeta: parent?.tenantMeta ?? localTenantMeta,
+          environment: parent?.environment,
+          triggeredBy:
+            triggeredByUserId === undefined || triggeredByUserId === null
+              ? { kind: "api" }
+              : { kind: "api", actor: triggeredByUserId },
+          tags: mergeTags(parent?.tags, [
+            "resume:true",
+            `parentRunId:${parent?.id ?? parentRunId}`,
+            ...(tags ?? []),
+          ]),
+          timeoutMs: durationToMs(workflow.config.timeout),
+          initialJournal: resumeSeed.journal,
+          initialMetadataAppliedCount: resumeSeed.metadataAppliedCount,
+        },
+        {
+          store: memStore,
+          handler: stepHandler,
+          onStreamChunk: (chunk) => chunkBus.publish({ runId: nextRunId, chunk }),
+        },
+      )
+    } catch (err) {
+      return {
+        ok: false,
+        message: err instanceof Error ? err.message : String(err),
+        exitCode: 1,
+      }
+    }
+
+    if (!store.update) {
+      return { ok: false, message: "snapshot run store does not support update", exitCode: 1 }
+    }
+    const stored = recordToSnapshot(record, {
+      entryFile: entryAbs,
+      replayOf: parent?.id ?? parentRunId,
+    })
+    const saved = await store.update(stored)
+    await wakeupManager.syncStoredRun(saved)
+    return {
+      ok: true,
+      saved,
+      parentRunId: parent?.id ?? parentRunId,
+      resumeFromStep: resumeSeed.resumeFromStep,
+    }
+  }
+
+  const injectWaitpoint: ServeDeps["injectWaitpoint"] = async ({ runId, injection }) => {
+    const existing = await store.get(runId)
+    if (!existing) {
+      return { ok: false, message: `run "${runId}" not found`, exitCode: 1 }
+    }
+    if (existing.status !== "waiting") {
+      return {
+        ok: false,
+        message: `run "${runId}" is not parked (status: ${existing.status})`,
+        exitCode: 2,
+      }
+    }
+    const record = snapshotToRecord(existing)
+    if (!record) {
+      return { ok: false, message: `run "${runId}" has no resumable snapshot`, exitCode: 1 }
+    }
+    const memStore = createInMemoryRunStore()
+    await memStore.save(record)
+    const out = await resume(
+      { runId, injection },
+      {
+        store: memStore,
+        handler: stepHandler,
+        onStreamChunk: (chunk) => chunkBus.publish({ runId, chunk }),
+      },
+    )
+    if (!out.ok) {
+      const exitCode = out.status === "no_match" || out.status === "not_parked" ? 2 : 1
+      return { ok: false, message: out.message, exitCode }
+    }
+    if (!store.update) {
+      return { ok: false, message: "snapshot run store does not support update", exitCode: 1 }
+    }
+    const saved = await store.update(recordToSnapshot(out.record, existing))
+    await wakeupManager.syncStoredRun(saved)
+    return { ok: true, saved }
+  }
+
+  try {
+    await wakeupManager.bootstrap()
+  } catch (err) {
+    console.warn(
+      `[voyant] failed to bootstrap wakeup leases from run store: ${
+        err instanceof Error ? err.message : String(err)
+      }`,
+    )
+  }
+  wakeupManager.start()
+
+  let scheduler: SchedulerHandle | undefined
+  let listSchedules: ServeDeps["listSchedules"]
+  const sources: ScheduleSource[] = []
+  for (const workflow of wfMod.__listRegisteredWorkflows()) {
+    const decl = workflow.config.schedule
+    if (!decl) continue
+    const decls = Array.isArray(decl) ? decl : [decl]
+    for (const source of decls) {
+      sources.push({ workflowId: workflow.id, decl: source })
+    }
+  }
+  if (sources.length > 0) {
+    scheduler = createScheduler({
+      sources,
+      onFire: async ({ workflowId, input }) => {
+        await triggerRun({ workflowId, input })
+      },
+      logger: (level, message) => {
+        if (level === "error") console.error(`[scheduler] ${message}`)
+        else if (level === "warn") console.warn(`[scheduler] ${message}`)
+      },
+    })
+    listSchedules = () => scheduler!.nextFirings()
+  }
+
+  return {
+    store,
+    createServer,
+    healthCheck,
+    readinessCheck,
+    collectMetrics,
+    shutdown: async () => {
+      wakeupManager.stop()
+      await pg?.close()
+    },
+    staticDir,
+    triggerRun,
+    resumeRun,
+    listWorkflows,
+    injectWaitpoint,
+    scheduler,
+    listSchedules,
+    cancelRun,
+    chunkBus,
+  }
+}

package/src/node-selfhost-resume-input.ts

@@ -0,0 +1,27 @@
+export function mergeTags(...groups: ReadonlyArray<ReadonlyArray<string> | undefined>): string[] {
+  const tags = new Set<string>()
+  for (const group of groups) {
+    for (const tag of group ?? []) tags.add(tag)
+  }
+  return Array.from(tags)
+}
+
+export function requireExternalResumeFromStep(resumeFromStep: string | undefined): string {
+  if (!resumeFromStep) {
+    throw new Error(
+      "resumeFromStep is required when the parent run is not stored by this self-host server",
+    )
+  }
+  return resumeFromStep
+}
+
+export function requireExternalSeedResults(
+  seedResults: Record<string, unknown> | undefined,
+): Record<string, unknown> {
+  if (!seedResults) {
+    throw new Error(
+      "seedResults is required when the parent run is not stored by this self-host server",
+    )
+  }
+  return seedResults
+}

package/src/node-standalone-driver.ts

@@ -1,4 +1,5 @@
 // Mode 2 driver — pure Node, Postgres-backed.
+// agent-quality: file-size exception -- Public driver factory currently owns manifest, trigger, event-ingest, schedule, and admin wiring; split only with a dedicated driver-surface refactor.
 //
 // Returns a `DriverFactory` (per architecture doc §6.3) that the framework
 // invokes after `createApp()` has assembled its `ModuleContainer`. Composes:
@@ -125,6 +126,61 @@ const DEFAULT_TENANT_META: RunRecord["tenantMeta"] = {
 
 const DEFAULT_MANIFEST_KEEP = 3
 
+function serializeWorkflowManifest(manifest: WorkflowManifest): Record<string, unknown> {
+  return { ...manifest }
+}
+
+function deserializeWorkflowManifest(manifest: Record<string, unknown>): WorkflowManifest {
+  const {
+    schemaVersion,
+    projectId,
+    versionId,
+    builtAt,
+    builderVersion,
+    capabilities,
+    workflows,
+    eventFilters,
+    bindings,
+    environments,
+  } = manifest
+
+  if (
+    schemaVersion !== 1 ||
+    typeof projectId !== "string" ||
+    typeof versionId !== "string" ||
+    typeof builtAt !== "number" ||
+    typeof builderVersion !== "string" ||
+    !isStringArray(capabilities) ||
+    !Array.isArray(workflows) ||
+    !Array.isArray(eventFilters) ||
+    !isRecord(bindings) ||
+    !isRecord(environments)
+  ) {
+    throw new Error("stored workflow manifest has an invalid shape")
+  }
+
+  return {
+    schemaVersion,
+    projectId,
+    versionId,
+    builtAt,
+    builderVersion,
+    capabilities,
+    workflows: workflows as WorkflowManifest["workflows"],
+    eventFilters: eventFilters as WorkflowManifest["eventFilters"],
+    bindings: bindings as WorkflowManifest["bindings"],
+    environments: environments as WorkflowManifest["environments"],
+  }
+}
+
+function isRecord(value: unknown): value is Record<string, unknown> {
+  return typeof value === "object" && value !== null && !Array.isArray(value)
+}
+
+function isStringArray(value: unknown): value is string[] {
+  return Array.isArray(value) && value.every((item) => typeof item === "string")
+}
+
 /**
  * Build the Mode 2 driver factory. The factory closes over its options
  * and returns a fresh `WorkflowDriver` when `createApp()` (or a test)
@@ -224,7 +280,7 @@ export function createNodeStandaloneDriver(opts: NodeStandaloneDriverOptions): D
       const result = await manifestStore.registerManifest({
         environment: args.environment as string,
         versionId: args.manifest.versionId,
-        manifest: args.manifest as unknown as Record<string, unknown>,
+        manifest: serializeWorkflowManifest(args.manifest),
       })
       // Best-effort prune; failures here shouldn't fail boot.
       try {
@@ -245,7 +301,7 @@ export function createNodeStandaloneDriver(opts: NodeStandaloneDriverOptions): D
     async function getManifest(args: { environment: string }): Promise<WorkflowManifest | null> {
       const envelope = await manifestStore.getCurrent(args.environment)
       if (!envelope) return null
-      return envelope.manifest as unknown as WorkflowManifest
+      return deserializeWorkflowManifest(envelope.manifest)
     }
 
     async function trigger<TIn, TOut>(
@@ -289,7 +345,7 @@ export function createNodeStandaloneDriver(opts: NodeStandaloneDriverOptions): D
         }
       }
       const eventId = await ensureEventId(args.envelope)
-      const manifest = stored.manifest as unknown as WorkflowManifest
+      const manifest = deserializeWorkflowManifest(stored.manifest)
       const routed = routeEvent({
         manifest,
         envelope: args.envelope,

package/src/node-step-runner.ts

@@ -0,0 +1,28 @@
+import type { StepRunner } from "@voyantjs/workflows/handler"
+
+export const nodeStepRunner: StepRunner = async ({ attempt, fn, stepCtx }) => {
+  const startedAt = Date.now()
+  try {
+    const output = await fn(stepCtx)
+    return { attempt, status: "ok", output, startedAt, finishedAt: Date.now() }
+  } catch (err) {
+    const error = err as Error
+    const code =
+      typeof (err as { code?: unknown }).code === "string"
+        ? (err as { code: string }).code
+        : "UNKNOWN"
+    return {
+      attempt,
+      status: "err",
+      error: {
+        category: "USER_ERROR",
+        code,
+        message: error?.message ?? String(err),
+        name: error?.name,
+        stack: error?.stack,
+      },
+      startedAt,
+      finishedAt: Date.now(),
+    }
+  }
+}

package/src/postgres-manifest-store.ts

@@ -131,9 +131,11 @@ export function createPostgresManifestStore(opts: PostgresManifestStoreOptions):
       if (keepIds.length === 0) return { deleted: 0 }
 
       const result = await db.execute(
+        // agent-quality: raw-sql reviewed -- owner: workflows-orchestrator-node; dynamic SQL interpolation uses Drizzle parameter binding or vetted SQL identifiers.
         sql`DELETE FROM ${workflowManifestsTable}
             WHERE environment = ${environment}
             AND version_id NOT IN (${sql.join(
+              // agent-quality: raw-sql reviewed -- owner: workflows-orchestrator-node; dynamic SQL interpolation uses Drizzle parameter binding or vetted SQL identifiers.
               keepIds.map((id) => sql`${id}`),
               sql`, `,
             )})`,

package/src/postgres-run-record-store.ts

@@ -153,7 +153,7 @@ function recordToValues(record: RunRecord) {
       completedAt: record.completedAt,
     }),
     input: normalizeJson(record.input),
-    runRecord: normalizeRequiredJson(record as unknown as Record<string, unknown>),
+    runRecord: normalizeRequiredJson({ ...record }),
     entryFile: null,
     replayOf: null,
     idempotencyKey: record.idempotencyKey ?? null,

package/src/postgres-schema.ts

@@ -52,6 +52,7 @@ export const snapshotRunsTable = pgTable(
      */
     idempotencyIdx: uniqueIndex("voyant_snapshot_runs_idempotency_idx")
       .on(table.workflowId, table.idempotencyKey)
+      // agent-quality: raw-sql reviewed -- owner: workflows-orchestrator-node; dynamic SQL interpolation uses Drizzle parameter binding or vetted SQL identifiers.
       .where(sql`${table.idempotencyKey} IS NOT NULL`),
   }),
 )
@@ -95,6 +96,7 @@ export const workflowManifestsTable = pgTable(
     pk: primaryKey({ columns: [table.environment, table.versionId] }),
     currentIdx: uniqueIndex("voyant_workflow_manifests_current_idx")
       .on(table.environment)
+      // agent-quality: raw-sql reviewed -- owner: workflows-orchestrator-node; dynamic SQL interpolation uses Drizzle parameter binding or vetted SQL identifiers.
       .where(sql`${table.isCurrent}`),
   }),
 )