@webiny/api-workflows 0.0.0-unstable.7c2def32a7 → 0.0.0-unstable.9609e4e0c9

package/features/review/ReviewSaver/ReviewSaver.js

@@ -0,0 +1,170 @@
+import { Result } from "@webiny/feature/api";
+import { EventPublisher } from "@webiny/api-core/features/eventPublisher/index.js";
+import { Logger } from "@webiny/api-core/features/logger/index.js";
+import { AssignmentRepository } from "../../../domain/assignment/abstractions/AssignmentRepository.js";
+import { toAssignmentRecordValues } from "../../../domain/assignment/toAssignmentRecordValues.js";
+import { forEachWithConcurrency } from "../../../domain/forEachWithConcurrency.js";
+import { Review } from "../../../domain/review/Review.js";
+import { ReviewTargetSyncError } from "../../../domain/review/errors.js";
+import { ReviewRepository } from "../../../domain/review/abstractions/ReviewRepository.js";
+import { ReviewTargetSync } from "../ReviewTargetSync/abstractions.js";
+import { ReviewTaskAbortService } from "../../stepRun/ReviewTaskAbortService/index.js";
+import { ReviewApprovedEvent, ReviewStepApprovedEvent } from "../ApproveReviewStep/events.js";
+import { ReviewCancelledEvent } from "../CancelReview/events.js";
+import { ReviewStepFailedEvent } from "../shared/events.js";
+import { ReviewRequestedEvent } from "../RequestReview/events.js";
+import { ReviewStepReachedEvent } from "../ReviewStepReacher/events.js";
+import { ReviewStepReassignedEvent } from "../ReassignReviewStep/events.js";
+import { ReviewStepRejectedEvent } from "../RejectReviewStep/events.js";
+import { ReviewStepRestartedEvent } from "../RestartReviewStep/events.js";
+import { ReviewStepStartedEvent } from "../StartReviewStep/events.js";
+import { ReviewStepTakenOverEvent } from "../TakeOverReviewStep/events.js";
+import { ReviewSaver } from "./abstractions.js";
+import { hasErrorSource } from "../../../domain/hasErrorSource.js";
+const ASSIGNMENT_WRITE_CONCURRENCY = 5;
+class ReviewSaverImpl {
+    constructor(repository, targetSyncs, eventPublisher, assignments, logger, taskAbort){
+        this.repository = repository;
+        this.targetSyncs = targetSyncs;
+        this.eventPublisher = eventPublisher;
+        this.assignments = assignments;
+        this.logger = logger;
+        this.taskAbort = taskAbort;
+    }
+    async save(review) {
+        review.prepareForSave();
+        const facts = review.pullFacts();
+        const data = review.toData();
+        const isNew = facts.some((fact)=>"requested" === fact.type);
+        const result = isNew ? await this.repository.create(data) : await this.repository.update(data);
+        if (result.isFail()) {
+            const taskIds = [];
+            for (const fact of facts)if ("stepReached" === fact.type && fact.taskId) taskIds.push(fact.taskId);
+            await this.taskAbort.abort({
+                taskIds,
+                message: "The review could not be saved."
+            });
+            return Result.fail(result.error);
+        }
+        const saved = result.value;
+        const records = [];
+        for (const fact of facts)records.push(...toAssignmentRecordValues(saved, fact));
+        await forEachWithConcurrency(records, ASSIGNMENT_WRITE_CONCURRENCY, async (values)=>{
+            try {
+                const created = await this.assignments.create(values);
+                if (created.isFail()) this.logger.error({
+                    err: hasErrorSource(created.error) ? created.error.source : created.error,
+                    reviewId: saved.id,
+                    stepId: values.stepId,
+                    source: values.source
+                }, "Could not write an assignment record; the review was saved without it.");
+            } catch (error) {
+                this.logger.error({
+                    err: error,
+                    reviewId: saved.id,
+                    stepId: values.stepId,
+                    source: values.source
+                }, "Could not write an assignment record; the review was saved without it.");
+            }
+        });
+        let synced = Result.ok();
+        const targetSync = [
+            ...this.targetSyncs
+        ].reverse().find((item)=>item.canSync(saved.model));
+        if (targetSync) try {
+            synced = await targetSync.sync({
+                review: saved,
+                systemWorkflow: Review.fromData(saved).getSystemWorkflow()
+            });
+        } catch (error) {
+            synced = Result.fail(error instanceof Error ? error : new Error(String(error)));
+        }
+        for (const fact of facts){
+            const event = this.createEvent(saved, fact);
+            await this.eventPublisher.publish(event);
+        }
+        if (synced.isFail()) return Result.fail(new ReviewTargetSyncError({
+            review: saved,
+            error: synced.error
+        }));
+        return Result.ok(saved);
+    }
+    createEvent(review, fact) {
+        switch(fact.type){
+            case "requested":
+                return new ReviewRequestedEvent({
+                    review,
+                    fact
+                });
+            case "stepReached":
+                return new ReviewStepReachedEvent({
+                    review,
+                    fact
+                });
+            case "stepStarted":
+                return new ReviewStepStartedEvent({
+                    review,
+                    fact
+                });
+            case "stepTakenOver":
+                return new ReviewStepTakenOverEvent({
+                    review,
+                    fact
+                });
+            case "stepReassigned":
+                return new ReviewStepReassignedEvent({
+                    review,
+                    fact
+                });
+            case "stepApproved":
+                return new ReviewStepApprovedEvent({
+                    review,
+                    fact
+                });
+            case "stepRejected":
+                return new ReviewStepRejectedEvent({
+                    review,
+                    fact
+                });
+            case "stepFailed":
+                return new ReviewStepFailedEvent({
+                    review,
+                    fact
+                });
+            case "stepRestarted":
+                return new ReviewStepRestartedEvent({
+                    review,
+                    fact
+                });
+            case "cancelled":
+                return new ReviewCancelledEvent({
+                    review,
+                    fact
+                });
+            case "approved":
+                return new ReviewApprovedEvent({
+                    review,
+                    fact
+                });
+        }
+    }
+}
+const ReviewSaver_ReviewSaver = ReviewSaver.createImplementation({
+    implementation: ReviewSaverImpl,
+    dependencies: [
+        ReviewRepository,
+        [
+            ReviewTargetSync,
+            {
+                multiple: true
+            }
+        ],
+        EventPublisher,
+        AssignmentRepository,
+        Logger,
+        ReviewTaskAbortService
+    ]
+});
+export { ReviewSaver_ReviewSaver as ReviewSaver };
+
+//# sourceMappingURL=ReviewSaver.js.map

