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

package/features/review/StepAssignmentResolver/RoutingStepAssignmentResolver.d.ts

@@ -0,0 +1,20 @@
+import { Logger } from "@webiny/api-core/features/logger/index.js";
+import { RoutingEvaluatorService } from "../../../features/routing/RoutingEvaluatorService/abstractions.js";
+import { StepAssignmentResolver } from "./abstractions.js";
+/**
+ * Step reach routing (spec 6, R110): pick, rules, strategy, pool, through
+ * `RoutingEvaluatorService`. Never blocks the review (R116): a failed lookup gives the pool with a
+ * fixed reason, keeping what the evaluator had decided (the narrowed teams, a team-target rule,
+ * the skips gathered); a throwing read check gives the pool of the step's teams without skips.
+ * The error is logged.
+ */
+declare class RoutingStepAssignmentResolverImpl implements StepAssignmentResolver.Interface {
+    private evaluator;
+    private logger;
+    constructor(evaluator: RoutingEvaluatorService.Interface, logger: Logger.Interface);
+    resolve(params: StepAssignmentResolver.Params): Promise<StepAssignmentResolver.Resolution>;
+}
+export declare const RoutingStepAssignmentResolver: typeof RoutingStepAssignmentResolverImpl & {
+    __abstraction: import("@webiny/di").Abstraction<import("./abstractions.js").IStepAssignmentResolver>;
+};
+export {};

package/features/review/StepAssignmentResolver/RoutingStepAssignmentResolver.js

@@ -0,0 +1,86 @@
+import { Logger } from "@webiny/api-core/features/logger/index.js";
+import { parseReviewStepConfig } from "../../../domain/workflow/reviewStepConfigSchema.js";
+import { createRoutingFailedResolution } from "../../../domain/routing/createRoutingFailedResolution.js";
+import { toStepAssignmentResolution } from "../../../domain/routing/toStepAssignmentResolution.js";
+import { ROUTING_FAILED_REASON } from "../../../domain/routing/reasons.js";
+import { RoutingEvaluatorService } from "../../routing/RoutingEvaluatorService/abstractions.js";
+import { StepAssignmentResolver } from "./abstractions.js";
+import { hasErrorSource } from "../../../domain/hasErrorSource.js";
+class RoutingStepAssignmentResolverImpl {
+    constructor(evaluator, logger){
+        this.evaluator = evaluator;
+        this.logger = logger;
+    }
+    async resolve(params) {
+        const config = parseReviewStepConfig(params.step.config);
+        if (!config) return {
+            owner: null,
+            candidateTeamIds: [],
+            assignment: {
+                source: "pool"
+            },
+            records: [
+                {
+                    kind: "outcome",
+                    userId: null,
+                    source: "pool",
+                    ruleId: null,
+                    by: null,
+                    reason: null
+                }
+            ]
+        };
+        try {
+            const evaluated = await this.evaluator.evaluate({
+                config,
+                model: params.review.model,
+                workflowId: params.review.workflowId,
+                reviewId: params.review.id,
+                stepId: params.step.id,
+                requesterId: params.review.createdBy.id,
+                pickedUserId: params.step.pickedUserId,
+                folder: params.review.targetContext.folder,
+                read: {
+                    type: "target",
+                    targetId: params.review.targetId,
+                    targetRevisionId: params.review.targetRevisionId
+                },
+                now: params.now
+            });
+            if (evaluated.isFail()) {
+                this.logger.error({
+                    err: hasErrorSource(evaluated.error) ? evaluated.error.source : evaluated.error,
+                    reviewId: params.review.id,
+                    stepId: params.step.id
+                }, ROUTING_FAILED_REASON);
+                return createRoutingFailedResolution(evaluated.error.decided ?? {
+                    candidateTeamIds: config.teams,
+                    ruleId: null,
+                    skips: []
+                });
+            }
+            return toStepAssignmentResolution(evaluated.value);
+        } catch (error) {
+            this.logger.error({
+                err: error,
+                reviewId: params.review.id,
+                stepId: params.step.id
+            }, ROUTING_FAILED_REASON);
+            return createRoutingFailedResolution({
+                candidateTeamIds: config.teams,
+                ruleId: null,
+                skips: []
+            });
+        }
+    }
+}
+const RoutingStepAssignmentResolver = StepAssignmentResolver.createImplementation({
+    implementation: RoutingStepAssignmentResolverImpl,
+    dependencies: [
+        RoutingEvaluatorService,
+        Logger
+    ]
+});
+export { RoutingStepAssignmentResolver };
+
+//# sourceMappingURL=RoutingStepAssignmentResolver.js.map

