@webiny/api-workflows 0.0.0-unstable.a4f3e4ea8b → 0.0.0-unstable.a85ef555b2

package/features/stepRun/GetReviewStepRun/toReviewStepRunInfo.js

@@ -0,0 +1,52 @@
+import { TaskDataStatus } from "@webiny/api-core/features/task/TaskService/index.js";
+const STATUS_BY_TASK_STATUS = {
+    [TaskDataStatus.PENDING]: "pending",
+    [TaskDataStatus.RUNNING]: "running",
+    [TaskDataStatus.SUCCESS]: "done",
+    [TaskDataStatus.FAILED]: "failed",
+    [TaskDataStatus.ABORTED]: "aborted"
+};
+const getCurrentAttempt = (step)=>{
+    const attempt = {
+        startedOn: step.startedOn,
+        finishedOn: step.finishedOn,
+        outcome: null,
+        reason: null
+    };
+    if ("failed" === step.state) {
+        attempt.outcome = "failed";
+        attempt.reason = step.comment;
+    }
+    if ("approved" === step.state) attempt.outcome = "approved";
+    if ("rejected" === step.state) attempt.outcome = "rejected";
+    return attempt;
+};
+const getEarlierAttempt = (run)=>({
+        startedOn: run.startedOn,
+        finishedOn: run.finishedOn,
+        outcome: run.outcome,
+        reason: run.reason
+    });
+const getRunCount = (task)=>{
+    const storedWaits = task.output?.idWaits;
+    const idWaits = "number" == typeof storedWaits ? storedWaits : task.iterations - 1;
+    return Math.max(0, task.iterations - idWaits);
+};
+const toReviewStepRunInfo = (params)=>{
+    const { step, taskId, task } = params;
+    const earlier = step.runs.find((run)=>run.taskId === taskId);
+    let attempt = getCurrentAttempt(step);
+    if (step.taskId !== taskId && earlier) attempt = getEarlierAttempt(earlier);
+    return {
+        taskId,
+        status: STATUS_BY_TASK_STATUS[task.taskStatus],
+        startedOn: attempt.startedOn ?? task.startedOn ?? null,
+        finishedOn: attempt.finishedOn ?? task.finishedOn ?? null,
+        iterations: getRunCount(task),
+        outcome: attempt.outcome,
+        reason: attempt.reason
+    };
+};
+export { toReviewStepRunInfo };
+
+//# sourceMappingURL=toReviewStepRunInfo.js.map

package/features/stepRun/GetReviewStepRun/toReviewStepRunInfo.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"features/stepRun/GetReviewStepRun/toReviewStepRunInfo.js","sources":["../../../../src/features/stepRun/GetReviewStepRun/toReviewStepRunInfo.ts"],"sourcesContent":["import {\n    TaskDataStatus,\n    type TaskService\n} from \"@webiny/api-core/features/task/TaskService/index.js\";\nimport type { ReviewStepRunInfo, StepRunTaskStatus } from \"~/domain/review/ReviewStepRunInfo.js\";\nimport type { ReviewStep, ReviewStepRun, StepRunOutcome } from \"~/domain/review/types.js\";\n\nexport interface ToReviewStepRunInfoParams {\n    step: ReviewStep;\n    /** The step's current task id or the task id of one of its earlier runs. */\n    taskId: string;\n    task: TaskService.Task;\n}\n\n/** What the review knows about one attempt: its times, its outcome and its fixed reason. */\ninterface StepRunAttempt {\n    startedOn: string | null;\n    finishedOn: string | null;\n    outcome: StepRunOutcome | null;\n    reason: string | null;\n}\n\nconst STATUS_BY_TASK_STATUS: Record<TaskDataStatus, StepRunTaskStatus> = {\n    [TaskDataStatus.PENDING]: \"pending\",\n    [TaskDataStatus.RUNNING]: \"running\",\n    [TaskDataStatus.SUCCESS]: \"done\",\n    [TaskDataStatus.FAILED]: \"failed\",\n    [TaskDataStatus.ABORTED]: \"aborted\"\n};\n\n/** The current attempt reads its outcome from the step's state (R257). */\nconst getCurrentAttempt = (step: ReviewStep): StepRunAttempt => {\n    const attempt: StepRunAttempt = {\n        startedOn: step.startedOn,\n        finishedOn: step.finishedOn,\n        outcome: null,\n        reason: null\n    };\n    if (step.state === \"failed\") {\n        attempt.outcome = \"failed\";\n        attempt.reason = step.comment;\n    }\n    if (step.state === \"approved\") {\n        attempt.outcome = \"approved\";\n    }\n    if (step.state === \"rejected\") {\n        attempt.outcome = \"rejected\";\n    }\n    return attempt;\n};\n\nconst getEarlierAttempt = (run: ReviewStepRun): StepRunAttempt => {\n    return {\n        startedOn: run.startedOn,\n        finishedOn: run.finishedOn,\n        outcome: run.outcome,\n        reason: run.reason\n    };\n};\n\n/**\n * The run count of the automation itself, computed as `WorkflowStepRunTaskHandler` does: the\n * task's `iterations` also count the waits for the task id (`output.idWaits`, which defaults to\n * `iterations - 1` when it was never stored), and those are not runs.\n */\nconst getRunCount = (task: TaskService.Task): number => {\n    const storedWaits = task.output?.idWaits;\n    const idWaits = typeof storedWaits === \"number\" ? storedWaits : task.iterations - 1;\n    return Math.max(0, task.iterations - idWaits);\n};\n\n/**\n * Builds the step run info of one attempt (R257) from the review's step and the task. `outcome`\n * and `reason` come from the review, never from the task (R146); times prefer the review's record\n * and fall back to the task's. Nothing else of the task is read.\n */\nexport const toReviewStepRunInfo = (params: ToReviewStepRunInfoParams): ReviewStepRunInfo => {\n    const { step, taskId, task } = params;\n    const earlier = step.runs.find(run => run.taskId === taskId);\n\n    let attempt = getCurrentAttempt(step);\n    if (step.taskId !== taskId && earlier) {\n        attempt = getEarlierAttempt(earlier);\n    }\n\n    return {\n        taskId,\n        status: STATUS_BY_TASK_STATUS[task.taskStatus],\n        startedOn: attempt.startedOn ?? task.startedOn ?? null,\n        finishedOn: attempt.finishedOn ?? task.finishedOn ?? null,\n        iterations: getRunCount(task),\n        outcome: attempt.outcome,\n        reason: attempt.reason\n    };\n};\n"],"names":["STATUS_BY_TASK_STATUS","TaskDataStatus","getCurrentAttempt","step","attempt","getEarlierAttempt","run","getRunCount","task","storedWaits","idWaits","Math","toReviewStepRunInfo","params","taskId","earlier"],"mappings":";AAsBA,MAAMA,wBAAmE;IACrE,CAACC,eAAe,OAAO,CAAC,EAAE;IAC1B,CAACA,eAAe,OAAO,CAAC,EAAE;IAC1B,CAACA,eAAe,OAAO,CAAC,EAAE;IAC1B,CAACA,eAAe,MAAM,CAAC,EAAE;IACzB,CAACA,eAAe,OAAO,CAAC,EAAE;AAC9B;AAGA,MAAMC,oBAAoB,CAACC;IACvB,MAAMC,UAA0B;QAC5B,WAAWD,KAAK,SAAS;QACzB,YAAYA,KAAK,UAAU;QAC3B,SAAS;QACT,QAAQ;IACZ;IACA,IAAIA,AAAe,aAAfA,KAAK,KAAK,EAAe;QACzBC,QAAQ,OAAO,GAAG;QAClBA,QAAQ,MAAM,GAAGD,KAAK,OAAO;IACjC;IACA,IAAIA,AAAe,eAAfA,KAAK,KAAK,EACVC,QAAQ,OAAO,GAAG;IAEtB,IAAID,AAAe,eAAfA,KAAK,KAAK,EACVC,QAAQ,OAAO,GAAG;IAEtB,OAAOA;AACX;AAEA,MAAMC,oBAAoB,CAACC,MAChB;QACH,WAAWA,IAAI,SAAS;QACxB,YAAYA,IAAI,UAAU;QAC1B,SAASA,IAAI,OAAO;QACpB,QAAQA,IAAI,MAAM;IACtB;AAQJ,MAAMC,cAAc,CAACC;IACjB,MAAMC,cAAcD,KAAK,MAAM,EAAE;IACjC,MAAME,UAAU,AAAuB,YAAvB,OAAOD,cAA2BA,cAAcD,KAAK,UAAU,GAAG;IAClF,OAAOG,KAAK,GAAG,CAAC,GAAGH,KAAK,UAAU,GAAGE;AACzC;AAOO,MAAME,sBAAsB,CAACC;IAChC,MAAM,EAAEV,IAAI,EAAEW,MAAM,EAAEN,IAAI,EAAE,GAAGK;IAC/B,MAAME,UAAUZ,KAAK,IAAI,CAAC,IAAI,CAACG,CAAAA,MAAOA,IAAI,MAAM,KAAKQ;IAErD,IAAIV,UAAUF,kBAAkBC;IAChC,IAAIA,KAAK,MAAM,KAAKW,UAAUC,SAC1BX,UAAUC,kBAAkBU;IAGhC,OAAO;QACHD;QACA,QAAQd,qBAAqB,CAACQ,KAAK,UAAU,CAAC;QAC9C,WAAWJ,QAAQ,SAAS,IAAII,KAAK,SAAS,IAAI;QAClD,YAAYJ,QAAQ,UAAU,IAAII,KAAK,UAAU,IAAI;QACrD,YAAYD,YAAYC;QACxB,SAASJ,QAAQ,OAAO;QACxB,QAAQA,QAAQ,MAAM;IAC1B;AACJ"}