package/features/review/ReviewSaver/ReviewSaver.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"features/review/ReviewSaver/ReviewSaver.js","sources":["../../../../src/features/review/ReviewSaver/ReviewSaver.ts"],"sourcesContent":["import { Result } from \"@webiny/feature/api\";\nimport { EventPublisher } from \"@webiny/api-core/features/eventPublisher/index.js\";\nimport { Logger } from \"@webiny/api-core/features/logger/index.js\";\nimport { AssignmentRepository } from \"~/domain/assignment/abstractions/AssignmentRepository.js\";\nimport { toAssignmentRecordValues } from \"~/domain/assignment/toAssignmentRecordValues.js\";\nimport type { AssignmentRecordValues } from \"~/domain/assignment/types.js\";\nimport { forEachWithConcurrency } from \"~/domain/forEachWithConcurrency.js\";\nimport { Review } from \"~/domain/review/Review.js\";\nimport type { ReviewFact } from \"~/domain/review/facts.js\";\nimport type { ReviewData } from \"~/domain/review/types.js\";\nimport { ReviewTargetSyncError } from \"~/domain/review/errors.js\";\nimport { ReviewRepository } from \"~/domain/review/abstractions/ReviewRepository.js\";\nimport { ReviewTargetSync } from \"../ReviewTargetSync/abstractions.js\";\nimport { ReviewTaskAbortService } from \"~/features/stepRun/ReviewTaskAbortService/index.js\";\nimport { ReviewApprovedEvent, ReviewStepApprovedEvent } from \"../ApproveReviewStep/events.js\";\nimport { ReviewCancelledEvent } from \"../CancelReview/events.js\";\nimport { type ReviewEvent, ReviewStepFailedEvent } from \"../shared/events.js\";\nimport { ReviewRequestedEvent } from \"../RequestReview/events.js\";\nimport { ReviewStepReachedEvent } from \"../ReviewStepReacher/events.js\";\nimport { ReviewStepReassignedEvent } from \"../ReassignReviewStep/events.js\";\nimport { ReviewStepRejectedEvent } from \"../RejectReviewStep/events.js\";\nimport { ReviewStepRestartedEvent } from \"../RestartReviewStep/events.js\";\nimport { ReviewStepStartedEvent } from \"../StartReviewStep/events.js\";\nimport { ReviewStepTakenOverEvent } from \"../TakeOverReviewStep/events.js\";\nimport { ReviewSaver as ReviewSaverAbstraction } from \"./abstractions.js\";\nimport { hasErrorSource } from \"~/domain/hasErrorSource.js\";\n\n/** How many assignment records are written at once. */\nconst ASSIGNMENT_WRITE_CONCURRENCY = 5;\n\nclass ReviewSaverImpl implements ReviewSaverAbstraction.Interface {\n    constructor(\n        private repository: ReviewRepository.Interface,\n        private targetSyncs: ReviewTargetSync.Interface[],\n        private eventPublisher: EventPublisher.Interface,\n        private assignments: AssignmentRepository.Interface,\n        private logger: Logger.Interface,\n        private taskAbort: ReviewTaskAbortService.Interface\n    ) {}\n\n    async save(review: Review): ReviewSaverAbstraction.Return {\n        review.prepareForSave();\n        // Facts are pulled before persisting. If the save fails they are lost from this instance,\n        // which is fine: every use case discards the instance after a failed save.\n        const facts = review.pullFacts();\n\n        // No optimistic locking on reviews (D27). Only `Review.request` records `requested`, so a\n        // review without it already exists: updating it never re-creates one deleted meanwhile.\n        const data = review.toData();\n        const isNew = facts.some(fact => fact.type === \"requested\");\n        const result = isNew\n            ? await this.repository.create(data)\n            : await this.repository.update(data);\n        if (result.isFail()) {\n            // The automation reach triggers its task before this save (R143). The review will not\n            // carry the task id, so abort the tasks the recorded reaches started. Best effort: the\n            // abort never throws and never changes the error returned here.\n            const taskIds: string[] = [];\n            for (const fact of facts) {\n                if (fact.type === \"stepReached\" && fact.taskId) {\n                    taskIds.push(fact.taskId);\n                }\n            }\n            await this.taskAbort.abort({\n                taskIds,\n                message: \"The review could not be saved.\"\n            });\n            return Result.fail(result.error);\n        }\n        const saved = result.value;\n\n        // The review is saved, so its assignment decisions happened: write them to the log\n        // (R117). Writing after the save leaves no orphaned records when the save fails; a failed\n        // write is logged and never fails the request. The CMS has no create-multiple, so the\n        // records are written a few at a time; their order does not matter, each record carries\n        // its own `assignedOn`.\n        const records: AssignmentRecordValues[] = [];\n        for (const fact of facts) {\n            records.push(...toAssignmentRecordValues(saved, fact));\n        }\n        await forEachWithConcurrency(records, ASSIGNMENT_WRITE_CONCURRENCY, async values => {\n            try {\n                const created = await this.assignments.create(values);\n                if (created.isFail()) {\n                    this.logger.error(\n                        {\n                            err: hasErrorSource(created.error)\n                                ? created.error.source\n                                : created.error,\n                            reviewId: saved.id,\n                            stepId: values.stepId,\n                            source: values.source\n                        },\n                        \"Could not write an assignment record; the review was saved without it.\"\n                    );\n                }\n            } catch (error) {\n                this.logger.error(\n                    {\n                        err: error,\n                        reviewId: saved.id,\n                        stepId: values.stepId,\n                        source: values.source\n                    },\n                    \"Could not write an assignment record; the review was saved without it.\"\n                );\n            }\n        });\n\n        // One sync per namespace; the last registered match wins. No match: nothing to sync.\n        let synced: Result<void, Error> = Result.ok();\n        const targetSync = [...this.targetSyncs].reverse().find(item => item.canSync(saved.model));\n        if (targetSync) {\n            try {\n                synced = await targetSync.sync({\n                    review: saved,\n                    systemWorkflow: Review.fromData(saved).getSystemWorkflow()\n                });\n            } catch (error) {\n                synced = Result.fail(error instanceof Error ? error : new Error(String(error)));\n            }\n        }\n\n        // The review is saved, so its facts happened: publish them even when the sync failed\n        // (R16). Handler exceptions propagate, as everywhere else in the repo. One at a time, in\n        // fact order: handlers see the facts in the order they happened (a step is reached\n        // before it is started), and a throwing handler stops the facts after it.\n        for (const fact of facts) {\n            const event = this.createEvent(saved, fact);\n            // oxlint-disable-next-line no-await-in-loop -- the facts are published in order, one at a time.\n            await this.eventPublisher.publish(event);\n        }\n\n        if (synced.isFail()) {\n            return Result.fail(new ReviewTargetSyncError({ review: saved, error: synced.error }));\n        }\n        return Result.ok(saved);\n    }\n\n    private createEvent(review: ReviewData, fact: ReviewFact): ReviewEvent {\n        switch (fact.type) {\n            case \"requested\":\n                return new ReviewRequestedEvent({ review, fact });\n            case \"stepReached\":\n                return new ReviewStepReachedEvent({ review, fact });\n            case \"stepStarted\":\n                return new ReviewStepStartedEvent({ review, fact });\n            case \"stepTakenOver\":\n                return new ReviewStepTakenOverEvent({ review, fact });\n            case \"stepReassigned\":\n                return new ReviewStepReassignedEvent({ review, fact });\n            case \"stepApproved\":\n                return new ReviewStepApprovedEvent({ review, fact });\n            case \"stepRejected\":\n                return new ReviewStepRejectedEvent({ review, fact });\n            case \"stepFailed\":\n                return new ReviewStepFailedEvent({ review, fact });\n            case \"stepRestarted\":\n                return new ReviewStepRestartedEvent({ review, fact });\n            case \"cancelled\":\n                return new ReviewCancelledEvent({ review, fact });\n            case \"approved\":\n                return new ReviewApprovedEvent({ review, fact });\n        }\n    }\n}\n\nexport const ReviewSaver = ReviewSaverAbstraction.createImplementation({\n    implementation: ReviewSaverImpl,\n    dependencies: [\n        ReviewRepository,\n        [ReviewTargetSync, { multiple: true }],\n        EventPublisher,\n        AssignmentRepository,\n        Logger,\n        ReviewTaskAbortService\n    ]\n});\n"],"names":["ASSIGNMENT_WRITE_CONCURRENCY","ReviewSaverImpl","repository","targetSyncs","eventPublisher","assignments","logger","taskAbort","review","facts","data","isNew","fact","result","taskIds","Result","saved","records","toAssignmentRecordValues","forEachWithConcurrency","values","created","hasErrorSource","error","synced","targetSync","item","Review","Error","String","event","ReviewTargetSyncError","ReviewRequestedEvent","ReviewStepReachedEvent","ReviewStepStartedEvent","ReviewStepTakenOverEvent","ReviewStepReassignedEvent","ReviewStepApprovedEvent","ReviewStepRejectedEvent","ReviewStepFailedEvent","ReviewStepRestartedEvent","ReviewCancelledEvent","ReviewApprovedEvent","ReviewSaver","ReviewSaverAbstraction","ReviewRepository","ReviewTargetSync","EventPublisher","AssignmentRepository","Logger","ReviewTaskAbortService"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;AA4BA,MAAMA,+BAA+B;AAErC,MAAMC;IACF,YACYC,UAAsC,EACtCC,WAAyC,EACzCC,cAAwC,EACxCC,WAA2C,EAC3CC,MAAwB,EACxBC,SAA2C,CACrD;aANUL,UAAU,GAAVA;aACAC,WAAW,GAAXA;aACAC,cAAc,GAAdA;aACAC,WAAW,GAAXA;aACAC,MAAM,GAANA;aACAC,SAAS,GAATA;IACT;IAEH,MAAM,KAAKC,MAAc,EAAiC;QACtDA,OAAO,cAAc;QAGrB,MAAMC,QAAQD,OAAO,SAAS;QAI9B,MAAME,OAAOF,OAAO,MAAM;QAC1B,MAAMG,QAAQF,MAAM,IAAI,CAACG,CAAAA,OAAQA,AAAc,gBAAdA,KAAK,IAAI;QAC1C,MAAMC,SAASF,QACT,MAAM,IAAI,CAAC,UAAU,CAAC,MAAM,CAACD,QAC7B,MAAM,IAAI,CAAC,UAAU,CAAC,MAAM,CAACA;QACnC,IAAIG,OAAO,MAAM,IAAI;YAIjB,MAAMC,UAAoB,EAAE;YAC5B,KAAK,MAAMF,QAAQH,MACf,IAAIG,AAAc,kBAAdA,KAAK,IAAI,IAAsBA,KAAK,MAAM,EAC1CE,QAAQ,IAAI,CAACF,KAAK,MAAM;YAGhC,MAAM,IAAI,CAAC,SAAS,CAAC,KAAK,CAAC;gBACvBE;gBACA,SAAS;YACb;YACA,OAAOC,OAAO,IAAI,CAACF,OAAO,KAAK;QACnC;QACA,MAAMG,QAAQH,OAAO,KAAK;QAO1B,MAAMI,UAAoC,EAAE;QAC5C,KAAK,MAAML,QAAQH,MACfQ,QAAQ,IAAI,IAAIC,yBAAyBF,OAAOJ;QAEpD,MAAMO,uBAAuBF,SAASjB,8BAA8B,OAAMoB;YACtE,IAAI;gBACA,MAAMC,UAAU,MAAM,IAAI,CAAC,WAAW,CAAC,MAAM,CAACD;gBAC9C,IAAIC,QAAQ,MAAM,IACd,IAAI,CAAC,MAAM,CAAC,KAAK,CACb;oBACI,KAAKC,eAAeD,QAAQ,KAAK,IAC3BA,QAAQ,KAAK,CAAC,MAAM,GACpBA,QAAQ,KAAK;oBACnB,UAAUL,MAAM,EAAE;oBAClB,QAAQI,OAAO,MAAM;oBACrB,QAAQA,OAAO,MAAM;gBACzB,GACA;YAGZ,EAAE,OAAOG,OAAO;gBACZ,IAAI,CAAC,MAAM,CAAC,KAAK,CACb;oBACI,KAAKA;oBACL,UAAUP,MAAM,EAAE;oBAClB,QAAQI,OAAO,MAAM;oBACrB,QAAQA,OAAO,MAAM;gBACzB,GACA;YAER;QACJ;QAGA,IAAII,SAA8BT,OAAO,EAAE;QAC3C,MAAMU,aAAa;eAAI,IAAI,CAAC,WAAW;SAAC,CAAC,OAAO,GAAG,IAAI,CAACC,CAAAA,OAAQA,KAAK,OAAO,CAACV,MAAM,KAAK;QACxF,IAAIS,YACA,IAAI;YACAD,SAAS,MAAMC,WAAW,IAAI,CAAC;gBAC3B,QAAQT;gBACR,gBAAgBW,OAAO,QAAQ,CAACX,OAAO,iBAAiB;YAC5D;QACJ,EAAE,OAAOO,OAAO;YACZC,SAAST,OAAO,IAAI,CAACQ,iBAAiBK,QAAQL,QAAQ,IAAIK,MAAMC,OAAON;QAC3E;QAOJ,KAAK,MAAMX,QAAQH,MAAO;YACtB,MAAMqB,QAAQ,IAAI,CAAC,WAAW,CAACd,OAAOJ;YAEtC,MAAM,IAAI,CAAC,cAAc,CAAC,OAAO,CAACkB;QACtC;QAEA,IAAIN,OAAO,MAAM,IACb,OAAOT,OAAO,IAAI,CAAC,IAAIgB,sBAAsB;YAAE,QAAQf;YAAO,OAAOQ,OAAO,KAAK;QAAC;QAEtF,OAAOT,OAAO,EAAE,CAACC;IACrB;IAEQ,YAAYR,MAAkB,EAAEI,IAAgB,EAAe;QACnE,OAAQA,KAAK,IAAI;YACb,KAAK;gBACD,OAAO,IAAIoB,qBAAqB;oBAAExB;oBAAQI;gBAAK;YACnD,KAAK;gBACD,OAAO,IAAIqB,uBAAuB;oBAAEzB;oBAAQI;gBAAK;YACrD,KAAK;gBACD,OAAO,IAAIsB,uBAAuB;oBAAE1B;oBAAQI;gBAAK;YACrD,KAAK;gBACD,OAAO,IAAIuB,yBAAyB;oBAAE3B;oBAAQI;gBAAK;YACvD,KAAK;gBACD,OAAO,IAAIwB,0BAA0B;oBAAE5B;oBAAQI;gBAAK;YACxD,KAAK;gBACD,OAAO,IAAIyB,wBAAwB;oBAAE7B;oBAAQI;gBAAK;YACtD,KAAK;gBACD,OAAO,IAAI0B,wBAAwB;oBAAE9B;oBAAQI;gBAAK;YACtD,KAAK;gBACD,OAAO,IAAI2B,sBAAsB;oBAAE/B;oBAAQI;gBAAK;YACpD,KAAK;gBACD,OAAO,IAAI4B,yBAAyB;oBAAEhC;oBAAQI;gBAAK;YACvD,KAAK;gBACD,OAAO,IAAI6B,qBAAqB;oBAAEjC;oBAAQI;gBAAK;YACnD,KAAK;gBACD,OAAO,IAAI8B,oBAAoB;oBAAElC;oBAAQI;gBAAK;QACtD;IACJ;AACJ;AAEO,MAAM+B,0BAAcC,YAAAA,oBAA2C,CAAC;IACnE,gBAAgB3C;IAChB,cAAc;QACV4C;QACA;YAACC;YAAkB;gBAAE,UAAU;YAAK;SAAE;QACtCC;QACAC;QACAC;QACAC;KACH;AACL"}

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

@@ -0,0 +1,21 @@
+import { type Result } from "@webiny/feature/api";
+import type { Review } from "../../../domain/review/Review.js";
+import type { ReviewData } from "../../../domain/review/types.js";
+import type { ReviewNotFoundError, ReviewPersistenceError, ReviewTargetSyncError } from "../../../domain/review/errors.js";
+export type ReviewSaverError = ReviewNotFoundError | ReviewPersistenceError | ReviewTargetSyncError;
+export interface IReviewSaver {
+    save(review: Review): Promise<Result<ReviewData, ReviewSaverError>>;
+}
+/**
+ * The single save path for reviews (R10, D19, D52): prepare the review-level fields, persist
+ * (create a new review, update an existing one; a deleted one is not re-created), write the facts' assignment records (R117; a failed write is only logged),
+ * sync `system.workflow`, then publish one event per recorded fact. A failed sync keeps the save
+ * and the events and returns `ReviewTargetSyncError` (R16). A failed persist aborts the step run
+ * tasks started by the recorded reaches (R143) before returning the persistence error.
+ */
+export declare const ReviewSaver: import("@webiny/di").Abstraction<IReviewSaver>;
+export declare namespace ReviewSaver {
+    type Interface = IReviewSaver;
+    type Error = ReviewSaverError;
+    type Return = Promise<Result<ReviewData, ReviewSaverError>>;
+}

package/features/review/ReviewSaver/abstractions.js

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"features/review/ReviewSaver/abstractions.js","sources":["../../../../src/features/review/ReviewSaver/abstractions.ts"],"sourcesContent":["import { createAbstraction, type Result } from \"@webiny/feature/api\";\nimport type { Review } from \"~/domain/review/Review.js\";\nimport type { ReviewData } from \"~/domain/review/types.js\";\nimport type {\n    ReviewNotFoundError,\n    ReviewPersistenceError,\n    ReviewTargetSyncError\n} from \"~/domain/review/errors.js\";\n\nexport type ReviewSaverError = ReviewNotFoundError | ReviewPersistenceError | ReviewTargetSyncError;\n\nexport interface IReviewSaver {\n    save(review: Review): Promise<Result<ReviewData, ReviewSaverError>>;\n}\n\n/**\n * The single save path for reviews (R10, D19, D52): prepare the review-level fields, persist\n * (create a new review, update an existing one; a deleted one is not re-created), write the facts' assignment records (R117; a failed write is only logged),\n * sync `system.workflow`, then publish one event per recorded fact. A failed sync keeps the save\n * and the events and returns `ReviewTargetSyncError` (R16). A failed persist aborts the step run\n * tasks started by the recorded reaches (R143) before returning the persistence error.\n */\nexport const ReviewSaver = createAbstraction<IReviewSaver>(\"ReviewSaver\");\n\nexport namespace ReviewSaver {\n    export type Interface = IReviewSaver;\n    export type Error = ReviewSaverError;\n    export type Return = Promise<Result<ReviewData, ReviewSaverError>>;\n}\n"],"names":["ReviewSaver","createAbstraction"],"mappings":";AAsBO,MAAMA,cAAcC,kBAAgC"}

