@webiny/api-workflows 0.0.0-unstable.b9b64acb6d → 0.0.0-unstable.d0f34a8194

package/features/stepRun/StepRunner/abstractions.d.ts

@@ -0,0 +1,72 @@
+import type { StepRunTaskIdentity } from "../../../domain/review/getStaleStepRunReason.js";
+import type { Actor, AiIssue, ReviewData, ReviewStep } from "../../../domain/review/types.js";
+/**
+ * `approved` and `rejected` end the step; a `rejected` outcome needs a comment of 10 or more
+ * characters after trimming (D100). `issues` are the AI findings stored on the step (R171).
+ */
+export interface StepRunnerDecisionOutcome {
+    type: "approved" | "rejected";
+    comment?: string;
+    issues?: AiIssue[];
+}
+/** Run the step again: `wait` seconds later, with `state` handed back on the next call. */
+export interface StepRunnerContinueOutcome {
+    type: "continue";
+    wait?: number;
+    state?: Record<string, unknown>;
+}
+export type StepRunnerOutcome = StepRunnerDecisionOutcome | StepRunnerContinueOutcome;
+/** Fixed texts stored as the step's reason when the step fails (R146); never a raw error. */
+export interface StepRunnerFailureReasons {
+    /** The run threw, or its outcome could not be applied. */
+    error: string;
+    /** The task was aborted. */
+    aborted: string;
+    /** The task ended without writing a result (stuck detection, R152). */
+    stuck: string;
+}
+export interface StepRunnerRunParams {
+    /** The review as stored when the run started; read-only for the runner. */
+    review: ReviewData;
+    /** The step being run, from the review snapshot (A53). */
+    step: ReviewStep;
+    /** The review's requester: the identity everything runs as (R161). */
+    requester: Actor;
+    /** The task's own identity, the one the stale guard compares (R144). */
+    task: StepRunTaskIdentity;
+    /** The runner's own run count: 1 on the first call, +1 for every `continue`; waits for the task id are not counted (R163). */
+    iteration: number;
+    /** The `state` of the previous `continue` outcome; `null` on the first call. */
+    state: Record<string, unknown> | null;
+    /** Fires when the task's remaining runtime is nearly used up (R175). */
+    signal: AbortSignal;
+}
+export interface IStepRunner {
+    /** The step type this runner runs (`step.type`). */
+    readonly type: string;
+    /**
+     * True when the runner never returns `continue`: the handler persists `{ idWaits, state }`
+     * before calling it and refuses a re-entered task (R170). False for automation.
+     */
+    readonly singleRun: boolean;
+    readonly failureReasons: StepRunnerFailureReasons;
+    /** The fixed reason when the task hit its iteration ceiling (R145). */
+    maxIterationsReason(step: ReviewStep): string;
+    /** The actor that owns the step and applies its outcome (R141, R164). */
+    getActor(requester: Actor): Actor;
+    /** Throws `StepRunFailure` for a failure with a fixed reason (R146). */
+    run(params: StepRunnerRunParams): Promise<StepRunnerOutcome>;
+}
+/**
+ * Runs one step type inside the private `workflowsStepRun` task (R168). Multi-registered; the
+ * registry returns the last registration per `type`. The handler owns what is shared (read, stale
+ * guard, id wait, identity, applying the outcome, the one failure path); a runner owns what is
+ * specific to its step type.
+ */
+export declare const StepRunner: import("@webiny/di").Abstraction<IStepRunner>;
+export declare namespace StepRunner {
+    type Interface = IStepRunner;
+    type Outcome = StepRunnerOutcome;
+    type Params = StepRunnerRunParams;
+    type FailureReasons = StepRunnerFailureReasons;
+}

package/features/stepRun/StepRunner/abstractions.js

@@ -0,0 +1,5 @@
+import { createAbstraction } from "@webiny/feature/api";
+const StepRunner = createAbstraction("StepRunner");
+export { StepRunner };
+
+//# sourceMappingURL=abstractions.js.map