package/features/stepRun/ReviewTaskAbortService/ReviewTaskAbortService.d.ts

@@ -0,0 +1,13 @@
+import { Logger } from "@webiny/api-core/features/logger/index.js";
+import { TaskService } from "@webiny/api-core/features/task/TaskService/index.js";
+import { ReviewTaskAbortService as Abstraction } from "./abstractions.js";
+declare class ReviewTaskAbortServiceImpl implements Abstraction.Interface {
+    private taskService;
+    private logger;
+    constructor(taskService: TaskService.Interface, logger: Logger.Interface);
+    abort(params: Abstraction.Params): Promise<void>;
+}
+export declare const ReviewTaskAbortService: typeof ReviewTaskAbortServiceImpl & {
+    __abstraction: import("@webiny/di").Abstraction<import("./abstractions.js").IReviewTaskAbortService>;
+};
+export {};

package/features/stepRun/ReviewTaskAbortService/ReviewTaskAbortService.js

@@ -0,0 +1,41 @@
+import { TaskAbortError, TaskNotFoundError } from "@webiny/background-tasks/api/domain/errors.js";
+import { Logger } from "@webiny/api-core/features/logger/index.js";
+import { TaskService } from "@webiny/api-core/features/task/TaskService/index.js";
+import { ReviewTaskAbortService } from "./abstractions.js";
+import { hasErrorSource } from "../../../domain/hasErrorSource.js";
+class ReviewTaskAbortServiceImpl {
+    constructor(taskService, logger){
+        this.taskService = taskService;
+        this.logger = logger;
+    }
+    async abort(params) {
+        for (const taskId of params.taskIds)try {
+            const result = await this.taskService.abort({
+                id: taskId,
+                message: params.message
+            });
+            if (result.isFail() && (result.error instanceof TaskAbortError || result.error instanceof TaskNotFoundError)) this.logger.info({
+                taskId
+            }, "The step run task had already ended.");
+            else if (result.isFail()) this.logger.error({
+                err: hasErrorSource(result.error) ? result.error.source : result.error,
+                taskId
+            }, "Could not abort a workflow step run task.");
+        } catch (error) {
+            this.logger.error({
+                err: error,
+                taskId
+            }, "Could not abort a workflow step run task.");
+        }
+    }
+}
+const ReviewTaskAbortService_ReviewTaskAbortService = ReviewTaskAbortService.createImplementation({
+    implementation: ReviewTaskAbortServiceImpl,
+    dependencies: [
+        TaskService,
+        Logger
+    ]
+});
+export { ReviewTaskAbortService_ReviewTaskAbortService as ReviewTaskAbortService };
+
+//# sourceMappingURL=ReviewTaskAbortService.js.map