package/features/review/ReviewStepReacher/ReviewStepReacher.d.ts

@@ -0,0 +1,12 @@
+import { Result } from "@webiny/feature/api";
+import { StepTypeRegistryService } from "../../../features/stepTypes/StepTypeRegistryService/index.js";
+import { ReviewStepReacher as ReviewStepReacherAbstraction } from "./abstractions.js";
+declare class ReviewStepReacherImpl implements ReviewStepReacherAbstraction.Interface {
+    private stepTypes;
+    constructor(stepTypes: StepTypeRegistryService.Interface);
+    reach(params: ReviewStepReacherAbstraction.Params): Promise<Result<void, ReviewStepReacherAbstraction.Error>>;
+}
+export declare const ReviewStepReacher: typeof ReviewStepReacherImpl & {
+    __abstraction: import("@webiny/di").Abstraction<import("./abstractions.js").IReviewStepReacher>;
+};
+export {};

package/features/review/ReviewStepReacher/ReviewStepReacher.js

@@ -0,0 +1,45 @@
+import { Result } from "@webiny/feature/api";
+import { getAutomationActor } from "../../../domain/automation/getAutomationActor.js";
+import { StepTypeRegistryService } from "../../stepTypes/StepTypeRegistryService/index.js";
+import { ReviewStepReacher } from "./abstractions.js";
+class ReviewStepReacherImpl {
+    constructor(stepTypes){
+        this.stepTypes = stepTypes;
+    }
+    async reach(params) {
+        const step = params.review.getStepToReach();
+        if (!step) return Result.ok();
+        const stepType = this.stepTypes.get(step.type);
+        if (!stepType) {
+            const reached = params.review.reachRun({
+                actor: params.actor,
+                owner: getAutomationActor(params.review.toData().createdBy),
+                taskId: null,
+                now: params.now
+            });
+            if (reached.isFail()) return Result.fail(reached.error);
+            const failed = params.review.fail({
+                stepId: step.id,
+                reason: `The step type "${step.type}" is not available.`,
+                now: params.now
+            });
+            if (failed.isFail()) return Result.fail(failed.error);
+            return Result.ok();
+        }
+        return stepType.reach({
+            review: params.review,
+            step,
+            actor: params.actor,
+            now: params.now
+        });
+    }
+}
+const ReviewStepReacher_ReviewStepReacher = ReviewStepReacher.createImplementation({
+    implementation: ReviewStepReacherImpl,
+    dependencies: [
+        StepTypeRegistryService
+    ]
+});
+export { ReviewStepReacher_ReviewStepReacher as ReviewStepReacher };
+
+//# sourceMappingURL=ReviewStepReacher.js.map