package/features/stepRun/StepRunner/abstractions.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"features/stepRun/StepRunner/abstractions.js","sources":["../../../../src/features/stepRun/StepRunner/abstractions.ts"],"sourcesContent":["import { createAbstraction } from \"@webiny/feature/api\";\nimport type { StepRunTaskIdentity } from \"~/domain/review/getStaleStepRunReason.js\";\nimport type { Actor, AiIssue, ReviewData, ReviewStep } from \"~/domain/review/types.js\";\n\n/**\n * `approved` and `rejected` end the step; a `rejected` outcome needs a comment of 10 or more\n * characters after trimming (D100). `issues` are the AI findings stored on the step (R171).\n */\nexport interface StepRunnerDecisionOutcome {\n    type: \"approved\" | \"rejected\";\n    comment?: string;\n    issues?: AiIssue[];\n}\n\n/** Run the step again: `wait` seconds later, with `state` handed back on the next call. */\nexport interface StepRunnerContinueOutcome {\n    type: \"continue\";\n    wait?: number;\n    state?: Record<string, unknown>;\n}\n\nexport type StepRunnerOutcome = StepRunnerDecisionOutcome | StepRunnerContinueOutcome;\n\n/** Fixed texts stored as the step's reason when the step fails (R146); never a raw error. */\nexport interface StepRunnerFailureReasons {\n    /** The run threw, or its outcome could not be applied. */\n    error: string;\n    /** The task was aborted. */\n    aborted: string;\n    /** The task ended without writing a result (stuck detection, R152). */\n    stuck: string;\n}\n\nexport interface StepRunnerRunParams {\n    /** The review as stored when the run started; read-only for the runner. */\n    review: ReviewData;\n    /** The step being run, from the review snapshot (A53). */\n    step: ReviewStep;\n    /** The review's requester: the identity everything runs as (R161). */\n    requester: Actor;\n    /** The task's own identity, the one the stale guard compares (R144). */\n    task: StepRunTaskIdentity;\n    /** The runner's own run count: 1 on the first call, +1 for every `continue`; waits for the task id are not counted (R163). */\n    iteration: number;\n    /** The `state` of the previous `continue` outcome; `null` on the first call. */\n    state: Record<string, unknown> | null;\n    /** Fires when the task's remaining runtime is nearly used up (R175). */\n    signal: AbortSignal;\n}\n\nexport interface IStepRunner {\n    /** The step type this runner runs (`step.type`). */\n    readonly type: string;\n    /**\n     * True when the runner never returns `continue`: the handler persists `{ idWaits, state }`\n     * before calling it and refuses a re-entered task (R170). False for automation.\n     */\n    readonly singleRun: boolean;\n    readonly failureReasons: StepRunnerFailureReasons;\n    /** The fixed reason when the task hit its iteration ceiling (R145). */\n    maxIterationsReason(step: ReviewStep): string;\n    /** The actor that owns the step and applies its outcome (R141, R164). */\n    getActor(requester: Actor): Actor;\n    /** Throws `StepRunFailure` for a failure with a fixed reason (R146). */\n    run(params: StepRunnerRunParams): Promise<StepRunnerOutcome>;\n}\n\n/**\n * Runs one step type inside the private `workflowsStepRun` task (R168). Multi-registered; the\n * registry returns the last registration per `type`. The handler owns what is shared (read, stale\n * guard, id wait, identity, applying the outcome, the one failure path); a runner owns what is\n * specific to its step type.\n */\nexport const StepRunner = createAbstraction<IStepRunner>(\"StepRunner\");\n\nexport namespace StepRunner {\n    export type Interface = IStepRunner;\n    export type Outcome = StepRunnerOutcome;\n    export type Params = StepRunnerRunParams;\n    export type FailureReasons = StepRunnerFailureReasons;\n}\n"],"names":["StepRunner","createAbstraction"],"mappings":";AAyEO,MAAMA,aAAaC,kBAA+B"}

package/features/stepRun/StepRunner/index.d.ts

@@ -0,0 +1 @@
+export { StepRunner } from "./abstractions.js";

package/features/stepRun/StepRunner/index.js

@@ -0,0 +1 @@
+export { StepRunner } from "./abstractions.js";

package/features/stepRun/StepRunnerRegistryService/StepRunnerRegistryService.d.ts

@@ -0,0 +1,11 @@
+import { StepRunner } from "../../../features/stepRun/StepRunner/abstractions.js";
+import { StepRunnerRegistryService as Abstraction } from "./abstractions.js";
+declare class StepRunnerRegistryServiceImpl implements Abstraction.Interface {
+    private readonly runners;
+    constructor(runners: StepRunner.Interface[]);
+    get(type: string): StepRunner.Interface | null;
+}
+export declare const StepRunnerRegistryService: typeof StepRunnerRegistryServiceImpl & {
+    __abstraction: import("@webiny/di").Abstraction<import("./abstractions.js").IStepRunnerRegistryService>;
+};
+export {};

package/features/stepRun/StepRunnerRegistryService/StepRunnerRegistryService.js

@@ -0,0 +1,25 @@
+import { StepRunner } from "../StepRunner/abstractions.js";
+import { StepRunnerRegistryService } from "./abstractions.js";
+class StepRunnerRegistryServiceImpl {
+    constructor(runners){
+        this.runners = new Map();
+        for (const runner of runners)this.runners.set(runner.type, runner);
+    }
+    get(type) {
+        return this.runners.get(type) ?? null;
+    }
+}
+const StepRunnerRegistryService_StepRunnerRegistryService = StepRunnerRegistryService.createImplementation({
+    implementation: StepRunnerRegistryServiceImpl,
+    dependencies: [
+        [
+            StepRunner,
+            {
+                multiple: true
+            }
+        ]
+    ]
+});
+export { StepRunnerRegistryService_StepRunnerRegistryService as StepRunnerRegistryService };
+
+//# sourceMappingURL=StepRunnerRegistryService.js.map

package/features/stepRun/StepRunnerRegistryService/StepRunnerRegistryService.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"features/stepRun/StepRunnerRegistryService/StepRunnerRegistryService.js","sources":["../../../../src/features/stepRun/StepRunnerRegistryService/StepRunnerRegistryService.ts"],"sourcesContent":["import { StepRunner } from \"~/features/stepRun/StepRunner/abstractions.js\";\nimport { StepRunnerRegistryService as Abstraction } from \"./abstractions.js\";\n\nclass StepRunnerRegistryServiceImpl implements Abstraction.Interface {\n    private readonly runners = new Map<string, StepRunner.Interface>();\n\n    public constructor(runners: StepRunner.Interface[]) {\n        for (const runner of runners) {\n            this.runners.set(runner.type, runner);\n        }\n    }\n\n    public get(type: string): StepRunner.Interface | null {\n        return this.runners.get(type) ?? null;\n    }\n}\n\nexport const StepRunnerRegistryService = Abstraction.createImplementation({\n    implementation: StepRunnerRegistryServiceImpl,\n    dependencies: [[StepRunner, { multiple: true }]]\n});\n"],"names":["StepRunnerRegistryServiceImpl","runners","Map","runner","type","StepRunnerRegistryService","Abstraction","StepRunner"],"mappings":";;AAGA,MAAMA;IAGF,YAAmBC,OAA+B,CAAE;aAFnC,OAAO,GAAG,IAAIC;QAG3B,KAAK,MAAMC,UAAUF,QACjB,IAAI,CAAC,OAAO,CAAC,GAAG,CAACE,OAAO,IAAI,EAAEA;IAEtC;IAEO,IAAIC,IAAY,EAA+B;QAClD,OAAO,IAAI,CAAC,OAAO,CAAC,GAAG,CAACA,SAAS;IACrC;AACJ;AAEO,MAAMC,sDAA4BC,0BAAAA,oBAAgC,CAAC;IACtE,gBAAgBN;IAChB,cAAc;QAAC;YAACO;YAAY;gBAAE,UAAU;YAAK;SAAE;KAAC;AACpD"}