package/features/review/StepAssignmentResolver/RoutingStepAssignmentResolver.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"features/review/StepAssignmentResolver/RoutingStepAssignmentResolver.js","sources":["../../../../src/features/review/StepAssignmentResolver/RoutingStepAssignmentResolver.ts"],"sourcesContent":["import { Logger } from \"@webiny/api-core/features/logger/index.js\";\nimport { parseReviewStepConfig } from \"~/domain/workflow/reviewStepConfigSchema.js\";\nimport { createRoutingFailedResolution } from \"~/domain/routing/createRoutingFailedResolution.js\";\nimport { toStepAssignmentResolution } from \"~/domain/routing/toStepAssignmentResolution.js\";\nimport { ROUTING_FAILED_REASON } from \"~/domain/routing/reasons.js\";\nimport { RoutingEvaluatorService } from \"~/features/routing/RoutingEvaluatorService/abstractions.js\";\nimport { StepAssignmentResolver } from \"./abstractions.js\";\nimport { hasErrorSource } from \"~/domain/hasErrorSource.js\";\n\n/**\n * Step reach routing (spec 6, R110): pick, rules, strategy, pool, through\n * `RoutingEvaluatorService`. Never blocks the review (R116): a failed lookup gives the pool with a\n * fixed reason, keeping what the evaluator had decided (the narrowed teams, a team-target rule,\n * the skips gathered); a throwing read check gives the pool of the step's teams without skips.\n * The error is logged.\n */\nclass RoutingStepAssignmentResolverImpl implements StepAssignmentResolver.Interface {\n    public constructor(\n        private evaluator: RoutingEvaluatorService.Interface,\n        private logger: Logger.Interface\n    ) {}\n\n    public async resolve(\n        params: StepAssignmentResolver.Params\n    ): Promise<StepAssignmentResolver.Resolution> {\n        // Save-time validation guarantees a parsable config. An unparsable one (edited storage)\n        // leaves an empty pool; the review step type does not fail such a step (R116).\n        const config = parseReviewStepConfig(params.step.config);\n        if (!config) {\n            return {\n                owner: null,\n                candidateTeamIds: [],\n                assignment: { source: \"pool\" },\n                records: [\n                    {\n                        kind: \"outcome\",\n                        userId: null,\n                        source: \"pool\",\n                        ruleId: null,\n                        by: null,\n                        reason: null\n                    }\n                ]\n            };\n        }\n\n        try {\n            const evaluated = await this.evaluator.evaluate({\n                config,\n                model: params.review.model,\n                workflowId: params.review.workflowId,\n                // Least loaded does not count the review being routed (its previous step).\n                reviewId: params.review.id,\n                stepId: params.step.id,\n                requesterId: params.review.createdBy.id,\n                pickedUserId: params.step.pickedUserId,\n                // The target's current folder: moves are refused while a review is in progress\n                // (D84, R55). Its ancestors are read now, through the folder port (R130).\n                folder: params.review.targetContext.folder,\n                read: {\n                    type: \"target\",\n                    targetId: params.review.targetId,\n                    targetRevisionId: params.review.targetRevisionId\n                },\n                now: params.now\n            });\n            if (evaluated.isFail()) {\n                this.logger.error(\n                    {\n                        err: hasErrorSource(evaluated.error)\n                            ? evaluated.error.source\n                            : evaluated.error,\n                        reviewId: params.review.id,\n                        stepId: params.step.id\n                    },\n                    ROUTING_FAILED_REASON\n                );\n                return createRoutingFailedResolution(\n                    evaluated.error.decided ?? {\n                        candidateTeamIds: config.teams,\n                        ruleId: null,\n                        skips: []\n                    }\n                );\n            }\n            return toStepAssignmentResolution(evaluated.value);\n        } catch (error) {\n            this.logger.error(\n                { err: error, reviewId: params.review.id, stepId: params.step.id },\n                ROUTING_FAILED_REASON\n            );\n            return createRoutingFailedResolution({\n                candidateTeamIds: config.teams,\n                ruleId: null,\n                skips: []\n            });\n        }\n    }\n}\n\nexport const RoutingStepAssignmentResolver = StepAssignmentResolver.createImplementation({\n    implementation: RoutingStepAssignmentResolverImpl,\n    dependencies: [RoutingEvaluatorService, Logger]\n});\n"],"names":["RoutingStepAssignmentResolverImpl","evaluator","logger","params","config","parseReviewStepConfig","evaluated","hasErrorSource","ROUTING_FAILED_REASON","createRoutingFailedResolution","toStepAssignmentResolution","error","RoutingStepAssignmentResolver","StepAssignmentResolver","RoutingEvaluatorService","Logger"],"mappings":";;;;;;;;AAgBA,MAAMA;IACF,YACYC,SAA4C,EAC5CC,MAAwB,CAClC;aAFUD,SAAS,GAATA;aACAC,MAAM,GAANA;IACT;IAEH,MAAa,QACTC,MAAqC,EACK;QAG1C,MAAMC,SAASC,sBAAsBF,OAAO,IAAI,CAAC,MAAM;QACvD,IAAI,CAACC,QACD,OAAO;YACH,OAAO;YACP,kBAAkB,EAAE;YACpB,YAAY;gBAAE,QAAQ;YAAO;YAC7B,SAAS;gBACL;oBACI,MAAM;oBACN,QAAQ;oBACR,QAAQ;oBACR,QAAQ;oBACR,IAAI;oBACJ,QAAQ;gBACZ;aACH;QACL;QAGJ,IAAI;YACA,MAAME,YAAY,MAAM,IAAI,CAAC,SAAS,CAAC,QAAQ,CAAC;gBAC5CF;gBACA,OAAOD,OAAO,MAAM,CAAC,KAAK;gBAC1B,YAAYA,OAAO,MAAM,CAAC,UAAU;gBAEpC,UAAUA,OAAO,MAAM,CAAC,EAAE;gBAC1B,QAAQA,OAAO,IAAI,CAAC,EAAE;gBACtB,aAAaA,OAAO,MAAM,CAAC,SAAS,CAAC,EAAE;gBACvC,cAAcA,OAAO,IAAI,CAAC,YAAY;gBAGtC,QAAQA,OAAO,MAAM,CAAC,aAAa,CAAC,MAAM;gBAC1C,MAAM;oBACF,MAAM;oBACN,UAAUA,OAAO,MAAM,CAAC,QAAQ;oBAChC,kBAAkBA,OAAO,MAAM,CAAC,gBAAgB;gBACpD;gBACA,KAAKA,OAAO,GAAG;YACnB;YACA,IAAIG,UAAU,MAAM,IAAI;gBACpB,IAAI,CAAC,MAAM,CAAC,KAAK,CACb;oBACI,KAAKC,eAAeD,UAAU,KAAK,IAC7BA,UAAU,KAAK,CAAC,MAAM,GACtBA,UAAU,KAAK;oBACrB,UAAUH,OAAO,MAAM,CAAC,EAAE;oBAC1B,QAAQA,OAAO,IAAI,CAAC,EAAE;gBAC1B,GACAK;gBAEJ,OAAOC,8BACHH,UAAU,KAAK,CAAC,OAAO,IAAI;oBACvB,kBAAkBF,OAAO,KAAK;oBAC9B,QAAQ;oBACR,OAAO,EAAE;gBACb;YAER;YACA,OAAOM,2BAA2BJ,UAAU,KAAK;QACrD,EAAE,OAAOK,OAAO;YACZ,IAAI,CAAC,MAAM,CAAC,KAAK,CACb;gBAAE,KAAKA;gBAAO,UAAUR,OAAO,MAAM,CAAC,EAAE;gBAAE,QAAQA,OAAO,IAAI,CAAC,EAAE;YAAC,GACjEK;YAEJ,OAAOC,8BAA8B;gBACjC,kBAAkBL,OAAO,KAAK;gBAC9B,QAAQ;gBACR,OAAO,EAAE;YACb;QACJ;IACJ;AACJ;AAEO,MAAMQ,gCAAgCC,uBAAuB,oBAAoB,CAAC;IACrF,gBAAgBb;IAChB,cAAc;QAACc;QAAyBC;KAAO;AACnD"}