package/features/review/ReviewStepReacher/ReviewStepReacher.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"features/review/ReviewStepReacher/ReviewStepReacher.js","sources":["../../../../src/features/review/ReviewStepReacher/ReviewStepReacher.ts"],"sourcesContent":["import { Result } from \"@webiny/feature/api\";\nimport { getAutomationActor } from \"~/domain/automation/getAutomationActor.js\";\nimport { StepTypeRegistryService } from \"~/features/stepTypes/StepTypeRegistryService/index.js\";\nimport { ReviewStepReacher as ReviewStepReacherAbstraction } from \"./abstractions.js\";\n\nclass ReviewStepReacherImpl implements ReviewStepReacherAbstraction.Interface {\n    constructor(private stepTypes: StepTypeRegistryService.Interface) {}\n\n    async reach(\n        params: ReviewStepReacherAbstraction.Params\n    ): Promise<Result<void, ReviewStepReacherAbstraction.Error>> {\n        const step = params.review.getStepToReach();\n        if (!step) {\n            return Result.ok();\n        }\n\n        const stepType = this.stepTypes.get(step.type);\n        if (!stepType) {\n            // A workflow saved before its step type was removed keeps running from its snapshot\n            // (A53), so an unregistered type fails the step instead of leaving it pending. Like a\n            // run step that cannot start (R168), the step is reached first, without a task, so the\n            // reach is recorded; the built-in review type is always registered, so this is a run\n            // type and the requester's automation actor owns it.\n            const reached = params.review.reachRun({\n                actor: params.actor,\n                owner: getAutomationActor(params.review.toData().createdBy),\n                taskId: null,\n                now: params.now\n            });\n            if (reached.isFail()) {\n                return Result.fail(reached.error);\n            }\n            const failed = params.review.fail({\n                stepId: step.id,\n                reason: `The step type \"${step.type}\" is not available.`,\n                now: params.now\n            });\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        return stepType.reach({\n            review: params.review,\n            step,\n            actor: params.actor,\n            now: params.now\n        });\n    }\n}\n\nexport const ReviewStepReacher = ReviewStepReacherAbstraction.createImplementation({\n    implementation: ReviewStepReacherImpl,\n    dependencies: [StepTypeRegistryService]\n});\n"],"names":["ReviewStepReacherImpl","stepTypes","params","step","Result","stepType","reached","getAutomationActor","failed","ReviewStepReacher","ReviewStepReacherAbstraction","StepTypeRegistryService"],"mappings":";;;;AAKA,MAAMA;IACF,YAAoBC,SAA4C,CAAE;aAA9CA,SAAS,GAATA;IAA+C;IAEnE,MAAM,MACFC,MAA2C,EACc;QACzD,MAAMC,OAAOD,OAAO,MAAM,CAAC,cAAc;QACzC,IAAI,CAACC,MACD,OAAOC,OAAO,EAAE;QAGpB,MAAMC,WAAW,IAAI,CAAC,SAAS,CAAC,GAAG,CAACF,KAAK,IAAI;QAC7C,IAAI,CAACE,UAAU;YAMX,MAAMC,UAAUJ,OAAO,MAAM,CAAC,QAAQ,CAAC;gBACnC,OAAOA,OAAO,KAAK;gBACnB,OAAOK,mBAAmBL,OAAO,MAAM,CAAC,MAAM,GAAG,SAAS;gBAC1D,QAAQ;gBACR,KAAKA,OAAO,GAAG;YACnB;YACA,IAAII,QAAQ,MAAM,IACd,OAAOF,OAAO,IAAI,CAACE,QAAQ,KAAK;YAEpC,MAAME,SAASN,OAAO,MAAM,CAAC,IAAI,CAAC;gBAC9B,QAAQC,KAAK,EAAE;gBACf,QAAQ,CAAC,eAAe,EAAEA,KAAK,IAAI,CAAC,mBAAmB,CAAC;gBACxD,KAAKD,OAAO,GAAG;YACnB;YAEA,IAAIM,OAAO,MAAM,IACb,OAAOJ,OAAO,IAAI,CAACI,OAAO,KAAK;YAEnC,OAAOJ,OAAO,EAAE;QACpB;QAEA,OAAOC,SAAS,KAAK,CAAC;YAClB,QAAQH,OAAO,MAAM;YACrBC;YACA,OAAOD,OAAO,KAAK;YACnB,KAAKA,OAAO,GAAG;QACnB;IACJ;AACJ;AAEO,MAAMO,sCAAoBC,kBAAAA,oBAAiD,CAAC;IAC/E,gBAAgBV;IAChB,cAAc;QAACW;KAAwB;AAC3C"}

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