package/features/stepRun/StepRunnerRegistryService/abstractions.d.ts

@@ -0,0 +1,13 @@
+import type { StepRunner } from "../../../features/stepRun/StepRunner/abstractions.js";
+export interface IStepRunnerRegistryService {
+    /**
+     * The runner for this step type; `null` when none is registered. The last resolved
+     * registration per `type` wins (instance registrations resolve before class registrations).
+     */
+    get(type: string): StepRunner.Interface | null;
+}
+/** The registered step runners (R168). */
+export declare const StepRunnerRegistryService: import("@webiny/di").Abstraction<IStepRunnerRegistryService>;
+export declare namespace StepRunnerRegistryService {
+    type Interface = IStepRunnerRegistryService;
+}

package/features/stepRun/StepRunnerRegistryService/abstractions.js

@@ -0,0 +1,5 @@
+import { createAbstraction } from "@webiny/feature/api";
+const StepRunnerRegistryService = createAbstraction("StepRunnerRegistryService");
+export { StepRunnerRegistryService };
+
+//# sourceMappingURL=abstractions.js.map

package/features/stepRun/StepRunnerRegistryService/abstractions.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"features/stepRun/StepRunnerRegistryService/abstractions.js","sources":["../../../../src/features/stepRun/StepRunnerRegistryService/abstractions.ts"],"sourcesContent":["import { createAbstraction } from \"@webiny/feature/api\";\nimport type { StepRunner } from \"~/features/stepRun/StepRunner/abstractions.js\";\n\nexport interface IStepRunnerRegistryService {\n    /**\n     * The runner for this step type; `null` when none is registered. The last resolved\n     * registration per `type` wins (instance registrations resolve before class registrations).\n     */\n    get(type: string): StepRunner.Interface | null;\n}\n\n/** The registered step runners (R168). */\nexport const StepRunnerRegistryService = createAbstraction<IStepRunnerRegistryService>(\n    \"StepRunnerRegistryService\"\n);\n\nexport namespace StepRunnerRegistryService {\n    export type Interface = IStepRunnerRegistryService;\n}\n"],"names":["StepRunnerRegistryService","createAbstraction"],"mappings":";AAYO,MAAMA,4BAA4BC,kBACrC"}

package/features/stepRun/StepRunnerRegistryService/feature.d.ts

@@ -0,0 +1,4 @@
+export declare const StepRunnerRegistryFeature: {
+    name: string;
+    register(container: import("@webiny/di").Container): void;
+};

package/features/stepRun/StepRunnerRegistryService/feature.js

@@ -0,0 +1,11 @@
+import { createFeature } from "@webiny/feature/api";
+import { StepRunnerRegistryService } from "./StepRunnerRegistryService.js";
+const StepRunnerRegistryFeature = createFeature({
+    name: "Workflows/StepRunnerRegistry",
+    register (container) {
+        container.register(StepRunnerRegistryService);
+    }
+});
+export { StepRunnerRegistryFeature };
+
+//# sourceMappingURL=feature.js.map

package/features/stepRun/StepRunnerRegistryService/feature.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"features/stepRun/StepRunnerRegistryService/feature.js","sources":["../../../../src/features/stepRun/StepRunnerRegistryService/feature.ts"],"sourcesContent":["import { createFeature } from \"@webiny/feature/api\";\nimport { StepRunnerRegistryService } from \"./StepRunnerRegistryService.js\";\n\nexport const StepRunnerRegistryFeature = createFeature({\n    name: \"Workflows/StepRunnerRegistry\",\n    register(container) {\n        container.register(StepRunnerRegistryService);\n    }\n});\n"],"names":["StepRunnerRegistryFeature","createFeature","container","StepRunnerRegistryService"],"mappings":";;AAGO,MAAMA,4BAA4BC,cAAc;IACnD,MAAM;IACN,UAASC,SAAS;QACdA,UAAU,QAAQ,CAACC;IACvB;AACJ"}

package/features/stepRun/StepRunnerRegistryService/index.d.ts

@@ -0,0 +1 @@
+export { StepRunnerRegistryService } from "./abstractions.js";

package/features/stepRun/StepRunnerRegistryService/index.js

@@ -0,0 +1 @@
+export { StepRunnerRegistryService } from "./abstractions.js";

package/features/stepRun/StuckStepService/StuckStepService.d.ts

@@ -0,0 +1,20 @@
+import { Logger } from "@webiny/api-core/features/logger/index.js";
+import { GetTaskUseCase } from "@webiny/background-tasks/api/features/GetTask/index.js";
+import type { ReviewData } from "../../../domain/review/types.js";
+import { ReviewSaver } from "../../../features/review/ReviewSaver/abstractions.js";
+import { ReviewRepository } from "../../../domain/review/abstractions/ReviewRepository.js";
+import { StepRunnerRegistryService } from "../../../features/stepRun/StepRunnerRegistryService/index.js";
+import { StuckStepService as Abstraction } from "./abstractions.js";
+declare class StuckStepServiceImpl implements Abstraction.Interface {
+    private getTask;
+    private repository;
+    private saver;
+    private logger;
+    private runners;
+    constructor(getTask: GetTaskUseCase.Interface, repository: ReviewRepository.Interface, saver: ReviewSaver.Interface, logger: Logger.Interface, runners: StepRunnerRegistryService.Interface);
+    check(review: ReviewData): Promise<ReviewData>;
+}
+export declare const StuckStepService: typeof StuckStepServiceImpl & {
+    __abstraction: import("@webiny/di").Abstraction<import("./abstractions.js").IStuckStepService>;
+};
+export {};

