bazis 0.136.0 → 0.138.0

package/core/workflow/definitions_module/services/WorkflowDefinitions.service.ts

@@ -19,6 +19,7 @@ import type { CodeProcessCatalog } from "../code/CodeProcessCatalog";
 import type { OwnedCodeProcess } from "../code/codeProcesses";
 import { WORKFLOW_PROCESS_CHANGED, type ProcessChange } from "../events/Definitions.events";
 import type { DefinitionsDbContext } from "../model/Definitions.dbContext";
+import type { PublishedVersions } from "../internal/PublishedVersions";
 import { WfProcess } from "../model/WfProcess.model";
 import { WfVersion } from "../model/WfVersion.model";
 import {
@@ -52,6 +53,7 @@ export class WorkflowDefinitions extends IWorkflowDefinitions {
     private readonly events: WorkflowEvents,
     private readonly languages: WorkflowLanguages,
     private readonly references: WorkflowReferences,
+    private readonly publishedVersions: PublishedVersions,
     /** The scope: the port is asked here, so that the application's own registration replaces the default. */
     private readonly services: ServiceProvider,
   ) {
@@ -351,13 +353,21 @@ export class WorkflowDefinitions extends IWorkflowDefinitions {
   }
 
   async published(): Promise<readonly VersionDetails[]> {
-    const processes = await this.db.processes.asNoTracking().where((p) => p.archivedAt.isNull().and(p.latestVersion.isNotNull())).toList();
-    if (processes.length === 0) return [];
-    const byId = new Map(processes.map((process) => [process.id, process]));
-    const versions = await this.db.versions.asNoTracking().where((v) => v.processId.in([...byId.keys()])).toList();
-    return versions
-      .filter((version) => byId.get(version.processId)?.latestVersion === version.version)
-      .map((version) => versionOf(byId.get(version.processId)!.key, version));
+    // Without the drafts and documents: this runs on every event and every firing of a schedule.
+    const rows = await this.db.processes.asNoTracking()
+      .where((p) => p.archivedAt.isNull().and(p.latestVersion.isNotNull()))
+      .select((p) => ({ id: p.id, key: p.key, latestVersion: p.latestVersion }))
+      .toList();
+    const heads = rows.map((row) => ({ id: row.id, key: row.key, latestVersion: row.latestVersion! }));
+    return await this.publishedVersions.resolve(heads, async (missing) => {
+      const versions = await this.db.versions.asNoTracking()
+        .where((v) => v.processId.in(missing.map((head) => head.id)).and(v.version.in([...new Set(missing.map((head) => head.latestVersion))])))
+        .toList();
+      const byId = new Map(missing.map((head) => [head.id, head]));
+      return versions
+        .filter((version) => byId.get(version.processId)?.latestVersion === version.version)
+        .map((version) => versionOf(byId.get(version.processId)!.key, version));
+    });
   }
 
   async versionById(id: string): Promise<VersionDetails | undefined> {

package/core/workflow/generated/deps.ts

@@ -14,6 +14,7 @@ import { CatalogImport } from "../definitions_module/code/CatalogImport";
 import { CodeProcessCatalog } from "../definitions_module/code/CodeProcessCatalog";
 import { CodeProcessPublisher } from "../definitions_module/code/CodeProcessPublisher";
 import { ProcessesController } from "../definitions_module/http/Processes.controller";
+import { PublishedVersions } from "../definitions_module/internal/PublishedVersions";
 import { DefinitionsDbContext } from "../definitions_module/model/Definitions.dbContext";
 import { IWorkflowDefinitions } from "../definitions_module/services/IWorkflowDefinitions.service";
 import { WorkflowDefinitions } from "../definitions_module/services/WorkflowDefinitions.service";
@@ -66,7 +67,7 @@ registerFrameworkClassDeps([
   [TasksDbContext, [DbContextOptions]],
   [TimerStep, [RuntimeDbContext, WorkflowEngine]],
   [ToolStep, [RuntimeDbContext, WorkflowEngine, WorkflowTools, WorkflowReferences, WorkflowLanguages, ServiceProvider]],
-  [WorkflowDefinitions, [DefinitionsDbContext, WorkflowTools, CodeProcessCatalog, WorkflowClock, WorkflowEvents, WorkflowLanguages, WorkflowReferences, ServiceProvider]],
+  [WorkflowDefinitions, [DefinitionsDbContext, WorkflowTools, CodeProcessCatalog, WorkflowClock, WorkflowEvents, WorkflowLanguages, WorkflowReferences, PublishedVersions, ServiceProvider]],
   [WorkflowEngine, [RuntimeDbContext, IWorkflowDefinitions, GraphCache, WorkflowEvents, WorkflowClock]],
   [WorkflowEvents, [EventBus, ServiceProvider, "optional:Logger"]],
   [WorkflowLanguages, ["Config:workflow"]],

package/core/workflow/index.ts

@@ -3,11 +3,28 @@
  * with the Definitions and Runtime parts, their services, HTTP, events and
  * extension points. The document format is `bazis/library/workflow`.
  */
+import type { PermissionsOf } from "../access";
+import type { definitionsPermissions } from "./definitions_module/access/Definitions.permissions";
 import type { CodeProcess } from "./definitions_module/code/defineProcess";
+import type { runtimePermissions } from "./runtime_module/access/Runtime.permissions";
+import type { tasksPermissions } from "./tasks_module/access/Tasks.permissions";
 import "./generated/deps";
 
 export { WorkflowModule } from "./Workflow.module";
-export { defineProcess, type CodeProcess, type ProcessDefinition } from "./definitions_module/code/defineProcess";
+export {
+  defineProcess,
+  type CodeNodeConfigs,
+  type CodeProcess,
+  type CodeProcessDocument,
+  type CodeProcessNode,
+  type CodeProcessSettings,
+  type ProcessDefinition,
+  type ProcessInput,
+  type ProcessOutput,
+  type ProcessRef,
+  type ToolClass,
+  type ToolRef,
+} from "./definitions_module/code/defineProcess";
 export { WorkflowSetupError } from "./definitions_module/code/codeProcesses";
 export { WorkflowClock, SystemWorkflowClock } from "./contracts/WorkflowClock";
 export { WorkflowDefinitionsModule } from "./definitions_module/WorkflowDefinitions.module";
@@ -73,6 +90,11 @@ export { WorkflowPartitions, DefaultWorkflowPartitions, type ProcessPartition }
 export { WorkflowError, type WorkflowErrorCode } from "./contracts/WorkflowError";
 export type { WorkflowActor, WorkflowAuditOptions, WorkflowPage, WorkflowPaging, WorkflowRequest, WorkflowToolMetadata } from "./contracts/types";
 
+// The pack's own permissions: an application that imports the pack may name them in `can` and `defineRoles`.
+declare module "../access/index" {
+  interface BazisPermissions extends PermissionsOf<typeof definitionsPermissions>, PermissionsOf<typeof runtimePermissions>, PermissionsOf<typeof tasksPermissions> {}
+}
+
 // Augment the declaring file, not the "../di" re-export: re-export targets
 // depend on program file order and silently stop merging in some projects.
 declare module "../di/module/types/BazisModule" {

package/core/workflow/internal/WorkflowLanguages.ts

@@ -16,7 +16,7 @@ export class WorkflowLanguages {
   /** The best language of an `Accept-Language` header: by weight, then by order; `ru-RU` also finds `ru`. */
   of(header: string | undefined): string {
     if (header === undefined) return this.default;
-    const known = new Set([this.default, ...this.config.get("languages").split(",").map((item) => item.trim())]);
+    const known = new Set([this.default, ...this.config.get("languages")]);
     const wanted = header.split(",")
       .map((part, index) => {
         const [tag = "", ...parameters] = part.trim().split(";");

package/core/workflow/internal/http.ts

@@ -1,4 +1,4 @@
-import { IAccess, type AccessObject, type SubjectAccess } from "../../access";
+import { IAccess, type AccessObject, type SubjectAccess, type PermissionKey } from "../../access";
 import { ForbiddenError, type HttpContext } from "../../http";
 import { frameworkBadRequest } from "../../http/Errors/HttpError";
 import { ListQueryError, parseListQuery, type ListQuery, type ListQueryOptions, type ListQueryProblem } from "../../../library/jsonapi";
@@ -32,7 +32,7 @@ export function defaultLanguage(ctx: HttpContext): string {
  * right. The actor's id is the first owner id, so that `{ own: true }` means
  * the instances the subject started.
  */
-export async function callerOf(ctx: HttpContext, permission?: string, object?: AccessObject): Promise<WorkflowCaller> {
+export async function callerOf(ctx: HttpContext, permission?: PermissionKey, object?: AccessObject): Promise<WorkflowCaller> {
   const access = await ctx.services.resolve(IAccess).for(ctx);
   if (permission !== undefined && !await access.can(permission, object)) throw new ForbiddenError();
   const sub = access.subject.sub;

package/core/workflow/runtime_module/background/WorkflowWorker.ts

@@ -38,8 +38,12 @@ export class WorkflowWorker extends BackgroundService {
       try {
         const jobs = await this.jobs.claim(batchSize);
         claimed = jobs.length;
-        for (const job of jobs) {
-          if (signal.aborted) return;
+        for (const [index, job] of jobs.entries()) {
+          if (signal.aborted) {
+            // What was claimed and will not run is free for another worker at once, not in a lease.
+            await this.jobs.release(jobs.slice(index));
+            return;
+          }
           await this.jobs.run(job, signal);
         }
       } catch (error) {

package/core/workflow/runtime_module/http/Instances.controller.ts

@@ -32,7 +32,7 @@ export class InstancesController {
       language,
       ...(request.test === true ? { test: true } : {}),
     });
-    return Created(`${ctx.path}/${instance.id}`, instance);
+    return Created(instance, `${ctx.path}/${instance.id}`);
   }
 
   /** A start per element, for an action over many records (WORKFLOW-002 §5.1). */

package/core/workflow/runtime_module/internal/WorkflowJobs.ts

@@ -26,7 +26,10 @@ export class WorkflowJobs {
     private readonly report: JobFailureReport,
   ) {}
 
-  /** Takes up to `batchSize` due jobs with `FOR UPDATE SKIP LOCKED` and a lease, so instances never take one job twice. */
+  /**
+   * Takes up to `batchSize` due jobs with `FOR UPDATE SKIP LOCKED` and a lease, so
+   * instances never take one job twice. {@link run} renews the lease of each as it starts.
+   */
   async claim(batchSize: number): Promise<WfJob[]> {
     const scope = this.services.createScope();
     try {
@@ -51,7 +54,46 @@ export class WorkflowJobs {
     }
   }
 
+  /**
+   * The lease of a claimed job starts when the job does: a batch runs one job after
+   * another, and a job that waited for the ones before it longer than a lease may
+   * have been taken by another worker. `false` then: the job is not this worker's.
+   */
+  private async begin(job: WfJob): Promise<boolean> {
+    const scope = this.services.createScope();
+    try {
+      const db = scope.resolve(RuntimeDbContext);
+      const lockedUntil = new Date(scope.resolve(WorkflowClock).now().getTime() + LEASE_MS);
+      const held = job.lockedUntil;
+      const { affectedRows } = await db.jobs.asNoTracking()
+        .where((j) => j.id.eq(job.id).and(held === null ? j.lockedUntil.isNull() : j.lockedUntil.eq(held)))
+        .executeUpdate({ lockedUntil });
+      if (affectedRows === 0) return false;
+      job.lockedUntil = lockedUntil;
+      return true;
+    } finally {
+      await scope.dispose();
+    }
+  }
+
+  /** Gives back claimed jobs that will not run, a stopping worker's: they are free at once, and the claim does not count as an attempt. */
+  async release(jobs: readonly WfJob[]): Promise<void> {
+    if (jobs.length === 0) return;
+    const scope = this.services.createScope();
+    try {
+      const db = scope.resolve(RuntimeDbContext);
+      for (const job of jobs) {
+        const held = job.lockedUntil;
+        if (held === null) continue;
+        await db.jobs.asNoTracking().where((j) => j.id.eq(job.id).and(j.lockedUntil.eq(held))).executeUpdate({ lockedUntil: null, attempts: Math.max(job.attempts - 1, 0) });
+      }
+    } finally {
+      await scope.dispose();
+    }
+  }
+
   async run(job: WfJob, signal: AbortSignal): Promise<void> {
+    if (!await this.begin(job).catch((error: unknown) => { this.report("job could not begin", error, { job: job.id }); return false; })) return;
     const scope = this.services.createScope();
     try {
       switch (job.kind) {

package/core/workflow/runtime_module/model/WfHistory.model.ts

@@ -1,4 +1,4 @@
-import { Column, Entity, ForeignKey, Index, UUID } from "../../../orm";
+import { Column, Entity, ForeignKey, Index, UUID, Nullable } from "../../../orm";
 import { WfInstance } from "./WfInstance.model";
 
 export type HistoryType = "started" | "queued" | "released" | "entered" | "left" | "tool" | "assigned" | "iteration" | "called" | "returned" | "skipped" | "timer" | "event" | "error" | "retried" | "cancelled" | "timedOut" | "handler" | "completed";
@@ -11,26 +11,33 @@ export class WfHistory {
   @UUID({ version: "v7" })
   id = "";
 
+  @Nullable()
   @Column({ type: "text" })
   instanceId = "";
 
-  @Column({ type: "text", nullable: true })
+  @Nullable()
+  @Column({ type: "text" })
   tokenId: string | null = null;
 
-  @Column({ type: "text", nullable: true })
+  @Nullable()
+  @Column({ type: "text" })
   nodeId: string | null = null;
 
+  @Nullable()
   @Column({ type: "text" })
   type: HistoryType = "entered";
 
-  @Column({ type: "json", nullable: true })
+  @Nullable()
+  @Column({ type: "json" })
   data: Record<string, unknown> | null = null;
 
   /** Who did it: cancel, retry, task completion; `null` for engine steps. */
-  @Column({ type: "text", nullable: true })
+  @Nullable()
+  @Column({ type: "text" })
   actorKind: string | null = null;
 
-  @Column({ type: "text", nullable: true })
+  @Nullable()
+  @Column({ type: "text" })
   actorId: string | null = null;
 
   @Column({ type: "createdAt" })

package/core/workflow/runtime_module/model/WfInstance.model.ts

@@ -1,4 +1,4 @@
-import { Column, Entity, Index, UUID } from "../../../orm";
+import { Column, Entity, Index, UUID, Nullable } from "../../../orm";
 
 /**
  * `completed`, `cancelled` and `timedOut` are finished: retention deletes them.
@@ -23,76 +23,96 @@ export class WfInstance {
   id = "";
 
   /** The version (a Definitions row: a reference without a foreign key). */
+  @Nullable()
   @Column({ type: "text" })
   versionId = "";
 
+  @Nullable()
   @Column({ type: "text" })
   processKey = "";
 
+  @Nullable()
   @Column({ type: "integer" })
   version = 0;
 
   /** The application's scope: a space, an organization. Never interpreted. */
-  @Column({ type: "text", nullable: true })
+  @Nullable()
+  @Column({ type: "text" })
   partition: string | null = null;
 
+  @Nullable()
   @Column({ type: "text" })
   status: InstanceStatus = "running";
 
+  @Nullable()
   @Column({ type: "json" })
   input: Record<string, unknown> = {};
 
+  @Nullable()
   @Column({ type: "json" })
   vars: Record<string, unknown> = {};
 
   /** The result of every passed step by node id: `$nodes.<node>.<field>`. */
+  @Nullable()
   @Column({ type: "json" })
   nodes: Record<string, unknown> = {};
 
   /** What the process gave back: its `out` variables when it completed. */
-  @Column({ type: "json", nullable: true })
+  @Nullable()
+  @Column({ type: "json" })
   output: Record<string, unknown> | null = null;
 
   /** `$event`: the data of the event that started or last continued it. */
-  @Column({ type: "json", nullable: true })
+  @Nullable()
+  @Column({ type: "json" })
   event: unknown = null;
 
   /** `$trigger`: how it was started. */
-  @Column({ type: "json", nullable: true })
+  @Nullable()
+  @Column({ type: "json" })
   trigger: Record<string, unknown> | null = null;
 
   /** A trial run (WORKFLOW-002 §5.4, stage 5). */
+  @Nullable()
   @Column({ type: "boolean" })
   test = false;
 
   /** The instance whose `callProcess` started this one, and the waiting token there. */
   @Index()
-  @Column({ type: "text", nullable: true })
+  @Nullable()
+  @Column({ type: "text" })
   parentInstanceId: string | null = null;
 
-  @Column({ type: "text", nullable: true })
+  @Nullable()
+  @Column({ type: "text" })
   parentTokenId: string | null = null;
 
   @Index()
-  @Column({ type: "text", nullable: true })
+  @Nullable()
+  @Column({ type: "text" })
   businessKey: string | null = null;
 
+  @Nullable()
   @Column({ type: "text" })
   startedVia: StartedVia = "manual";
 
+  @Nullable()
   @Column({ type: "text" })
   startedByKind: "user" | "system" = "user";
 
+  @Nullable()
   @Column({ type: "text" })
   startedById = "";
 
   /** Why the instance failed: node, code and message. */
-  @Column({ type: "json", nullable: true })
+  @Nullable()
+  @Column({ type: "json" })
   error: { readonly node: string; readonly code: string; readonly message: string } | null = null;
 
   @Column({ type: "createdAt" })
   createdAt = new Date(0);
 
-  @Column({ type: "datetime", nullable: true })
+  @Nullable()
+  @Column({ type: "datetime" })
   endedAt: Date | null = null;
 }

package/core/workflow/runtime_module/model/WfJob.model.ts

@@ -1,4 +1,4 @@
-import { Column, Entity, ForeignKey, Index, UUID } from "../../../orm";
+import { Column, Entity, ForeignKey, Index, UUID, Nullable } from "../../../orm";
 import { WfInstance } from "./WfInstance.model";
 
 /**
@@ -24,50 +24,62 @@ export class WfJob {
   @UUID({ version: "v7" })
   id = "";
 
+  @Nullable()
   @Column({ type: "text" })
   kind: JobKind = "tool";
 
   /** `null` for `schedule`, `event` and `eventStart` jobs: the instance does not exist yet. */
   @Index()
-  @Column({ type: "text", nullable: true })
+  @Nullable()
+  @Column({ type: "text" })
   instanceId: string | null = null;
 
   @Index()
-  @Column({ type: "text", nullable: true })
+  @Nullable()
+  @Column({ type: "text" })
   tokenId: string | null = null;
 
   /** The version a `schedule` or `eventStart` job starts. */
-  @Column({ type: "text", nullable: true })
+  @Nullable()
+  @Column({ type: "text" })
   versionId: string | null = null;
 
   @Index()
+  @Nullable()
   @Column({ type: "datetime" })
   dueAt = new Date(0);
 
   /** What a job carries besides its token: the caller to tell, the process to release. */
-  @Column({ type: "json", nullable: true })
+  @Nullable()
+  @Column({ type: "json" })
   payload: unknown = null;
 
   /** Jobs with one key merge into the last: `debounce` of an event start. */
   @Index()
-  @Column({ type: "text", nullable: true })
+  @Nullable()
+  @Column({ type: "text" })
   dedupeKey: string | null = null;
 
   /** The partition and the start node of a `schedule` or `eventStart` job. */
-  @Column({ type: "text", nullable: true })
+  @Nullable()
+  @Column({ type: "text" })
   partition: string | null = null;
 
-  @Column({ type: "text", nullable: true })
+  @Nullable()
+  @Column({ type: "text" })
   nodeId: string | null = null;
 
+  @Nullable()
   @Column({ type: "integer" })
   attempts = 0;
 
   /** The worker holds the job until then; if it dies, the job becomes free again. */
-  @Column({ type: "datetime", nullable: true })
+  @Nullable()
+  @Column({ type: "datetime" })
   lockedUntil: Date | null = null;
 
-  @Column({ type: "text", nullable: true })
+  @Nullable()
+  @Column({ type: "text" })
   lastError: string | null = null;
 
   @Column({ type: "createdAt" })

package/core/workflow/runtime_module/model/WfSubscription.model.ts

@@ -1,4 +1,4 @@
-import { Column, Entity, ForeignKey, Index, UUID } from "../../../orm";
+import { Column, Entity, ForeignKey, Index, UUID, Nullable } from "../../../orm";
 import { WfInstance } from "./WfInstance.model";
 
 /** A token waiting for an event: `eventWait` or `boundaryEvent`. Matched by key and correlation. */
@@ -9,20 +9,25 @@ export class WfSubscription {
   @UUID({ version: "v7" })
   id = "";
 
+  @Nullable()
   @Column({ type: "text" })
   instanceId = "";
 
   @Index()
+  @Nullable()
   @Column({ type: "text" })
   tokenId = "";
 
+  @Nullable()
   @Column({ type: "text" })
   eventKey = "";
 
-  @Column({ type: "text", nullable: true })
+  @Nullable()
+  @Column({ type: "text" })
   correlation: string | null = null;
 
-  @Column({ type: "text", nullable: true })
+  @Nullable()
+  @Column({ type: "text" })
   partition: string | null = null;
 
   @Column({ type: "createdAt" })

package/core/workflow/runtime_module/model/WfToken.model.ts

@@ -1,4 +1,4 @@
-import { Column, Entity, ForeignKey, Index, UUID } from "../../../orm";
+import { Column, Entity, ForeignKey, Index, UUID, Nullable } from "../../../orm";
 import { WfInstance } from "./WfInstance.model";
 
 /**
@@ -16,36 +16,45 @@ export class WfToken {
   @UUID({ version: "v7" })
   id = "";
 
+  @Nullable()
   @Column({ type: "text" })
   instanceId = "";
 
+  @Nullable()
   @Column({ type: "text" })
   nodeId = "";
 
   /** The flow the token came by; `null` on a start node. */
-  @Column({ type: "text", nullable: true })
+  @Nullable()
+  @Column({ type: "text" })
   viaFlowId: string | null = null;
 
+  @Nullable()
   @Column({ type: "text" })
   status: TokenStatus = "active";
 
   /** A step's result; a loop keeps its progress here while it runs. */
-  @Column({ type: "json", nullable: true })
+  @Nullable()
+  @Column({ type: "json" })
   output: unknown = null;
 
   /** The loop token this one runs inside, with its iteration and what only the body sees: `Locals` of the engine. */
-  @Column({ type: "text", nullable: true })
+  @Nullable()
+  @Column({ type: "text" })
   parentTokenId: string | null = null;
 
-  @Column({ type: "integer", nullable: true })
+  @Nullable()
+  @Column({ type: "integer" })
   iteration: number | null = null;
 
-  @Column({ type: "json", nullable: true })
+  @Nullable()
+  @Column({ type: "json" })
   locals: Record<string, unknown> | null = null;
 
   @Column({ type: "createdAt" })
   createdAt = new Date(0);
 
-  @Column({ type: "datetime", nullable: true })
+  @Nullable()
+  @Column({ type: "datetime" })
   endedAt: Date | null = null;
 }

package/core/workflow/runtime_module/services/IWorkflowRuntime.service.ts

@@ -1,13 +1,15 @@
 import type { AccessFilter } from "../../../access";
 import type { FormIssue } from "../../../../library/workflow";
 import type { OrmTransaction } from "../../../orm";
+import type { CodeProcess } from "../../definitions_module/code/defineProcess";
 import type { WorkflowActor, WorkflowAuditOptions, WorkflowPage, WorkflowPaging } from "../../contracts/types";
 import type { HistoryType } from "../model/WfHistory.model";
 import type { InstanceStatus, StartedVia } from "../model/WfInstance.model";
 import type { TokenStatus } from "../model/WfToken.model";
 
-export interface StartInstance extends WorkflowAuditOptions {
-  readonly input?: unknown;
+export interface StartInstance<Input = unknown> extends WorkflowAuditOptions {
+  /** The `in` variables of the process. */
+  readonly input?: Input;
   /** The application's scope: a space, an organization. */
   readonly partition?: string | null;
   /** The application's own key of what the instance is about: `order:42`. */
@@ -24,14 +26,14 @@ export interface StartInstance extends WorkflowAuditOptions {
 }
 
 /** One element of a mass start. */
-export interface StartManyItem {
-  readonly input?: unknown;
+export interface StartManyItem<Input = unknown> {
+  readonly input?: Input;
   /** What the instance is about: required, it is what `sameKey` compares. */
   readonly businessKey: string;
 }
 
-export interface StartMany extends WorkflowAuditOptions {
-  readonly items: readonly StartManyItem[];
+export interface StartMany<Input = unknown> extends WorkflowAuditOptions {
+  readonly items: readonly StartManyItem<Input>[];
   readonly partition?: string | null;
   readonly actor: WorkflowActor;
   readonly language?: string;
@@ -163,8 +165,10 @@ export interface InstanceListQuery extends WorkflowPaging {
  */
 export abstract class IWorkflowRuntime {
   /** Starts the latest version of a process from its manual start. It may wait as `pending` (`maxConcurrent`, `sameKey: "queue"`). */
+  abstract start<Input>(process: CodeProcess<Input, unknown>, options: StartInstance<Input>): Promise<InstanceDetails>;
   abstract start(processKey: string, options: StartInstance): Promise<InstanceDetails>;
   /** Starts an instance per element, each in its own transaction, and says what became of each. */
+  abstract startMany<Input>(process: CodeProcess<Input, unknown>, options: StartMany<Input>): Promise<readonly StartManyResult[]>;
   abstract startMany(processKey: string, options: StartMany): Promise<readonly StartManyResult[]>;
   abstract cancel(instanceId: string, options: CancelInstance): Promise<InstanceDetails>;
   /** Retries the failed steps of a `failed` instance. An instance called by another one is retried through its caller. */

package/core/workflow/runtime_module/services/WorkflowRuntime.service.ts

@@ -1,3 +1,4 @@
+import type { CodeProcess } from "../../definitions_module/code/defineProcess";
 import { grantsToWhere } from "../../../access";
 import { paginate, type OrmTransaction } from "../../../orm";
 import { inputSpecOf, type FormSpec } from "../../../../library/workflow";
@@ -46,7 +47,8 @@ export class WorkflowRuntime extends IWorkflowRuntime {
     super();
   }
 
-  async start(processKey: string, options: StartInstance): Promise<InstanceDetails> {
+  async start(process: string | CodeProcess<unknown, unknown>, options: StartInstance): Promise<InstanceDetails> {
+    const processKey = typeof process === "string" ? process : process.key;
     actorOf(options.actor);
     const partition = optionalText(options.partition, "partition");
     const businessKey = optionalText(options.businessKey, "businessKey");
@@ -60,7 +62,8 @@ export class WorkflowRuntime extends IWorkflowRuntime {
     return await this.instance(id);
   }
 
-  async startMany(processKey: string, options: StartMany): Promise<readonly StartManyResult[]> {
+  async startMany(process: string | CodeProcess<unknown, unknown>, options: StartMany): Promise<readonly StartManyResult[]> {
+    const processKey = typeof process === "string" ? process : process.key;
     actorOf(options.actor);
     const partition = optionalText(options.partition, "partition");
     if (!Array.isArray(options.items) || options.items.length === 0 || options.items.length > MAX_START_MANY) throw new WorkflowError("invalid_input", `items must be a list of 1–${MAX_START_MANY}`);