bazis 0.133.0 → 0.135.0

package/core/workflow/internal/WorkflowReferences.ts

@@ -0,0 +1,69 @@
+import { IAccessCatalog } from "../../access";
+import type { ServiceProvider } from "../../di";
+import { documentReferences, schemaReferenceKinds, type DocumentReference, type InputReference, type ProcessDocument } from "../../../library/workflow";
+import type { WorkflowTools } from "./WorkflowTools";
+
+/** Whose references: the partition of the instance, when there is one. */
+export interface ReferenceCheckContext {
+  readonly scope: string | null;
+  readonly language: string;
+}
+
+/**
+ * Asks the owners of reference kinds (ACCESS-001 §6) about the references of
+ * processes (WORKFLOW-002 §6.3). The owners are resolved in the scope of the call.
+ */
+export class WorkflowReferences {
+  constructor(
+    private readonly catalog: IAccessCatalog,
+    private readonly tools: WorkflowTools,
+    private readonly services: ServiceProvider,
+  ) {}
+
+  /** The input schema of a Tool, in JSON Schema, if the Tool has one. */
+  inputSchemaOf(tool: string): unknown {
+    const input = this.tools.bound?.describe(tool)?.input;
+    return input?.kind === "json-schema" ? input.schema : undefined;
+  }
+
+  /** The literal references of a document. */
+  of(document: ProcessDocument): DocumentReference[] {
+    return documentReferences(document, (tool) => this.inputSchemaOf(tool));
+  }
+
+  /** Reference kinds the Tools name and no module owns: the application is built wrong. */
+  unownedToolKinds(): readonly { readonly tool: string; readonly kind: string }[] {
+    const found: { tool: string; kind: string }[] = [];
+    for (const contract of this.tools.list()) {
+      const schema = contract.input?.kind === "json-schema" ? contract.input.schema : undefined;
+      for (const kind of schemaReferenceKinds(schema)) if (!this.owned(kind)) found.push({ tool: contract.name, kind });
+    }
+    return found;
+  }
+
+  owned(kind: string): boolean {
+    return this.catalog.referenceKind(kind) !== undefined;
+  }
+
+  /** Those of `references` their owners do not know. A kind nobody owns is reported as not found. */
+  async missing<T extends InputReference>(references: readonly T[], context: ReferenceCheckContext): Promise<readonly T[]> {
+    const groups = new Map<string, T[]>();
+    for (const reference of references) {
+      const key = JSON.stringify([reference.kind, reference.within ?? null]);
+      groups.set(key, [...groups.get(key) ?? [], reference]);
+    }
+    const out: T[] = [];
+    for (const group of groups.values()) {
+      const { kind, within } = group[0]!;
+      const owner = this.catalog.referenceKind(kind);
+      if (owner === undefined) {
+        out.push(...group);
+        continue;
+      }
+      const ids = [...new Set(group.map((reference) => reference.id))];
+      const known = await this.services.resolve(owner.type).exists(ids, { scope: context.scope, language: context.language, ...(within === undefined ? {} : { within }) });
+      out.push(...group.filter((reference) => !known.has(reference.id)));
+    }
+    return out;
+  }
+}

package/core/workflow/runtime_module/WorkflowRuntime.module.ts

@@ -1,6 +1,7 @@
 import { AccessModule } from "../../access";
 import { Module, scoped, singleton } from "../../di";
 import { DefaultWorkflowInputValidator, WorkflowInputValidator } from "../contracts/WorkflowInputValidator";
+import { WorkflowProcessUsage } from "../contracts/WorkflowProcessUsage";
 import { WorkflowDefinitionsModule } from "../definitions_module/WorkflowDefinitions.module";
 import { runtimePermissions } from "./access/Runtime.permissions";
 import { WorkflowRetention } from "./background/WorkflowRetention";
@@ -8,8 +9,10 @@ import { WorkflowWorker } from "./background/WorkflowWorker";
 import { EventsController } from "./http/Events.controller";
 import { InstancesController } from "./http/Instances.controller";
 import { ChildCalls } from "./internal/ChildCalls";
+import { EventDelivery } from "./internal/EventDelivery";
 import { GraphCache } from "./internal/GraphCache";
 import { RunLimits } from "./internal/RunLimits";