package/features/stepRun/ReviewTaskAbortService/ReviewTaskAbortService.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"features/stepRun/ReviewTaskAbortService/ReviewTaskAbortService.js","sources":["../../../../src/features/stepRun/ReviewTaskAbortService/ReviewTaskAbortService.ts"],"sourcesContent":["import { TaskAbortError, TaskNotFoundError } from \"@webiny/background-tasks/api/domain/errors.js\";\nimport { Logger } from \"@webiny/api-core/features/logger/index.js\";\nimport { TaskService } from \"@webiny/api-core/features/task/TaskService/index.js\";\nimport { ReviewTaskAbortService as Abstraction } from \"./abstractions.js\";\nimport { hasErrorSource } from \"~/domain/hasErrorSource.js\";\n\nclass ReviewTaskAbortServiceImpl implements Abstraction.Interface {\n    public constructor(\n        private taskService: TaskService.Interface,\n        private logger: Logger.Interface\n    ) {}\n\n    public async abort(params: Abstraction.Params): Promise<void> {\n        for (const taskId of params.taskIds) {\n            try {\n                // oxlint-disable-next-line no-await-in-loop -- one abort per task (no batch abort); a handful of tasks per call.\n                const result = await this.taskService.abort({\n                    id: taskId,\n                    message: params.message\n                });\n                if (\n                    result.isFail() &&\n                    (result.error instanceof TaskAbortError ||\n                        result.error instanceof TaskNotFoundError)\n                ) {\n                    // The task is no longer pending or running, or it already cleaned itself up\n                    // (R179): nothing left to abort.\n                    this.logger.info({ taskId }, \"The step run task had already ended.\");\n                } else if (result.isFail()) {\n                    this.logger.error(\n                        {\n                            err: hasErrorSource(result.error) ? result.error.source : result.error,\n                            taskId\n                        },\n                        \"Could not abort a workflow step run task.\"\n                    );\n                }\n            } catch (error) {\n                this.logger.error(\n                    { err: error, taskId },\n                    \"Could not abort a workflow step run task.\"\n                );\n            }\n        }\n    }\n}\n\nexport const ReviewTaskAbortService = Abstraction.createImplementation({\n    implementation: ReviewTaskAbortServiceImpl,\n    dependencies: [TaskService, Logger]\n});\n"],"names":["ReviewTaskAbortServiceImpl","taskService","logger","params","taskId","result","TaskAbortError","TaskNotFoundError","hasErrorSource","error","ReviewTaskAbortService","Abstraction","TaskService","Logger"],"mappings":";;;;;AAMA,MAAMA;IACF,YACYC,WAAkC,EAClCC,MAAwB,CAClC;aAFUD,WAAW,GAAXA;aACAC,MAAM,GAANA;IACT;IAEH,MAAa,MAAMC,MAA0B,EAAiB;QAC1D,KAAK,MAAMC,UAAUD,OAAO,OAAO,CAC/B,IAAI;YAEA,MAAME,SAAS,MAAM,IAAI,CAAC,WAAW,CAAC,KAAK,CAAC;gBACxC,IAAID;gBACJ,SAASD,OAAO,OAAO;YAC3B;YACA,IACIE,OAAO,MAAM,MACZA,CAAAA,OAAO,KAAK,YAAYC,kBACrBD,OAAO,KAAK,YAAYE,iBAAgB,GAI5C,IAAI,CAAC,MAAM,CAAC,IAAI,CAAC;gBAAEH;YAAO,GAAG;iBAC1B,IAAIC,OAAO,MAAM,IACpB,IAAI,CAAC,MAAM,CAAC,KAAK,CACb;gBACI,KAAKG,eAAeH,OAAO,KAAK,IAAIA,OAAO,KAAK,CAAC,MAAM,GAAGA,OAAO,KAAK;gBACtED;YACJ,GACA;QAGZ,EAAE,OAAOK,OAAO;YACZ,IAAI,CAAC,MAAM,CAAC,KAAK,CACb;gBAAE,KAAKA;gBAAOL;YAAO,GACrB;QAER;IAER;AACJ;AAEO,MAAMM,gDAAyBC,uBAAAA,oBAAgC,CAAC;IACnE,gBAAgBX;IAChB,cAAc;QAACY;QAAaC;KAAO;AACvC"}

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

@@ -0,0 +1,20 @@
+export interface ReviewTaskAbortParams {
+    taskIds: string[];
+    message: string;
+}
+export interface IReviewTaskAbortService {
+    /**
+     * Aborts the step run tasks, best effort: a failed or throwing abort is logged and never
+     * propagates; the other ids are still aborted. An empty list makes no call.
+     */
+    abort(params: ReviewTaskAbortParams): Promise<void>;
+}
+/**
+ * Shared by `ReviewSaver` (abort when the save fails, R143), the automation reach (abort when
+ * `reachRun` fails after a trigger) and cancel and delete (R151).
+ */
+export declare const ReviewTaskAbortService: import("@webiny/di").Abstraction<IReviewTaskAbortService>;
+export declare namespace ReviewTaskAbortService {
+    type Interface = IReviewTaskAbortService;
+    type Params = ReviewTaskAbortParams;
+}

package/features/stepRun/ReviewTaskAbortService/abstractions.js

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"features/stepRun/ReviewTaskAbortService/abstractions.js","sources":["../../../../src/features/stepRun/ReviewTaskAbortService/abstractions.ts"],"sourcesContent":["import { createAbstraction } from \"@webiny/feature/api\";\n\nexport interface ReviewTaskAbortParams {\n    taskIds: string[];\n    message: string;\n}\n\nexport interface IReviewTaskAbortService {\n    /**\n     * Aborts the step run tasks, best effort: a failed or throwing abort is logged and never\n     * propagates; the other ids are still aborted. An empty list makes no call.\n     */\n    abort(params: ReviewTaskAbortParams): Promise<void>;\n}\n\n/**\n * Shared by `ReviewSaver` (abort when the save fails, R143), the automation reach (abort when\n * `reachRun` fails after a trigger) and cancel and delete (R151).\n */\nexport const ReviewTaskAbortService =\n    createAbstraction<IReviewTaskAbortService>(\"ReviewTaskAbortService\");\n\nexport namespace ReviewTaskAbortService {\n    export type Interface = IReviewTaskAbortService;\n    export type Params = ReviewTaskAbortParams;\n}\n"],"names":["ReviewTaskAbortService","createAbstraction"],"mappings":";AAmBO,MAAMA,yBACTC,kBAA2C"}

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

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