package/features/review/StepAssignmentResolver/abstractions.d.ts

@@ -0,0 +1,30 @@
+import type { ReviewData, ReviewStep, StepAssignmentResolution } from "../../../domain/review/types.js";
+/**
+ * Resolvers must read the step being reached from `params.step`. The review-level current-step
+ * fields on `params.review` (`currentStepId`, `currentStepState`, `currentOwnerId`,
+ * `currentCandidateTeamIds`) still describe the previous step while a step is being reached.
+ */
+export interface StepAssignmentResolverParams {
+    review: ReviewData;
+    /** The review step being reached; carries `pickedUserId` and the step config. */
+    step: ReviewStep;
+    /**
+     * The reach time (R118): exclusion expiry and the records' `assignedOn` use it. Routing never
+     * calls `new Date()`.
+     */
+    now: Date;
+}
+export interface IStepAssignmentResolver {
+    resolve(params: StepAssignmentResolverParams): Promise<StepAssignmentResolution>;
+}
+/**
+ * Decides who holds a review step when it is reached (spec 5.2, 6). The registered
+ * implementation is `RoutingStepAssignmentResolver`: pick, rules, strategy, pool; any failure
+ * falls through to the pool (R110, R116). A later registration wins on resolve.
+ */
+export declare const StepAssignmentResolver: import("@webiny/di").Abstraction<IStepAssignmentResolver>;
+export declare namespace StepAssignmentResolver {
+    type Interface = IStepAssignmentResolver;
+    type Params = StepAssignmentResolverParams;
+    type Resolution = StepAssignmentResolution;
+}

package/features/review/StepAssignmentResolver/abstractions.js

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

package/features/review/StepAssignmentResolver/abstractions.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"features/review/StepAssignmentResolver/abstractions.js","sources":["../../../../src/features/review/StepAssignmentResolver/abstractions.ts"],"sourcesContent":["import { createAbstraction } from \"@webiny/feature/api\";\nimport type { ReviewData, ReviewStep, StepAssignmentResolution } from \"~/domain/review/types.js\";\n\n/**\n * Resolvers must read the step being reached from `params.step`. The review-level current-step\n * fields on `params.review` (`currentStepId`, `currentStepState`, `currentOwnerId`,\n * `currentCandidateTeamIds`) still describe the previous step while a step is being reached.\n */\nexport interface StepAssignmentResolverParams {\n    review: ReviewData;\n    /** The review step being reached; carries `pickedUserId` and the step config. */\n    step: ReviewStep;\n    /**\n     * The reach time (R118): exclusion expiry and the records' `assignedOn` use it. Routing never\n     * calls `new Date()`.\n     */\n    now: Date;\n}\n\nexport interface IStepAssignmentResolver {\n    resolve(params: StepAssignmentResolverParams): Promise<StepAssignmentResolution>;\n}\n\n/**\n * Decides who holds a review step when it is reached (spec 5.2, 6). The registered\n * implementation is `RoutingStepAssignmentResolver`: pick, rules, strategy, pool; any failure\n * falls through to the pool (R110, R116). A later registration wins on resolve.\n */\nexport const StepAssignmentResolver =\n    createAbstraction<IStepAssignmentResolver>(\"StepAssignmentResolver\");\n\nexport namespace StepAssignmentResolver {\n    export type Interface = IStepAssignmentResolver;\n    export type Params = StepAssignmentResolverParams;\n    export type Resolution = StepAssignmentResolution;\n}\n"],"names":["StepAssignmentResolver","createAbstraction"],"mappings":";AA4BO,MAAMA,yBACTC,kBAA2C"}

