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

package/features/hooks/DeleteReviewsOnRevisionDelete.js

@@ -0,0 +1,46 @@
+import { EntryRevisionAfterDeleteEventHandler } from "@webiny/api-headless-cms/features/contentEntry/DeleteEntryRevision/index.js";
+import { Logger } from "@webiny/api-core/features/logger/index.js";
+import { DeleteTargetReviewsUseCase } from "@webiny/api-workflows/features/review/DeleteTargetReviews/index.js";
+import { getCmsNamespace } from "../../utils/appName.js";
+import { hasErrorSource } from "@webiny/api-workflows/domain/hasErrorSource.js";
+class DeleteReviewsOnRevisionDeleteImpl {
+    constructor(deleteTargetReviews, logger){
+        this.deleteTargetReviews = deleteTargetReviews;
+        this.logger = logger;
+    }
+    async handle(event) {
+        const { model, entry } = event.payload;
+        const namespace = getCmsNamespace(model);
+        if (!namespace) return;
+        try {
+            const deleted = await this.deleteTargetReviews.execute({
+                model: namespace,
+                targetIds: [
+                    entry.entryId
+                ],
+                targetRevisionId: entry.id
+            });
+            if (deleted.isFail()) this.logger.error({
+                err: hasErrorSource(deleted.error) ? deleted.error.source : deleted.error,
+                model: namespace,
+                targetRevisionId: entry.id
+            }, "Could not delete the reviews of a deleted revision; they are left orphaned.");
+        } catch (error) {
+            this.logger.error({
+                err: error,
+                model: namespace,
+                targetRevisionId: entry.id
+            }, "Could not delete the reviews of a deleted revision; they are left orphaned.");
+        }
+    }
+}
+const DeleteReviewsOnRevisionDelete = EntryRevisionAfterDeleteEventHandler.createImplementation({
+    implementation: DeleteReviewsOnRevisionDeleteImpl,
+    dependencies: [
+        DeleteTargetReviewsUseCase,
+        Logger
+    ]
+});
+export { DeleteReviewsOnRevisionDelete };
+
+//# sourceMappingURL=DeleteReviewsOnRevisionDelete.js.map

package/features/hooks/DeleteReviewsOnRevisionDelete.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"features/hooks/DeleteReviewsOnRevisionDelete.js","sources":["../../../src/features/hooks/DeleteReviewsOnRevisionDelete.ts"],"sourcesContent":["import { EntryRevisionAfterDeleteEventHandler } from \"@webiny/api-headless-cms/features/contentEntry/DeleteEntryRevision/index.js\";\nimport { Logger } from \"@webiny/api-core/features/logger/index.js\";\nimport { DeleteTargetReviewsUseCase } from \"@webiny/api-workflows/features/review/DeleteTargetReviews/index.js\";\nimport { getCmsNamespace } from \"~/utils/appName.js\";\nimport { hasErrorSource } from \"@webiny/api-workflows/domain/hasErrorSource.js\";\n\n/**\n * Deletes the reviews of a deleted CMS revision with their assignment records (spec 9.3, R56).\n * Deleting the last revision deletes the entry, which `DeleteReviewsOnEntryDelete` handles.\n * Failures, failed results and throws alike, are logged, never thrown (R81).\n */\nclass DeleteReviewsOnRevisionDeleteImpl implements EntryRevisionAfterDeleteEventHandler.Interface {\n    public constructor(\n        private deleteTargetReviews: DeleteTargetReviewsUseCase.Interface,\n        private logger: Logger.Interface\n    ) {}\n\n    public async handle(event: EntryRevisionAfterDeleteEventHandler.Event): Promise<void> {\n        const { model, entry } = event.payload;\n        const namespace = getCmsNamespace(model);\n        if (!namespace) {\n            return;\n        }\n\n        try {\n            const deleted = await this.deleteTargetReviews.execute({\n                model: namespace,\n                targetIds: [entry.entryId],\n                targetRevisionId: entry.id\n            });\n            if (deleted.isFail()) {\n                this.logger.error(\n                    {\n                        err: hasErrorSource(deleted.error) ? deleted.error.source : deleted.error,\n                        model: namespace,\n                        targetRevisionId: entry.id\n                    },\n                    \"Could not delete the reviews of a deleted revision; they are left orphaned.\"\n                );\n            }\n        } catch (error) {\n            this.logger.error(\n                { err: error, model: namespace, targetRevisionId: entry.id },\n                \"Could not delete the reviews of a deleted revision; they are left orphaned.\"\n            );\n        }\n    }\n}\n\nexport const DeleteReviewsOnRevisionDelete =\n    EntryRevisionAfterDeleteEventHandler.createImplementation({\n        implementation: DeleteReviewsOnRevisionDeleteImpl,\n        dependencies: [DeleteTargetReviewsUseCase, Logger]\n    });\n"],"names":["DeleteReviewsOnRevisionDeleteImpl","deleteTargetReviews","logger","event","model","entry","namespace","getCmsNamespace","deleted","hasErrorSource","error","DeleteReviewsOnRevisionDelete","EntryRevisionAfterDeleteEventHandler","DeleteTargetReviewsUseCase","Logger"],"mappings":";;;;;AAWA,MAAMA;IACF,YACYC,mBAAyD,EACzDC,MAAwB,CAClC;aAFUD,mBAAmB,GAAnBA;aACAC,MAAM,GAANA;IACT;IAEH,MAAa,OAAOC,KAAiD,EAAiB;QAClF,MAAM,EAAEC,KAAK,EAAEC,KAAK,EAAE,GAAGF,MAAM,OAAO;QACtC,MAAMG,YAAYC,gBAAgBH;QAClC,IAAI,CAACE,WACD;QAGJ,IAAI;YACA,MAAME,UAAU,MAAM,IAAI,CAAC,mBAAmB,CAAC,OAAO,CAAC;gBACnD,OAAOF;gBACP,WAAW;oBAACD,MAAM,OAAO;iBAAC;gBAC1B,kBAAkBA,MAAM,EAAE;YAC9B;YACA,IAAIG,QAAQ,MAAM,IACd,IAAI,CAAC,MAAM,CAAC,KAAK,CACb;gBACI,KAAKC,eAAeD,QAAQ,KAAK,IAAIA,QAAQ,KAAK,CAAC,MAAM,GAAGA,QAAQ,KAAK;gBACzE,OAAOF;gBACP,kBAAkBD,MAAM,EAAE;YAC9B,GACA;QAGZ,EAAE,OAAOK,OAAO;YACZ,IAAI,CAAC,MAAM,CAAC,KAAK,CACb;gBAAE,KAAKA;gBAAO,OAAOJ;gBAAW,kBAAkBD,MAAM,EAAE;YAAC,GAC3D;QAER;IACJ;AACJ;AAEO,MAAMM,gCACTC,qCAAqC,oBAAoB,CAAC;IACtD,gBAAgBZ;IAChB,cAAc;QAACa;QAA4BC;KAAO;AACtD"}

package/features/hooks/FullyDeleteModelBoundToWorkflowDecorator.d.ts

@@ -0,0 +1,28 @@
+import { DeleteModelOperations } from "@webiny/api-headless-cms-tasks/graphql/deleteModel/abstractions.js";
+import type { IDeleteCmsModelTask, IStoreValue } from "@webiny/api-headless-cms-tasks/features/DeleteModelTask/types.js";
+import { GetModelUseCase } from "@webiny/api-headless-cms/features/contentModel/GetModel/index.js";
+import { AccessControl } from "@webiny/api-headless-cms/features/shared/abstractions.js";
+import { ListWorkflowsUseCase } from "@webiny/api-workflows/features/workflow/ListWorkflows/index.js";
+/**
+ * Refuses to start the "fully delete model" background task for a model bound to a workflow
+ * (D134 point 4, R64). The task deletes every entry and folder before it calls
+ * `DeleteModelUseCase`, so the use-case decorator alone would fire after the content is gone.
+ * `fullyDeleteModel` reports errors by throwing (its GraphQL resolver maps them), so this throws
+ * too. The other operations pass through.
+ */
+declare class FullyDeleteModelBoundToWorkflowDecoratorImpl implements DeleteModelOperations.Interface {
+    private getModel;
+    private accessControl;
+    private listWorkflows;
+    private decoratee;
+    constructor(getModel: GetModelUseCase.Interface, accessControl: AccessControl.Interface, listWorkflows: ListWorkflowsUseCase.Interface, decoratee: DeleteModelOperations.Interface);
+    listModelsBeingDeleted(): Promise<IStoreValue[]>;
+    isModelBeingDeleted(modelId: string): Promise<boolean>;
+    fullyDeleteModel(modelId: string): Promise<IDeleteCmsModelTask>;
+    cancelFullyDeleteModel(modelId: string): Promise<IDeleteCmsModelTask>;
+    getDeleteModelProgress(modelId: string): Promise<IDeleteCmsModelTask>;
+}
+export declare const FullyDeleteModelBoundToWorkflowDecorator: typeof FullyDeleteModelBoundToWorkflowDecoratorImpl & {
+    __abstraction: import("@webiny/di").Abstraction<import("@webiny/api-headless-cms-tasks/graphql/deleteModel/abstractions.js").IDeleteModelOperations>;
+};
+export {};