package/features/stepRun/StuckStepService/StuckStepService.js

@@ -0,0 +1,142 @@
+import { Logger } from "@webiny/api-core/features/logger/index.js";
+import { TaskDataStatus } from "@webiny/api-core/features/task/TaskService/index.js";
+import { GetTaskUseCase } from "@webiny/background-tasks/api/features/GetTask/index.js";
+import { TaskNotFoundError } from "@webiny/background-tasks/api/domain/errors.js";
+import { Review } from "../../../domain/review/Review.js";
+import { ReviewTargetSyncError } from "../../../domain/review/errors.js";
+import { getStaleStepRunReason } from "../../../domain/review/getStaleStepRunReason.js";
+import { STEP_RUN_NEUTRAL_FAILED_REASON, STEP_RUN_STUCK_GRACE_MS } from "../constants.js";
+import { ReviewSaver } from "../../review/ReviewSaver/abstractions.js";
+import { ReviewRepository } from "../../../domain/review/abstractions/ReviewRepository.js";
+import { StepRunnerRegistryService } from "../StepRunnerRegistryService/index.js";
+import { StuckStepService } from "./abstractions.js";
+import { hasErrorSource } from "../../../domain/hasErrorSource.js";
+class StuckStepServiceImpl {
+    constructor(getTask, repository, saver, logger, runners){
+        this.getTask = getTask;
+        this.repository = repository;
+        this.saver = saver;
+        this.logger = logger;
+        this.runners = runners;
+    }
+    async check(review) {
+        const step = review.steps.find((item)=>item.id === review.currentStepId);
+        if (!step || "inReview" !== step.state) return review;
+        const taskId = step.taskId;
+        if (!taskId) return review;
+        const read = await this.getTask.execute(taskId);
+        if (read.isFail() && !(read.error instanceof TaskNotFoundError)) {
+            this.logger.error({
+                err: read.error,
+                reviewId: review.id,
+                stepId: step.id,
+                taskId
+            }, "Could not read the step run task; the review is returned as read.");
+            return review;
+        }
+        const task = read.isOk() ? read.value : null;
+        if (task) {
+            if (task.taskStatus === TaskDataStatus.PENDING || task.taskStatus === TaskDataStatus.RUNNING) return review;
+            if (task.taskStatus !== TaskDataStatus.SUCCESS) {
+                const finishedAt = Date.parse(task.finishedOn ?? task.savedOn);
+                if (!(Date.now() - finishedAt > STEP_RUN_STUCK_GRACE_MS)) return review;
+            }
+        } else {
+            const stepSince = Date.parse(step.startedOn ?? step.reachedOn ?? review.lastChangedOn);
+            if (!(Date.now() - stepSince > STEP_RUN_STUCK_GRACE_MS)) return review;
+        }
+        const stale = getStaleStepRunReason(review, step.id, {
+            id: taskId,
+            createdById: task ? task.createdBy.id : review.createdBy.id
+        });
+        if (stale) {
+            this.logger.info({
+                reviewId: review.id,
+                stepId: step.id,
+                taskId,
+                reason: stale
+            }, "Stuck detection skipped a stale step run.");
+            return review;
+        }
+        const stored = await this.repository.get(review.id);
+        if (stored.isFail()) {
+            this.logger.error({
+                err: hasErrorSource(stored.error) ? stored.error.source : stored.error,
+                reviewId: review.id,
+                stepId: step.id,
+                taskId
+            }, "Could not re-read the review before failing a stuck step; it is returned as read.");
+            return review;
+        }
+        const storedStale = getStaleStepRunReason(stored.value, step.id, {
+            id: taskId,
+            createdById: task ? task.createdBy.id : stored.value.createdBy.id
+        });
+        if (storedStale) {
+            this.logger.info({
+                reviewId: review.id,
+                stepId: step.id,
+                taskId,
+                reason: storedStale
+            }, "Stuck detection skipped a step run that moved on after the review was read.");
+            return stored.value;
+        }
+        const runner = this.runners.get(step.type);
+        const stuck = Review.fromData(stored.value);
+        const failed = stuck.fail({
+            stepId: step.id,
+            reason: runner ? runner.failureReasons.stuck : STEP_RUN_NEUTRAL_FAILED_REASON,
+            now: new Date().toISOString()
+        });
+        if (failed.isFail()) {
+            this.logger.error({
+                err: hasErrorSource(failed.error) ? failed.error.source : failed.error,
+                reviewId: review.id,
+                stepId: step.id,
+                taskId
+            }, "Could not mark the stuck step as failed; the review is returned as read.");
+            return review;
+        }
+        try {
+            const saved = await this.saver.save(stuck);
+            if (saved.isOk()) return saved.value;
+            if (saved.error instanceof ReviewTargetSyncError) {
+                this.logger.error({
+                    err: hasErrorSource(saved.error) ? saved.error.source : saved.error,
+                    reviewId: review.id,
+                    stepId: step.id,
+                    taskId
+                }, "The stuck step was failed, but syncing the target failed.");
+                return saved.error.data.review;
+            }
+            this.logger.error({
+                err: hasErrorSource(saved.error) ? saved.error.source : saved.error,
+                reviewId: review.id,
+                stepId: step.id,
+                taskId
+            }, "Could not mark the stuck step as failed; the review is returned as read.");
+            return review;
+        } catch (error) {
+            this.logger.error({
+                err: error,
+                reviewId: review.id,
+                stepId: step.id,
+                taskId
+            }, "Could not mark the stuck step as failed; the review is returned as read.");
+            return review;
+        }
+    }
+}
+const StuckStepService_StuckStepService = StuckStepService.createImplementation({
+    implementation: StuckStepServiceImpl,
+    dependencies: [
+        GetTaskUseCase,
+        ReviewRepository,
+        ReviewSaver,
+        Logger,
+        StepRunnerRegistryService
+    ]
+});
+export { StuckStepService_StuckStepService as StuckStepService };
+
+//# sourceMappingURL=StuckStepService.js.map