package/features/review/StepAssignmentResolver/index.d.ts

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

package/features/review/StepAssignmentResolver/index.js

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

package/features/review/TakeOverReviewStep/TakeOverReviewStepUseCase.d.ts

@@ -0,0 +1,13 @@
+import { ReviewRepository } from "../../../domain/review/abstractions/ReviewRepository.js";
+import { ReviewSaver } from "../ReviewSaver/abstractions.js";
+import { TakeOverReviewStepUseCase as TakeOverReviewStepUseCaseAbstraction } from "./abstractions.js";
+declare class TakeOverReviewStepUseCaseImpl implements TakeOverReviewStepUseCaseAbstraction.Interface {
+    private repository;
+    private saver;
+    constructor(repository: ReviewRepository.Interface, saver: ReviewSaver.Interface);
+    execute(input: TakeOverReviewStepUseCaseAbstraction.Input): TakeOverReviewStepUseCaseAbstraction.Return;
+}
+export declare const TakeOverReviewStepUseCase: typeof TakeOverReviewStepUseCaseImpl & {
+    __abstraction: import("@webiny/di").Abstraction<import("./abstractions.js").ITakeOverReviewStepUseCase>;
+};
+export {};

package/features/review/TakeOverReviewStep/TakeOverReviewStepUseCase.js

@@ -0,0 +1,35 @@
+import { Result } from "@webiny/feature/api";
+import { Review } from "../../../domain/review/Review.js";
+import { ReviewRepository } from "../../../domain/review/abstractions/ReviewRepository.js";
+import { ReviewSaver } from "../ReviewSaver/abstractions.js";
+import { TakeOverReviewStepUseCase } from "./abstractions.js";
+class TakeOverReviewStepUseCaseImpl {
+    constructor(repository, saver){
+        this.repository = repository;
+        this.saver = saver;
+    }
+    async execute(input) {
+        const loaded = await this.repository.get(input.reviewId);
+        if (loaded.isFail()) return Result.fail(loaded.error);
+        const review = Review.fromData(loaded.value);
+        const takenOver = review.takeOver({
+            stepId: input.stepId,
+            actor: input.actor,
+            actorTeamIds: input.actorTeamIds,
+            notifyPreviousOwner: input.notifyPreviousOwner ?? true,
+            now: new Date().toISOString()
+        });
+        if (takenOver.isFail()) return Result.fail(takenOver.error);
+        return this.saver.save(review);
+    }
+}
+const TakeOverReviewStepUseCase_TakeOverReviewStepUseCase = TakeOverReviewStepUseCase.createImplementation({
+    implementation: TakeOverReviewStepUseCaseImpl,
+    dependencies: [
+        ReviewRepository,
+        ReviewSaver
+    ]
+});
+export { TakeOverReviewStepUseCase_TakeOverReviewStepUseCase as TakeOverReviewStepUseCase };
+
+//# sourceMappingURL=TakeOverReviewStepUseCase.js.map

package/features/review/TakeOverReviewStep/TakeOverReviewStepUseCase.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"features/review/TakeOverReviewStep/TakeOverReviewStepUseCase.js","sources":["../../../../src/features/review/TakeOverReviewStep/TakeOverReviewStepUseCase.ts"],"sourcesContent":["import { Result } from \"@webiny/feature/api\";\nimport { Review } from \"~/domain/review/Review.js\";\nimport { ReviewRepository } from \"~/domain/review/abstractions/ReviewRepository.js\";\nimport { ReviewSaver } from \"../ReviewSaver/abstractions.js\";\nimport { TakeOverReviewStepUseCase as TakeOverReviewStepUseCaseAbstraction } from \"./abstractions.js\";\n\nclass TakeOverReviewStepUseCaseImpl implements TakeOverReviewStepUseCaseAbstraction.Interface {\n    constructor(\n        private repository: ReviewRepository.Interface,\n        private saver: ReviewSaver.Interface\n    ) {}\n\n    async execute(\n        input: TakeOverReviewStepUseCaseAbstraction.Input\n    ): TakeOverReviewStepUseCaseAbstraction.Return {\n        const loaded = await this.repository.get(input.reviewId);\n        if (loaded.isFail()) {\n            return Result.fail(loaded.error);\n        }\n        const review = Review.fromData(loaded.value);\n\n        const takenOver = review.takeOver({\n            stepId: input.stepId,\n            actor: input.actor,\n            actorTeamIds: input.actorTeamIds,\n            notifyPreviousOwner: input.notifyPreviousOwner ?? true,\n            now: new Date().toISOString()\n        });\n        if (takenOver.isFail()) {\n            return Result.fail(takenOver.error);\n        }\n\n        return this.saver.save(review);\n    }\n}\n\nexport const TakeOverReviewStepUseCase = TakeOverReviewStepUseCaseAbstraction.createImplementation({\n    implementation: TakeOverReviewStepUseCaseImpl,\n    dependencies: [ReviewRepository, ReviewSaver]\n});\n"],"names":["TakeOverReviewStepUseCaseImpl","repository","saver","input","loaded","Result","review","Review","takenOver","Date","TakeOverReviewStepUseCase","TakeOverReviewStepUseCaseAbstraction","ReviewRepository","ReviewSaver"],"mappings":";;;;;AAMA,MAAMA;IACF,YACYC,UAAsC,EACtCC,KAA4B,CACtC;aAFUD,UAAU,GAAVA;aACAC,KAAK,GAALA;IACT;IAEH,MAAM,QACFC,KAAiD,EACN;QAC3C,MAAMC,SAAS,MAAM,IAAI,CAAC,UAAU,CAAC,GAAG,CAACD,MAAM,QAAQ;QACvD,IAAIC,OAAO,MAAM,IACb,OAAOC,OAAO,IAAI,CAACD,OAAO,KAAK;QAEnC,MAAME,SAASC,OAAO,QAAQ,CAACH,OAAO,KAAK;QAE3C,MAAMI,YAAYF,OAAO,QAAQ,CAAC;YAC9B,QAAQH,MAAM,MAAM;YACpB,OAAOA,MAAM,KAAK;YAClB,cAAcA,MAAM,YAAY;YAChC,qBAAqBA,MAAM,mBAAmB,IAAI;YAClD,KAAK,IAAIM,OAAO,WAAW;QAC/B;QACA,IAAID,UAAU,MAAM,IAChB,OAAOH,OAAO,IAAI,CAACG,UAAU,KAAK;QAGtC,OAAO,IAAI,CAAC,KAAK,CAAC,IAAI,CAACF;IAC3B;AACJ;AAEO,MAAMI,sDAA4BC,0BAAAA,oBAAyD,CAAC;IAC/F,gBAAgBX;IAChB,cAAc;QAACY;QAAkBC;KAAY;AACjD"}