package/features/hooks/FullyDeleteModelBoundToWorkflowDecorator.js

@@ -0,0 +1,63 @@
+import { DeleteModelOperations } from "@webiny/api-headless-cms-tasks/graphql/deleteModel/abstractions.js";
+import { GetModelUseCase } from "@webiny/api-headless-cms/features/contentModel/GetModel/index.js";
+import { AccessControl } from "@webiny/api-headless-cms/features/shared/abstractions.js";
+import { ListWorkflowsUseCase } from "@webiny/api-workflows/features/workflow/ListWorkflows/index.js";
+import { ModelBoundToWorkflowError } from "../../domain/errors.js";
+import { toCmsNamespace } from "../../utils/appName.js";
+const BOUND_WORKFLOWS_LIMIT = 10;
+class FullyDeleteModelBoundToWorkflowDecoratorImpl {
+    constructor(getModel, accessControl, listWorkflows, decoratee){
+        this.getModel = getModel;
+        this.accessControl = accessControl;
+        this.listWorkflows = listWorkflows;
+        this.decoratee = decoratee;
+    }
+    listModelsBeingDeleted() {
+        return this.decoratee.listModelsBeingDeleted();
+    }
+    isModelBeingDeleted(modelId) {
+        return this.decoratee.isModelBeingDeleted(modelId);
+    }
+    async fullyDeleteModel(modelId) {
+        const model = await this.getModel.execute(modelId);
+        if (model.isFail()) return this.decoratee.fullyDeleteModel(modelId);
+        if (!await this.accessControl.canAccessModel({
+            model: model.value,
+            rwd: "d"
+        })) return this.decoratee.fullyDeleteModel(modelId);
+        const workflows = await this.listWorkflows.execute({
+            where: {
+                models_in: [
+                    toCmsNamespace(modelId)
+                ]
+            },
+            limit: BOUND_WORKFLOWS_LIMIT
+        });
+        if (workflows.isFail()) throw workflows.error;
+        if (workflows.value.items.length > 0) throw new ModelBoundToWorkflowError({
+            modelId,
+            workflows: workflows.value.items.map((workflow)=>({
+                    id: workflow.id,
+                    name: workflow.name
+                }))
+        });
+        return this.decoratee.fullyDeleteModel(modelId);
+    }
+    cancelFullyDeleteModel(modelId) {
+        return this.decoratee.cancelFullyDeleteModel(modelId);
+    }
+    getDeleteModelProgress(modelId) {
+        return this.decoratee.getDeleteModelProgress(modelId);
+    }
+}
+const FullyDeleteModelBoundToWorkflowDecorator = DeleteModelOperations.createDecorator({
+    decorator: FullyDeleteModelBoundToWorkflowDecoratorImpl,
+    dependencies: [
+        GetModelUseCase,
+        AccessControl,
+        ListWorkflowsUseCase
+    ]
+});
+export { FullyDeleteModelBoundToWorkflowDecorator };
+
+//# sourceMappingURL=FullyDeleteModelBoundToWorkflowDecorator.js.map

package/features/hooks/FullyDeleteModelBoundToWorkflowDecorator.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"features/hooks/FullyDeleteModelBoundToWorkflowDecorator.js","sources":["../../../src/features/hooks/FullyDeleteModelBoundToWorkflowDecorator.ts"],"sourcesContent":["import { DeleteModelOperations } from \"@webiny/api-headless-cms-tasks/graphql/deleteModel/abstractions.js\";\nimport type {\n    IDeleteCmsModelTask,\n    IStoreValue\n} from \"@webiny/api-headless-cms-tasks/features/DeleteModelTask/types.js\";\nimport { GetModelUseCase } from \"@webiny/api-headless-cms/features/contentModel/GetModel/index.js\";\nimport { AccessControl } from \"@webiny/api-headless-cms/features/shared/abstractions.js\";\nimport { ListWorkflowsUseCase } from \"@webiny/api-workflows/features/workflow/ListWorkflows/index.js\";\nimport { ModelBoundToWorkflowError } from \"~/domain/errors.js\";\nimport { toCmsNamespace } from \"~/utils/appName.js\";\n\n/** v1 binds one workflow per model (D15); a few extra cover the accepted save race (D41). */\nconst BOUND_WORKFLOWS_LIMIT = 10;\n\n/**\n * Refuses to start the \"fully delete model\" background task for a model bound to a workflow\n * (D134 point 4, R64). The task deletes every entry and folder before it calls\n * `DeleteModelUseCase`, so the use-case decorator alone would fire after the content is gone.\n * `fullyDeleteModel` reports errors by throwing (its GraphQL resolver maps them), so this throws\n * too. The other operations pass through.\n */\nclass FullyDeleteModelBoundToWorkflowDecoratorImpl implements DeleteModelOperations.Interface {\n    public constructor(\n        private getModel: GetModelUseCase.Interface,\n        private accessControl: AccessControl.Interface,\n        private listWorkflows: ListWorkflowsUseCase.Interface,\n        private decoratee: DeleteModelOperations.Interface\n    ) {}\n\n    public listModelsBeingDeleted(): Promise<IStoreValue[]> {\n        return this.decoratee.listModelsBeingDeleted();\n    }\n\n    public isModelBeingDeleted(modelId: string): Promise<boolean> {\n        return this.decoratee.isModelBeingDeleted(modelId);\n    }\n\n    public async fullyDeleteModel(modelId: string): Promise<IDeleteCmsModelTask> {\n        // A caller who cannot read and delete the model gets the CMS's own error from the decorated\n        // chain, never the bound workflows' ids and names (R64).\n        const model = await this.getModel.execute(modelId);\n        if (model.isFail()) {\n            return this.decoratee.fullyDeleteModel(modelId);\n        }\n        if (!(await this.accessControl.canAccessModel({ model: model.value, rwd: \"d\" }))) {\n            return this.decoratee.fullyDeleteModel(modelId);\n        }\n\n        const workflows = await this.listWorkflows.execute({\n            where: { models_in: [toCmsNamespace(modelId)] },\n            limit: BOUND_WORKFLOWS_LIMIT\n        });\n        if (workflows.isFail()) {\n            throw workflows.error;\n        }\n        if (workflows.value.items.length > 0) {\n            throw new ModelBoundToWorkflowError({\n                modelId,\n                workflows: workflows.value.items.map(workflow => {\n                    return { id: workflow.id, name: workflow.name };\n                })\n            });\n        }\n        return this.decoratee.fullyDeleteModel(modelId);\n    }\n\n    public cancelFullyDeleteModel(modelId: string): Promise<IDeleteCmsModelTask> {\n        return this.decoratee.cancelFullyDeleteModel(modelId);\n    }\n\n    public getDeleteModelProgress(modelId: string): Promise<IDeleteCmsModelTask> {\n        return this.decoratee.getDeleteModelProgress(modelId);\n    }\n}\n\nexport const FullyDeleteModelBoundToWorkflowDecorator = DeleteModelOperations.createDecorator({\n    decorator: FullyDeleteModelBoundToWorkflowDecoratorImpl,\n    dependencies: [GetModelUseCase, AccessControl, ListWorkflowsUseCase]\n});\n"],"names":["BOUND_WORKFLOWS_LIMIT","FullyDeleteModelBoundToWorkflowDecoratorImpl","getModel","accessControl","listWorkflows","decoratee","modelId","model","workflows","toCmsNamespace","ModelBoundToWorkflowError","workflow","FullyDeleteModelBoundToWorkflowDecorator","DeleteModelOperations","GetModelUseCase","AccessControl","ListWorkflowsUseCase"],"mappings":";;;;;;AAYA,MAAMA,wBAAwB;AAS9B,MAAMC;IACF,YACYC,QAAmC,EACnCC,aAAsC,EACtCC,aAA6C,EAC7CC,SAA0C,CACpD;aAJUH,QAAQ,GAARA;aACAC,aAAa,GAAbA;aACAC,aAAa,GAAbA;aACAC,SAAS,GAATA;IACT;IAEI,yBAAiD;QACpD,OAAO,IAAI,CAAC,SAAS,CAAC,sBAAsB;IAChD;IAEO,oBAAoBC,OAAe,EAAoB;QAC1D,OAAO,IAAI,CAAC,SAAS,CAAC,mBAAmB,CAACA;IAC9C;IAEA,MAAa,iBAAiBA,OAAe,EAAgC;QAGzE,MAAMC,QAAQ,MAAM,IAAI,CAAC,QAAQ,CAAC,OAAO,CAACD;QAC1C,IAAIC,MAAM,MAAM,IACZ,OAAO,IAAI,CAAC,SAAS,CAAC,gBAAgB,CAACD;QAE3C,IAAI,CAAE,MAAM,IAAI,CAAC,aAAa,CAAC,cAAc,CAAC;YAAE,OAAOC,MAAM,KAAK;YAAE,KAAK;QAAI,IACzE,OAAO,IAAI,CAAC,SAAS,CAAC,gBAAgB,CAACD;QAG3C,MAAME,YAAY,MAAM,IAAI,CAAC,aAAa,CAAC,OAAO,CAAC;YAC/C,OAAO;gBAAE,WAAW;oBAACC,eAAeH;iBAAS;YAAC;YAC9C,OAAON;QACX;QACA,IAAIQ,UAAU,MAAM,IAChB,MAAMA,UAAU,KAAK;QAEzB,IAAIA,UAAU,KAAK,CAAC,KAAK,CAAC,MAAM,GAAG,GAC/B,MAAM,IAAIE,0BAA0B;YAChCJ;YACA,WAAWE,UAAU,KAAK,CAAC,KAAK,CAAC,GAAG,CAACG,CAAAA,WAC1B;oBAAE,IAAIA,SAAS,EAAE;oBAAE,MAAMA,SAAS,IAAI;gBAAC;QAEtD;QAEJ,OAAO,IAAI,CAAC,SAAS,CAAC,gBAAgB,CAACL;IAC3C;IAEO,uBAAuBA,OAAe,EAAgC;QACzE,OAAO,IAAI,CAAC,SAAS,CAAC,sBAAsB,CAACA;IACjD;IAEO,uBAAuBA,OAAe,EAAgC;QACzE,OAAO,IAAI,CAAC,SAAS,CAAC,sBAAsB,CAACA;IACjD;AACJ;AAEO,MAAMM,2CAA2CC,sBAAsB,eAAe,CAAC;IAC1F,WAAWZ;IACX,cAAc;QAACa;QAAiBC;QAAeC;KAAqB;AACxE"}

