bazis 0.126.0 → 0.127.0

package/core/infra/connectors/codex/CodexAppServerClient.ts

@@ -232,7 +232,7 @@ export class CodexAppServerClient implements CodexClient {
         if (method === "account/updated") this.modelCache = undefined;
       }, () => { this.clearLogin(); this.modelCache = undefined; });
       const initialized = await client.request("initialize", {
-        clientInfo: { name: "bazis", title: "Bazis", version: "0.126.0" }, capabilities: { experimentalApi: true },
+        clientInfo: { name: "bazis", title: "Bazis", version: "0.127.0" }, capabilities: { experimentalApi: true },
       }, 15_000, signal);
       if (resolve(text(initialized.codexHome, 4096)) !== this.paths.home) throw new CodexError("PROTOCOL_ERROR");
       client.notify("initialized");

package/core/workflow/Workflow.module.ts

@@ -3,13 +3,15 @@ import { WorkflowDefinitionsModule } from "./definitions_module/WorkflowDefiniti
 import { IWorkflowDefinitions } from "./definitions_module/services/IWorkflowDefinitions.service";
 import { WorkflowRuntimeModule } from "./runtime_module/WorkflowRuntime.module";
 import { IWorkflowRuntime } from "./runtime_module/services/IWorkflowRuntime.service";
+import { WorkflowTasksModule } from "./tasks_module/WorkflowTasks.module";
+import { IWorkflowTasks } from "./tasks_module/services/IWorkflowTasks.service";
 
 /**
  * Business processes (WORKFLOW-001): the pack only assembles its parts
  * ([passport](MODULE.md)). An application imports it, or only the parts it needs.
  */
 @Module({
-  imports: [WorkflowDefinitionsModule, WorkflowRuntimeModule],
-  exports: [IWorkflowDefinitions, IWorkflowRuntime],
+  imports: [WorkflowDefinitionsModule, WorkflowRuntimeModule, WorkflowTasksModule],
+  exports: [IWorkflowDefinitions, IWorkflowRuntime, IWorkflowTasks],
 })
 export class WorkflowModule {}

package/core/workflow/index.ts

@@ -6,6 +6,9 @@
 export { WorkflowModule } from "./Workflow.module";
 export { WorkflowDefinitionsModule } from "./definitions_module/WorkflowDefinitions.module";
 export { WorkflowRuntimeModule } from "./runtime_module/WorkflowRuntime.module";