package/features/review/TakeOverReviewStep/abstractions.d.ts

@@ -0,0 +1,33 @@
+import { type Result } from "@webiny/feature/api";
+import type { ReviewData } from "../../../domain/review/types.js";
+import type { ReviewActorNotUserError, ReviewAlreadyOwnerError, ReviewInvalidStateError, ReviewNotCandidateError, ReviewNotFoundError, ReviewPersistenceError, ReviewRequesterCannotReviewError, ReviewStepNotCurrentError, ReviewStepNotTakeableError, ReviewTargetSyncError } from "../../../domain/review/errors.js";
+import type { ReviewActorInput } from "../shared/types.js";
+export interface ITakeOverReviewStepUseCaseErrors {
+    notFound: ReviewNotFoundError;
+    invalidState: ReviewInvalidStateError;
+    stepNotCurrent: ReviewStepNotCurrentError;
+    actorNotUser: ReviewActorNotUserError;
+    requesterCannotReview: ReviewRequesterCannotReviewError;
+    notCandidate: ReviewNotCandidateError;
+    alreadyOwner: ReviewAlreadyOwnerError;
+    stepNotTakeable: ReviewStepNotTakeableError;
+    persistence: ReviewPersistenceError;
+    targetSync: ReviewTargetSyncError;
+}
+export interface TakeOverReviewStepInput extends ReviewActorInput {
+    /** D111: whether the previous owner is told; omitted means true. Reaches the fact, never stored. */
+    notifyPreviousOwner?: boolean;
+}
+type UseCaseError = ITakeOverReviewStepUseCaseErrors[keyof ITakeOverReviewStepUseCaseErrors];
+export interface ITakeOverReviewStepUseCase {
+    execute(input: TakeOverReviewStepInput): Promise<Result<ReviewData, UseCaseError>>;
+}
+/** Another candidate takes a human step in review (spec 5.1 "take over", D32, D9). */
+export declare const TakeOverReviewStepUseCase: import("@webiny/di").Abstraction<ITakeOverReviewStepUseCase>;
+export declare namespace TakeOverReviewStepUseCase {
+    type Interface = ITakeOverReviewStepUseCase;
+    type Input = TakeOverReviewStepInput;
+    type Error = UseCaseError;
+    type Return = Promise<Result<ReviewData, UseCaseError>>;
+}
+export {};

package/features/review/TakeOverReviewStep/abstractions.js

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