package/features/hooks/NullReviewStateOnRevisionCreate.d.ts

@@ -0,0 +1,15 @@
+import { EntryRevisionBeforeCreateEventHandler } from "@webiny/api-headless-cms/features/contentEntry/CreateEntryRevisionFrom/index.js";
+/**
+ * Every new revision starts without a review state (spec 4.5, D59). Covers CMS entries; CMS
+ * copies `original.system` otherwise. Website Builder pages publish no CMS entry events, so their
+ * adapter clears the state on its own page events. Mutates the entry the use case persists next.
+ * A new revision created with `status: "published"` on a bound model needs no review, on purpose:
+ * data transfer from other systems (D134 point 2, R83). No handler guards the status here.
+ */
+declare class NullReviewStateOnRevisionCreateImpl implements EntryRevisionBeforeCreateEventHandler.Interface {
+    handle(event: EntryRevisionBeforeCreateEventHandler.Event): Promise<void>;
+}
+export declare const NullReviewStateOnRevisionCreate: typeof NullReviewStateOnRevisionCreateImpl & {
+    __abstraction: import("@webiny/di").Abstraction<import("@webiny/api-core/features/eventPublisher").IEventHandler<import("@webiny/api-headless-cms/features/contentEntry/CreateEntryRevisionFrom/events").EntryRevisionBeforeCreateEvent>>;
+};
+export {};

package/features/hooks/NullReviewStateOnRevisionCreate.js

@@ -0,0 +1,17 @@
+import { EntryRevisionBeforeCreateEventHandler } from "@webiny/api-headless-cms/features/contentEntry/CreateEntryRevisionFrom/index.js";
+class NullReviewStateOnRevisionCreateImpl {
+    async handle(event) {
+        const { entry } = event.payload;
+        entry.system = {
+            ...entry.system,
+            workflow: null
+        };
+    }
+}
+const NullReviewStateOnRevisionCreate = EntryRevisionBeforeCreateEventHandler.createImplementation({
+    implementation: NullReviewStateOnRevisionCreateImpl,
+    dependencies: []
+});
+export { NullReviewStateOnRevisionCreate };
+
+//# sourceMappingURL=NullReviewStateOnRevisionCreate.js.map

package/features/hooks/NullReviewStateOnRevisionCreate.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"features/hooks/NullReviewStateOnRevisionCreate.js","sources":["../../../src/features/hooks/NullReviewStateOnRevisionCreate.ts"],"sourcesContent":["import { EntryRevisionBeforeCreateEventHandler } from \"@webiny/api-headless-cms/features/contentEntry/CreateEntryRevisionFrom/index.js\";\n\n/**\n * Every new revision starts without a review state (spec 4.5, D59). Covers CMS entries; CMS\n * copies `original.system` otherwise. Website Builder pages publish no CMS entry events, so their\n * adapter clears the state on its own page events. Mutates the entry the use case persists next.\n * A new revision created with `status: \"published\"` on a bound model needs no review, on purpose:\n * data transfer from other systems (D134 point 2, R83). No handler guards the status here.\n */\nclass NullReviewStateOnRevisionCreateImpl\n    implements EntryRevisionBeforeCreateEventHandler.Interface\n{\n    public async handle(event: EntryRevisionBeforeCreateEventHandler.Event): Promise<void> {\n        const { entry } = event.payload;\n        entry.system = { ...entry.system, workflow: null };\n    }\n}\n\nexport const NullReviewStateOnRevisionCreate =\n    EntryRevisionBeforeCreateEventHandler.createImplementation({\n        implementation: NullReviewStateOnRevisionCreateImpl,\n        dependencies: []\n    });\n"],"names":["NullReviewStateOnRevisionCreateImpl","event","entry","NullReviewStateOnRevisionCreate","EntryRevisionBeforeCreateEventHandler"],"mappings":";AASA,MAAMA;IAGF,MAAa,OAAOC,KAAkD,EAAiB;QACnF,MAAM,EAAEC,KAAK,EAAE,GAAGD,MAAM,OAAO;QAC/BC,MAAM,MAAM,GAAG;YAAE,GAAGA,MAAM,MAAM;YAAE,UAAU;QAAK;IACrD;AACJ;AAEO,MAAMC,kCACTC,sCAAsC,oBAAoB,CAAC;IACvD,gBAAgBJ;IAChB,cAAc,EAAE;AACpB"}

package/features/hooks/RequireApprovedReviewOnPublish.d.ts

@@ -0,0 +1,22 @@
+import { EntryBeforePublishEventHandler } from "@webiny/api-headless-cms/features/contentEntry/PublishEntry/index.js";
+import { GetBoundWorkflowUseCase } from "@webiny/api-workflows/features/workflow/GetBoundWorkflow/index.js";
+import { GetActiveTargetReviewUseCase } from "@webiny/api-workflows/features/review/GetActiveTargetReview/index.js";
+/**
+ * Publish rule of the `cms.*` adapter (spec 5.1, D79, D121, R53). On a model bound to a workflow a
+ * revision is published only with its active review approved; an approved revision that was
+ * unpublished can be published again because approved reviews stay active (D23). Lookup failures
+ * block (fail closed). `system.workflow` is not trusted: the update input can set it. Private
+ * models (Website Builder pages, R52) are left to their app (`RequireApprovedReviewOnPagePublish`).
+ * Only the publish actions are guarded (this and `RequireApprovedReviewOnRepublish`): creating
+ * content as published stays allowed for data transfer (D134 point 2, R83).
+ */
+declare class RequireApprovedReviewOnPublishImpl implements EntryBeforePublishEventHandler.Interface {
+    private getBoundWorkflow;
+    private getActiveTargetReview;
+    constructor(getBoundWorkflow: GetBoundWorkflowUseCase.Interface, getActiveTargetReview: GetActiveTargetReviewUseCase.Interface);
+    handle(event: EntryBeforePublishEventHandler.Event): Promise<void>;
+}
+export declare const RequireApprovedReviewOnPublish: typeof RequireApprovedReviewOnPublishImpl & {
+    __abstraction: import("@webiny/di").Abstraction<import("@webiny/api-core/features/eventPublisher").IEventHandler<import("@webiny/api-headless-cms/features/contentEntry/PublishEntry/events").EntryBeforePublishEvent>>;
+};
+export {};

package/features/hooks/RequireApprovedReviewOnPublish.js