@@ -0,0 +1,28 @@
+import { type Result } from "@webiny/feature/api";
+import type { Review } from "../../../domain/review/Review.js";
+import type { Actor } from "../../../domain/review/types.js";
+import type { ReviewInvalidStateError, ReviewStepNotCurrentError } from "../../../domain/review/errors.js";
+/** What `StepType.reach` and `Review.fail` / `Review.reachRun` can return (R159). */
+export type ReviewStepReacherError = ReviewInvalidStateError | ReviewStepNotCurrentError;
+export interface ReviewStepReacherParams {
+    review: Review;
+    /** Who caused the step to be reached (requester, or approver of the previous step). */
+    actor: Actor;
+    now: string;
+}
+export interface IReviewStepReacher {
+    reach(params: ReviewStepReacherParams): Promise<Result<void, ReviewStepReacherError>>;
+}
+/**
+ * The one code path for "step reached" (spec 5.2, D2, D6). No-op when the current step is not
+ * pending. Dispatches by step type through `StepTypeRegistryService` (R131): the `review` type
+ * resolves an assignment, the `automation` type triggers its background task (R149); a step whose
+ * type is not registered is failed with a reason. A failed step is not an error of the reach; an
+ * error of `reach`, `reachRun` or `fail` is returned as it is (R159).
+ */
+export declare const ReviewStepReacher: import("@webiny/di").Abstraction<IReviewStepReacher>;
+export declare namespace ReviewStepReacher {
+    type Interface = IReviewStepReacher;
+    type Params = ReviewStepReacherParams;
+    type Error = ReviewStepReacherError;
+}

package/features/review/ReviewStepReacher/abstractions.js

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"features/review/ReviewStepReacher/abstractions.js","sources":["../../../../src/features/review/ReviewStepReacher/abstractions.ts"],"sourcesContent":["import { createAbstraction, type Result } from \"@webiny/feature/api\";\nimport type { Review } from \"~/domain/review/Review.js\";\nimport type { Actor } from \"~/domain/review/types.js\";\nimport type { ReviewInvalidStateError, ReviewStepNotCurrentError } from \"~/domain/review/errors.js\";\n\n/** What `StepType.reach` and `Review.fail` / `Review.reachRun` can return (R159). */\nexport type ReviewStepReacherError = ReviewInvalidStateError | ReviewStepNotCurrentError;\n\nexport interface ReviewStepReacherParams {\n    review: Review;\n    /** Who caused the step to be reached (requester, or approver of the previous step). */\n    actor: Actor;\n    now: string;\n}\n\nexport interface IReviewStepReacher {\n    reach(params: ReviewStepReacherParams): Promise<Result<void, ReviewStepReacherError>>;\n}\n\n/**\n * The one code path for \"step reached\" (spec 5.2, D2, D6). No-op when the current step is not\n * pending. Dispatches by step type through `StepTypeRegistryService` (R131): the `review` type\n * resolves an assignment, the `automation` type triggers its background task (R149); a step whose\n * type is not registered is failed with a reason. A failed step is not an error of the reach; an\n * error of `reach`, `reachRun` or `fail` is returned as it is (R159).\n */\nexport const ReviewStepReacher = createAbstraction<IReviewStepReacher>(\"ReviewStepReacher\");\n\nexport namespace ReviewStepReacher {\n    export type Interface = IReviewStepReacher;\n    export type Params = ReviewStepReacherParams;\n    export type Error = ReviewStepReacherError;\n}\n"],"names":["ReviewStepReacher","createAbstraction"],"mappings":";AA0BO,MAAMA,oBAAoBC,kBAAsC"}