package/features/review/TakeOverReviewStep/abstractions.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"features/review/TakeOverReviewStep/abstractions.js","sources":["../../../../src/features/review/TakeOverReviewStep/abstractions.ts"],"sourcesContent":["import { createAbstraction, type Result } from \"@webiny/feature/api\";\nimport type { ReviewData } from \"~/domain/review/types.js\";\nimport type {\n    ReviewActorNotUserError,\n    ReviewAlreadyOwnerError,\n    ReviewInvalidStateError,\n    ReviewNotCandidateError,\n    ReviewNotFoundError,\n    ReviewPersistenceError,\n    ReviewRequesterCannotReviewError,\n    ReviewStepNotCurrentError,\n    ReviewStepNotTakeableError,\n    ReviewTargetSyncError\n} from \"~/domain/review/errors.js\";\nimport type { ReviewActorInput } from \"../shared/types.js\";\n\nexport interface ITakeOverReviewStepUseCaseErrors {\n    notFound: ReviewNotFoundError;\n    invalidState: ReviewInvalidStateError;\n    stepNotCurrent: ReviewStepNotCurrentError;\n    actorNotUser: ReviewActorNotUserError;\n    requesterCannotReview: ReviewRequesterCannotReviewError;\n    notCandidate: ReviewNotCandidateError;\n    alreadyOwner: ReviewAlreadyOwnerError;\n    stepNotTakeable: ReviewStepNotTakeableError;\n    persistence: ReviewPersistenceError;\n    targetSync: ReviewTargetSyncError;\n}\n\nexport interface TakeOverReviewStepInput extends ReviewActorInput {\n    /** D111: whether the previous owner is told; omitted means true. Reaches the fact, never stored. */\n    notifyPreviousOwner?: boolean;\n}\n\ntype UseCaseError = ITakeOverReviewStepUseCaseErrors[keyof ITakeOverReviewStepUseCaseErrors];\n\nexport interface ITakeOverReviewStepUseCase {\n    execute(input: TakeOverReviewStepInput): Promise<Result<ReviewData, UseCaseError>>;\n}\n\n/** Another candidate takes a human step in review (spec 5.1 \"take over\", D32, D9). */\nexport const TakeOverReviewStepUseCase = createAbstraction<ITakeOverReviewStepUseCase>(\n    \"TakeOverReviewStepUseCase\"\n);\n\nexport namespace TakeOverReviewStepUseCase {\n    export type Interface = ITakeOverReviewStepUseCase;\n    export type Input = TakeOverReviewStepInput;\n    export type Error = UseCaseError;\n    export type Return = Promise<Result<ReviewData, UseCaseError>>;\n}\n"],"names":["TakeOverReviewStepUseCase","createAbstraction"],"mappings":";AAyCO,MAAMA,4BAA4BC,kBACrC"}

package/features/review/TakeOverReviewStep/events.d.ts

@@ -0,0 +1,16 @@
+import { DomainEvent } from "@webiny/api-core/features/eventPublisher/index.js";
+import type { IEventHandler } from "@webiny/api-core/features/eventPublisher/index.js";
+import type { ReviewStepTakenOverFact } from "../../../domain/review/facts.js";
+import type { ReviewEventPayload } from "../shared/events.js";
+/**
+ * ReviewStepTakenOverEvent - published after the review is saved.
+ */
+export declare class ReviewStepTakenOverEvent extends DomainEvent<ReviewEventPayload<ReviewStepTakenOverFact>> {
+    eventType: "Workflows/Review/StepTakenOver";
+    getHandlerAbstraction(): import("@webiny/di").Abstraction<IEventHandler<ReviewStepTakenOverEvent>>;
+}
+export declare const ReviewStepTakenOverEventHandler: import("@webiny/di").Abstraction<IEventHandler<ReviewStepTakenOverEvent>>;
+export declare namespace ReviewStepTakenOverEventHandler {
+    type Interface = IEventHandler<ReviewStepTakenOverEvent>;
+    type Event = ReviewStepTakenOverEvent;
+}

package/features/review/TakeOverReviewStep/events.js

@@ -0,0 +1,14 @@
+import { createAbstraction } from "@webiny/feature/api";
+import { DomainEvent } from "@webiny/api-core/features/eventPublisher/index.js";
+class ReviewStepTakenOverEvent extends DomainEvent {
+    getHandlerAbstraction() {
+        return ReviewStepTakenOverEventHandler;
+    }
+    constructor(...args){
+        super(...args), this.eventType = "Workflows/Review/StepTakenOver";
+    }
+}
+const ReviewStepTakenOverEventHandler = createAbstraction("ReviewStepTakenOverEventHandler");
+export { ReviewStepTakenOverEvent, ReviewStepTakenOverEventHandler };
+
+//# sourceMappingURL=events.js.map

package/features/review/TakeOverReviewStep/events.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"features/review/TakeOverReviewStep/events.js","sources":["../../../../src/features/review/TakeOverReviewStep/events.ts"],"sourcesContent":["import { createAbstraction } from \"@webiny/feature/api\";\nimport { DomainEvent } from \"@webiny/api-core/features/eventPublisher/index.js\";\nimport type { IEventHandler } from \"@webiny/api-core/features/eventPublisher/index.js\";\nimport type { ReviewStepTakenOverFact } from \"~/domain/review/facts.js\";\nimport type { ReviewEventPayload } from \"../shared/events.js\";\n\n/**\n * ReviewStepTakenOverEvent - published after the review is saved.\n */\nexport class ReviewStepTakenOverEvent extends DomainEvent<\n    ReviewEventPayload<ReviewStepTakenOverFact>\n> {\n    eventType = \"Workflows/Review/StepTakenOver\" as const;\n\n    getHandlerAbstraction() {\n        return ReviewStepTakenOverEventHandler;\n    }\n}\n\nexport const ReviewStepTakenOverEventHandler = createAbstraction<\n    IEventHandler<ReviewStepTakenOverEvent>\n>(\"ReviewStepTakenOverEventHandler\");\n\nexport namespace ReviewStepTakenOverEventHandler {\n    export type Interface = IEventHandler<ReviewStepTakenOverEvent>;\n    export type Event = ReviewStepTakenOverEvent;\n}\n"],"names":["ReviewStepTakenOverEvent","DomainEvent","ReviewStepTakenOverEventHandler","createAbstraction"],"mappings":";;AASO,MAAMA,iCAAiCC;IAK1C,wBAAwB;QACpB,OAAOC;IACX;;QAPG,qBAGH,SAAS,GAAG;;AAKhB;AAEO,MAAMA,kCAAkCC,kBAE7C"}

package/features/review/TakeOverReviewStep/feature.d.ts

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