@@ -0,0 +1,43 @@
+import { EntryBeforePublishEventHandler } from "@webiny/api-headless-cms/features/contentEntry/PublishEntry/index.js";
+import { GetBoundWorkflowUseCase } from "@webiny/api-workflows/features/workflow/GetBoundWorkflow/index.js";
+import { GetActiveTargetReviewUseCase } from "@webiny/api-workflows/features/review/GetActiveTargetReview/index.js";
+import { ReviewPublishBlockedError } from "@webiny/api-workflows/domain/review/errors.js";
+import { getCmsNamespace } from "../../utils/appName.js";
+class RequireApprovedReviewOnPublishImpl {
+    constructor(getBoundWorkflow, getActiveTargetReview){
+        this.getBoundWorkflow = getBoundWorkflow;
+        this.getActiveTargetReview = getActiveTargetReview;
+    }
+    async handle(event) {
+        const { model, original } = event.payload;
+        const namespace = getCmsNamespace(model);
+        if (!namespace) return;
+        const bound = await this.getBoundWorkflow.execute({
+            model: namespace
+        });
+        if (bound.isFail()) throw bound.error;
+        if (!bound.value) return;
+        const review = await this.getActiveTargetReview.execute({
+            model: namespace,
+            targetRevisionId: original.id
+        });
+        if (review.isFail()) throw review.error;
+        if (review.value?.state === "approved") return;
+        throw new ReviewPublishBlockedError({
+            model: namespace,
+            targetRevisionId: original.id,
+            workflowId: bound.value.id,
+            reviewState: review.value?.state ?? null
+        });
+    }
+}
+const RequireApprovedReviewOnPublish = EntryBeforePublishEventHandler.createImplementation({
+    implementation: RequireApprovedReviewOnPublishImpl,
+    dependencies: [
+        GetBoundWorkflowUseCase,
+        GetActiveTargetReviewUseCase
+    ]
+});
+export { RequireApprovedReviewOnPublish };
+
+//# sourceMappingURL=RequireApprovedReviewOnPublish.js.map

package/features/hooks/RequireApprovedReviewOnPublish.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"features/hooks/RequireApprovedReviewOnPublish.js","sources":["../../../src/features/hooks/RequireApprovedReviewOnPublish.ts"],"sourcesContent":["import { EntryBeforePublishEventHandler } from \"@webiny/api-headless-cms/features/contentEntry/PublishEntry/index.js\";\nimport { GetBoundWorkflowUseCase } from \"@webiny/api-workflows/features/workflow/GetBoundWorkflow/index.js\";\nimport { GetActiveTargetReviewUseCase } from \"@webiny/api-workflows/features/review/GetActiveTargetReview/index.js\";\nimport { ReviewPublishBlockedError } from \"@webiny/api-workflows/domain/review/errors.js\";\nimport { getCmsNamespace } from \"~/utils/appName.js\";\n\n/**\n * Publish rule of the `cms.*` adapter (spec 5.1, D79, D121, R53). On a model bound to a workflow a\n * revision is published only with its active review approved; an approved revision that was\n * unpublished can be published again because approved reviews stay active (D23). Lookup failures\n * block (fail closed). `system.workflow` is not trusted: the update input can set it. Private\n * models (Website Builder pages, R52) are left to their app (`RequireApprovedReviewOnPagePublish`).\n * Only the publish actions are guarded (this and `RequireApprovedReviewOnRepublish`): creating\n * content as published stays allowed for data transfer (D134 point 2, R83).\n */\nclass RequireApprovedReviewOnPublishImpl implements EntryBeforePublishEventHandler.Interface {\n    public constructor(\n        private getBoundWorkflow: GetBoundWorkflowUseCase.Interface,\n        private getActiveTargetReview: GetActiveTargetReviewUseCase.Interface\n    ) {}\n\n    public async handle(event: EntryBeforePublishEventHandler.Event): Promise<void> {\n        const { model, original } = event.payload;\n        const namespace = getCmsNamespace(model);\n        if (!namespace) {\n            return;\n        }\n\n        const bound = await this.getBoundWorkflow.execute({ model: namespace });\n        if (bound.isFail()) {\n            throw bound.error;\n        }\n        if (!bound.value) {\n            return;\n        }\n\n        const review = await this.getActiveTargetReview.execute({\n            model: namespace,\n            targetRevisionId: original.id\n        });\n        if (review.isFail()) {\n            throw review.error;\n        }\n        if (review.value?.state === \"approved\") {\n            return;\n        }\n\n        throw new ReviewPublishBlockedError({\n            model: namespace,\n            targetRevisionId: original.id,\n            workflowId: bound.value.id,\n            reviewState: review.value?.state ?? null\n        });\n    }\n}\n\nexport const RequireApprovedReviewOnPublish = EntryBeforePublishEventHandler.createImplementation({\n    implementation: RequireApprovedReviewOnPublishImpl,\n    dependencies: [GetBoundWorkflowUseCase, GetActiveTargetReviewUseCase]\n});\n"],"names":["RequireApprovedReviewOnPublishImpl","getBoundWorkflow","getActiveTargetReview","event","model","original","namespace","getCmsNamespace","bound","review","ReviewPublishBlockedError","RequireApprovedReviewOnPublish","EntryBeforePublishEventHandler","GetBoundWorkflowUseCase","GetActiveTargetReviewUseCase"],"mappings":";;;;;AAeA,MAAMA;IACF,YACYC,gBAAmD,EACnDC,qBAA6D,CACvE;aAFUD,gBAAgB,GAAhBA;aACAC,qBAAqB,GAArBA;IACT;IAEH,MAAa,OAAOC,KAA2C,EAAiB;QAC5E,MAAM,EAAEC,KAAK,EAAEC,QAAQ,EAAE,GAAGF,MAAM,OAAO;QACzC,MAAMG,YAAYC,gBAAgBH;QAClC,IAAI,CAACE,WACD;QAGJ,MAAME,QAAQ,MAAM,IAAI,CAAC,gBAAgB,CAAC,OAAO,CAAC;YAAE,OAAOF;QAAU;QACrE,IAAIE,MAAM,MAAM,IACZ,MAAMA,MAAM,KAAK;QAErB,IAAI,CAACA,MAAM,KAAK,EACZ;QAGJ,MAAMC,SAAS,MAAM,IAAI,CAAC,qBAAqB,CAAC,OAAO,CAAC;YACpD,OAAOH;YACP,kBAAkBD,SAAS,EAAE;QACjC;QACA,IAAII,OAAO,MAAM,IACb,MAAMA,OAAO,KAAK;QAEtB,IAAIA,OAAO,KAAK,EAAE,UAAU,YACxB;QAGJ,MAAM,IAAIC,0BAA0B;YAChC,OAAOJ;YACP,kBAAkBD,SAAS,EAAE;YAC7B,YAAYG,MAAM,KAAK,CAAC,EAAE;YAC1B,aAAaC,OAAO,KAAK,EAAE,SAAS;QACxC;IACJ;AACJ;AAEO,MAAME,iCAAiCC,+BAA+B,oBAAoB,CAAC;IAC9F,gBAAgBZ;IAChB,cAAc;QAACa;QAAyBC;KAA6B;AACzE"}

package/features/hooks/RequireApprovedReviewOnRepublish.d.ts

@@ -0,0 +1,23 @@
+import { EntryBeforeRepublishEventHandler } from "@webiny/api-headless-cms/features/contentEntry/RepublishEntry/index.js";
+import { GetRevisionByIdUseCase } from "@webiny/api-headless-cms/features/contentEntry/GetRevisionById/index.js";
+import { GetBoundWorkflowUseCase } from "@webiny/api-workflows/features/workflow/GetBoundWorkflow/index.js";
+import { GetActiveTargetReviewUseCase } from "@webiny/api-workflows/features/review/GetActiveTargetReview/index.js";
+/**
+ * Publish rule for `republish<Model>(revision)` (D79, R53). `RepublishEntryUseCase` takes any
+ * revision and publishes `EntryBeforeRepublish`, not `EntryBeforePublish`, so without this rule an
+ * unapproved draft of a bound model could be published. The payload's `status` is already set to
+ * published, so the stored revision is read as the caller: one that is already published is only
+ * refreshed and allowed; any other needs an approved review, as for publish. Private models are left to their
+ * app (R52); unbound models never look up reviews; failed lookups block (fail closed).
+ */
+declare class RequireApprovedReviewOnRepublishImpl implements EntryBeforeRepublishEventHandler.Interface {
+    private getRevisionById;
+    private getBoundWorkflow;
+    private getActiveTargetReview;
+    constructor(getRevisionById: GetRevisionByIdUseCase.Interface, getBoundWorkflow: GetBoundWorkflowUseCase.Interface, getActiveTargetReview: GetActiveTargetReviewUseCase.Interface);
+    handle(event: EntryBeforeRepublishEventHandler.Event): Promise<void>;
+}
+export declare const RequireApprovedReviewOnRepublish: typeof RequireApprovedReviewOnRepublishImpl & {
+    __abstraction: import("@webiny/di").Abstraction<import("@webiny/api-core/features/eventPublisher").IEventHandler<import("@webiny/api-headless-cms/features/contentEntry/RepublishEntry/events").EntryBeforeRepublishEvent>>;
+};
+export {};

package/features/hooks/RequireApprovedReviewOnRepublish.js