+export { WorkflowTasksModule } from "./tasks_module/WorkflowTasks.module";
+export { IWorkflowTasks, type TaskDetails, type TaskListQuery } from "./tasks_module/services/IWorkflowTasks.service";
+export type { TaskStatus } from "./tasks_module/model/WfTask.model";
 export {
   IWorkflowDefinitions,
   type CreateProcess,
@@ -18,6 +21,8 @@ export {
 } from "./definitions_module/services/IWorkflowDefinitions.service";
 export {
   IWorkflowRuntime,
+  type EmitOptions,
+  type EmitResult,
   type HistoryEntry,
   type InstanceDetails,
   type InstanceListQuery,
@@ -27,9 +32,11 @@ export {
 } from "./runtime_module/services/IWorkflowRuntime.service";
 export {
   WORKFLOW_INSTANCE_FINISHED,
+  WORKFLOW_INSTANCES_DELETED,
   WORKFLOW_TASK_REQUESTED,
   WORKFLOW_TOKEN_CLOSED,
   type WorkflowInstanceFinished,
+  type WorkflowInstancesDeleted,
   type WorkflowTaskRequested,
   type WorkflowTokenClosed,
 } from "./runtime_module/events/Runtime.events";

package/core/workflow/internal/http.ts

@@ -16,6 +16,12 @@ export async function authorize(ctx: HttpContext, action: WorkflowAction, target
   return actor;
 }
 
+/** Whom the caller's tasks are addressed to, from the application's {@link WorkflowAccess}. */
+export async function assigneesOf(ctx: HttpContext, actor: WorkflowActor): Promise<readonly string[]> {
+  const access = ctx.services.tryResolve(WorkflowAccess);
+  return access === undefined ? [] : await access.assignees(ctx, actor);
+}
+
 /** A route parameter as a string. */
 export function param(ctx: HttpContext, name: string): string {
   return String(ctx.params[name] ?? "");

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

@@ -1,7 +1,8 @@
 import { BackgroundService, delay } from "../../../background";
 import type { ServiceProvider } from "../../../di";
-import type { ConfigView } from "../../../kernel";
+import { EventBus, type ConfigView } from "../../../kernel";
 import { IWorkflowDefinitions } from "../../definitions_module/services/IWorkflowDefinitions.service";
+import { WORKFLOW_INSTANCES_DELETED } from "../events/Runtime.events";
 import { RuntimeDbContext } from "../model/Runtime.dbContext";
 import type { WorkflowSettings } from "./WorkflowWorker";
 
@@ -11,6 +12,8 @@ const DAY_MS = 86_400_000;
  * Deletes `completed` and `cancelled` 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.
+ * Each deleted batch is published as `WORKFLOW_INSTANCES_DELETED`, so parts
+ * with their own data (tasks) drop theirs.
  */
 export class WorkflowRetention extends BackgroundService {
   constructor(
@@ -55,6 +58,7 @@ export class WorkflowRetention extends BackgroundService {
           if (ids.length === 0) break;
           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;
         }
       }

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

@@ -32,6 +32,12 @@ export interface WorkflowInstanceFinished {
   readonly status: Extract<InstanceStatus, "completed" | "cancelled">;
 }
 
+/** Retention deleted these finished instances with their tokens and history. */
+export interface WorkflowInstancesDeleted {
+  readonly instanceIds: readonly string[];
+}
+
 export const WORKFLOW_TASK_REQUESTED = createEventToken<WorkflowTaskRequested>("workflow.task-requested");
 export const WORKFLOW_TOKEN_CLOSED = createEventToken<WorkflowTokenClosed>("workflow.token-closed");
 export const WORKFLOW_INSTANCE_FINISHED = createEventToken<WorkflowInstanceFinished>("workflow.instance-finished");
+export const WORKFLOW_INSTANCES_DELETED = createEventToken<WorkflowInstancesDeleted>("workflow.instances-deleted");

package/core/workflow/tasks_module/WorkflowTasks.module.ts

@@ -0,0 +1,29 @@
+import { DI, Module, scoped } from "../../di";
+import { withEventSubscribers } from "../../kernel";
+import { IWorkflowRuntime } from "../runtime_module/services/IWorkflowRuntime.service";
+import { WorkflowRuntimeModule } from "../runtime_module/WorkflowRuntime.module";
+import { TaskEvents } from "./events/TaskEvents";
+import { TasksController } from "./http/Tasks.controller";
+import { TasksDbContext, tasksStore } from "./model/Tasks.dbContext";
+import { WfTask } from "./model/WfTask.model";
+import { IWorkflowTasks } from "./services/IWorkflowTasks.service";
+import { WorkflowTasks } from "./services/WorkflowTasks.service";
+
+/**
+ * Tasks for people: the inbox of `userTask` steps ([passport](MODULE.md)).
+ * Dependencies are explicit: the framework's classes are not covered by the
+ * application's codegen.
+ */
+@Module({
+  imports: [WorkflowRuntimeModule],
+  ormBazis: { context: TasksDbContext, entities: [WfTask], ownedStore: tasksStore, registerRepositories: false },
+  providers: [
+    scoped(WorkflowTasks, WorkflowTasks, [TasksDbContext, IWorkflowRuntime] as const),
+    DI.scoped(DI.factoryProviderWithResolver(IWorkflowTasks, [], (resolver) => resolver.resolve(WorkflowTasks))),
+    scoped(TaskEvents, TaskEvents, [WorkflowTasks] as const),
+    ...withEventSubscribers(TaskEvents),
+  ],
+  controllers: [DI.bindDeps(TasksController, IWorkflowTasks)],
+  exports: [IWorkflowTasks],
+})
+export class WorkflowTasksModule {}

package/core/workflow/tasks_module/events/TaskEvents.ts

@@ -0,0 +1,23 @@
+import { OnEvent } from "../../../kernel";
+import { WORKFLOW_INSTANCES_DELETED, WORKFLOW_TASK_REQUESTED, WORKFLOW_TOKEN_CLOSED, type WorkflowInstancesDeleted, type WorkflowTaskRequested, type WorkflowTokenClosed } from "../../runtime_module/events/Runtime.events";
+import type { WorkflowTasks } from "../services/WorkflowTasks.service";
+
+/** Keeps the inbox in line with the steps: a waiting user task gets a task, a closed one cancels it. */
+export class TaskEvents {
+  constructor(private readonly tasks: WorkflowTasks) {}
+
+  @OnEvent(WORKFLOW_TASK_REQUESTED)
+  requested(event: WorkflowTaskRequested): Promise<void> {
+    return this.tasks.requested(event);
+  }
+
+  @OnEvent(WORKFLOW_TOKEN_CLOSED)
+  closed(event: WorkflowTokenClosed): Promise<void> {
+    return this.tasks.closed(event);
+  }
+
+  @OnEvent(WORKFLOW_INSTANCES_DELETED)
+  deleted(event: WorkflowInstancesDeleted): Promise<void> {
+    return this.tasks.deleted(event);
+  }
+}

package/core/workflow/tasks_module/http/Tasks.controller.ts

@@ -0,0 +1,67 @@
+import { contextOnlyController } from "../../../http/Routing/contextOnlyControllers";
+import { Controller, Get, Post, type HttpContext } from "../../../http";
+import type { WorkflowActor } from "../../contracts/types";
+import { WorkflowError } from "../../contracts/WorkflowError";
+import { assigneesOf, authorize, body, optionalString, pagingQuery, param } from "../../internal/http";
+import type { TaskStatus } from "../model/WfTask.model";
+import { IWorkflowTasks, type TaskDetails } from "../services/IWorkflowTasks.service";
+
+/**
+ * The caller's tasks (WORKFLOW-001 §5): those addressed to any of
+ * `WorkflowAccess.assignees` or claimed by the caller. Another person's task
+ * answers 404, as if it did not exist.
+ */
+@Controller("workflow/tasks")
+export class TasksController {
+  constructor(private readonly tasks: IWorkflowTasks) {}
+
+  @Get()
+  async list(ctx: HttpContext) {
+    const partition = optionalString(ctx.query("partition"), "partition");
+    const actor = await authorize(ctx, "tasks.work", { partition: partition ?? null });
+    const status = ctx.query("status");
+    const page = await this.tasks.list({
+      ...pagingQuery(ctx),
+      assignees: await assigneesOf(ctx, actor),
+      actor,
+      ...(status === undefined ? {} : { status: status.split(",") as TaskStatus[] }),
+      partition,
+      processKey: optionalString(ctx.query("processKey"), "processKey"),
+    });
+    return { data: page.items, meta: { total: page.total } };
+  }
+
+  @Get(":id")
+  async get(ctx: HttpContext) {
+    return (await this.visible(ctx)).task;
+  }
+
+  @Post(":id/claim")
+  async claim(ctx: HttpContext) {
+    const { task, actor } = await this.visible(ctx);
+    return await this.tasks.claim(task.id, actor);
+  }
+
+  @Post(":id/release")
+  async release(ctx: HttpContext) {
+    const { task, actor } = await this.visible(ctx);
+    return await this.tasks.release(task.id, actor);
+  }
+
+  @Post(":id/complete")
+  async complete(ctx: HttpContext) {
+    const { task, actor } = await this.visible(ctx);
+    const request = await body(ctx);
+    return await this.tasks.complete(task.id, request.output ?? {}, actor);
+  }
+
+  /** The task if the caller may see it: addressed to one of their assignees or claimed by them. */
+  private async visible(ctx: HttpContext): Promise<{ task: TaskDetails; actor: WorkflowActor }> {
+    const task = await this.tasks.get(param(ctx, "id"));
+    const actor = await authorize(ctx, "tasks.work", { processKey: task.processKey, partition: task.partition, instanceId: task.instanceId, taskId: task.id });
+    const assignees = await assigneesOf(ctx, actor);
+    if (!assignees.includes(task.assignee) && task.claimedBy !== actor.id) throw new WorkflowError("not_found", `Task ${task.id} does not exist`);
+    return { task, actor };
+  }
+}
+contextOnlyController(TasksController);

package/core/workflow/tasks_module/model/Tasks.dbContext.ts

@@ -0,0 +1,14 @@
+import { DbContext, defineOrmOwnedStoreV1 } from "../../../orm";
+import { WfTask } from "./WfTask.model";
+
+export class TasksDbContext extends DbContext {
+  readonly tasks = this.set(WfTask);
+}
+
+/** The table of the Tasks part: bazis creates and checks it in the application database. */
+export const tasksStore = defineOrmOwnedStoreV1({
+  contract: "bazis.orm-owned-store/v1",
+  storeKey: "bazis.workflow.tasks",
+  formatVersion: 1,
+  ownedScope: { schema: "public", tablePrefix: "bazis_wf_task_" },
+});

package/core/workflow/tasks_module/model/WfTask.model.ts

@@ -0,0 +1,69 @@
+import { Column, Entity, Index, UUID } from "../../../orm";
+import type { FormSpec } from "../../../../library/workflow";
+
+/** `open` waits for someone, `claimed` is taken by one person, `completed` and `cancelled` are done. */
+export type TaskStatus = "open" | "claimed" | "completed" | "cancelled";
+
+/**
+ * A task for a person: a `userTask` step of an instance waiting for its form.
+ * Created from `WORKFLOW_TASK_REQUESTED`; references are text (other stores).
+ */
+@Index(["assignee", "status"])
+@Index(["partition", "status"])
+@Entity({ table: "bazis_wf_task_items" })
+export class WfTask {
+  @UUID({ version: "v7" })
+  id = "";
+
+  /** The waiting token: one task per token. */
+  @Index({ unique: true })
+  @Column({ type: "text" })
+  tokenId = "";
+
+  @Index()
+  @Column({ type: "text" })
+  instanceId = "";
+
+  @Column({ type: "text" })
+  processKey = "";
+
+  @Column({ type: "text" })
+  nodeId = "";
+
+  @Column({ type: "text", nullable: true })
+  partition: string | null = null;
+
+  @Column({ type: "text" })
+  title = "";
+
+  /** `role:<code>` or `user:<id>`. */
+  @Column({ type: "text" })
+  assignee = "";
+
+  @Column({ type: "json", nullable: true })
+  form: FormSpec | null = null;
+
+  @Column({ type: "datetime", nullable: true })
+  dueAt: Date | null = null;
+
+  @Column({ type: "text" })
+  status: TaskStatus = "open";
+
+  @Column({ type: "text", nullable: true })
+  claimedById: string | null = null;
+
+  @Column({ type: "datetime", nullable: true })
+  claimedAt: Date | null = null;
+
+  @Column({ type: "text", nullable: true })
+  completedById: string | null = null;
+
+  @Column({ type: "datetime", nullable: true })
+  completedAt: Date | null = null;
+
+  @Column({ type: "json", nullable: true })
+  output: Record<string, unknown> | null = null;
+
+  @Column({ type: "createdAt" })
+  createdAt = new Date(0);
+}

package/core/workflow/tasks_module/services/IWorkflowTasks.service.ts

@@ -0,0 +1,52 @@
+import type { FormSpec } from "../../../../library/workflow";
+import type { WorkflowActor, WorkflowPage, WorkflowPaging } from "../../contracts/types";
+import type { TaskStatus } from "../model/WfTask.model";
+
+export interface TaskDetails {
+  readonly id: string;
+  readonly instanceId: string;
+  readonly tokenId: string;
+  readonly processKey: string;
+  readonly nodeId: string;
+  readonly partition: string | null;
+  readonly title: string;
+  readonly assignee: string;
+  readonly form: FormSpec | null;
+  readonly dueAt: Date | null;
+  readonly status: TaskStatus;
+  readonly claimedBy: string | null;
+  readonly claimedAt: Date | null;
+  readonly completedBy: string | null;
+  readonly completedAt: Date | null;
+  readonly output: Record<string, unknown> | null;
+  readonly createdAt: Date;
+}
+
+export interface TaskListQuery extends WorkflowPaging {
+  /** Tasks addressed to any of these (`role:support`, `user:42`), plus those the actor claimed. */
+  readonly assignees: readonly string[];
+  /** Whose claimed tasks count as theirs. */
+  readonly actor?: WorkflowActor;
+  /** `open` and `claimed` by default. */
+  readonly status?: readonly TaskStatus[];
+  readonly partition?: string;
+  readonly processKey?: string;
+}
+
+/**
+ * Tasks for people (WORKFLOW-001 §5): the inbox of `userTask` steps. A task
+ * appears when its step starts waiting and is cancelled when the step closes
+ * otherwise. Errors are {@link WorkflowError}: `not_found`, `conflict` (claimed
+ * by another person), `wrong_status`, `invalid_input` with the form issues.
+ */
+export abstract class IWorkflowTasks {
+  /** The tasks of these assignees, oldest first. */
+  abstract list(query: TaskListQuery): Promise<WorkflowPage<TaskDetails>>;
+  abstract get(taskId: string): Promise<TaskDetails>;
+  /** Takes an open task: nobody else can complete it until it is released. */
+  abstract claim(taskId: string, actor: WorkflowActor): Promise<TaskDetails>;
+  /** Gives a claimed task back. */
+  abstract release(taskId: string, actor: WorkflowActor): Promise<TaskDetails>;
+  /** Fills the form: the process moves on. */
+  abstract complete(taskId: string, output: unknown, actor: WorkflowActor): Promise<TaskDetails>;
+}

package/core/workflow/tasks_module/services/WorkflowTasks.service.ts

@@ -0,0 +1,167 @@
+import { UniqueViolationError } from "../../../orm";
+import { isUuid, pagingOf, type WorkflowActor, type WorkflowPage } from "../../contracts/types";
+import { WorkflowError } from "../../contracts/WorkflowError";
+import type { WorkflowInstancesDeleted, WorkflowTaskRequested, WorkflowTokenClosed } from "../../runtime_module/events/Runtime.events";
+import type { IWorkflowRuntime } from "../../runtime_module/services/IWorkflowRuntime.service";
+import type { TasksDbContext } from "../model/Tasks.dbContext";
+import { WfTask, type TaskStatus } from "../model/WfTask.model";
+import { IWorkflowTasks, type TaskDetails, type TaskListQuery } from "./IWorkflowTasks.service";
+
+const STATUSES = new Set<TaskStatus>(["open", "claimed", "completed", "cancelled"]);
+
+export class WorkflowTasks extends IWorkflowTasks {
+  constructor(
+    private readonly db: TasksDbContext,
+    private readonly runtime: IWorkflowRuntime,
+  ) {
+    super();
+  }
+
+  async list(query: TaskListQuery): Promise<WorkflowPage<TaskDetails>> {
+    const { limit, offset } = pagingOf(query);
+    const statuses = [...(query.status ?? ["open", "claimed"])];
+    if (statuses.length === 0 || statuses.some((status) => !STATUSES.has(status))) throw new WorkflowError("invalid_input", "status must be open, claimed, completed or cancelled");
+    const assignees = [...query.assignees];
+    const mine = query.actor?.id;
+    if (assignees.length === 0 && mine === undefined) return { items: [], total: 0 };
+    let source = this.db.tasks.asNoTracking().where((t) => t.status.in(statuses));
+    source = mine === undefined
+      ? source.where((t) => t.assignee.in(assignees))
+      : assignees.length === 0
+        ? source.where((t) => t.claimedById.eq(mine))
+        : source.where((t) => t.assignee.in(assignees).or(t.claimedById.eq(mine)));
+    if (query.partition !== undefined) source = source.where((t) => t.partition.eq(query.partition!));
+    if (query.processKey !== undefined) source = source.where((t) => t.processKey.eq(query.processKey!));
+    const total = await source.count();
+    const rows = await source.orderBy((t) => t.id).skip(offset).take(limit).toList();
+    return { items: rows.map(detailsOf), total };
+  }
+
+  async get(taskId: string): Promise<TaskDetails> {
+    return detailsOf(await this.task(taskId, false));
+  }
+
+  async claim(taskId: string, actor: WorkflowActor): Promise<TaskDetails> {
+    return await this.db.transactionScope(async () => {
+      const task = await this.locked(taskId);
+      if (task.status === "claimed" && task.claimedById === actor.id) return detailsOf(task);
+      if (task.status === "claimed") throw new WorkflowError("conflict", "The task is taken by someone else");
+      if (task.status !== "open") throw new WorkflowError("wrong_status", `The task is ${task.status}`);
+      task.status = "claimed";
+      task.claimedById = actor.id;
+      task.claimedAt = new Date();
+      await this.db.saveChanges();
+      return detailsOf(task);
+    });
+  }
+
+  async release(taskId: string, actor: WorkflowActor): Promise<TaskDetails> {
+    return await this.db.transactionScope(async () => {
+      const task = await this.locked(taskId);
+      if (task.status !== "claimed" || task.claimedById !== actor.id) throw new WorkflowError("wrong_status", "Only the person who took the task gives it back");
+      task.status = "open";
+      task.claimedById = null;
+      task.claimedAt = null;
+      await this.db.saveChanges();
+      return detailsOf(task);
+    });
+  }
+
+  async complete(taskId: string, output: unknown, actor: WorkflowActor): Promise<TaskDetails> {
+    const task = await this.task(taskId, false);
+    if (task.status === "claimed" && task.claimedById !== actor.id) throw new WorkflowError("conflict", "The task is taken by someone else");
+    if (task.status !== "open" && task.status !== "claimed") throw new WorkflowError("wrong_status", `The task is ${task.status}`);
+    let instance;
+    try {
+      // The form is checked and the process moves on first; the task follows.
+      instance = await this.runtime.completeToken(task.tokenId, output, actor);
+    } catch (error) {
+      if (error instanceof WorkflowError && error.code === "wrong_status") await this.close(task.tokenId, "cancelled");
+      throw error;
+    }
+    const saved = instance.nodes[task.nodeId];
+    await this.db.tasks.asNoTracking().where((t) => t.id.eq(task.id)).executeUpdate({
+      status: "completed",
+      completedById: actor.id,
+      completedAt: new Date(),
+      output: typeof saved === "object" && saved !== null && !Array.isArray(saved) ? saved as Record<string, unknown> : null,
+    });
+    return await this.get(task.id);
+  }
+
+  /** A step started waiting for a person: its task. Repeated events of one token make one task. */
+  async requested(event: WorkflowTaskRequested): Promise<void> {
+    const assignee = "role" in event.assignee ? `role:${event.assignee.role}` : `user:${event.assignee.user}`;
+    this.db.tasks.add(Object.assign(new WfTask(), {
+      tokenId: event.tokenId,
+      instanceId: event.instanceId,
+      processKey: event.processKey,
+      nodeId: event.nodeId,
+      partition: event.partition,
+      title: event.title,
+      assignee,
+      form: event.form,
+      dueAt: event.dueAt,
+    }));
+    try {
+      await this.db.saveChanges();
+    } catch (error) {
+      if (!(error instanceof UniqueViolationError)) throw error;
+    }
+  }
+
+  /** The step closed otherwise than by its task: the task is cancelled. */
+  async closed(event: WorkflowTokenClosed): Promise<void> {
+    await this.close(event.tokenId, "cancelled");
+  }
+
+  /** Retention deleted the instances: their tasks go too. */
+  async deleted(event: WorkflowInstancesDeleted): Promise<void> {
+    if (event.instanceIds.length > 0) await this.db.tasks.asNoTracking().where((t) => t.instanceId.in([...event.instanceIds])).executeDelete();
+  }
+
+  private async close(tokenId: string, status: "cancelled"): Promise<void> {
+    await this.db.tasks.asNoTracking().where((t) => t.tokenId.eq(tokenId).and(t.status.in(["open", "claimed"]))).executeUpdate({ status });
+  }
+
+  private async task(taskId: string, tracked: boolean): Promise<WfTask> {
+    if (!isUuid(taskId)) throw notFound(taskId);
+    const source = tracked ? this.db.tasks : this.db.tasks.asNoTracking();
+    const task = await source.firstOrDefault((t) => t.id.eq(taskId));
+    if (!task) throw notFound(taskId);
+    return task;
+  }
+
+  private async locked(taskId: string): Promise<WfTask> {
+    if (!isUuid(taskId)) throw notFound(taskId);
+    const task = await this.db.tasks.where((t) => t.id.eq(taskId)).forUpdate().firstOrDefault();
+    if (!task) throw notFound(taskId);
+    return task;
+  }
+}
+
+function notFound(taskId: string): WorkflowError {
+  return new WorkflowError("not_found", `Task ${taskId} does not exist`);
+}
+
+function detailsOf(row: WfTask): TaskDetails {
+  return {
+    id: row.id,
+    instanceId: row.instanceId,
+    tokenId: row.tokenId,
+    processKey: row.processKey,
+    nodeId: row.nodeId,
+    partition: row.partition,
+    title: row.title,
+    assignee: row.assignee,
+    form: row.form,
+    dueAt: row.dueAt,
+    status: row.status,
+    claimedBy: row.claimedById,
+    claimedAt: row.claimedAt,
+    completedBy: row.completedById,
+    completedAt: row.completedAt,
+    output: row.output,
+    createdAt: row.createdAt,
+  };
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "bazis",
-  "version": "0.126.0",
+  "version": "0.127.0",
   "description": "Modular backend framework for Bun in TypeScript: DI wired by codegen, HTTP, a PostgreSQL ORM, JWT, WebSocket, agents and a CLI.",
   "license": "MIT",
   "author": "Alexander Alenin",