+import { RuntimeProcessUsage } from "./internal/RuntimeProcessUsage";
 import { Schedules } from "./internal/Schedules";
 import { TimerStep } from "./internal/TimerStep";
 import { ToolStep } from "./internal/ToolStep";
@@ -35,6 +38,8 @@ import { WorkflowRuntime } from "./services/WorkflowRuntime.service";
     scoped(Schedules),
     scoped(ChildCalls),
     scoped(RunLimits),
+    scoped(EventDelivery),
+    scoped(WorkflowProcessUsage, RuntimeProcessUsage),
     singleton(WorkflowInputValidator, DefaultWorkflowInputValidator),
     scoped(IWorkflowRuntime, WorkflowRuntime),
   ],

package/core/workflow/runtime_module/access/Runtime.permissions.ts

@@ -14,7 +14,7 @@ export const runtimePermissions = definePermissions({
   "workflow.instances.read": {
     title: { en: "See instances", ru: "Видеть экземпляры" },
     scope: { column: "partition" },
-    on: { process, folder },
+    on: { process, folder, test: { type: "boolean" } },
     owner: "startedById",
   },
   "workflow.instances.manage": {

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

@@ -4,7 +4,9 @@ import { EventBus, type ConfigView } from "../../../kernel";
 import { WorkflowClock } from "../../contracts/WorkflowClock";
 import { IWorkflowDefinitions } from "../../definitions_module/services/IWorkflowDefinitions.service";
 import { WORKFLOW_INSTANCES_DELETED } from "../events/Runtime.events";
+import type { EntityQuery } from "../../../orm";
 import { RuntimeDbContext } from "../model/Runtime.dbContext";
+import type { WfInstance } from "../model/WfInstance.model";
 import type { WorkflowSettings } from "../../contracts/Workflow.config";
 
 const DAY_MS = 86_400_000;
@@ -13,6 +15,7 @@ const DAY_MS = 86_400_000;
  * Deletes `completed`, `cancelled` and `timedOut` instances older than their process's
  * `retentionDays`, with tokens, jobs, subscriptions and history (by cascade),
  * `retention.batchSize` at a time. `failed` instances wait for a person and stay.
+ * Trial runs are gone after a day, whatever their status and process.
  * Each deleted batch is published as `WORKFLOW_INSTANCES_DELETED`, so parts
  * with their own data (tasks) drop theirs.
  */
@@ -47,22 +50,23 @@ export class WorkflowRetention extends BackgroundService {
       const definitions = scope.resolve(IWorkflowDefinitions);
       const db = scope.resolve(RuntimeDbContext);
       const now = scope.resolve(WorkflowClock).now().getTime();
-      for (const policy of await definitions.retentionPolicies()) {
-        const cutoff = new Date(now - policy.retentionDays * DAY_MS);
+      const drop = async (select: () => EntityQuery<WfInstance>): Promise<boolean> => {
         for (;;) {
-          if (signal?.aborted) return deleted;
-          const ids = (await db.instances.asNoTracking()
-            .where((i) => i.processKey.eq(policy.key).and(i.status.in(["completed", "cancelled", "timedOut"])).and(i.endedAt.lt(cutoff)))
-            .orderBy((i) => i.id)
-            .take(batchSize)
-            .select((i) => ({ id: i.id }))
-            .toList()).map((row) => row.id);
-          if (ids.length === 0) break;
+          if (signal?.aborted) return false;
+          const ids = (await select().orderBy((i) => i.id).take(batchSize).select((i) => ({ id: i.id })).toList()).map((row) => row.id);
+          if (ids.length === 0) return true;
           await db.instances.asNoTracking().where((i) => i.id.in(ids)).executeDelete();
           deleted += ids.length;
           await scope.resolve(EventBus).publishScoped(scope, WORKFLOW_INSTANCES_DELETED, { instanceIds: ids });
-          if (ids.length < batchSize) break;
+          if (ids.length < batchSize) return true;
         }
+      };
+      const dayAgo = new Date(now - DAY_MS);
+      if (!await drop(() => db.instances.asNoTracking().where((i) => i.test.eq(true).and(i.createdAt.lt(dayAgo))))) return deleted;
+      for (const policy of await definitions.retentionPolicies()) {
+        const cutoff = new Date(now - policy.retentionDays * DAY_MS);
+        const kept = await drop(() => db.instances.asNoTracking().where((i) => i.processKey.eq(policy.key).and(i.status.in(["completed", "cancelled", "timedOut"])).and(i.endedAt.lt(cutoff))));
+        if (!kept) return deleted;
       }
     } finally {
       await scope.dispose();

package/core/workflow/runtime_module/events/Runtime.events.ts

@@ -68,3 +68,10 @@ export const WORKFLOW_INSTANCES_DELETED = createEventToken<WorkflowInstancesDele
 export const WORKFLOW_INSTANCE_STARTED = createEventToken<WorkflowInstanceStarted>("workflow.instance-started");
 export const WORKFLOW_INSTANCE_CANCELLED = createEventToken<WorkflowInstanceCancelled>("workflow.instance-cancelled");
 export const WORKFLOW_INSTANCE_RETRIED = createEventToken<WorkflowInstanceRetried>("workflow.instance-retried");
+
+/**
+ * Only for the part with the tasks: a trial run publishes nothing to the
+ * application, but its tasks still come and go (WORKFLOW-002 §5.4).
+ */
+export const WORKFLOW_TRIAL_TASK_REQUESTED = createEventToken<WorkflowTaskRequested>("workflow.trial-task-requested");
+export const WORKFLOW_TRIAL_TOKEN_CLOSED = createEventToken<WorkflowTokenClosed>("workflow.trial-token-closed");

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

@@ -2,6 +2,7 @@ import { contextOnlyController } from "../../../http/Routing/contextOnlyControll
 import { can, type AccessObject } from "../../../access";
 import { Authorize, Controller, Created, Get, Post, type HttpContext } from "../../../http";
 import { buildListDocument } from "../../../../library/jsonapi";
+import { WorkflowError } from "../../contracts/WorkflowError";
 import { body, callerOf, filterOf, listQuery, optionalString, pagingOfList, param, requiredString } from "../../internal/http";
 import type { InstanceStatus } from "../model/WfInstance.model";
 import { IWorkflowDefinitions } from "../../definitions_module/services/IWorkflowDefinitions.service";
@@ -29,6 +30,7 @@ export class InstancesController {
       actor,
       request: from,
       language,
+      ...(request.test === true ? { test: true } : {}),
     });
     return Created(`${ctx.path}/${instance.id}`, instance);
   }
@@ -49,9 +51,11 @@ export class InstancesController {
   async list(ctx: HttpContext) {
     const { access } = await callerOf(ctx);
     const list = listQuery(ctx, {
-      filter: { partition: ["eq"], processKey: ["eq"], status: ["eq"], businessKey: ["eq"], startedById: ["eq"], parentInstanceId: ["eq"] },
+      filter: { partition: ["eq"], processKey: ["eq"], status: ["eq"], businessKey: ["eq"], startedById: ["eq"], parentInstanceId: ["eq"], test: ["eq"] },
       sort: ["createdAt", "endedAt", "status", "processKey"],
     });
+    const test = filterOf(list, "test");
+    if (test !== undefined && test !== "true" && test !== "false") throw new WorkflowError("invalid_input", "test must be true or false");
     const page = await this.runtime.instances({
       ...pagingOfList(list),
       access: await access.filter("workflow.instances.read"),
@@ -61,6 +65,7 @@ export class InstancesController {
       businessKey: filterOf(list, "businessKey"),
       startedById: filterOf(list, "startedById"),
       parentInstanceId: filterOf(list, "parentInstanceId"),
+      ...(test === undefined ? {} : { test: test === "true" }),
     });
     return buildListDocument(page.items, list, page.total, { basePath: ctx.path });
   }
@@ -100,7 +105,7 @@ export class InstancesController {
 
   /** The instance as the object of a permission. */
   private async objectOf(instance: InstanceSummary): Promise<AccessObject> {
-    return { scope: instance.partition, process: instance.processKey, folder: await this.definitions.folderOf(instance.processKey), startedById: instance.startedBy.id };
+    return { scope: instance.partition, process: instance.processKey, folder: await this.definitions.folderOf(instance.processKey), startedById: instance.startedBy.id, test: instance.test };
   }
 }
 contextOnlyController(InstancesController);

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

@@ -108,6 +108,7 @@ export class ChildCalls {
       const current = step.tokens.find((t) => t.id === token.id);
       if (current?.status !== "waiting" || step.instance.status !== "running") return;
       const { id } = await this.engine.begin(childGraph, start[0], {
+        test: instance.test,
         input: value,
         partition: step.instance.partition,
         businessKey: null,

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

@@ -0,0 +1,234 @@
+import { createHash } from "node:crypto";
+import { durationMs, evaluateExpression, inputSpecOf, isTruthy, type Expr, type FormIssue, type InstanceData, type ProcessNode } from "../../../../library/workflow";
+import { LOGGER } from "../../../kernel";
+import type { ServiceProvider } from "../../../di";
+import { isUuid, type WorkflowActor, type WorkflowRequest } from "../../contracts/types";
+import { WorkflowError } from "../../contracts/WorkflowError";
+import { WorkflowInputValidator } from "../../contracts/WorkflowInputValidator";
+import { WorkflowPartitions } from "../../contracts/WorkflowPartitions";
+import type { IWorkflowDefinitions, VersionDetails } from "../../definitions_module/services/IWorkflowDefinitions.service";
+import { canonicalJson } from "../../internal/canonicalJson";
+import type { WorkflowLanguages } from "../../internal/WorkflowLanguages";
+import type { RuntimeDbContext } from "../model/Runtime.dbContext";
+import { WfJob } from "../model/WfJob.model";
+import type { EmitCause, EmitResult } from "../services/IWorkflowRuntime.service";
+import type { WorkflowEngine } from "./WorkflowEngine";
+
+/** An event on its way: what `emit` got, with the defaults in place. */
+export interface EventMessage {
+  readonly eventKey: string;
+  readonly payload: Record<string, unknown>;
+  readonly correlation: string | null;
+  readonly partition: string | null;
+  readonly actor: WorkflowActor;
+  readonly request: WorkflowRequest | null;
+  readonly cause: EmitCause | null;
+}
+
+interface EventStartConfig {
+  readonly filter?: Expr;
+  readonly debounce?: { readonly key: Expr; readonly window: string };
+  readonly delay?: string;
+  readonly ignoreOwn?: boolean;
+}
+
+/** A process the event is to start, with its checked input. */
+interface PlannedStart {
+  readonly version: VersionDetails;
+  readonly nodeId: string;
+  readonly config: EventStartConfig;
+  readonly input: Record<string, unknown>;
+}
+
+/**
+ * Takes an event to whoever waits for it and to the processes it starts
+ * (WORKFLOW-002 §5.1, §5.2). An `event` job (`emitLater`) turns into an
+ * `eventStart` job per process in one transaction, and each of those starts its
+ * instance in one transaction with its own removal: a repeat after a crash starts
+ * nothing twice. Waits are safe as they are: a subscription leaves with its step.
+ */
+export class EventDelivery {
+  constructor(
+    private readonly db: RuntimeDbContext,
+    private readonly engine: WorkflowEngine,
+    private readonly definitions: IWorkflowDefinitions,
+    private readonly languages: WorkflowLanguages,
+    /** The scope: the application's own ports replace the defaults. */
+    private readonly services: ServiceProvider,
+  ) {}
+
+  /** Moves the waits and starts the processes, now or, under `debounce` and `delay`, by a job. */
+  async emit(message: EventMessage): Promise<EmitResult> {
+    const continued = await this.continueWaits(message);
+    const { planned, rejected } = await this.plan(message);
+    const started: string[] = [];
+    const skipped: { processKey: string; instanceId: string }[] = [];
+    const deferred: { processKey: string }[] = [];
+    for (const start of planned) {
+      if (start.config.debounce !== undefined || start.config.delay !== undefined) {
+        await this.defer(start, message);
+        deferred.push({ processKey: start.version.key });
+        continue;
+      }
+      const begun = await this.begin(start.version, start.nodeId, start.input, message);
+      if (begun.skipped) skipped.push({ processKey: start.version.key, instanceId: begun.id });
+      else started.push(begun.id);
+    }
+    return { started, skipped, deferred, continued, rejected };
+  }
+
+  /** An `event` job: the waits move, and the job becomes an `eventStart` job per process it starts. */
+  async deliverLater(job: WfJob): Promise<void> {
+    const message = job.payload as EventMessage;
+    await this.continueWaits(message);
+    const { planned, rejected } = await this.plan(message);
+    for (const { processKey, issues } of rejected) this.services.tryResolve(LOGGER)?.warn("workflow event did not start a process", { event: message.eventKey, processKey, issues });
+    await this.db.transactionScope(async () => {
+      await this.db.jobs.asNoTracking().where((j) => j.id.eq(job.id)).executeDelete();
+      for (const start of planned) await this.defer(start, message);
+    });
+  }
+
+  /** An `eventStart` job: its instance starts together with the removal of the job. An archived process takes nothing. */
+  async startLater(job: WfJob): Promise<void> {
+    const { message, input } = job.payload as { readonly message: EventMessage; readonly input: Record<string, unknown> };
+    const version = job.versionId === null ? undefined : await this.definitions.versionById(job.versionId);
+    if (version === undefined || job.nodeId === null || !await this.available(version.key)) {
+      await this.db.jobs.asNoTracking().where((j) => j.id.eq(job.id)).executeDelete();
+      return;
+    }
+    const graph = this.engine.cache(version);
+    await this.db.transactionScope(async () => {
+      await this.db.jobs.asNoTracking().where((j) => j.id.eq(job.id)).executeDelete();
+      await this.engine.begin(graph, job.nodeId!, this.beginOptions(input, message));
+    });
+  }
+
+  private async available(processKey: string): Promise<boolean> {
+    try {
+      await this.definitions.latest(processKey);
+      return true;
+    } catch (error) {
+      if (error instanceof WorkflowError) return false;
+      throw error;
+    }
+  }
+
+  /** Every wait of the event: `eventWait.until` may leave a step waiting. */
+  private async continueWaits(message: EventMessage): Promise<string[]> {
+    const { eventKey, correlation, partition, payload } = message;
+    let waits = this.db.subscriptions.asNoTracking().where((s) => s.eventKey.eq(eventKey));
+    waits = correlation === null ? waits.where((s) => s.correlation.isNull()) : waits.where((s) => s.correlation.isNull().or(s.correlation.eq(correlation)));
+    if (partition !== null) waits = waits.where((s) => s.partition.eq(partition));
+    const continued = new Set<string>();
+    for (const wait of await waits.orderBy((s) => s.id).toList()) {
+      const moved = await this.engine.inStep(wait.instanceId, async (step) => {
+        if (!this.engine.eventAccepted(step, wait.tokenId, payload)) return false;
+        await this.db.subscriptions.asNoTracking().where((s) => s.id.eq(wait.id)).executeDelete();
+        return await this.engine.eventReceived(step, wait.tokenId, eventKey, payload);
+      });
+      if (moved === true) continued.add(wait.instanceId);
+    }
+    return [...continued];
+  }
+
+  /** The `eventStart` nodes that take the event: connected to its partition, past `ignoreOwn` and `filter`, with a valid input. */
+  private async plan(message: EventMessage): Promise<{ readonly planned: PlannedStart[]; readonly rejected: { processKey: string; issues: readonly FormIssue[] }[] }> {
+    const { eventKey, payload, partition, actor } = message;
+    const planned: PlannedStart[] = [];
+    const rejected: { processKey: string; issues: readonly FormIssue[] }[] = [];
+    const data = eventData(message, this.engine.now());
+    const own = await this.causeProcess(message.cause);
+    for (const version of await this.definitions.published()) {
+      for (const [nodeId, node] of Object.entries(version.document.nodes)) {
+        if (node.kind !== "eventStart" || node.config?.event !== eventKey) continue;
+        const config = eventStartConfig(node);
+        if (!await this.connected(version.key, partition)) continue;
+        if (config.ignoreOwn === true && own === version.key) continue;
+        if (config.filter !== undefined && !isTruthy(evaluateExpression(config.filter, data))) continue;
+        // An event carries more than a process needs: fields the input does not declare are dropped, not refused.
+        const { value, issues: all } = await this.services.resolve(WorkflowInputValidator).validate(inputSpecOf(version.document), payload, { purpose: "input", processKey: version.key, partition, language: this.languages.default, actor });
+        const issues = all.filter((issue) => issue.code !== "unknown");
+        if (issues.length > 0) rejected.push({ processKey: version.key, issues });
+        else planned.push({ version, nodeId, config, input: value });
+      }
+    }
+    return { planned, rejected };
+  }
+
+  /** Whether the process works in the partition of the event; an event without a partition is for processes without them. */
+  private async connected(processKey: string, partition: string | null): Promise<boolean> {
+    const partitions = await this.services.resolve(WorkflowPartitions).of(processKey, { partition, language: this.languages.default, actor: null });
+    return partitions.some((item) => item.enabled && item.partition === partition);
+  }
+
+  /** The process of the instance that caused the event. */
+  private async causeProcess(cause: EmitCause | null): Promise<string | undefined> {
+    const id = cause?.instanceId;
+    if (!isUuid(id)) return undefined;
+    const row = await this.db.instances.asNoTracking().firstOrDefault((i) => i.id.eq(id));
+    return row?.processKey;
+  }
+
+  private async begin(version: VersionDetails, nodeId: string, input: Record<string, unknown>, message: EventMessage) {
+    return await this.engine.begin(this.engine.cache(version), nodeId, this.beginOptions(input, message));
+  }
+
+  private beginOptions(input: Record<string, unknown>, message: EventMessage) {
+    return {
+      input,
+      partition: message.partition,
+      businessKey: message.correlation,
+      startedVia: "event" as const,
+      actor: message.actor,
+      request: message.request,
+      event: { key: message.eventKey, payload: message.payload },
+      ...(message.cause === null ? {} : { cause: message.cause }),
+    };
+  }
+
+  /**
+   * An `eventStart` job due after `delay` and the `debounce` window. The window runs
+   * from its first event and later ones replace what the job carries, so a steady
+   * stream of events still starts a process once per window. A job a worker holds
+   * takes no more events: the next one opens a new window.
+   */
+  private async defer(start: PlannedStart, message: EventMessage): Promise<void> {
+    const { version, nodeId, config, input } = start;
+    const now = this.engine.now();
+    const dueAt = new Date(now.getTime() + (config.debounce === undefined ? 0 : durationMs(config.debounce.window) ?? 0) + (config.delay === undefined ? 0 : durationMs(config.delay) ?? 0));
+    const payload = { message, input };
+    const dedupeKey = config.debounce === undefined ? null : debounceKey(version.key, nodeId, message, config.debounce.key, now);
+    const job = Object.assign(new WfJob(), { id: Bun.randomUUIDv7(), kind: "eventStart" as const, versionId: version.id, nodeId, partition: message.partition, dueAt, payload, dedupeKey, createdAt: now });
+    if (dedupeKey === null) {
+      await this.db.jobs.insertIfAbsent(job, { conflictBy: (j) => [j.id] });
+      return;
+    }
+    await this.db.transactionScope(async () => {
+      await this.db.database.querySqlRaw("SELECT pg_advisory_xact_lock(hashtext({0}))", dedupeKey);
+      const merged = await this.db.jobs.asNoTracking().where((j) => j.dedupeKey.eq(dedupeKey).and(j.lockedUntil.isNull())).executeUpdate({ payload, versionId: version.id });
+      if (merged.affectedRows === 0) await this.db.jobs.insertIfAbsent(job, { conflictBy: (j) => [j.id] });
+    });
+  }
+}
+
+function eventStartConfig(node: ProcessNode): EventStartConfig {
+  return (node.config ?? {}) as unknown as EventStartConfig;
+}
+
+/** What the expressions of an `eventStart` read: there is no instance yet. */
+function eventData(message: EventMessage, now: Date): InstanceData {
+  return {
+    input: {},
+    vars: {},
+    nodes: {},
+    event: message.payload,
+    trigger: { via: "event", at: now.toISOString(), actor: message.actor, eventKey: message.eventKey, ...(message.cause === null ? {} : { cause: message.cause }) },
+    now: now.toISOString(),
+  };
+}
+
+function debounceKey(processKey: string, nodeId: string, message: EventMessage, key: Expr, now: Date): string {
+  const value = evaluateExpression(key, eventData(message, now)) ?? null;
+  return createHash("sha256").update(canonicalJson([processKey, nodeId, message.partition, value])).digest("hex");
+}

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

@@ -3,12 +3,12 @@ import { WorkflowError } from "../../contracts/WorkflowError";
 import type { IWorkflowDefinitions, VersionDetails } from "../../definitions_module/services/IWorkflowDefinitions.service";
 import type { RuntimeDbContext } from "../model/Runtime.dbContext";
 import type { WfJob } from "../model/WfJob.model";
-import type { WorkflowEngine } from "./WorkflowEngine";
+import { queuesSchedule, type WorkflowEngine } from "./WorkflowEngine";
 
 /** How many waiting instances of a process one pass looks at. */
 const RELEASE_BATCH = 1000;
 
-/** What a whole run is limited by and what follows its failure: `runTimeout`, `maxConcurrent`, `sameKey: "queue"`, `errorHandler`. */
+/** What a whole run is limited by and what follows its failure: `runTimeout`, `maxConcurrent`, `sameKey: "queue"`, `overlap: "queue"`, `errorHandler`. */
 export class RunLimits {
   constructor(
     private readonly db: RuntimeDbContext,
@@ -39,7 +39,7 @@ export class RunLimits {
   }
 
   private async releaseProcess(processKey: string): Promise<void> {
-    const waiting = await this.db.instances.asNoTracking().where((i) => i.processKey.eq(processKey).and(i.status.eq("pending"))).orderBy((i) => i.id).take(RELEASE_BATCH).toList();
+    const waiting = await this.db.instances.asNoTracking().where((i) => i.processKey.eq(processKey).and(i.test.eq(false)).and(i.status.eq("pending"))).orderBy((i) => i.id).take(RELEASE_BATCH).toList();
     if (waiting.length === 0) return;
     // Graphs live in the Definitions store, out of reach inside the transaction; `inStep` finds them cached.
     const graphs = new Map(await Promise.all(waiting.map(async (row) => [row.id, await this.engine.graphOf(row.versionId)] as const)));
@@ -47,9 +47,11 @@ export class RunLimits {
       await this.engine.lockProcess(processKey);
       let running = await this.engine.runningOf(processKey);
       for (const row of waiting) {
-        const { maxConcurrent, sameKey } = graphs.get(row.id)!.document.settings ?? {};
+        const { document } = graphs.get(row.id)!;
+        const { maxConcurrent, sameKey } = document.settings ?? {};
         if (maxConcurrent !== undefined && running >= maxConcurrent) continue;
         if (sameKey === "queue" && row.businessKey !== null && await this.keyTaken(processKey, row.businessKey, row.id)) continue;
+        if (row.startedVia === "schedule" && queuesSchedule(document) && await this.scheduleTaken(processKey, row.partition, row.id)) continue;
         const released = await this.engine.inStep(row.id, async (step) => {
           if (step.instance.status !== "pending") return false;
           await this.engine.release(step);
@@ -63,7 +65,15 @@ export class RunLimits {
   /** Whether an instance older than this one still works on the key: it goes first. */
   private async keyTaken(processKey: string, businessKey: string, id: string): Promise<boolean> {
     const same = await this.db.instances.asNoTracking()
-      .where((i) => i.processKey.eq(processKey).and(i.businessKey.eq(businessKey)).and(i.status.in(["pending", "running", "failed"])).and(i.id.lt(id)))
+      .where((i) => i.processKey.eq(processKey).and(i.test.eq(false)).and(i.businessKey.eq(businessKey)).and(i.status.in(["pending", "running", "failed"])).and(i.id.lt(id)))
+      .count();
+    return same > 0;
+  }
+
+  /** Whether a scheduled run of the partition goes on, or waits since before this one. */
+  private async scheduleTaken(processKey: string, partition: string | null, id: string): Promise<boolean> {
+    const same = await this.db.instances.asNoTracking()
+      .where((i) => i.processKey.eq(processKey).and(i.test.eq(false)).and(i.startedVia.eq("schedule")).and(partition === null ? i.partition.isNull() : i.partition.eq(partition)).and(i.status.eq("running").or(i.status.eq("pending").and(i.id.lt(id)))))
       .count();
     return same > 0;
   }
@@ -103,6 +113,7 @@ export class RunLimits {
     await this.engine.inStep(failed.id, async (step) => {
       await this.dropJob(job);
       const { id } = await this.engine.begin(graph, start[0], {
+        test: failed.test,
         input: value,
         partition: failed.partition,
         businessKey: null,

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

@@ -0,0 +1,13 @@
+import { WorkflowProcessUsage } from "../../contracts/WorkflowProcessUsage";
+import type { RuntimeDbContext } from "../model/Runtime.dbContext";
+
+/** Unfinished instances of a process: they stop it from being deleted. */
+export class RuntimeProcessUsage extends WorkflowProcessUsage {
+  constructor(private readonly db: RuntimeDbContext) {
+    super();
+  }
+
+  async liveInstances(processKey: string): Promise<number> {
+    return await this.db.instances.asNoTracking().where((i) => i.processKey.eq(processKey).and(i.status.in(["pending", "running", "failed"]))).count();
+  }
+}