@@ -0,0 +1,49 @@
+import { EntryBeforeRepublishEventHandler } from "@webiny/api-headless-cms/features/contentEntry/RepublishEntry/index.js";
+import { GetRevisionByIdUseCase } from "@webiny/api-headless-cms/features/contentEntry/GetRevisionById/index.js";
+import { GetBoundWorkflowUseCase } from "@webiny/api-workflows/features/workflow/GetBoundWorkflow/index.js";
+import { GetActiveTargetReviewUseCase } from "@webiny/api-workflows/features/review/GetActiveTargetReview/index.js";
+import { ReviewPublishBlockedError } from "@webiny/api-workflows/domain/review/errors.js";
+import { getCmsNamespace } from "../../utils/appName.js";
+class RequireApprovedReviewOnRepublishImpl {
+    constructor(getRevisionById, getBoundWorkflow, getActiveTargetReview){
+        this.getRevisionById = getRevisionById;
+        this.getBoundWorkflow = getBoundWorkflow;
+        this.getActiveTargetReview = getActiveTargetReview;
+    }
+    async handle(event) {
+        const { model, entry } = event.payload;
+        const namespace = getCmsNamespace(model);
+        if (!namespace) return;
+        const bound = await this.getBoundWorkflow.execute({
+            model: namespace
+        });
+        if (bound.isFail()) throw bound.error;
+        if (!bound.value) return;
+        const stored = await this.getRevisionById.execute(model, entry.id);
+        if (stored.isFail()) throw stored.error;
+        if ("published" === stored.value.status) return;
+        const review = await this.getActiveTargetReview.execute({
+            model: namespace,
+            targetRevisionId: entry.id
+        });
+        if (review.isFail()) throw review.error;
+        if (review.value?.state === "approved") return;
+        throw new ReviewPublishBlockedError({
+            model: namespace,
+            targetRevisionId: entry.id,
+            workflowId: bound.value.id,
+            reviewState: review.value?.state ?? null
+        });
+    }
+}
+const RequireApprovedReviewOnRepublish = EntryBeforeRepublishEventHandler.createImplementation({
+    implementation: RequireApprovedReviewOnRepublishImpl,
+    dependencies: [
+        GetRevisionByIdUseCase,
+        GetBoundWorkflowUseCase,
+        GetActiveTargetReviewUseCase
+    ]
+});
+export { RequireApprovedReviewOnRepublish };
+
+//# sourceMappingURL=RequireApprovedReviewOnRepublish.js.map

package/features/hooks/RequireApprovedReviewOnRepublish.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"features/hooks/RequireApprovedReviewOnRepublish.js","sources":["../../../src/features/hooks/RequireApprovedReviewOnRepublish.ts"],"sourcesContent":["import { EntryBeforeRepublishEventHandler } from \"@webiny/api-headless-cms/features/contentEntry/RepublishEntry/index.js\";\nimport { GetRevisionByIdUseCase } from \"@webiny/api-headless-cms/features/contentEntry/GetRevisionById/index.js\";\nimport { GetBoundWorkflowUseCase } from \"@webiny/api-workflows/features/workflow/GetBoundWorkflow/index.js\";\nimport { GetActiveTargetReviewUseCase } from \"@webiny/api-workflows/features/review/GetActiveTargetReview/index.js\";\nimport { ReviewPublishBlockedError } from \"@webiny/api-workflows/domain/review/errors.js\";\nimport { getCmsNamespace } from \"~/utils/appName.js\";\n\n/**\n * Publish rule for `republish<Model>(revision)` (D79, R53). `RepublishEntryUseCase` takes any\n * revision and publishes `EntryBeforeRepublish`, not `EntryBeforePublish`, so without this rule an\n * unapproved draft of a bound model could be published. The payload's `status` is already set to\n * published, so the stored revision is read as the caller: one that is already published is only\n * refreshed and allowed; any other needs an approved review, as for publish. Private models are left to their\n * app (R52); unbound models never look up reviews; failed lookups block (fail closed).\n */\nclass RequireApprovedReviewOnRepublishImpl implements EntryBeforeRepublishEventHandler.Interface {\n    public constructor(\n        private getRevisionById: GetRevisionByIdUseCase.Interface,\n        private getBoundWorkflow: GetBoundWorkflowUseCase.Interface,\n        private getActiveTargetReview: GetActiveTargetReviewUseCase.Interface\n    ) {}\n\n    public async handle(event: EntryBeforeRepublishEventHandler.Event): Promise<void> {\n        const { model, entry } = event.payload;\n        const namespace = getCmsNamespace(model);\n        if (!namespace) {\n            return;\n        }\n\n        const bound = await this.getBoundWorkflow.execute({ model: namespace });\n        if (bound.isFail()) {\n            throw bound.error;\n        }\n        if (!bound.value) {\n            return;\n        }\n\n        const stored = await this.getRevisionById.execute(model, entry.id);\n        if (stored.isFail()) {\n            throw stored.error;\n        }\n        if (stored.value.status === \"published\") {\n            return;\n        }\n\n        const review = await this.getActiveTargetReview.execute({\n            model: namespace,\n            targetRevisionId: entry.id\n        });\n        if (review.isFail()) {\n            throw review.error;\n        }\n        if (review.value?.state === \"approved\") {\n            return;\n        }\n\n        throw new ReviewPublishBlockedError({\n            model: namespace,\n            targetRevisionId: entry.id,\n            workflowId: bound.value.id,\n            reviewState: review.value?.state ?? null\n        });\n    }\n}\n\nexport const RequireApprovedReviewOnRepublish =\n    EntryBeforeRepublishEventHandler.createImplementation({\n        implementation: RequireApprovedReviewOnRepublishImpl,\n        dependencies: [\n            GetRevisionByIdUseCase,\n            GetBoundWorkflowUseCase,\n            GetActiveTargetReviewUseCase\n        ]\n    });\n"],"names":["RequireApprovedReviewOnRepublishImpl","getRevisionById","getBoundWorkflow","getActiveTargetReview","event","model","entry","namespace","getCmsNamespace","bound","stored","review","ReviewPublishBlockedError","RequireApprovedReviewOnRepublish","EntryBeforeRepublishEventHandler","GetRevisionByIdUseCase","GetBoundWorkflowUseCase","GetActiveTargetReviewUseCase"],"mappings":";;;;;;AAeA,MAAMA;IACF,YACYC,eAAiD,EACjDC,gBAAmD,EACnDC,qBAA6D,CACvE;aAHUF,eAAe,GAAfA;aACAC,gBAAgB,GAAhBA;aACAC,qBAAqB,GAArBA;IACT;IAEH,MAAa,OAAOC,KAA6C,EAAiB;QAC9E,MAAM,EAAEC,KAAK,EAAEC,KAAK,EAAE,GAAGF,MAAM,OAAO;QACtC,MAAMG,YAAYC,gBAAgBH;QAClC,IAAI,CAACE,WACD;QAGJ,MAAME,QAAQ,MAAM,IAAI,CAAC,gBAAgB,CAAC,OAAO,CAAC;YAAE,OAAOF;QAAU;QACrE,IAAIE,MAAM,MAAM,IACZ,MAAMA,MAAM,KAAK;QAErB,IAAI,CAACA,MAAM,KAAK,EACZ;QAGJ,MAAMC,SAAS,MAAM,IAAI,CAAC,eAAe,CAAC,OAAO,CAACL,OAAOC,MAAM,EAAE;QACjE,IAAII,OAAO,MAAM,IACb,MAAMA,OAAO,KAAK;QAEtB,IAAIA,AAAwB,gBAAxBA,OAAO,KAAK,CAAC,MAAM,EACnB;QAGJ,MAAMC,SAAS,MAAM,IAAI,CAAC,qBAAqB,CAAC,OAAO,CAAC;YACpD,OAAOJ;YACP,kBAAkBD,MAAM,EAAE;QAC9B;QACA,IAAIK,OAAO,MAAM,IACb,MAAMA,OAAO,KAAK;QAEtB,IAAIA,OAAO,KAAK,EAAE,UAAU,YACxB;QAGJ,MAAM,IAAIC,0BAA0B;YAChC,OAAOL;YACP,kBAAkBD,MAAM,EAAE;YAC1B,YAAYG,MAAM,KAAK,CAAC,EAAE;YAC1B,aAAaE,OAAO,KAAK,EAAE,SAAS;QACxC;IACJ;AACJ;AAEO,MAAME,mCACTC,iCAAiC,oBAAoB,CAAC;IAClD,gBAAgBd;IAChB,cAAc;QACVe;QACAC;QACAC;KACH;AACL"}

package/features/hooks/feature.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Workflow handlers on CMS events (spec 9.2). The single handlers cover every CMS model with a
+ * review namespace (R51); the `cms.*` adapter rules act on public CMS models only (R52).
+ */
+export declare const CmsHooksFeature: {
+    name: string;
+    register(container: import("@webiny/di").Container): void;
+};

package/features/hooks/feature.js