package/features/review/TakeOverReviewStep/feature.js

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

package/features/review/TakeOverReviewStep/feature.js.map

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

package/features/review/TakeOverReviewStep/index.d.ts

@@ -0,0 +1,3 @@
+export { TakeOverReviewStepUseCase } from "./abstractions.js";
+export type { ReviewActorInput } from "../shared/types.js";
+export { ReviewStepTakenOverEventHandler } from "./events.js";

package/features/review/TakeOverReviewStep/index.js

@@ -0,0 +1,2 @@
+export { TakeOverReviewStepUseCase } from "./abstractions.js";
+export { ReviewStepTakenOverEventHandler } from "./events.js";

package/features/review/shared/ReviewEntryMapper.d.ts

@@ -0,0 +1,83 @@
+import type { CmsEntry } from "@webiny/api-headless-cms/types/index.js";
+import type { WorkflowStepNotification } from "../../../domain/workflow/types.js";
+import type { ReviewData, TargetContextAuthor, TargetContextFolder } from "../../../domain/review/types.js";
+import { type ActorEntryValues } from "../../../features/shared/ActorEntryMapper.js";
+export interface ReviewEntryStepAssignment {
+    source: string;
+    ruleId: string | null;
+    reason: string | null;
+    by: ActorEntryValues | null;
+}
+export interface ReviewEntryStepRun {
+    taskId: string | null;
+    startedOn: string | Date | null;
+    finishedOn: string | Date | null;
+    outcome: string | null;
+    reason: string | null;
+}
+export interface ReviewEntryStepIssue {
+    fieldPath: string | null;
+    severity: string;
+    message: string;
+    suggestion: string | null;
+}
+export interface ReviewEntryStep {
+    id: string;
+    title: string;
+    color: string | null;
+    description: string | null;
+    type: string;
+    notifications: WorkflowStepNotification[] | null;
+    config: unknown;
+    state: string;
+    owner: ActorEntryValues | null;
+    comment: string | null;
+    pickedUserId: string | null;
+    candidateTeamIds: string[] | null;
+    assignmentSource: string | null;
+    assignment: ReviewEntryStepAssignment | null;
+    reachedOn: string | Date | null;
+    startedOn: string | Date | null;
+    finishedOn: string | Date | null;
+    taskId: string | null;
+    runs: ReviewEntryStepRun[] | null;
+    issues: ReviewEntryStepIssue[] | null;
+}
+export interface ReviewEntryTargetContext {
+    folder: TargetContextFolder | null;
+    modelId: string;
+    title: string;
+    author: TargetContextAuthor | null;
+}
+export interface ReviewEntryWorkflow {
+    name: string;
+    models: string[] | null;
+}
+export interface ReviewEntryValues {
+    workflowId: string;
+    model: string;
+    targetId: string;
+    targetRevisionId: string;
+    title: string;
+    isActive: boolean;
+    state: string;
+    currentStepId: string | null;
+    currentStepState: string | null;
+    currentStepType: string | null;
+    currentOwnerId: string | null;
+    currentCandidateTeamIds: string[] | null;
+    targetContext: ReviewEntryTargetContext | null;
+    workflow: ReviewEntryWorkflow | null;
+    steps: ReviewEntryStep[] | null;
+    requester: ActorEntryValues | null;
+    cancelledBy?: ActorEntryValues | null;
+    lastChangedOn: string | Date | null;
+}
+/** Maps reviews to and from `wbyWorkflowReview` entries; nulls in storage become absent optionals. */
+export declare class ReviewEntryMapper {
+    static toValues(review: ReviewData): ReviewEntryValues;
+    static fromEntry(entry: CmsEntry<ReviewEntryValues>): ReviewData;
+    private static stepToEntry;
+    private static stepFromEntry;
+    private static assignmentFromEntry;
+}

package/features/review/shared/ReviewEntryMapper.js