package/features/stepRun/ReviewTaskAbortService/feature.js

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

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

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

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

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

package/features/stepRun/ReviewTaskAbortService/index.js

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

package/features/stepRun/StepRunFailure.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Thrown inside the step run handler to fail the step with a fixed reason (R146). `run` catches it
+ * and writes the failure once; it never leaves the handler.
+ */
+export declare class StepRunFailure extends Error {
+    readonly reason: string;
+    constructor(reason: string);
+}

package/features/stepRun/StepRunFailure.js

@@ -0,0 +1,9 @@
+class StepRunFailure extends Error {
+    constructor(reason){
+        super(reason), this.reason = reason;
+        this.name = "StepRunFailure";
+    }
+}
+export { StepRunFailure };
+
+//# sourceMappingURL=StepRunFailure.js.map

package/features/stepRun/StepRunFailure.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"features/stepRun/StepRunFailure.js","sources":["../../../src/features/stepRun/StepRunFailure.ts"],"sourcesContent":["/**\n * Thrown inside the step run handler to fail the step with a fixed reason (R146). `run` catches it\n * and writes the failure once; it never leaves the handler.\n */\nexport class StepRunFailure extends Error {\n    public constructor(public readonly reason: string) {\n        super(reason);\n        this.name = \"StepRunFailure\";\n    }\n}\n"],"names":["StepRunFailure","Error","reason"],"mappings":"AAIO,MAAMA,uBAAuBC;IAChC,YAAmCC,MAAc,CAAE;QAC/C,KAAK,CAACA,SAAAA,IAAAA,CADyBA,MAAM,GAANA;QAE/B,IAAI,CAAC,IAAI,GAAG;IAChB;AACJ"}

package/features/stepRun/StepRunReachService/StepRunReachService.d.ts

@@ -0,0 +1,18 @@
+import { Result } from "@webiny/feature/api";
+import { IdentityContext } from "@webiny/api-core/features/security/IdentityContext/index.js";
+import { Logger } from "@webiny/api-core/features/logger/index.js";
+import { TaskService } from "@webiny/api-core/features/task/TaskService/index.js";
+import { ReviewTaskAbortService } from "../../../features/stepRun/ReviewTaskAbortService/index.js";
+import { StepRunReachService as Abstraction } from "./abstractions.js";
+declare class StepRunReachServiceImpl implements Abstraction.Interface {
+    private taskService;
+    private identityContext;
+    private taskAbort;
+    private logger;
+    constructor(taskService: TaskService.Interface, identityContext: IdentityContext.Interface, taskAbort: ReviewTaskAbortService.Interface, logger: Logger.Interface);
+    reach({ review, step, actor, owner, now, failure, startFailure }: Abstraction.Params): Promise<Result<void, never> | Result<never, import("../../../domain/review/Review.js").ReviewFailError>>;
+}
+export declare const StepRunReachService: typeof StepRunReachServiceImpl & {
+    __abstraction: import("@webiny/di").Abstraction<import("./abstractions.js").IStepRunReachService>;
+};
+export {};

package/features/stepRun/StepRunReachService/StepRunReachService.js

@@ -0,0 +1,87 @@
+import { Result } from "@webiny/feature/api";
+import { IdentityContext } from "@webiny/api-core/features/security/IdentityContext/index.js";
+import { Logger } from "@webiny/api-core/features/logger/index.js";
+import { TaskService } from "@webiny/api-core/features/task/TaskService/index.js";
+import { getRequesterIdentity } from "../../../domain/automation/getRequesterIdentity.js";
+import { STEP_RUN_TASK_DEFINITION_ID } from "../constants.js";
+import { ReviewTaskAbortService } from "../ReviewTaskAbortService/index.js";
+import { StepRunReachService } from "./abstractions.js";
+import { hasErrorSource } from "../../../domain/hasErrorSource.js";
+class StepRunReachServiceImpl {
+    constructor(taskService, identityContext, taskAbort, logger){
+        this.taskService = taskService;
+        this.identityContext = identityContext;
+        this.taskAbort = taskAbort;
+        this.logger = logger;
+    }
+    async reach({ review, step, actor, owner, now, failure, startFailure }) {
+        const data = review.toData();
+        const requester = data.createdBy;
+        let reason = failure;
+        let taskId = null;
+        if (null === reason) {
+            const input = {
+                reviewId: data.id,
+                stepId: step.id
+            };
+            const identity = getRequesterIdentity(requester);
+            try {
+                const triggered = await this.identityContext.withIdentity(identity, ()=>this.taskService.trigger({
+                        definition: STEP_RUN_TASK_DEFINITION_ID,
+                        name: `Workflow step: ${step.title}`,
+                        input
+                    }));
+                if (triggered.isFail()) {
+                    this.logger.error({
+                        err: hasErrorSource(triggered.error) ? triggered.error.source : triggered.error,
+                        reviewId: data.id,
+                        stepId: step.id
+                    }, "Could not start the step run task.");
+                    reason = startFailure;
+                } else taskId = triggered.value.id;
+            } catch (error) {
+                this.logger.error({
+                    err: error,
+                    reviewId: data.id,
+                    stepId: step.id
+                }, "Could not start the step run task.");
+                reason = startFailure;
+            }
+        }
+        const reached = review.reachRun({
+            actor,
+            owner,
+            taskId,
+            now
+        });
+        if (reached.isFail()) {
+            if (null !== taskId) await this.taskAbort.abort({
+                taskIds: [
+                    taskId
+                ],
+                message: "The review could not be saved."
+            });
+            return Result.fail(reached.error);
+        }
+        if (null === reason) return Result.ok();
+        const failed = review.fail({
+            stepId: step.id,
+            reason,
+            now
+        });
+        if (failed.isFail()) return Result.fail(failed.error);
+        return Result.ok();
+    }
+}
+const StepRunReachService_StepRunReachService = StepRunReachService.createImplementation({
+    implementation: StepRunReachServiceImpl,
+    dependencies: [
+        TaskService,
+        IdentityContext,
+        ReviewTaskAbortService,
+        Logger
+    ]
+});
+export { StepRunReachService_StepRunReachService as StepRunReachService };
+
+//# sourceMappingURL=StepRunReachService.js.map