@@ -0,0 +1,39 @@
+import { createFeature } from "@webiny/feature/api";
+import { NullReviewStateOnRevisionCreate } from "./NullReviewStateOnRevisionCreate.js";
+import { BlockUpdateWhileInReview } from "./BlockUpdateWhileInReview.js";
+import { RequireApprovedReviewOnPublish } from "./RequireApprovedReviewOnPublish.js";
+import { RequireApprovedReviewOnRepublish } from "./RequireApprovedReviewOnRepublish.js";
+import { BlockMoveWhileInReview } from "./BlockMoveWhileInReview.js";
+import { BlockFolderChangeWhileInReview } from "./BlockFolderChangeWhileInReview.js";
+import { BlockDeleteWhileInReview } from "./BlockDeleteWhileInReview.js";
+import { BlockRevisionDeleteWhileInReview } from "./BlockRevisionDeleteWhileInReview.js";
+import { BlockDeleteMultipleWhileInReview } from "./BlockDeleteMultipleWhileInReview.js";
+import { DeleteReviewsOnEntryDelete } from "./DeleteReviewsOnEntryDelete.js";
+import { DeleteReviewsOnRevisionDelete } from "./DeleteReviewsOnRevisionDelete.js";
+import { DeleteReviewsOnEntriesDeleteMultiple } from "./DeleteReviewsOnEntriesDeleteMultiple.js";
+import { DeleteModelBoundToWorkflowDecorator } from "./DeleteModelBoundToWorkflowDecorator.js";
+import { FullyDeleteModelBoundToWorkflowDecorator } from "./FullyDeleteModelBoundToWorkflowDecorator.js";
+import { DeleteModelTaskBoundToWorkflowDecorator } from "./DeleteModelTaskBoundToWorkflowDecorator.js";
+const CmsHooksFeature = createFeature({
+    name: "CmsWorkflows/Hooks",
+    register (container) {
+        container.register(NullReviewStateOnRevisionCreate);
+        container.register(BlockUpdateWhileInReview);
+        container.register(RequireApprovedReviewOnPublish);
+        container.register(RequireApprovedReviewOnRepublish);
+        container.register(BlockMoveWhileInReview);
+        container.register(BlockFolderChangeWhileInReview);
+        container.register(BlockDeleteWhileInReview);
+        container.register(BlockRevisionDeleteWhileInReview);
+        container.register(BlockDeleteMultipleWhileInReview);
+        container.register(DeleteReviewsOnEntryDelete);
+        container.register(DeleteReviewsOnRevisionDelete);
+        container.register(DeleteReviewsOnEntriesDeleteMultiple);
+        container.registerDecorator(DeleteModelBoundToWorkflowDecorator);
+        container.registerDecorator(FullyDeleteModelBoundToWorkflowDecorator);
+        container.registerDecorator(DeleteModelTaskBoundToWorkflowDecorator);
+    }
+});
+export { CmsHooksFeature };
+
+//# sourceMappingURL=feature.js.map

package/features/hooks/feature.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"features/hooks/feature.js","sources":["../../../src/features/hooks/feature.ts"],"sourcesContent":["import { createFeature } from \"@webiny/feature/api\";\nimport { NullReviewStateOnRevisionCreate } from \"./NullReviewStateOnRevisionCreate.js\";\nimport { BlockUpdateWhileInReview } from \"./BlockUpdateWhileInReview.js\";\nimport { RequireApprovedReviewOnPublish } from \"./RequireApprovedReviewOnPublish.js\";\nimport { RequireApprovedReviewOnRepublish } from \"./RequireApprovedReviewOnRepublish.js\";\nimport { BlockMoveWhileInReview } from \"./BlockMoveWhileInReview.js\";\nimport { BlockFolderChangeWhileInReview } from \"./BlockFolderChangeWhileInReview.js\";\nimport { BlockDeleteWhileInReview } from \"./BlockDeleteWhileInReview.js\";\nimport { BlockRevisionDeleteWhileInReview } from \"./BlockRevisionDeleteWhileInReview.js\";\nimport { BlockDeleteMultipleWhileInReview } from \"./BlockDeleteMultipleWhileInReview.js\";\nimport { DeleteReviewsOnEntryDelete } from \"./DeleteReviewsOnEntryDelete.js\";\nimport { DeleteReviewsOnRevisionDelete } from \"./DeleteReviewsOnRevisionDelete.js\";\nimport { DeleteReviewsOnEntriesDeleteMultiple } from \"./DeleteReviewsOnEntriesDeleteMultiple.js\";\nimport { DeleteModelBoundToWorkflowDecorator } from \"./DeleteModelBoundToWorkflowDecorator.js\";\nimport { FullyDeleteModelBoundToWorkflowDecorator } from \"./FullyDeleteModelBoundToWorkflowDecorator.js\";\nimport { DeleteModelTaskBoundToWorkflowDecorator } from \"./DeleteModelTaskBoundToWorkflowDecorator.js\";\n\n/**\n * Workflow handlers on CMS events (spec 9.2). The single handlers cover every CMS model with a\n * review namespace (R51); the `cms.*` adapter rules act on public CMS models only (R52).\n */\nexport const CmsHooksFeature = createFeature({\n    name: \"CmsWorkflows/Hooks\",\n    register(container) {\n        // Single handlers for every CMS model with a review namespace (R51); Website Builder pages\n        // publish no CMS entry events and have their own handlers.\n        container.register(NullReviewStateOnRevisionCreate);\n        container.register(BlockUpdateWhileInReview);\n\n        // `cms.*` adapter rules (public CMS models only, R52)\n        container.register(RequireApprovedReviewOnPublish);\n        container.register(RequireApprovedReviewOnRepublish);\n        container.register(BlockMoveWhileInReview);\n        container.register(BlockFolderChangeWhileInReview);\n\n        // Trash and delete (D134, R73) and review cleanup after a permanent delete (R56, R81)\n        container.register(BlockDeleteWhileInReview);\n        container.register(BlockRevisionDeleteWhileInReview);\n        container.register(BlockDeleteMultipleWhileInReview);\n        container.register(DeleteReviewsOnEntryDelete);\n        container.register(DeleteReviewsOnRevisionDelete);\n        container.register(DeleteReviewsOnEntriesDeleteMultiple);\n\n        // Model delete blocks (D64, D134 point 4); the use-case decorator runs before the CMS's\n        // own DeleteModel decorators, the operations decorator before the task is triggered, and\n        // the task handler decorator on every run, also one started through `triggerTask`.\n        container.registerDecorator(DeleteModelBoundToWorkflowDecorator);\n        container.registerDecorator(FullyDeleteModelBoundToWorkflowDecorator);\n        container.registerDecorator(DeleteModelTaskBoundToWorkflowDecorator);\n    }\n});\n"],"names":["CmsHooksFeature","createFeature","container","NullReviewStateOnRevisionCreate","BlockUpdateWhileInReview","RequireApprovedReviewOnPublish","RequireApprovedReviewOnRepublish","BlockMoveWhileInReview","BlockFolderChangeWhileInReview","BlockDeleteWhileInReview","BlockRevisionDeleteWhileInReview","BlockDeleteMultipleWhileInReview","DeleteReviewsOnEntryDelete","DeleteReviewsOnRevisionDelete","DeleteReviewsOnEntriesDeleteMultiple","DeleteModelBoundToWorkflowDecorator","FullyDeleteModelBoundToWorkflowDecorator","DeleteModelTaskBoundToWorkflowDecorator"],"mappings":";;;;;;;;;;;;;;;;AAqBO,MAAMA,kBAAkBC,cAAc;IACzC,MAAM;IACN,UAASC,SAAS;QAGdA,UAAU,QAAQ,CAACC;QACnBD,UAAU,QAAQ,CAACE;QAGnBF,UAAU,QAAQ,CAACG;QACnBH,UAAU,QAAQ,CAACI;QACnBJ,UAAU,QAAQ,CAACK;QACnBL,UAAU,QAAQ,CAACM;QAGnBN,UAAU,QAAQ,CAACO;QACnBP,UAAU,QAAQ,CAACQ;QACnBR,UAAU,QAAQ,CAACS;QACnBT,UAAU,QAAQ,CAACU;QACnBV,UAAU,QAAQ,CAACW;QACnBX,UAAU,QAAQ,CAACY;QAKnBZ,UAAU,iBAAiB,CAACa;QAC5Bb,UAAU,iBAAiB,CAACc;QAC5Bd,UAAU,iBAAiB,CAACe;IAChC;AACJ"}

package/features/target/CandidateFolderReadRules/CandidateFolderReadRules.d.ts

@@ -0,0 +1,18 @@
+import { IdentityContext } from "@webiny/api-core/features/security/IdentityContext/index.js";
+import { FolderLevelPermissions } from "@webiny/api-aco/features/flp/FolderLevelPermissions/index.js";
+import { GetFlpUseCase } from "@webiny/api-aco/features/flp/GetFlp/index.js";
+import { ReviewTeamLoader } from "@webiny/api-workflows/features/identity/ReviewTeamLoader/index.js";
+import type { FolderReadRule } from "../FolderReadRule.js";
+import { CandidateFolderReadRules as Abstraction } from "./abstractions.js";
+declare class CandidateFolderReadRulesImpl implements Abstraction.Interface {
+    private identityContext;
+    private folderLevelPermissions;
+    private teamLoader;
+    private getFlp?;
+    constructor(identityContext: IdentityContext.Interface, folderLevelPermissions: FolderLevelPermissions.Interface, teamLoader: ReviewTeamLoader.Interface, getFlp?: GetFlpUseCase.Interface | undefined);
+    create(params: Abstraction.Params): FolderReadRule;
+}
+export declare const CandidateFolderReadRules: typeof CandidateFolderReadRulesImpl & {
+    __abstraction: import("@webiny/di").Abstraction<import("./abstractions.js").ICandidateFolderReadRules>;
+};
+export {};