package/features/stepRun/StuckStepService/StuckStepService.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"features/stepRun/StuckStepService/StuckStepService.js","sources":["../../../../src/features/stepRun/StuckStepService/StuckStepService.ts"],"sourcesContent":["import { Logger } from \"@webiny/api-core/features/logger/index.js\";\nimport { TaskDataStatus } from \"@webiny/api-core/features/task/TaskService/index.js\";\nimport { GetTaskUseCase } from \"@webiny/background-tasks/api/features/GetTask/index.js\";\nimport { TaskNotFoundError } from \"@webiny/background-tasks/api/domain/errors.js\";\nimport { Review } from \"~/domain/review/Review.js\";\nimport { ReviewTargetSyncError } from \"~/domain/review/errors.js\";\nimport { getStaleStepRunReason } from \"~/domain/review/getStaleStepRunReason.js\";\nimport type { ReviewData } from \"~/domain/review/types.js\";\nimport {\n    STEP_RUN_NEUTRAL_FAILED_REASON,\n    STEP_RUN_STUCK_GRACE_MS\n} from \"~/features/stepRun/constants.js\";\nimport { ReviewSaver } from \"~/features/review/ReviewSaver/abstractions.js\";\nimport { ReviewRepository } from \"~/domain/review/abstractions/ReviewRepository.js\";\nimport { StepRunnerRegistryService } from \"~/features/stepRun/StepRunnerRegistryService/index.js\";\nimport { StuckStepService as Abstraction } from \"./abstractions.js\";\nimport { hasErrorSource } from \"~/domain/hasErrorSource.js\";\n\nclass StuckStepServiceImpl implements Abstraction.Interface {\n    constructor(\n        private getTask: GetTaskUseCase.Interface,\n        private repository: ReviewRepository.Interface,\n        private saver: ReviewSaver.Interface,\n        private logger: Logger.Interface,\n        private runners: StepRunnerRegistryService.Interface\n    ) {}\n\n    async check(review: ReviewData): Promise<ReviewData> {\n        const step = review.steps.find(item => item.id === review.currentStepId);\n        if (!step || step.state !== \"inReview\") {\n            return review;\n        }\n        const taskId = step.taskId;\n        if (!taskId) {\n            return review;\n        }\n\n        const read = await this.getTask.execute(taskId);\n        if (read.isFail() && !(read.error instanceof TaskNotFoundError)) {\n            this.logger.error(\n                { err: read.error, reviewId: review.id, stepId: step.id, taskId },\n                \"Could not read the step run task; the review is returned as read.\"\n            );\n            return review;\n        }\n        const task = read.isOk() ? read.value : null;\n        if (!task) {\n            // A missing task gets a grace, measured from when the step started (R152).\n            const stepSince = Date.parse(step.startedOn ?? step.reachedOn ?? review.lastChangedOn);\n            // `!(a > b)` also keeps an unparseable time inside the grace.\n            if (!(Date.now() - stepSince > STEP_RUN_STUCK_GRACE_MS)) {\n                return review;\n            }\n        } else {\n            // A pending or running task is alive.\n            if (\n                task.taskStatus === TaskDataStatus.PENDING ||\n                task.taskStatus === TaskDataStatus.RUNNING\n            ) {\n                return review;\n            }\n            // A failed or aborted task may still be followed by the runner's `onError` /\n            // `onAbort` hook, which fails the step with the proper reason: wait out the grace\n            // before treating the step as stuck (R152). A `success` task writes nothing more.\n            if (task.taskStatus !== TaskDataStatus.SUCCESS) {\n                const finishedAt = Date.parse(task.finishedOn ?? task.savedOn);\n                // `!(a > b)` also keeps an unparseable time inside the grace.\n                if (!(Date.now() - finishedAt > STEP_RUN_STUCK_GRACE_MS)) {\n                    return review;\n                }\n            }\n        }\n\n        // A task that is gone has no creator to compare, so the requester stands in for it.\n        const stale = getStaleStepRunReason(review, step.id, {\n            id: taskId,\n            createdById: task ? task.createdBy.id : review.createdBy.id\n        });\n        if (stale) {\n            this.logger.info(\n                { reviewId: review.id, stepId: step.id, taskId, reason: stale },\n                \"Stuck detection skipped a stale step run.\"\n            );\n            return review;\n        }\n\n        // The review may have moved on since it was read: a run saves its decision before its\n        // task turns `success`, so a read taken before that save sees the step still in review.\n        // Only the stored review is failed, and only when its step is still this run (D27).\n        const stored = await this.repository.get(review.id);\n        if (stored.isFail()) {\n            this.logger.error(\n                {\n                    err: hasErrorSource(stored.error) ? stored.error.source : stored.error,\n                    reviewId: review.id,\n                    stepId: step.id,\n                    taskId\n                },\n                \"Could not re-read the review before failing a stuck step; it is returned as read.\"\n            );\n            return review;\n        }\n        const storedStale = getStaleStepRunReason(stored.value, step.id, {\n            id: taskId,\n            createdById: task ? task.createdBy.id : stored.value.createdBy.id\n        });\n        if (storedStale) {\n            this.logger.info(\n                { reviewId: review.id, stepId: step.id, taskId, reason: storedStale },\n                \"Stuck detection skipped a step run that moved on after the review was read.\"\n            );\n            return stored.value;\n        }\n\n        // The runner of the step's type names the reason; a step whose type has no runner (the\n        // flag or licence was turned off) is still failed, with the neutral text (R168).\n        const runner = this.runners.get(step.type);\n        const stuck = Review.fromData(stored.value);\n        const failed = stuck.fail({\n            stepId: step.id,\n            reason: runner ? runner.failureReasons.stuck : STEP_RUN_NEUTRAL_FAILED_REASON,\n            now: new Date().toISOString()\n        });\n        if (failed.isFail()) {\n            this.logger.error(\n                {\n                    err: hasErrorSource(failed.error) ? failed.error.source : failed.error,\n                    reviewId: review.id,\n                    stepId: step.id,\n                    taskId\n                },\n                \"Could not mark the stuck step as failed; the review is returned as read.\"\n            );\n            return review;\n        }\n\n        try {\n            const saved = await this.saver.save(stuck);\n            if (saved.isOk()) {\n                return saved.value;\n            }\n            // The review is saved, only the target sync failed (R16): the step is failed. The\n            // sync failure is still logged (R159).\n            if (saved.error instanceof ReviewTargetSyncError) {\n                this.logger.error(\n                    {\n                        err: hasErrorSource(saved.error) ? saved.error.source : saved.error,\n                        reviewId: review.id,\n                        stepId: step.id,\n                        taskId\n                    },\n                    \"The stuck step was failed, but syncing the target failed.\"\n                );\n                return saved.error.data.review;\n            }\n            this.logger.error(\n                {\n                    err: hasErrorSource(saved.error) ? saved.error.source : saved.error,\n                    reviewId: review.id,\n                    stepId: step.id,\n                    taskId\n                },\n                \"Could not mark the stuck step as failed; the review is returned as read.\"\n            );\n            return review;\n        } catch (error) {\n            this.logger.error(\n                { err: error, reviewId: review.id, stepId: step.id, taskId },\n                \"Could not mark the stuck step as failed; the review is returned as read.\"\n            );\n            return review;\n        }\n    }\n}\n\nexport const StuckStepService = Abstraction.createImplementation({\n    implementation: StuckStepServiceImpl,\n    dependencies: [GetTaskUseCase, ReviewRepository, ReviewSaver, Logger, StepRunnerRegistryService]\n});\n"],"names":["StuckStepServiceImpl","getTask","repository","saver","logger","runners","review","step","item","taskId","read","TaskNotFoundError","task","TaskDataStatus","finishedAt","Date","STEP_RUN_STUCK_GRACE_MS","stepSince","stale","getStaleStepRunReason","stored","hasErrorSource","storedStale","runner","stuck","Review","failed","STEP_RUN_NEUTRAL_FAILED_REASON","saved","ReviewTargetSyncError","error","StuckStepService","Abstraction","GetTaskUseCase","ReviewRepository","ReviewSaver","Logger","StepRunnerRegistryService"],"mappings":"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"}