package/features/review/ReviewStepReacher/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 { ReviewStepReachedFact } from "../../../domain/review/facts.js";
+import type { ReviewEventPayload } from "../shared/events.js";
+/**
+ * ReviewStepReachedEvent - published after the review is saved.
+ */
+export declare class ReviewStepReachedEvent extends DomainEvent<ReviewEventPayload<ReviewStepReachedFact>> {
+    eventType: "Workflows/Review/StepReached";
+    getHandlerAbstraction(): import("@webiny/di").Abstraction<IEventHandler<ReviewStepReachedEvent>>;
+}
+export declare const ReviewStepReachedEventHandler: import("@webiny/di").Abstraction<IEventHandler<ReviewStepReachedEvent>>;
+export declare namespace ReviewStepReachedEventHandler {
+    type Interface = IEventHandler<ReviewStepReachedEvent>;
+    type Event = ReviewStepReachedEvent;
+}

package/features/review/ReviewStepReacher/events.js

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"features/review/ReviewStepReacher/events.js","sources":["../../../../src/features/review/ReviewStepReacher/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 { ReviewStepReachedFact } from \"~/domain/review/facts.js\";\nimport type { ReviewEventPayload } from \"../shared/events.js\";\n\n/**\n * ReviewStepReachedEvent - published after the review is saved.\n */\nexport class ReviewStepReachedEvent extends DomainEvent<ReviewEventPayload<ReviewStepReachedFact>> {\n    eventType = \"Workflows/Review/StepReached\" as const;\n\n    getHandlerAbstraction() {\n        return ReviewStepReachedEventHandler;\n    }\n}\n\nexport const ReviewStepReachedEventHandler = createAbstraction<\n    IEventHandler<ReviewStepReachedEvent>\n>(\"ReviewStepReachedEventHandler\");\n\nexport namespace ReviewStepReachedEventHandler {\n    export type Interface = IEventHandler<ReviewStepReachedEvent>;\n    export type Event = ReviewStepReachedEvent;\n}\n"],"names":["ReviewStepReachedEvent","DomainEvent","ReviewStepReachedEventHandler","createAbstraction"],"mappings":";;AASO,MAAMA,+BAA+BC;IAGxC,wBAAwB;QACpB,OAAOC;IACX;;QALG,qBACH,SAAS,GAAG;;AAKhB;AAEO,MAAMA,gCAAgCC,kBAE3C"}

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

@@ -0,0 +1,61 @@
+import type { Result } from "@webiny/feature/api";
+import type { ReviewTargetEditorError } from "../../../domain/review/errors.js";
+export interface ReviewTargetEditorField {
+    /** The key `update` takes: a field id, or dotted ids for a nested object (`address.street`). */
+    path: string;
+    label: string;
+    /** The target's own field type, e.g. "text", "long-text", "number", "object". */
+    type: string;
+    value: unknown;
+    /** Whether `update` accepts this path (R172). The model is told, so it does not try the rest. */
+    writable: boolean;
+}
+export interface ReviewTargetContent {
+    title: string;
+    fields: ReviewTargetEditorField[];
+}
+export interface ReviewTargetEditorReadParams {
+    /** Namespace id, e.g. "cms.article" or "wb.page" (D41). */
+    model: string;
+    targetId: string;
+    targetRevisionId: string;
+}
+export interface ReviewTargetEditorUpdateParams extends ReviewTargetEditorReadParams {
+    /** The new values by field path, as read. */
+    values: Record<string, unknown>;
+}
+export interface ReviewTargetEditorUpdateResult {
+    /** The paths that were written. */
+    applied: string[];
+}
+export interface IReviewTargetEditor {
+    /** Whether this editor handles the namespace id, e.g. "cms.article" or "wb.page". */
+    canEdit(model: string): boolean;
+    /**
+     * The whole content under review, every field with `writable`. Fails with a
+     * `ReviewTargetEditorError` (target not found, not readable); never throws.
+     */
+    read(params: ReviewTargetEditorReadParams): Promise<Result<ReviewTargetContent, ReviewTargetEditorError>>;
+    /**
+     * Writes the bounded set of fields (R172), atomically: any path that is unknown or read-only,
+     * or any value the target rejects, fails the whole call and writes nothing. It does not check
+     * permissions or stale state and does not apply the bypass: the tool that calls it does (R173).
+     * Never throws; a non-validation failure is logged by the adapter and answered with a generic
+     * message.
+     */
+    update(params: ReviewTargetEditorUpdateParams): Promise<Result<ReviewTargetEditorUpdateResult, ReviewTargetEditorError>>;
+}
+/**
+ * Reads and writes the content under review for the AI tools (spec 9.3). One implementation per
+ * namespace, registered by the app target adapters (`cms.*`, `wb.page`); the last registered match
+ * wins (A10). The engine reaches it only through `ReviewTargetEditorService`.
+ */
+export declare const ReviewTargetEditor: import("@webiny/di").Abstraction<IReviewTargetEditor>;
+export declare namespace ReviewTargetEditor {
+    type Interface = IReviewTargetEditor;
+    type Field = ReviewTargetEditorField;
+    type Content = ReviewTargetContent;
+    type ReadParams = ReviewTargetEditorReadParams;
+    type UpdateParams = ReviewTargetEditorUpdateParams;
+    type UpdateResult = ReviewTargetEditorUpdateResult;
+}

package/features/review/ReviewTargetEditor/abstractions.js

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"features/review/ReviewTargetEditor/abstractions.js","sources":["../../../../src/features/review/ReviewTargetEditor/abstractions.ts"],"sourcesContent":["import { createAbstraction } from \"@webiny/feature/api\";\nimport type { Result } from \"@webiny/feature/api\";\nimport type { ReviewTargetEditorError } from \"~/domain/review/errors.js\";\n\nexport interface ReviewTargetEditorField {\n    /** The key `update` takes: a field id, or dotted ids for a nested object (`address.street`). */\n    path: string;\n    label: string;\n    /** The target's own field type, e.g. \"text\", \"long-text\", \"number\", \"object\". */\n    type: string;\n    value: unknown;\n    /** Whether `update` accepts this path (R172). The model is told, so it does not try the rest. */\n    writable: boolean;\n}\n\nexport interface ReviewTargetContent {\n    title: string;\n    fields: ReviewTargetEditorField[];\n}\n\nexport interface ReviewTargetEditorReadParams {\n    /** Namespace id, e.g. \"cms.article\" or \"wb.page\" (D41). */\n    model: string;\n    targetId: string;\n    targetRevisionId: string;\n}\n\nexport interface ReviewTargetEditorUpdateParams extends ReviewTargetEditorReadParams {\n    /** The new values by field path, as read. */\n    values: Record<string, unknown>;\n}\n\nexport interface ReviewTargetEditorUpdateResult {\n    /** The paths that were written. */\n    applied: string[];\n}\n\nexport interface IReviewTargetEditor {\n    /** Whether this editor handles the namespace id, e.g. \"cms.article\" or \"wb.page\". */\n    canEdit(model: string): boolean;\n    /**\n     * The whole content under review, every field with `writable`. Fails with a\n     * `ReviewTargetEditorError` (target not found, not readable); never throws.\n     */\n    read(\n        params: ReviewTargetEditorReadParams\n    ): Promise<Result<ReviewTargetContent, ReviewTargetEditorError>>;\n    /**\n     * Writes the bounded set of fields (R172), atomically: any path that is unknown or read-only,\n     * or any value the target rejects, fails the whole call and writes nothing. It does not check\n     * permissions or stale state and does not apply the bypass: the tool that calls it does (R173).\n     * Never throws; a non-validation failure is logged by the adapter and answered with a generic\n     * message.\n     */\n    update(\n        params: ReviewTargetEditorUpdateParams\n    ): Promise<Result<ReviewTargetEditorUpdateResult, ReviewTargetEditorError>>;\n}\n\n/**\n * Reads and writes the content under review for the AI tools (spec 9.3). One implementation per\n * namespace, registered by the app target adapters (`cms.*`, `wb.page`); the last registered match\n * wins (A10). The engine reaches it only through `ReviewTargetEditorService`.\n */\nexport const ReviewTargetEditor = createAbstraction<IReviewTargetEditor>(\"ReviewTargetEditor\");\n\nexport namespace ReviewTargetEditor {\n    export type Interface = IReviewTargetEditor;\n    export type Field = ReviewTargetEditorField;\n    export type Content = ReviewTargetContent;\n    export type ReadParams = ReviewTargetEditorReadParams;\n    export type UpdateParams = ReviewTargetEditorUpdateParams;\n    export type UpdateResult = ReviewTargetEditorUpdateResult;\n}\n"],"names":["ReviewTargetEditor","createAbstraction"],"mappings":";AAgEO,MAAMA,qBAAqBC,kBAAuC"}

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