package/features/target/CandidateFolderReadRules/CandidateFolderReadRules.js

@@ -0,0 +1,97 @@
+import { IdentityContext } from "@webiny/api-core/features/security/IdentityContext/index.js";
+import { FolderLevelPermissions } from "@webiny/api-aco/features/flp/FolderLevelPermissions/index.js";
+import { GetDefaultPermissions } from "@webiny/api-aco/features/flp/FolderLevelPermissions/useCases/index.js";
+import { GetFlpUseCase } from "@webiny/api-aco/features/flp/GetFlp/index.js";
+import { ReviewTeamLoader } from "@webiny/api-workflows/features/identity/ReviewTeamLoader/index.js";
+import { CandidateFolderReadRules } from "./abstractions.js";
+const TEAM_TARGET_PREFIX = "team:";
+class CandidateFolderReadRulesImpl {
+    constructor(identityContext, folderLevelPermissions, teamLoader, getFlp){
+        this.identityContext = identityContext;
+        this.folderLevelPermissions = folderLevelPermissions;
+        this.teamLoader = teamLoader;
+        this.getFlp = getFlp;
+    }
+    create(params) {
+        const usersById = new Map(params.users.map((user)=>[
+                user.id,
+                user
+            ]));
+        let stored = null;
+        let teamSlugs = null;
+        const loadStored = ()=>{
+            if (!stored && this.getFlp) stored = this.getFlp.execute(params.folderId).then((flp)=>flp?.permissions ?? []);
+            return stored ?? Promise.resolve([]);
+        };
+        const loadTeamSlugs = ()=>{
+            if (!teamSlugs) {
+                const teamIds = params.users.flatMap((user)=>user.teams ?? []);
+                teamSlugs = this.teamLoader.load(teamIds).then((loaded)=>{
+                    const teams = loaded.isOk() ? loaded.value : [];
+                    return new Map(teams.map((team)=>[
+                            team.id,
+                            team.slug
+                        ]));
+                });
+            }
+            return teamSlugs;
+        };
+        return {
+            canReadFolder: async (folderId)=>{
+                if (folderId !== params.folderId) return false;
+                if (!this.getFlp) {
+                    const permissions = await this.folderLevelPermissions.getFolderLevelPermissions(folderId);
+                    return this.folderLevelPermissions.canAccessFolderContent({
+                        permissions,
+                        rwd: "r"
+                    });
+                }
+                const stored = await loadStored();
+                let withDefaults;
+                if (this.folderLevelPermissions.canUseTeams()) {
+                    const identity = this.identityContext.getIdentity();
+                    const permissions = [
+                        ...stored
+                    ];
+                    const hasTeamGrants = stored.some((permission)=>permission.target.startsWith(TEAM_TARGET_PREFIX));
+                    const teamIds = usersById.get(identity.id)?.teams ?? [];
+                    if (hasTeamGrants && teamIds.length > 0) {
+                        const slugs = await loadTeamSlugs();
+                        for (const teamId of teamIds){
+                            const slug = slugs.get(teamId);
+                            const teamPermission = stored.find((permission)=>permission.target === `${TEAM_TARGET_PREFIX}${slug}`);
+                            if (slug && teamPermission) permissions.push({
+                                target: `admin:${identity.id}`,
+                                level: teamPermission.level,
+                                inheritedFrom: `${TEAM_TARGET_PREFIX}${slug}`
+                            });
+                        }
+                    }
+                    const defaults = new GetDefaultPermissions(this.identityContext);
+                    withDefaults = await defaults.execute(permissions);
+                } else withDefaults = await this.folderLevelPermissions.getDefaultPermissions(stored);
+                return this.folderLevelPermissions.canAccessFolderContent({
+                    permissions: withDefaults,
+                    rwd: "r"
+                });
+            }
+        };
+    }
+}
+const CandidateFolderReadRules_CandidateFolderReadRules = CandidateFolderReadRules.createImplementation({
+    implementation: CandidateFolderReadRulesImpl,
+    dependencies: [
+        IdentityContext,
+        FolderLevelPermissions,
+        ReviewTeamLoader,
+        [
+            GetFlpUseCase,
+            {
+                optional: true
+            }
+        ]
+    ]
+});
+export { CandidateFolderReadRules_CandidateFolderReadRules as CandidateFolderReadRules };
+
+//# sourceMappingURL=CandidateFolderReadRules.js.map