package/features/stepRun/StepRunReachService/StepRunReachService.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"features/stepRun/StepRunReachService/StepRunReachService.js","sources":["../../../../src/features/stepRun/StepRunReachService/StepRunReachService.ts"],"sourcesContent":["import { Result } from \"@webiny/feature/api\";\nimport { IdentityContext } from \"@webiny/api-core/features/security/IdentityContext/index.js\";\nimport { Logger } from \"@webiny/api-core/features/logger/index.js\";\nimport { TaskService } from \"@webiny/api-core/features/task/TaskService/index.js\";\nimport { getRequesterIdentity } from \"~/domain/automation/getRequesterIdentity.js\";\nimport { STEP_RUN_TASK_DEFINITION_ID } from \"~/features/stepRun/constants.js\";\nimport type { StepRunTaskInput } from \"~/features/stepRun/types.js\";\nimport { ReviewTaskAbortService } from \"~/features/stepRun/ReviewTaskAbortService/index.js\";\nimport { StepRunReachService as Abstraction } from \"./abstractions.js\";\nimport { hasErrorSource } from \"~/domain/hasErrorSource.js\";\n\nclass StepRunReachServiceImpl implements Abstraction.Interface {\n    public constructor(\n        private taskService: TaskService.Interface,\n        private identityContext: IdentityContext.Interface,\n        private taskAbort: ReviewTaskAbortService.Interface,\n        private logger: Logger.Interface\n    ) {}\n\n    public async reach({\n        review,\n        step,\n        actor,\n        owner,\n        now,\n        failure,\n        startFailure\n    }: Abstraction.Params) {\n        const data = review.toData();\n        const requester = data.createdBy;\n\n        // The trigger runs as the requester, never as `actor` (the approver of the previous step,\n        // the restarter or the task itself): the task's `createdBy` must be the requester, which\n        // the run handler checks (R148, R149). `TaskService.trigger` is unchanged; the identity\n        // is switched for this call only and restored by `withIdentity`.\n        let reason = failure;\n        let taskId: string | null = null;\n        if (reason === null) {\n            const input: StepRunTaskInput = { reviewId: data.id, stepId: step.id };\n            const identity = getRequesterIdentity(requester);\n            try {\n                const triggered = await this.identityContext.withIdentity(identity, () => {\n                    return this.taskService.trigger({\n                        definition: STEP_RUN_TASK_DEFINITION_ID,\n                        name: `Workflow step: ${step.title}`,\n                        input\n                    });\n                });\n                if (triggered.isFail()) {\n                    // The raw message can carry internals: logged, never stored (R146).\n                    this.logger.error(\n                        {\n                            err: hasErrorSource(triggered.error)\n                                ? triggered.error.source\n                                : triggered.error,\n                            reviewId: data.id,\n                            stepId: step.id\n                        },\n                        \"Could not start the step run task.\"\n                    );\n                    reason = startFailure;\n                } else {\n                    taskId = triggered.value.id;\n                }\n            } catch (error) {\n                this.logger.error(\n                    { err: error, reviewId: data.id, stepId: step.id },\n                    \"Could not start the step run task.\"\n                );\n                reason = startFailure;\n            }\n        }\n\n        // The task id is stored by the one save. If the step cannot be reached after a successful\n        // trigger, nothing will ever carry that id, so the task is aborted here.\n        const reached = review.reachRun({ actor, owner, taskId, now });\n        if (reached.isFail()) {\n            if (taskId !== null) {\n                await this.taskAbort.abort({\n                    taskIds: [taskId],\n                    message: \"The review could not be saved.\"\n                });\n            }\n            return Result.fail(reached.error);\n        }\n        if (reason === null) {\n            return Result.ok();\n        }\n\n        // No task exists: record the reach without one, then fail the step with the reason. The\n        // step stays restartable (D8); the use case saves the failed review as usual.\n        const failed = review.fail({ stepId: step.id, reason, now });\n        // Whatever `fail` returns is returned, never ignored (R159).\n        if (failed.isFail()) {\n            return Result.fail(failed.error);\n        }\n        return Result.ok();\n    }\n}\n\nexport const StepRunReachService = Abstraction.createImplementation({\n    implementation: StepRunReachServiceImpl,\n    dependencies: [TaskService, IdentityContext, ReviewTaskAbortService, Logger]\n});\n"],"names":["StepRunReachServiceImpl","taskService","identityContext","taskAbort","logger","review","step","actor","owner","now","failure","startFailure","data","requester","reason","taskId","input","identity","getRequesterIdentity","triggered","STEP_RUN_TASK_DEFINITION_ID","hasErrorSource","error","reached","Result","failed","StepRunReachService","Abstraction","TaskService","IdentityContext","ReviewTaskAbortService","Logger"],"mappings":";;;;;;;;;AAWA,MAAMA;IACF,YACYC,WAAkC,EAClCC,eAA0C,EAC1CC,SAA2C,EAC3CC,MAAwB,CAClC;aAJUH,WAAW,GAAXA;aACAC,eAAe,GAAfA;aACAC,SAAS,GAATA;aACAC,MAAM,GAANA;IACT;IAEH,MAAa,MAAM,EACfC,MAAM,EACNC,IAAI,EACJC,KAAK,EACLC,KAAK,EACLC,GAAG,EACHC,OAAO,EACPC,YAAY,EACK,EAAE;QACnB,MAAMC,OAAOP,OAAO,MAAM;QAC1B,MAAMQ,YAAYD,KAAK,SAAS;QAMhC,IAAIE,SAASJ;QACb,IAAIK,SAAwB;QAC5B,IAAID,AAAW,SAAXA,QAAiB;YACjB,MAAME,QAA0B;gBAAE,UAAUJ,KAAK,EAAE;gBAAE,QAAQN,KAAK,EAAE;YAAC;YACrE,MAAMW,WAAWC,qBAAqBL;YACtC,IAAI;gBACA,MAAMM,YAAY,MAAM,IAAI,CAAC,eAAe,CAAC,YAAY,CAACF,UAAU,IACzD,IAAI,CAAC,WAAW,CAAC,OAAO,CAAC;wBAC5B,YAAYG;wBACZ,MAAM,CAAC,eAAe,EAAEd,KAAK,KAAK,EAAE;wBACpCU;oBACJ;gBAEJ,IAAIG,UAAU,MAAM,IAAI;oBAEpB,IAAI,CAAC,MAAM,CAAC,KAAK,CACb;wBACI,KAAKE,eAAeF,UAAU,KAAK,IAC7BA,UAAU,KAAK,CAAC,MAAM,GACtBA,UAAU,KAAK;wBACrB,UAAUP,KAAK,EAAE;wBACjB,QAAQN,KAAK,EAAE;oBACnB,GACA;oBAEJQ,SAASH;gBACb,OACII,SAASI,UAAU,KAAK,CAAC,EAAE;YAEnC,EAAE,OAAOG,OAAO;gBACZ,IAAI,CAAC,MAAM,CAAC,KAAK,CACb;oBAAE,KAAKA;oBAAO,UAAUV,KAAK,EAAE;oBAAE,QAAQN,KAAK,EAAE;gBAAC,GACjD;gBAEJQ,SAASH;YACb;QACJ;QAIA,MAAMY,UAAUlB,OAAO,QAAQ,CAAC;YAAEE;YAAOC;YAAOO;YAAQN;QAAI;QAC5D,IAAIc,QAAQ,MAAM,IAAI;YAClB,IAAIR,AAAW,SAAXA,QACA,MAAM,IAAI,CAAC,SAAS,CAAC,KAAK,CAAC;gBACvB,SAAS;oBAACA;iBAAO;gBACjB,SAAS;YACb;YAEJ,OAAOS,OAAO,IAAI,CAACD,QAAQ,KAAK;QACpC;QACA,IAAIT,AAAW,SAAXA,QACA,OAAOU,OAAO,EAAE;QAKpB,MAAMC,SAASpB,OAAO,IAAI,CAAC;YAAE,QAAQC,KAAK,EAAE;YAAEQ;YAAQL;QAAI;QAE1D,IAAIgB,OAAO,MAAM,IACb,OAAOD,OAAO,IAAI,CAACC,OAAO,KAAK;QAEnC,OAAOD,OAAO,EAAE;IACpB;AACJ;AAEO,MAAME,0CAAsBC,oBAAAA,oBAAgC,CAAC;IAChE,gBAAgB3B;IAChB,cAAc;QAAC4B;QAAaC;QAAiBC;QAAwBC;KAAO;AAChF"}

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