@@ -0,0 +1,2 @@
+export { ReviewTargetEditor } from "./abstractions.js";
+export type { ReviewTargetContent, ReviewTargetEditorField, ReviewTargetEditorReadParams, ReviewTargetEditorUpdateParams, ReviewTargetEditorUpdateResult } from "./abstractions.js";

package/features/review/ReviewTargetEditor/index.js

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

package/features/review/ReviewTargetEditorService/ReviewTargetEditorService.d.ts

@@ -0,0 +1,14 @@
+import { Result } from "@webiny/feature/api";
+import { ReviewTargetEditorError } from "../../../domain/review/errors.js";
+import { ReviewTargetEditor } from "../../../features/review/ReviewTargetEditor/abstractions.js";
+import { ReviewTargetEditorService as ReviewTargetEditorServiceAbstraction } from "./abstractions.js";
+declare class ReviewTargetEditorServiceImpl implements ReviewTargetEditorServiceAbstraction.Interface {
+    private editors;
+    constructor(editors: ReviewTargetEditor.Interface[]);
+    read(params: ReviewTargetEditor.ReadParams): Promise<Result<import("~/features/review/ReviewTargetEditor/abstractions.js").ReviewTargetContent, ReviewTargetEditorError>>;
+    update(params: ReviewTargetEditor.UpdateParams): Promise<Result<import("~/features/review/ReviewTargetEditor/abstractions.js").ReviewTargetEditorUpdateResult, ReviewTargetEditorError>>;
+}
+export declare const ReviewTargetEditorService: typeof ReviewTargetEditorServiceImpl & {
+    __abstraction: import("@webiny/di").Abstraction<import("./abstractions.js").IReviewTargetEditorService>;
+};
+export {};

package/features/review/ReviewTargetEditorService/ReviewTargetEditorService.js

@@ -0,0 +1,37 @@
+import { Result } from "@webiny/feature/api";
+import { ReviewTargetEditorError } from "../../../domain/review/errors.js";
+import { ReviewTargetEditor } from "../ReviewTargetEditor/abstractions.js";
+import { ReviewTargetEditorService } from "./abstractions.js";
+class ReviewTargetEditorServiceImpl {
+    constructor(editors){
+        this.editors = editors;
+    }
+    async read(params) {
+        const editor = [
+            ...this.editors
+        ].reverse().find((item)=>item.canEdit(params.model));
+        if (!editor) return Result.fail(new ReviewTargetEditorError("This target cannot be edited."));
+        return editor.read(params);
+    }
+    async update(params) {
+        const editor = [
+            ...this.editors
+        ].reverse().find((item)=>item.canEdit(params.model));
+        if (!editor) return Result.fail(new ReviewTargetEditorError("This target cannot be edited."));
+        return editor.update(params);
+    }
+}
+const ReviewTargetEditorService_ReviewTargetEditorService = ReviewTargetEditorService.createImplementation({
+    implementation: ReviewTargetEditorServiceImpl,
+    dependencies: [
+        [
+            ReviewTargetEditor,
+            {
+                multiple: true
+            }
+        ]
+    ]
+});
+export { ReviewTargetEditorService_ReviewTargetEditorService as ReviewTargetEditorService };
+
+//# sourceMappingURL=ReviewTargetEditorService.js.map

package/features/review/ReviewTargetEditorService/ReviewTargetEditorService.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"features/review/ReviewTargetEditorService/ReviewTargetEditorService.js","sources":["../../../../src/features/review/ReviewTargetEditorService/ReviewTargetEditorService.ts"],"sourcesContent":["import { Result } from \"@webiny/feature/api\";\nimport { ReviewTargetEditorError } from \"~/domain/review/errors.js\";\nimport { ReviewTargetEditor } from \"~/features/review/ReviewTargetEditor/abstractions.js\";\nimport { ReviewTargetEditorService as ReviewTargetEditorServiceAbstraction } from \"./abstractions.js\";\n\nclass ReviewTargetEditorServiceImpl implements ReviewTargetEditorServiceAbstraction.Interface {\n    public constructor(private editors: ReviewTargetEditor.Interface[]) {}\n\n    public async read(params: ReviewTargetEditor.ReadParams) {\n        // Several editors may match (a generic one and a specific one); the last registered wins,\n        // the same rule as `ReviewTargetLoader` in `RequestReviewUseCase`.\n        const editor = [...this.editors].reverse().find(item => item.canEdit(params.model));\n        if (!editor) {\n            return Result.fail(new ReviewTargetEditorError(\"This target cannot be edited.\"));\n        }\n        return editor.read(params);\n    }\n\n    public async update(params: ReviewTargetEditor.UpdateParams) {\n        const editor = [...this.editors].reverse().find(item => item.canEdit(params.model));\n        if (!editor) {\n            return Result.fail(new ReviewTargetEditorError(\"This target cannot be edited.\"));\n        }\n        return editor.update(params);\n    }\n}\n\nexport const ReviewTargetEditorService = ReviewTargetEditorServiceAbstraction.createImplementation({\n    implementation: ReviewTargetEditorServiceImpl,\n    dependencies: [[ReviewTargetEditor, { multiple: true }]]\n});\n"],"names":["ReviewTargetEditorServiceImpl","editors","params","editor","item","Result","ReviewTargetEditorError","ReviewTargetEditorService","ReviewTargetEditorServiceAbstraction","ReviewTargetEditor"],"mappings":";;;;AAKA,MAAMA;IACF,YAA2BC,OAAuC,CAAE;aAAzCA,OAAO,GAAPA;IAA0C;IAErE,MAAa,KAAKC,MAAqC,EAAE;QAGrD,MAAMC,SAAS;eAAI,IAAI,CAAC,OAAO;SAAC,CAAC,OAAO,GAAG,IAAI,CAACC,CAAAA,OAAQA,KAAK,OAAO,CAACF,OAAO,KAAK;QACjF,IAAI,CAACC,QACD,OAAOE,OAAO,IAAI,CAAC,IAAIC,wBAAwB;QAEnD,OAAOH,OAAO,IAAI,CAACD;IACvB;IAEA,MAAa,OAAOA,MAAuC,EAAE;QACzD,MAAMC,SAAS;eAAI,IAAI,CAAC,OAAO;SAAC,CAAC,OAAO,GAAG,IAAI,CAACC,CAAAA,OAAQA,KAAK,OAAO,CAACF,OAAO,KAAK;QACjF,IAAI,CAACC,QACD,OAAOE,OAAO,IAAI,CAAC,IAAIC,wBAAwB;QAEnD,OAAOH,OAAO,MAAM,CAACD;IACzB;AACJ;AAEO,MAAMK,sDAA4BC,0BAAAA,oBAAyD,CAAC;IAC/F,gBAAgBR;IAChB,cAAc;QAAC;YAACS;YAAoB;gBAAE,UAAU;YAAK;SAAE;KAAC;AAC5D"}

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