package/features/target/CandidateFolderReadRules/CandidateFolderReadRules.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"features/target/CandidateFolderReadRules/CandidateFolderReadRules.js","sources":["../../../../src/features/target/CandidateFolderReadRules/CandidateFolderReadRules.ts"],"sourcesContent":["import { IdentityContext } from \"@webiny/api-core/features/security/IdentityContext/index.js\";\nimport { FolderLevelPermissions } from \"@webiny/api-aco/features/flp/FolderLevelPermissions/index.js\";\nimport { GetDefaultPermissions } from \"@webiny/api-aco/features/flp/FolderLevelPermissions/useCases/index.js\";\nimport { GetFlpUseCase } from \"@webiny/api-aco/features/flp/GetFlp/index.js\";\nimport type { FolderPermission } from \"@webiny/api-aco/types.js\";\nimport { ReviewTeamLoader } from \"@webiny/api-workflows/features/identity/ReviewTeamLoader/index.js\";\nimport type { FolderReadRule } from \"../FolderReadRule.js\";\nimport { CandidateFolderReadRules as Abstraction } from \"./abstractions.js\";\n\nconst TEAM_TARGET_PREFIX = \"team:\";\n\nclass CandidateFolderReadRulesImpl implements Abstraction.Interface {\n    public constructor(\n        private identityContext: IdentityContext.Interface,\n        private folderLevelPermissions: FolderLevelPermissions.Interface,\n        private teamLoader: ReviewTeamLoader.Interface,\n        // Registered with ACO's folder-level permissions; absent with the no-op ones.\n        private getFlp?: GetFlpUseCase.Interface\n    ) {}\n\n    public create(params: Abstraction.Params): FolderReadRule {\n        const usersById = new Map(params.users.map(user => [user.id, user]));\n        // Read once, on the first check, and shared by every candidate of the rule.\n        let stored: Promise<FolderPermission[]> | null = null;\n        let teamSlugs: Promise<Map<string, string>> | null = null;\n\n        const loadStored = (): Promise<FolderPermission[]> => {\n            if (!stored && this.getFlp) {\n                stored = this.getFlp.execute(params.folderId).then(flp => flp?.permissions ?? []);\n            }\n            return stored ?? Promise.resolve([]);\n        };\n        const loadTeamSlugs = (): Promise<Map<string, string>> => {\n            if (!teamSlugs) {\n                const teamIds = params.users.flatMap(user => user.teams ?? []);\n                teamSlugs = this.teamLoader.load(teamIds).then(loaded => {\n                    // A failed lookup grants no team permission, as `ListUserTeamsUseCase` does.\n                    const teams = loaded.isOk() ? loaded.value : [];\n                    return new Map(teams.map(team => [team.id, team.slug]));\n                });\n            }\n            return teamSlugs;\n        };\n\n        return {\n            canReadFolder: async (folderId: string): Promise<boolean> => {\n                if (folderId !== params.folderId) {\n                    return false;\n                }\n                if (!this.getFlp) {\n                    // No stored folder permissions to read once: the folder rules decide alone.\n                    const permissions =\n                        await this.folderLevelPermissions.getFolderLevelPermissions(folderId);\n                    return this.folderLevelPermissions.canAccessFolderContent({\n                        permissions,\n                        rwd: \"r\"\n                    });\n                }\n                const stored = await loadStored();\n                let withDefaults: FolderPermission[];\n                if (this.folderLevelPermissions.canUseTeams()) {\n                    /*\n                     * A copy of `GetDefaultPermissionsWithTeams` (@webiny/api-aco,\n                     * packages/api-aco/src/features/flp/FolderLevelPermissions/useCases/\n                     * GetDefaultPermissions/GetDefaultPermissionsWithTeams.ts): each team of the\n                     * candidate with a `team:<slug>` permission on the folder grants the candidate\n                     * that level, then ACO's `GetDefaultPermissions` applies the defaults.\n                     * Copied because ACO loads the current identity's teams once per call, and\n                     * each candidate is a separate call; here the teams of all candidates are\n                     * loaded once. Keep it in step with that file.\n                     */\n                    const identity = this.identityContext.getIdentity();\n                    const permissions = [...stored];\n                    const hasTeamGrants = stored.some(permission => {\n                        return permission.target.startsWith(TEAM_TARGET_PREFIX);\n                    });\n                    const teamIds = usersById.get(identity.id)?.teams ?? [];\n                    if (hasTeamGrants && teamIds.length > 0) {\n                        const slugs = await loadTeamSlugs();\n                        for (const teamId of teamIds) {\n                            const slug = slugs.get(teamId);\n                            const teamPermission = stored.find(permission => {\n                                return permission.target === `${TEAM_TARGET_PREFIX}${slug}`;\n                            });\n                            if (slug && teamPermission) {\n                                permissions.push({\n                                    target: `admin:${identity.id}`,\n                                    level: teamPermission.level,\n                                    inheritedFrom: `${TEAM_TARGET_PREFIX}${slug}`\n                                });\n                            }\n                        }\n                    }\n                    const defaults = new GetDefaultPermissions(this.identityContext);\n                    withDefaults = await defaults.execute(permissions);\n                } else {\n                    withDefaults = await this.folderLevelPermissions.getDefaultPermissions(stored);\n                }\n                // In memory: the candidate's own permissions are already loaded for the check.\n                return this.folderLevelPermissions.canAccessFolderContent({\n                    permissions: withDefaults,\n                    rwd: \"r\"\n                });\n            }\n        };\n    }\n}\n\nexport const CandidateFolderReadRules = Abstraction.createImplementation({\n    implementation: CandidateFolderReadRulesImpl,\n    dependencies: [\n        IdentityContext,\n        FolderLevelPermissions,\n        ReviewTeamLoader,\n        [GetFlpUseCase, { optional: true }]\n    ]\n});\n"],"names":["TEAM_TARGET_PREFIX","CandidateFolderReadRulesImpl","identityContext","folderLevelPermissions","teamLoader","getFlp","params","usersById","Map","user","stored","teamSlugs","loadStored","flp","Promise","loadTeamSlugs","teamIds","loaded","teams","team","folderId","permissions","withDefaults","identity","hasTeamGrants","permission","slugs","teamId","slug","teamPermission","defaults","GetDefaultPermissions","CandidateFolderReadRules","Abstraction","IdentityContext","FolderLevelPermissions","ReviewTeamLoader","GetFlpUseCase"],"mappings":";;;;;;AASA,MAAMA,qBAAqB;AAE3B,MAAMC;IACF,YACYC,eAA0C,EAC1CC,sBAAwD,EACxDC,UAAsC,EAEtCC,MAAgC,CAC1C;aALUH,eAAe,GAAfA;aACAC,sBAAsB,GAAtBA;aACAC,UAAU,GAAVA;aAEAC,MAAM,GAANA;IACT;IAEI,OAAOC,MAA0B,EAAkB;QACtD,MAAMC,YAAY,IAAIC,IAAIF,OAAO,KAAK,CAAC,GAAG,CAACG,CAAAA,OAAQ;gBAACA,KAAK,EAAE;gBAAEA;aAAK;QAElE,IAAIC,SAA6C;QACjD,IAAIC,YAAiD;QAErD,MAAMC,aAAa;YACf,IAAI,CAACF,UAAU,IAAI,CAAC,MAAM,EACtBA,SAAS,IAAI,CAAC,MAAM,CAAC,OAAO,CAACJ,OAAO,QAAQ,EAAE,IAAI,CAACO,CAAAA,MAAOA,KAAK,eAAe,EAAE;YAEpF,OAAOH,UAAUI,QAAQ,OAAO,CAAC,EAAE;QACvC;QACA,MAAMC,gBAAgB;YAClB,IAAI,CAACJ,WAAW;gBACZ,MAAMK,UAAUV,OAAO,KAAK,CAAC,OAAO,CAACG,CAAAA,OAAQA,KAAK,KAAK,IAAI,EAAE;gBAC7DE,YAAY,IAAI,CAAC,UAAU,CAAC,IAAI,CAACK,SAAS,IAAI,CAACC,CAAAA;oBAE3C,MAAMC,QAAQD,OAAO,IAAI,KAAKA,OAAO,KAAK,GAAG,EAAE;oBAC/C,OAAO,IAAIT,IAAIU,MAAM,GAAG,CAACC,CAAAA,OAAQ;4BAACA,KAAK,EAAE;4BAAEA,KAAK,IAAI;yBAAC;gBACzD;YACJ;YACA,OAAOR;QACX;QAEA,OAAO;YACH,eAAe,OAAOS;gBAClB,IAAIA,aAAad,OAAO,QAAQ,EAC5B,OAAO;gBAEX,IAAI,CAAC,IAAI,CAAC,MAAM,EAAE;oBAEd,MAAMe,cACF,MAAM,IAAI,CAAC,sBAAsB,CAAC,yBAAyB,CAACD;oBAChE,OAAO,IAAI,CAAC,sBAAsB,CAAC,sBAAsB,CAAC;wBACtDC;wBACA,KAAK;oBACT;gBACJ;gBACA,MAAMX,SAAS,MAAME;gBACrB,IAAIU;gBACJ,IAAI,IAAI,CAAC,sBAAsB,CAAC,WAAW,IAAI;oBAW3C,MAAMC,WAAW,IAAI,CAAC,eAAe,CAAC,WAAW;oBACjD,MAAMF,cAAc;2BAAIX;qBAAO;oBAC/B,MAAMc,gBAAgBd,OAAO,IAAI,CAACe,CAAAA,aACvBA,WAAW,MAAM,CAAC,UAAU,CAACzB;oBAExC,MAAMgB,UAAUT,UAAU,GAAG,CAACgB,SAAS,EAAE,GAAG,SAAS,EAAE;oBACvD,IAAIC,iBAAiBR,QAAQ,MAAM,GAAG,GAAG;wBACrC,MAAMU,QAAQ,MAAMX;wBACpB,KAAK,MAAMY,UAAUX,QAAS;4BAC1B,MAAMY,OAAOF,MAAM,GAAG,CAACC;4BACvB,MAAME,iBAAiBnB,OAAO,IAAI,CAACe,CAAAA,aACxBA,WAAW,MAAM,KAAK,GAAGzB,qBAAqB4B,MAAM;4BAE/D,IAAIA,QAAQC,gBACRR,YAAY,IAAI,CAAC;gCACb,QAAQ,CAAC,MAAM,EAAEE,SAAS,EAAE,EAAE;gCAC9B,OAAOM,eAAe,KAAK;gCAC3B,eAAe,GAAG7B,qBAAqB4B,MAAM;4BACjD;wBAER;oBACJ;oBACA,MAAME,WAAW,IAAIC,sBAAsB,IAAI,CAAC,eAAe;oBAC/DT,eAAe,MAAMQ,SAAS,OAAO,CAACT;gBAC1C,OACIC,eAAe,MAAM,IAAI,CAAC,sBAAsB,CAAC,qBAAqB,CAACZ;gBAG3E,OAAO,IAAI,CAAC,sBAAsB,CAAC,sBAAsB,CAAC;oBACtD,aAAaY;oBACb,KAAK;gBACT;YACJ;QACJ;IACJ;AACJ;AAEO,MAAMU,oDAA2BC,yBAAAA,oBAAgC,CAAC;IACrE,gBAAgBhC;IAChB,cAAc;QACViC;QACAC;QACAC;QACA;YAACC;YAAe;gBAAE,UAAU;YAAK;SAAE;KACtC;AACL"}

package/features/target/CandidateFolderReadRules/abstractions.d.ts

@@ -0,0 +1,35 @@
+import type { FolderReadRule } from "../FolderReadRule.js";
+/** A candidate, as the engine listed it (`AdminUser` fits). */
+export interface CandidateFolderUser {
+    id: string;
+    /** Team ids, as stored on the admin user. */
+    teams?: string[];
+}
+export interface CandidateFolderReadRuleParams {
+    /** The folder the candidates are checked for; never the root folder. */
+    folderId: string;
+    /** Every candidate the rule is run for, with their teams, so no user is read per check. */
+    users: CandidateFolderUser[];
+}
+export interface ICandidateFolderReadRules {
+    /**
+     * A folder rule run as each candidate, inside `CandidateReadAccess`. The folder's permission
+     * record is read once, on first use, and the candidates' teams once (only with teams on and
+     * a team grant on the folder); each candidate's access is then evaluated in memory as
+     * `FolderLevelPermissions.getFolderLevelPermissions` and `canAccessFolderContent` evaluate it
+     * for that user: the team grants of the user's teams, then the defaults (full access is
+     * owner, a folder without permissions is public). Another folder answers `false`.
+     */
+    create(params: CandidateFolderReadRuleParams): FolderReadRule;
+}
+/**
+ * Folder content read for routing candidates (R48, Q79): one folder permission read per routing
+ * evaluation instead of one per candidate, and no team lookup per candidate. Shared by the CMS and
+ * Website Builder adapters, which check folders by id.
+ */
+export declare const CandidateFolderReadRules: import("@webiny/di").Abstraction<ICandidateFolderReadRules>;
+export declare namespace CandidateFolderReadRules {
+    type Interface = ICandidateFolderReadRules;
+    type User = CandidateFolderUser;
+    type Params = CandidateFolderReadRuleParams;
+}

package/features/target/CandidateFolderReadRules/abstractions.js

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