@@ -0,0 +1,38 @@
+import type { Result } from "@webiny/feature/api";
+import type { Review } from "../../../domain/review/Review.js";
+import type { Actor, ReviewStep } from "../../../domain/review/types.js";
+import type { ReviewInvalidStateError, ReviewStepNotCurrentError } from "../../../domain/review/errors.js";
+export interface StepRunReachParams {
+    review: Review;
+    /** The pending step being reached. */
+    step: ReviewStep;
+    /** Who caused the step to be reached (the approver of the previous step, the restarter, ...). */
+    actor: Actor;
+    /** The step's owner once reached: the automation actor or the AI actor of the requester. */
+    owner: Actor;
+    now: string;
+    /** A fixed reason when the step cannot be started: no task is triggered and the step fails with it. */
+    failure: string | null;
+    /** The fixed reason used when the trigger itself fails or throws (the raw error is only logged). */
+    startFailure: string;
+}
+export type StepRunReachError = ReviewInvalidStateError | ReviewStepNotCurrentError;
+export interface IStepRunReachService {
+    /**
+     * The one reach path of every step that runs as a `workflowsStepRun` task (R168): triggers the
+     * task as the requester (R149), stores its id on the step through `review.reachRun`, aborts
+     * the task when that fails (R143) and fails the step with a fixed reason when there is
+     * nothing to run (R146). Returns the review's transition errors as they are (R159).
+     */
+    reach(params: StepRunReachParams): Promise<Result<void, StepRunReachError>>;
+}
+/**
+ * Shared by `AutomationStepType.reach` and the AI step type's reach (R164, R168). Internal (D132):
+ * no permission checks; the caller has already decided what can run.
+ */
+export declare const StepRunReachService: import("@webiny/di").Abstraction<IStepRunReachService>;
+export declare namespace StepRunReachService {
+    type Interface = IStepRunReachService;
+    type Params = StepRunReachParams;
+    type Error = StepRunReachError;
+}

package/features/stepRun/StepRunReachService/abstractions.js

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"features/stepRun/StepRunReachService/abstractions.js","sources":["../../../../src/features/stepRun/StepRunReachService/abstractions.ts"],"sourcesContent":["import { createAbstraction } from \"@webiny/feature/api\";\nimport type { Result } from \"@webiny/feature/api\";\nimport type { Review } from \"~/domain/review/Review.js\";\nimport type { Actor, ReviewStep } from \"~/domain/review/types.js\";\nimport type { ReviewInvalidStateError, ReviewStepNotCurrentError } from \"~/domain/review/errors.js\";\n\nexport interface StepRunReachParams {\n    review: Review;\n    /** The pending step being reached. */\n    step: ReviewStep;\n    /** Who caused the step to be reached (the approver of the previous step, the restarter, ...). */\n    actor: Actor;\n    /** The step's owner once reached: the automation actor or the AI actor of the requester. */\n    owner: Actor;\n    now: string;\n    /** A fixed reason when the step cannot be started: no task is triggered and the step fails with it. */\n    failure: string | null;\n    /** The fixed reason used when the trigger itself fails or throws (the raw error is only logged). */\n    startFailure: string;\n}\n\nexport type StepRunReachError = ReviewInvalidStateError | ReviewStepNotCurrentError;\n\nexport interface IStepRunReachService {\n    /**\n     * The one reach path of every step that runs as a `workflowsStepRun` task (R168): triggers the\n     * task as the requester (R149), stores its id on the step through `review.reachRun`, aborts\n     * the task when that fails (R143) and fails the step with a fixed reason when there is\n     * nothing to run (R146). Returns the review's transition errors as they are (R159).\n     */\n    reach(params: StepRunReachParams): Promise<Result<void, StepRunReachError>>;\n}\n\n/**\n * Shared by `AutomationStepType.reach` and the AI step type's reach (R164, R168). Internal (D132):\n * no permission checks; the caller has already decided what can run.\n */\nexport const StepRunReachService = createAbstraction<IStepRunReachService>(\"StepRunReachService\");\n\nexport namespace StepRunReachService {\n    export type Interface = IStepRunReachService;\n    export type Params = StepRunReachParams;\n    export type Error = StepRunReachError;\n}\n"],"names":["StepRunReachService","createAbstraction"],"mappings":";AAqCO,MAAMA,sBAAsBC,kBAAwC"}

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

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