@@ -0,0 +1,17 @@
+import type { Result } from "@webiny/feature/api";
+import type { ReviewTargetEditorError } from "../../../domain/review/errors.js";
+import type { ReviewTargetContent, ReviewTargetEditorReadParams, ReviewTargetEditorUpdateParams, ReviewTargetEditorUpdateResult } from "../../../features/review/ReviewTargetEditor/abstractions.js";
+export interface IReviewTargetEditorService {
+    /** Reads through the last registered editor that handles `params.model`. */
+    read(params: ReviewTargetEditorReadParams): Promise<Result<ReviewTargetContent, ReviewTargetEditorError>>;
+    /** Writes through the last registered editor that handles `params.model`. */
+    update(params: ReviewTargetEditorUpdateParams): Promise<Result<ReviewTargetEditorUpdateResult, ReviewTargetEditorError>>;
+}
+/**
+ * Picks the target editor for a namespace (spec 9.3). Internal (D132): no permission checks, no
+ * stale check and no bypass; the AI tools that call it own those (R173).
+ */
+export declare const ReviewTargetEditorService: import("@webiny/di").Abstraction<IReviewTargetEditorService>;
+export declare namespace ReviewTargetEditorService {
+    type Interface = IReviewTargetEditorService;
+}

package/features/review/ReviewTargetEditorService/abstractions.js

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"features/review/ReviewTargetEditorService/abstractions.js","sources":["../../../../src/features/review/ReviewTargetEditorService/abstractions.ts"],"sourcesContent":["import { createAbstraction } from \"@webiny/feature/api\";\nimport type { Result } from \"@webiny/feature/api\";\nimport type { ReviewTargetEditorError } from \"~/domain/review/errors.js\";\nimport type {\n    ReviewTargetContent,\n    ReviewTargetEditorReadParams,\n    ReviewTargetEditorUpdateParams,\n    ReviewTargetEditorUpdateResult\n} from \"~/features/review/ReviewTargetEditor/abstractions.js\";\n\nexport interface IReviewTargetEditorService {\n    /** Reads through the last registered editor that handles `params.model`. */\n    read(\n        params: ReviewTargetEditorReadParams\n    ): Promise<Result<ReviewTargetContent, ReviewTargetEditorError>>;\n    /** Writes through the last registered editor that handles `params.model`. */\n    update(\n        params: ReviewTargetEditorUpdateParams\n    ): Promise<Result<ReviewTargetEditorUpdateResult, ReviewTargetEditorError>>;\n}\n\n/**\n * Picks the target editor for a namespace (spec 9.3). Internal (D132): no permission checks, no\n * stale check and no bypass; the AI tools that call it own those (R173).\n */\nexport const ReviewTargetEditorService = createAbstraction<IReviewTargetEditorService>(\n    \"ReviewTargetEditorService\"\n);\n\nexport namespace ReviewTargetEditorService {\n    export type Interface = IReviewTargetEditorService;\n}\n"],"names":["ReviewTargetEditorService","createAbstraction"],"mappings":";AAyBO,MAAMA,4BAA4BC,kBACrC"}

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

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

package/features/review/ReviewTargetEditorService/index.js

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

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

@@ -0,0 +1,26 @@
+export interface ReviewTargetFolderChainParams {
+    /** Namespace id, e.g. "cms.article" or "wb.page". */
+    model: string;
+    folderId: string;
+}
+export interface IReviewTargetFolderChain {
+    /** Whether this adapter answers for the namespace. */
+    canHandle(model: string): boolean;
+    /**
+     * The folder and its ancestors, nearest first, as stored now (spec 6: a parent folder can
+     * move while a review runs, so routing reads the chain at step reach). Read without
+     * folder-level permissions. Throws when the folders cannot be read.
+     */
+    listFolderChainIds(params: ReviewTargetFolderChainParams): Promise<string[]>;
+}
+/**
+ * The engine's folder lookup for rule conditions (R114). One implementation per namespace,
+ * registered by the app adapters (ACO `GetFolderRepository` + `GetAncestorsUseCase`); the last
+ * registered match wins. No match while a folder rule needs the chain fails routing, which falls
+ * through to the pool (R116).
+ */
+export declare const ReviewTargetFolderChain: import("@webiny/di").Abstraction<IReviewTargetFolderChain>;
+export declare namespace ReviewTargetFolderChain {
+    type Interface = IReviewTargetFolderChain;
+    type Params = ReviewTargetFolderChainParams;
+}

package/features/review/ReviewTargetFolderChain/abstractions.js

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"features/review/ReviewTargetFolderChain/abstractions.js","sources":["../../../../src/features/review/ReviewTargetFolderChain/abstractions.ts"],"sourcesContent":["import { createAbstraction } from \"@webiny/feature/api\";\n\nexport interface ReviewTargetFolderChainParams {\n    /** Namespace id, e.g. \"cms.article\" or \"wb.page\". */\n    model: string;\n    folderId: string;\n}\n\nexport interface IReviewTargetFolderChain {\n    /** Whether this adapter answers for the namespace. */\n    canHandle(model: string): boolean;\n    /**\n     * The folder and its ancestors, nearest first, as stored now (spec 6: a parent folder can\n     * move while a review runs, so routing reads the chain at step reach). Read without\n     * folder-level permissions. Throws when the folders cannot be read.\n     */\n    listFolderChainIds(params: ReviewTargetFolderChainParams): Promise<string[]>;\n}\n\n/**\n * The engine's folder lookup for rule conditions (R114). One implementation per namespace,\n * registered by the app adapters (ACO `GetFolderRepository` + `GetAncestorsUseCase`); the last\n * registered match wins. No match while a folder rule needs the chain fails routing, which falls\n * through to the pool (R116).\n */\nexport const ReviewTargetFolderChain =\n    createAbstraction<IReviewTargetFolderChain>(\"ReviewTargetFolderChain\");\n\nexport namespace ReviewTargetFolderChain {\n    export type Interface = IReviewTargetFolderChain;\n    export type Params = ReviewTargetFolderChainParams;\n}\n"],"names":["ReviewTargetFolderChain","createAbstraction"],"mappings":";AAyBO,MAAMA,0BACTC,kBAA4C"}

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

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