@@ -0,0 +1,191 @@
+import { parseIdentifier } from "@webiny/utils";
+import { toIsoString } from "../../shared/toIsoString.js";
+import { ActorEntryMapper } from "../../shared/ActorEntryMapper.js";
+class ReviewEntryMapper {
+    static toValues(review) {
+        return {
+            workflowId: review.workflowId,
+            model: review.model,
+            targetId: review.targetId,
+            targetRevisionId: review.targetRevisionId,
+            title: review.title,
+            isActive: review.isActive,
+            state: review.state,
+            currentStepId: review.currentStepId,
+            currentStepState: review.currentStepState,
+            currentStepType: review.currentStepType,
+            currentOwnerId: review.currentOwnerId,
+            currentCandidateTeamIds: [
+                ...review.currentCandidateTeamIds
+            ],
+            targetContext: {
+                folder: review.targetContext.folder ? {
+                    ...review.targetContext.folder
+                } : null,
+                modelId: review.targetContext.modelId,
+                title: review.targetContext.title,
+                author: {
+                    ...review.targetContext.author
+                }
+            },
+            workflow: {
+                name: review.workflow.name,
+                models: [
+                    ...review.workflow.models
+                ]
+            },
+            steps: review.steps.map((step)=>ReviewEntryMapper.stepToEntry(step)),
+            requester: ActorEntryMapper.toEntry(review.createdBy),
+            cancelledBy: review.cancelledBy ? ActorEntryMapper.toEntry(review.cancelledBy) : null,
+            lastChangedOn: review.lastChangedOn
+        };
+    }
+    static fromEntry(entry) {
+        const { id } = parseIdentifier(entry.id);
+        const values = entry.values;
+        const folder = values.targetContext?.folder;
+        return {
+            id,
+            workflowId: values.workflowId,
+            model: values.model,
+            targetId: values.targetId,
+            targetRevisionId: values.targetRevisionId,
+            title: values.title,
+            isActive: true === values.isActive,
+            state: values.state,
+            currentStepId: values.currentStepId ?? null,
+            currentStepState: values.currentStepState ?? null,
+            currentStepType: values.currentStepType ?? null,
+            currentOwnerId: values.currentOwnerId ?? null,
+            currentCandidateTeamIds: values.currentCandidateTeamIds ?? [],
+            targetContext: {
+                folder: folder?.id ? {
+                    id: folder.id,
+                    type: folder.type
+                } : null,
+                modelId: values.targetContext?.modelId ?? "",
+                title: values.targetContext?.title ?? "",
+                author: {
+                    id: values.targetContext?.author?.id ?? "",
+                    displayName: values.targetContext?.author?.displayName ?? ""
+                }
+            },
+            workflow: {
+                name: values.workflow?.name ?? "",
+                models: values.workflow?.models ?? []
+            },
+            steps: (values.steps ?? []).map((step)=>ReviewEntryMapper.stepFromEntry(step)),
+            createdBy: ActorEntryMapper.fromEntry(values.requester) ?? {
+                type: "user",
+                id: "",
+                displayName: ""
+            },
+            cancelledBy: ActorEntryMapper.fromEntry(values.cancelledBy),
+            createdOn: entry.createdOn,
+            savedOn: entry.savedOn,
+            lastChangedOn: toIsoString(values.lastChangedOn) ?? entry.savedOn
+        };
+    }
+    static stepToEntry(step) {
+        return {
+            id: step.id,
+            title: step.title,
+            color: step.color,
+            description: step.description ?? null,
+            type: step.type,
+            notifications: step.notifications.map((notification)=>({
+                    id: notification.id
+                })),
+            config: step.config,
+            state: step.state,
+            owner: step.owner ? ActorEntryMapper.toEntry(step.owner) : null,
+            comment: step.comment,
+            pickedUserId: step.pickedUserId,
+            candidateTeamIds: [
+                ...step.candidateTeamIds
+            ],
+            assignmentSource: step.assignmentSource,
+            assignment: step.assignment ? {
+                source: step.assignment.source,
+                ruleId: step.assignment.ruleId ?? null,
+                reason: step.assignment.reason || null,
+                by: step.assignment.by ? ActorEntryMapper.toEntry(step.assignment.by) : null
+            } : null,
+            reachedOn: step.reachedOn,
+            startedOn: step.startedOn,
+            finishedOn: step.finishedOn,
+            taskId: step.taskId,
+            runs: step.runs.map((run)=>({
+                    taskId: run.taskId,
+                    startedOn: run.startedOn,
+                    finishedOn: run.finishedOn,
+                    outcome: run.outcome,
+                    reason: run.reason
+                })),
+            issues: step.issues.map((issue)=>({
+                    fieldPath: issue.fieldPath,
+                    severity: issue.severity,
+                    message: issue.message,
+                    suggestion: issue.suggestion
+                }))
+        };
+    }
+    static stepFromEntry(step) {
+        return {
+            id: step.id,
+            title: step.title,
+            color: step.color ?? "",
+            ...step.description ? {
+                description: step.description
+            } : {},
+            type: step.type,
+            notifications: (step.notifications ?? []).map((notification)=>({
+                    id: notification.id
+                })),
+            config: step.config ?? null,
+            state: step.state,
+            owner: ActorEntryMapper.fromEntry(step.owner),
+            comment: step.comment || null,
+            pickedUserId: step.pickedUserId ?? null,
+            candidateTeamIds: step.candidateTeamIds ?? [],
+            assignmentSource: step.assignmentSource ?? null,
+            assignment: ReviewEntryMapper.assignmentFromEntry(step.assignment),
+            reachedOn: toIsoString(step.reachedOn),
+            startedOn: toIsoString(step.startedOn),
+            finishedOn: toIsoString(step.finishedOn),
+            taskId: step.taskId || null,
+            runs: (step.runs ?? []).map((run)=>({
+                    taskId: run.taskId || null,
+                    startedOn: toIsoString(run.startedOn) ?? "",
+                    finishedOn: toIsoString(run.finishedOn),
+                    outcome: run.outcome || null,
+                    reason: run.reason || null
+                })),
+            issues: (step.issues ?? []).map((issue)=>({
+                    fieldPath: issue.fieldPath || null,
+                    severity: issue.severity,
+                    message: issue.message ?? "",
+                    suggestion: issue.suggestion || null
+                }))
+        };
+    }
+    static assignmentFromEntry(value) {
+        if (!value?.source) return null;
+        const by = ActorEntryMapper.fromEntry(value.by);
+        return {
+            source: value.source,
+            ...value.ruleId ? {
+                ruleId: value.ruleId
+            } : {},
+            ...value.reason ? {
+                reason: value.reason
+            } : {},
+            ...by ? {
+                by
+            } : {}
+        };
+    }
+}
+export { ReviewEntryMapper };
+
+//# sourceMappingURL=ReviewEntryMapper.js.map