package/features/stepRun/StepRunReachService/feature.js

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

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

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

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

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

package/features/stepRun/StepRunReachService/index.js

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

package/features/stepRun/StepRunStaleCheckService/StepRunStaleCheckService.d.ts

@@ -0,0 +1,15 @@
+import { Result } from "@webiny/feature/api";
+import { Logger } from "@webiny/api-core/features/logger/index.js";
+import { ReviewRepository } from "../../../domain/review/abstractions/ReviewRepository.js";
+import { ReviewPersistenceError } from "../../../domain/review/errors.js";
+import { StepRunStaleCheckService as Abstraction } from "./abstractions.js";
+declare class StepRunStaleCheckServiceImpl implements Abstraction.Interface {
+    private repository;
+    private logger;
+    constructor(repository: ReviewRepository.Interface, logger: Logger.Interface);
+    isStale({ reviewId, stepId, task }: Abstraction.Params): Promise<Result<boolean, ReviewPersistenceError>>;
+}
+export declare const StepRunStaleCheckService: typeof StepRunStaleCheckServiceImpl & {
+    __abstraction: import("@webiny/di").Abstraction<import("./abstractions.js").IStepRunStaleCheckService>;
+};
+export {};

package/features/stepRun/StepRunStaleCheckService/StepRunStaleCheckService.js

@@ -0,0 +1,47 @@
+import { Result } from "@webiny/feature/api";
+import { Logger } from "@webiny/api-core/features/logger/index.js";
+import { ReviewRepository } from "../../../domain/review/abstractions/ReviewRepository.js";
+import { ReviewNotFoundError, ReviewPersistenceError } from "../../../domain/review/errors.js";
+import { getStaleStepRunReason } from "../../../domain/review/getStaleStepRunReason.js";
+import { StepRunStaleCheckService } from "./abstractions.js";
+import { hasErrorSource } from "../../../domain/hasErrorSource.js";
+class StepRunStaleCheckServiceImpl {
+    constructor(repository, logger){
+        this.repository = repository;
+        this.logger = logger;
+    }
+    async isStale({ reviewId, stepId, task }) {
+        try {
+            const current = await this.repository.get(reviewId);
+            if (current.isFail()) {
+                if (current.error instanceof ReviewNotFoundError) return Result.ok(true);
+                this.logger.error({
+                    err: hasErrorSource(current.error) ? current.error.source : current.error,
+                    taskId: task.id,
+                    reviewId,
+                    stepId
+                }, "Could not read the review to check the step is current.");
+                return Result.fail(current.error instanceof ReviewPersistenceError ? current.error : new ReviewPersistenceError(current.error));
+            }
+            return Result.ok(null !== getStaleStepRunReason(current.value, stepId, task));
+        } catch (error) {
+            this.logger.error({
+                err: error,
+                taskId: task.id,
+                reviewId,
+                stepId
+            }, "Could not read the review to check the step is current.");
+            return Result.fail(new ReviewPersistenceError(error));
+        }
+    }
+}
+const StepRunStaleCheckService_StepRunStaleCheckService = StepRunStaleCheckService.createImplementation({
+    implementation: StepRunStaleCheckServiceImpl,
+    dependencies: [
+        ReviewRepository,
+        Logger
+    ]
+});
+export { StepRunStaleCheckService_StepRunStaleCheckService as StepRunStaleCheckService };
+
+//# sourceMappingURL=StepRunStaleCheckService.js.map

package/features/stepRun/StepRunStaleCheckService/StepRunStaleCheckService.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"features/stepRun/StepRunStaleCheckService/StepRunStaleCheckService.js","sources":["../../../../src/features/stepRun/StepRunStaleCheckService/StepRunStaleCheckService.ts"],"sourcesContent":["import { Result } from \"@webiny/feature/api\";\nimport { Logger } from \"@webiny/api-core/features/logger/index.js\";\nimport { ReviewRepository } from \"~/domain/review/abstractions/ReviewRepository.js\";\nimport { ReviewNotFoundError, ReviewPersistenceError } from \"~/domain/review/errors.js\";\nimport { getStaleStepRunReason } from \"~/domain/review/getStaleStepRunReason.js\";\nimport { StepRunStaleCheckService as Abstraction } from \"./abstractions.js\";\nimport { hasErrorSource } from \"~/domain/hasErrorSource.js\";\n\nclass StepRunStaleCheckServiceImpl implements Abstraction.Interface {\n    public constructor(\n        private repository: ReviewRepository.Interface,\n        private logger: Logger.Interface\n    ) {}\n\n    public async isStale({\n        reviewId,\n        stepId,\n        task\n    }: Abstraction.Params): Promise<Result<boolean, ReviewPersistenceError>> {\n        try {\n            const current = await this.repository.get(reviewId);\n            if (current.isFail()) {\n                if (current.error instanceof ReviewNotFoundError) {\n                    return Result.ok(true);\n                }\n                // Fail-closed: a failed read must not read as \"not stale\" for a caller that writes.\n                this.logger.error(\n                    {\n                        err: hasErrorSource(current.error) ? current.error.source : current.error,\n                        taskId: task.id,\n                        reviewId,\n                        stepId\n                    },\n                    \"Could not read the review to check the step is current.\"\n                );\n                return Result.fail(\n                    current.error instanceof ReviewPersistenceError\n                        ? current.error\n                        : new ReviewPersistenceError(current.error)\n                );\n            }\n            return Result.ok(getStaleStepRunReason(current.value, stepId, task) !== null);\n        } catch (error) {\n            this.logger.error(\n                { err: error, taskId: task.id, reviewId, stepId },\n                \"Could not read the review to check the step is current.\"\n            );\n            return Result.fail(new ReviewPersistenceError(error as Error));\n        }\n    }\n}\n\nexport const StepRunStaleCheckService = Abstraction.createImplementation({\n    implementation: StepRunStaleCheckServiceImpl,\n    dependencies: [ReviewRepository, Logger]\n});\n"],"names":["StepRunStaleCheckServiceImpl","repository","logger","reviewId","stepId","task","current","ReviewNotFoundError","Result","hasErrorSource","ReviewPersistenceError","getStaleStepRunReason","error","StepRunStaleCheckService","Abstraction","ReviewRepository","Logger"],"mappings":";;;;;;;AAQA,MAAMA;IACF,YACYC,UAAsC,EACtCC,MAAwB,CAClC;aAFUD,UAAU,GAAVA;aACAC,MAAM,GAANA;IACT;IAEH,MAAa,QAAQ,EACjBC,QAAQ,EACRC,MAAM,EACNC,IAAI,EACa,EAAoD;QACrE,IAAI;YACA,MAAMC,UAAU,MAAM,IAAI,CAAC,UAAU,CAAC,GAAG,CAACH;YAC1C,IAAIG,QAAQ,MAAM,IAAI;gBAClB,IAAIA,QAAQ,KAAK,YAAYC,qBACzB,OAAOC,OAAO,EAAE,CAAC;gBAGrB,IAAI,CAAC,MAAM,CAAC,KAAK,CACb;oBACI,KAAKC,eAAeH,QAAQ,KAAK,IAAIA,QAAQ,KAAK,CAAC,MAAM,GAAGA,QAAQ,KAAK;oBACzE,QAAQD,KAAK,EAAE;oBACfF;oBACAC;gBACJ,GACA;gBAEJ,OAAOI,OAAO,IAAI,CACdF,QAAQ,KAAK,YAAYI,yBACnBJ,QAAQ,KAAK,GACb,IAAII,uBAAuBJ,QAAQ,KAAK;YAEtD;YACA,OAAOE,OAAO,EAAE,CAACG,AAAuD,SAAvDA,sBAAsBL,QAAQ,KAAK,EAAEF,QAAQC;QAClE,EAAE,OAAOO,OAAO;YACZ,IAAI,CAAC,MAAM,CAAC,KAAK,CACb;gBAAE,KAAKA;gBAAO,QAAQP,KAAK,EAAE;gBAAEF;gBAAUC;YAAO,GAChD;YAEJ,OAAOI,OAAO,IAAI,CAAC,IAAIE,uBAAuBE;QAClD;IACJ;AACJ;AAEO,MAAMC,oDAA2BC,yBAAAA,oBAAgC,CAAC;IACrE,gBAAgBd;IAChB,cAAc;QAACe;QAAkBC;KAAO;AAC5C"}

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