package/features/stepRun/StuckStepService/abstractions.d.ts

@@ -0,0 +1,21 @@
+import type { ReviewData } from "../../../domain/review/types.js";
+export interface IStuckStepService {
+    /**
+     * Returns `review` unchanged, or the saved review whose current step was failed because its
+     * task ended without writing a result. Never throws.
+     */
+    check(review: ReviewData): Promise<ReviewData>;
+}
+/**
+ * Stuck detection for single reads (D28, D57, R152, R168): an `inReview` step of any type that
+ * carries a task id, whose task is `success`, `failed` / `aborted` for longer than the grace, or
+ * gone (null task) for longer than the grace, and that passes the stale guard (R144), is failed
+ * with the stuck reason of the runner of its type (`The automation task ended without a result.`
+ * for automation), or `The step failed.` when no runner is registered for the type. Called by
+ * `GetReviewUseCase` and `GetTargetReviewUseCase` only, never by lists. Internal (D132): no
+ * permission checks.
+ */
+export declare const StuckStepService: import("@webiny/di").Abstraction<IStuckStepService>;
+export declare namespace StuckStepService {
+    type Interface = IStuckStepService;
+}

package/features/stepRun/StuckStepService/abstractions.js

@@ -0,0 +1,5 @@
+import { createAbstraction } from "@webiny/feature/api";
+const StuckStepService = createAbstraction("StuckStepService");
+export { StuckStepService };
+
+//# sourceMappingURL=abstractions.js.map

package/features/stepRun/StuckStepService/abstractions.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"features/stepRun/StuckStepService/abstractions.js","sources":["../../../../src/features/stepRun/StuckStepService/abstractions.ts"],"sourcesContent":["import { createAbstraction } from \"@webiny/feature/api\";\nimport type { ReviewData } from \"~/domain/review/types.js\";\n\nexport interface IStuckStepService {\n    /**\n     * Returns `review` unchanged, or the saved review whose current step was failed because its\n     * task ended without writing a result. Never throws.\n     */\n    check(review: ReviewData): Promise<ReviewData>;\n}\n\n/**\n * Stuck detection for single reads (D28, D57, R152, R168): an `inReview` step of any type that\n * carries a task id, whose task is `success`, `failed` / `aborted` for longer than the grace, or\n * gone (null task) for longer than the grace, and that passes the stale guard (R144), is failed\n * with the stuck reason of the runner of its type (`The automation task ended without a result.`\n * for automation), or `The step failed.` when no runner is registered for the type. Called by\n * `GetReviewUseCase` and `GetTargetReviewUseCase` only, never by lists. Internal (D132): no\n * permission checks.\n */\nexport const StuckStepService = createAbstraction<IStuckStepService>(\"StuckStepService\");\n\nexport namespace StuckStepService {\n    export type Interface = IStuckStepService;\n}\n"],"names":["StuckStepService","createAbstraction"],"mappings":";AAoBO,MAAMA,mBAAmBC,kBAAqC"}

package/features/stepRun/StuckStepService/feature.d.ts

@@ -0,0 +1,4 @@
+export declare const StuckStepFeature: {
+    name: string;
+    register(container: import("@webiny/di").Container): void;
+};