@@ -0,0 +1,29 @@
+import type { Result } from "@webiny/feature/api";
+import type { ReviewPersistenceError } from "../../../domain/review/errors.js";
+import type { StepRunTaskIdentity } from "../../../domain/review/getStaleStepRunReason.js";
+export interface StepRunStaleCheckParams {
+    reviewId: string;
+    stepId: string;
+    /** The task's own identity, never values read from the task input (R148). */
+    task: StepRunTaskIdentity;
+}
+export interface IStepRunStaleCheckService {
+    /**
+     * `ok(true)` when this task must no longer write to the review (R144, R175): the review is
+     * gone, cancelled or finished, or the step was restarted under another task. One repository
+     * read per call; no throttle and no state, the caller owns both. Fail-closed: a failed or
+     * throwing read is logged here (callers do not log it again) and answered with a failed
+     * Result, never with `ok(false)`, so a caller about to write can refuse. Never throws.
+     */
+    isStale(params: StepRunStaleCheckParams): Promise<Result<boolean, ReviewPersistenceError>>;
+}
+/**
+ * Re-reads the stored review and applies the stale guard, for a runner whose call outlives the
+ * moment it started (the AI runner): `controller.runtime.isAborted()` only sees the task loaded at
+ * run start (R175). Internal (D132): no permission checks.
+ */
+export declare const StepRunStaleCheckService: import("@webiny/di").Abstraction<IStepRunStaleCheckService>;
+export declare namespace StepRunStaleCheckService {
+    type Interface = IStepRunStaleCheckService;
+    type Params = StepRunStaleCheckParams;
+}

package/features/stepRun/StepRunStaleCheckService/abstractions.js

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"features/stepRun/StepRunStaleCheckService/abstractions.js","sources":["../../../../src/features/stepRun/StepRunStaleCheckService/abstractions.ts"],"sourcesContent":["import { createAbstraction } from \"@webiny/feature/api\";\nimport type { Result } from \"@webiny/feature/api\";\nimport type { ReviewPersistenceError } from \"~/domain/review/errors.js\";\nimport type { StepRunTaskIdentity } from \"~/domain/review/getStaleStepRunReason.js\";\n\nexport interface StepRunStaleCheckParams {\n    reviewId: string;\n    stepId: string;\n    /** The task's own identity, never values read from the task input (R148). */\n    task: StepRunTaskIdentity;\n}\n\nexport interface IStepRunStaleCheckService {\n    /**\n     * `ok(true)` when this task must no longer write to the review (R144, R175): the review is\n     * gone, cancelled or finished, or the step was restarted under another task. One repository\n     * read per call; no throttle and no state, the caller owns both. Fail-closed: a failed or\n     * throwing read is logged here (callers do not log it again) and answered with a failed\n     * Result, never with `ok(false)`, so a caller about to write can refuse. Never throws.\n     */\n    isStale(params: StepRunStaleCheckParams): Promise<Result<boolean, ReviewPersistenceError>>;\n}\n\n/**\n * Re-reads the stored review and applies the stale guard, for a runner whose call outlives the\n * moment it started (the AI runner): `controller.runtime.isAborted()` only sees the task loaded at\n * run start (R175). Internal (D132): no permission checks.\n */\nexport const StepRunStaleCheckService = createAbstraction<IStepRunStaleCheckService>(\n    \"StepRunStaleCheckService\"\n);\n\nexport namespace StepRunStaleCheckService {\n    export type Interface = IStepRunStaleCheckService;\n    export type Params = StepRunStaleCheckParams;\n}\n"],"names":["StepRunStaleCheckService","createAbstraction"],"mappings":";AA4BO,MAAMA,2BAA2BC,kBACpC"}

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

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

package/features/stepRun/StepRunStaleCheckService/feature.js

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

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

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

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

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

package/features/stepRun/StepRunStaleCheckService/index.js

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