package/features/stepRun/StuckStepService/feature.js

@@ -0,0 +1,11 @@
+import { createFeature } from "@webiny/feature/api";
+import { StuckStepService } from "./StuckStepService.js";
+const StuckStepFeature = createFeature({
+    name: "Workflows/StuckStep",
+    register (container) {
+        container.register(StuckStepService);
+    }
+});
+export { StuckStepFeature };
+
+//# sourceMappingURL=feature.js.map

package/features/stepRun/StuckStepService/feature.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"features/stepRun/StuckStepService/feature.js","sources":["../../../../src/features/stepRun/StuckStepService/feature.ts"],"sourcesContent":["import { createFeature } from \"@webiny/feature/api\";\nimport { StuckStepService } from \"./StuckStepService.js\";\n\nexport const StuckStepFeature = createFeature({\n    name: \"Workflows/StuckStep\",\n    register(container) {\n        container.register(StuckStepService);\n    }\n});\n"],"names":["StuckStepFeature","createFeature","container","StuckStepService"],"mappings":";;AAGO,MAAMA,mBAAmBC,cAAc;IAC1C,MAAM;IACN,UAASC,SAAS;QACdA,UAAU,QAAQ,CAACC;IACvB;AACJ"}

package/features/stepRun/StuckStepService/index.d.ts

@@ -0,0 +1 @@
+export { StuckStepService } from "./abstractions.js";

package/features/stepRun/StuckStepService/index.js

@@ -0,0 +1 @@
+export { StuckStepService } from "./abstractions.js";

package/features/stepRun/WorkflowStepRunTask/WorkflowStepRunTaskDefinition.d.ts

@@ -0,0 +1,27 @@
+import { TaskDefinition } from "@webiny/api-core/features/task/TaskDefinition/index.js";
+/**
+ * The one private task that runs a workflow step (R142). Private, so the task list never shows
+ * it and the GraphQL `triggerTask` refuses it as unknown; only the engine
+ * triggers it, through `TaskService.trigger` in the step run reach. The ceiling is high on
+ * purpose: the handler enforces the automation definition's own `maxIterations` (R145).
+ *
+ * The task is kept (R256). Every outcome is already on the step: success through the runner,
+ * failure and abort through the fixed-text `onError` / `onAbort` hooks (raw errors live only in
+ * the logs). No self cleanup is set, so the task stays after the step ends: workflows reads it
+ * for the details drawer (`GetReviewStepRunUseCase`), and `DeleteTargetReviewsUseCase` cleans up
+ * the task of every attempt when its review is deleted. The definition sets no `databaseLogs`
+ * (an abort still writes one log row, which that cleanup deletes with the task). A step whose
+ * task is gone is handled by `StuckStepService` (grace from the step start).
+ */
+declare class WorkflowStepRunTaskDefinitionImpl implements TaskDefinition.Interface {
+    readonly id = "workflowsStepRun";
+    readonly title = "Workflow step run";
+    readonly description = "Runs a step of a workflow review.";
+    readonly isPrivate = true;
+    readonly maxIterations = 10000;
+    readonly handler: TaskDefinition.Interface["handler"];
+}
+export declare const WorkflowStepRunTaskDefinition: typeof WorkflowStepRunTaskDefinitionImpl & {
+    __abstraction: import("@webiny/di").Abstraction<import("@webiny/api-core/features/task/TaskDefinition/abstractions.js").ITaskDefinition<import("@webiny/api-core/features/task/TaskDefinition/abstractions.js").ITaskInput, import("@webiny/api-core/features/task/TaskDefinition/abstractions.js").ITaskOutput>>;
+};
+export {};

package/features/stepRun/WorkflowStepRunTask/WorkflowStepRunTaskDefinition.js

@@ -0,0 +1,20 @@
+import { TaskDefinition } from "@webiny/api-core/features/task/TaskDefinition/index.js";
+import { STEP_RUN_MAX_ITERATIONS, STEP_RUN_TASK_DEFINITION_ID } from "../constants.js";
+import { WorkflowStepRunTaskHandler } from "./WorkflowStepRunTaskHandler.js";
+class WorkflowStepRunTaskDefinitionImpl {
+    constructor(){
+        this.id = STEP_RUN_TASK_DEFINITION_ID;
+        this.title = "Workflow step run";
+        this.description = "Runs a step of a workflow review.";
+        this.isPrivate = true;
+        this.maxIterations = STEP_RUN_MAX_ITERATIONS;
+        this.handler = WorkflowStepRunTaskHandler;
+    }
+}
+const WorkflowStepRunTaskDefinition = TaskDefinition.createImplementation({
+    implementation: WorkflowStepRunTaskDefinitionImpl,
+    dependencies: []
+});
+export { WorkflowStepRunTaskDefinition };
+
+//# sourceMappingURL=WorkflowStepRunTaskDefinition.js.map

package/features/stepRun/WorkflowStepRunTask/WorkflowStepRunTaskDefinition.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"features/stepRun/WorkflowStepRunTask/WorkflowStepRunTaskDefinition.js","sources":["../../../../src/features/stepRun/WorkflowStepRunTask/WorkflowStepRunTaskDefinition.ts"],"sourcesContent":["import { TaskDefinition } from \"@webiny/api-core/features/task/TaskDefinition/index.js\";\nimport { STEP_RUN_MAX_ITERATIONS, STEP_RUN_TASK_DEFINITION_ID } from \"../constants.js\";\nimport { WorkflowStepRunTaskHandler } from \"./WorkflowStepRunTaskHandler.js\";\n\n/**\n * The one private task that runs a workflow step (R142). Private, so the task list never shows\n * it and the GraphQL `triggerTask` refuses it as unknown; only the engine\n * triggers it, through `TaskService.trigger` in the step run reach. The ceiling is high on\n * purpose: the handler enforces the automation definition's own `maxIterations` (R145).\n *\n * The task is kept (R256). Every outcome is already on the step: success through the runner,\n * failure and abort through the fixed-text `onError` / `onAbort` hooks (raw errors live only in\n * the logs). No self cleanup is set, so the task stays after the step ends: workflows reads it\n * for the details drawer (`GetReviewStepRunUseCase`), and `DeleteTargetReviewsUseCase` cleans up\n * the task of every attempt when its review is deleted. The definition sets no `databaseLogs`\n * (an abort still writes one log row, which that cleanup deletes with the task). A step whose\n * task is gone is handled by `StuckStepService` (grace from the step start).\n */\nclass WorkflowStepRunTaskDefinitionImpl implements TaskDefinition.Interface {\n    public readonly id = STEP_RUN_TASK_DEFINITION_ID;\n    public readonly title = \"Workflow step run\";\n    public readonly description = \"Runs a step of a workflow review.\";\n    public readonly isPrivate = true;\n    public readonly maxIterations = STEP_RUN_MAX_ITERATIONS;\n\n    public readonly handler: TaskDefinition.Interface[\"handler\"] = WorkflowStepRunTaskHandler;\n}\n\nexport const WorkflowStepRunTaskDefinition = TaskDefinition.createImplementation({\n    implementation: WorkflowStepRunTaskDefinitionImpl,\n    dependencies: []\n});\n"],"names":["WorkflowStepRunTaskDefinitionImpl","STEP_RUN_TASK_DEFINITION_ID","STEP_RUN_MAX_ITERATIONS","WorkflowStepRunTaskHandler","WorkflowStepRunTaskDefinition","TaskDefinition"],"mappings":";;;AAkBA,MAAMA;;aACc,EAAE,GAAGC;aACL,KAAK,GAAG;aACR,WAAW,GAAG;aACd,SAAS,GAAG;aACZ,aAAa,GAAGC;aAEhB,OAAO,GAAwCC;;AACnE;AAEO,MAAMC,gCAAgCC,eAAe,oBAAoB,CAAC;IAC7E,gBAAgBL;IAChB,cAAc,EAAE;AACpB"}

package/features/stepRun/WorkflowStepRunTask/WorkflowStepRunTaskHandler.d.ts

@@ -0,0 +1,43 @@
+import "@webiny/background-tasks/api/features/TaskController/augmentation.js";
+import { TaskHandler, type TaskDefinition } from "@webiny/api-core/features/task/TaskDefinition/index.js";
+import { IdentityContext } from "@webiny/api-core/features/security/IdentityContext/index.js";
+import { Logger } from "@webiny/api-core/features/logger/index.js";
+import { ReviewRepository } from "../../../domain/review/abstractions/ReviewRepository.js";
+import { ApproveReviewStepUseCase } from "../../../features/review/ApproveReviewStep/index.js";
+import { RejectReviewStepUseCase } from "../../../features/review/RejectReviewStep/index.js";
+import { ReviewSaver } from "../../../features/review/ReviewSaver/abstractions.js";
+import { StepRunnerRegistryService } from "../StepRunnerRegistryService/index.js";
+import type { StepRunTaskInput } from "../types.js";
+type RunParams = TaskHandler.RunParams<StepRunTaskInput>;
+type HookParams = TaskHandler.LifecycleHookParams<StepRunTaskInput>;
+/**
+ * Runs one step of any type (spec 7.4, R142, R168). `run` reads the review, applies the stale
+ * guard (a forged, foreign or restarted task writes nothing, R144, R148), waits a few iterations
+ * for its task id to appear on the step (R143), hands the step to the `StepRunner` registered for
+ * its type, which runs as the requester (R150, R161), and applies the runner's outcome through
+ * the base approve and reject use cases as the runner's actor (R141). Every failure fails the
+ * step once, with a fixed reason (R146). The failure hooks fail the step when the runner reports
+ * an error, the iteration ceiling or an abort. Every write is guarded; a hook never throws.
+ */
+declare class WorkflowStepRunTaskHandlerImpl implements TaskHandler.Interface<StepRunTaskInput> {
+    private repository;
+    private saver;
+    private logger;
+    private runners;
+    private approveStep;
+    private rejectStep;
+    private identityContext;
+    constructor(repository: ReviewRepository.Interface, saver: ReviewSaver.Interface, logger: Logger.Interface, runners: StepRunnerRegistryService.Interface, approveStep: ApproveReviewStepUseCase.Interface, rejectStep: RejectReviewStepUseCase.Interface, identityContext: IdentityContext.Interface);
+    run({ input, controller }: RunParams): Promise<import("@webiny/api-core/features/task/TaskDefinition/abstractions.js").ITaskResultError | TaskDefinition.ResultContinue<StepRunTaskInput> | TaskDefinition.ResultDone<import("@webiny/api-core/features/task/TaskDefinition/abstractions.js").ITaskOutput>>;
+    createInputValidation({ validator }: TaskDefinition.CreateInputValidationParams): {
+        reviewId: import("zod").ZodString;
+        stepId: import("zod").ZodString;
+    };
+    onError({ task }: HookParams): Promise<void>;
+    onMaxIterations({ task }: HookParams): Promise<void>;
+    onAbort({ task }: HookParams): Promise<void>;
+}
+export declare const WorkflowStepRunTaskHandler: typeof WorkflowStepRunTaskHandlerImpl & {
+    __abstraction: import("@webiny/di").Abstraction<import("@webiny/api-core/features/task/TaskDefinition/abstractions.js").ITaskHandler<import("@webiny/api-core/features/task/TaskDefinition/abstractions.js").ITaskInput, import("@webiny/api-core/features/task/TaskDefinition/abstractions.js").ITaskOutput>>;
+};
+export {};