@webiny/api-headless-cms-workflows 0.0.0-unstable.0d717d18dd

package/CmsWorkflowsFeature.d.ts

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

package/CmsWorkflowsFeature.js

@@ -0,0 +1,22 @@
+import { createFeature } from "@webiny/feature/api";
+import { CmsGraphQLSchemaFactory } from "@webiny/api-headless-cms";
+import { EntryWorkflowsFeature } from "./features/EntryWorkflows/feature.js";
+import { WorkflowsFeature } from "./features/Workflows/index.js";
+import { WorkflowsFeature as api_workflows_WorkflowsFeature } from "@webiny/api-workflows";
+import { createEntrySystemSchemaExtension } from "./graphql/entrySystemSchema.js";
+const CmsWorkflowsFeature = createFeature({
+    name: "CmsWorkflows",
+    register (container) {
+        EntryWorkflowsFeature.register(container);
+        WorkflowsFeature.register(container);
+        api_workflows_WorkflowsFeature.register(container);
+        container.registerInstance(CmsGraphQLSchemaFactory, {
+            execute: ()=>[
+                    createEntrySystemSchemaExtension()
+                ]
+        });
+    }
+});
+export { CmsWorkflowsFeature };
+
+//# sourceMappingURL=CmsWorkflowsFeature.js.map

package/CmsWorkflowsFeature.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"CmsWorkflowsFeature.js","sources":["../src/CmsWorkflowsFeature.ts"],"sourcesContent":["import { createFeature } from \"@webiny/feature/api\";\nimport { CmsGraphQLSchemaFactory } from \"@webiny/api-headless-cms\";\nimport { EntryWorkflowsFeature } from \"./features/EntryWorkflows/feature.js\";\nimport { WorkflowsFeature as CmsLocalWorkflowsFeature } from \"./features/Workflows/index.js\";\nimport { WorkflowsFeature } from \"@webiny/api-workflows\";\nimport { createEntrySystemSchemaExtension } from \"./graphql/entrySystemSchema.js\";\n\nexport const CmsWorkflowsFeature = createFeature({\n    name: \"CmsWorkflows\",\n    register(container) {\n        // WCP guard is enforced inside WorkflowsContextEnhancer — register unconditionally.\n        EntryWorkflowsFeature.register(container);\n        CmsLocalWorkflowsFeature.register(container);\n        WorkflowsFeature.register(container);\n\n        // Add the `workflow` field to CmsEntrySystem on the CMS endpoint. (api-workflows extends\n        // CmsEntrySystem on the base /graphql schema via WorkflowsSchemaFactory, but CMS entries are\n        // served from the separate CMS schema, which needs its own CmsGraphQLSchemaFactory entry.)\n        container.registerInstance(CmsGraphQLSchemaFactory, {\n            execute: () => [createEntrySystemSchemaExtension()]\n        });\n    }\n});\n"],"names":["CmsWorkflowsFeature","createFeature","container","EntryWorkflowsFeature","CmsLocalWorkflowsFeature","WorkflowsFeature","CmsGraphQLSchemaFactory","createEntrySystemSchemaExtension"],"mappings":";;;;;;AAOO,MAAMA,sBAAsBC,cAAc;IAC7C,MAAM;IACN,UAASC,SAAS;QAEdC,sBAAsB,QAAQ,CAACD;QAC/BE,iBAAAA,QAAiC,CAACF;QAClCG,+BAAAA,QAAyB,CAACH;QAK1BA,UAAU,gBAAgB,CAACI,yBAAyB;YAChD,SAAS,IAAM;oBAACC;iBAAmC;QACvD;IACJ;AACJ"}

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) Webiny
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,11 @@
+# @webiny/api-headless-cms-workflows
+
+> [!NOTE]
+> This package is part of the [Webiny](https://www.webiny.com) monorepo.
+> It’s **included in every Webiny project by default** and is not meant to be used as a standalone package.
+
+📘 **Documentation:** [https://www.webiny.com/docs](https://www.webiny.com/docs)
+
+---
+
+_This README file is automatically generated during the publish process._

package/features/EntryWorkflows/decorators/CmsWorkflowStateContextProvider.d.ts

@@ -0,0 +1,15 @@
+import { GetModelUseCase } from "@webiny/api-headless-cms/features/contentModel/GetModel/index.js";
+import { GetRevisionByIdUseCase } from "@webiny/api-headless-cms/features/contentEntry/GetRevisionById/index.js";
+import { WorkflowStateContextProvider } from "@webiny/api-workflows/features/workflowState/CreateWorkflowState/index.js";
+import type { GenericRecord } from "@webiny/api/types.js";
+declare class CmsWorkflowStateContextProviderImpl implements WorkflowStateContextProvider.Interface {
+    private getModel;
+    private getRevisionById;
+    private decoratee;
+    constructor(getModel: GetModelUseCase.Interface, getRevisionById: GetRevisionByIdUseCase.Interface, decoratee: WorkflowStateContextProvider.Interface);
+    provide(params: WorkflowStateContextProvider.Params): Promise<GenericRecord>;
+}
+export declare const CmsWorkflowStateContextProvider: typeof CmsWorkflowStateContextProviderImpl & {
+    __abstraction: import("@webiny/di").Abstraction<import("@webiny/api-workflows/features/workflowState/CreateWorkflowState/WorkflowStateContextProvider").IWorkflowStateContextProvider>;
+};
+export {};

package/features/EntryWorkflows/decorators/CmsWorkflowStateContextProvider.js

@@ -0,0 +1,35 @@
+import { GetModelUseCase } from "@webiny/api-headless-cms/features/contentModel/GetModel/index.js";
+import { GetRevisionByIdUseCase } from "@webiny/api-headless-cms/features/contentEntry/GetRevisionById/index.js";
+import { WorkflowStateContextProvider } from "@webiny/api-workflows/features/workflowState/CreateWorkflowState/index.js";
+import { getModelIdFromAppName } from "../../../utils/appName.js";
+class CmsWorkflowStateContextProviderImpl {
+    constructor(getModel, getRevisionById, decoratee){
+        this.getModel = getModel;
+        this.getRevisionById = getRevisionById;
+        this.decoratee = decoratee;
+    }
+    async provide(params) {
+        const modelId = getModelIdFromAppName(params.app);
+        if (!modelId) return this.decoratee.provide(params);
+        const modelResult = await this.getModel.execute(modelId);
+        if (modelResult.isFail()) return {};
+        const model = modelResult.value;
+        const entryResult = await this.getRevisionById.execute(model, params.targetRevisionId);
+        if (entryResult.isFail()) return {};
+        const entry = entryResult.value;
+        return {
+            folderId: entry.location?.folderId || null,
+            modelId
+        };
+    }
+}
+const CmsWorkflowStateContextProvider = WorkflowStateContextProvider.createDecorator({
+    decorator: CmsWorkflowStateContextProviderImpl,
+    dependencies: [
+        GetModelUseCase,
+        GetRevisionByIdUseCase
+    ]
+});
+export { CmsWorkflowStateContextProvider };
+
+//# sourceMappingURL=CmsWorkflowStateContextProvider.js.map

package/features/EntryWorkflows/decorators/CmsWorkflowStateContextProvider.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"features/EntryWorkflows/decorators/CmsWorkflowStateContextProvider.js","sources":["../../../../src/features/EntryWorkflows/decorators/CmsWorkflowStateContextProvider.ts"],"sourcesContent":["import { GetModelUseCase } from \"@webiny/api-headless-cms/features/contentModel/GetModel/index.js\";\nimport { GetRevisionByIdUseCase } from \"@webiny/api-headless-cms/features/contentEntry/GetRevisionById/index.js\";\nimport { WorkflowStateContextProvider } from \"@webiny/api-workflows/features/workflowState/CreateWorkflowState/index.js\";\nimport { getModelIdFromAppName } from \"~/utils/appName.js\";\nimport type { GenericRecord } from \"@webiny/api/types.js\";\n\nclass CmsWorkflowStateContextProviderImpl implements WorkflowStateContextProvider.Interface {\n    constructor(\n        private getModel: GetModelUseCase.Interface,\n        private getRevisionById: GetRevisionByIdUseCase.Interface,\n        private decoratee: WorkflowStateContextProvider.Interface\n    ) {}\n\n    async provide(params: WorkflowStateContextProvider.Params): Promise<GenericRecord> {\n        const modelId = getModelIdFromAppName(params.app);\n        if (!modelId) {\n            return this.decoratee.provide(params);\n        }\n\n        const modelResult = await this.getModel.execute(modelId);\n        if (modelResult.isFail()) {\n            return {};\n        }\n\n        const model = modelResult.value;\n        const entryResult = await this.getRevisionById.execute(model, params.targetRevisionId);\n\n        if (entryResult.isFail()) {\n            return {};\n        }\n\n        const entry = entryResult.value;\n\n        return {\n            folderId: entry.location?.folderId || null,\n            modelId\n        };\n    }\n}\n\nexport const CmsWorkflowStateContextProvider = WorkflowStateContextProvider.createDecorator({\n    decorator: CmsWorkflowStateContextProviderImpl,\n    dependencies: [GetModelUseCase, GetRevisionByIdUseCase]\n});\n"],"names":["CmsWorkflowStateContextProviderImpl","getModel","getRevisionById","decoratee","params","modelId","getModelIdFromAppName","modelResult","model","entryResult","entry","CmsWorkflowStateContextProvider","WorkflowStateContextProvider","GetModelUseCase","GetRevisionByIdUseCase"],"mappings":";;;;AAMA,MAAMA;IACF,YACYC,QAAmC,EACnCC,eAAiD,EACjDC,SAAiD,CAC3D;aAHUF,QAAQ,GAARA;aACAC,eAAe,GAAfA;aACAC,SAAS,GAATA;IACT;IAEH,MAAM,QAAQC,MAA2C,EAA0B;QAC/E,MAAMC,UAAUC,sBAAsBF,OAAO,GAAG;QAChD,IAAI,CAACC,SACD,OAAO,IAAI,CAAC,SAAS,CAAC,OAAO,CAACD;QAGlC,MAAMG,cAAc,MAAM,IAAI,CAAC,QAAQ,CAAC,OAAO,CAACF;QAChD,IAAIE,YAAY,MAAM,IAClB,OAAO,CAAC;QAGZ,MAAMC,QAAQD,YAAY,KAAK;QAC/B,MAAME,cAAc,MAAM,IAAI,CAAC,eAAe,CAAC,OAAO,CAACD,OAAOJ,OAAO,gBAAgB;QAErF,IAAIK,YAAY,MAAM,IAClB,OAAO,CAAC;QAGZ,MAAMC,QAAQD,YAAY,KAAK;QAE/B,OAAO;YACH,UAAUC,MAAM,QAAQ,EAAE,YAAY;YACtCL;QACJ;IACJ;AACJ;AAEO,MAAMM,kCAAkCC,6BAA6B,eAAe,CAAC;IACxF,WAAWZ;IACX,cAAc;QAACa;QAAiBC;KAAuB;AAC3D"}

package/features/EntryWorkflows/decorators/CmsWorkflowStateFilter.d.ts

@@ -0,0 +1,13 @@
+import { FolderLevelPermissions } from "@webiny/api-aco/features/flp/FolderLevelPermissions/index.js";
+import { WorkflowStateFilter } from "@webiny/api-workflows/features/workflowState/ListWorkflowStates/index.js";
+import type { WorkflowState } from "@webiny/api-workflows/domain/workflowState/WorkflowState.js";
+declare class CmsWorkflowStateFilterImpl implements WorkflowStateFilter.Interface {
+    private flp;
+    private decoratee;
+    constructor(flp: FolderLevelPermissions.Interface, decoratee: WorkflowStateFilter.Interface);
+    filter(items: WorkflowState[]): Promise<WorkflowState[]>;
+}
+export declare const CmsWorkflowStateFilter: typeof CmsWorkflowStateFilterImpl & {
+    __abstraction: import("@webiny/di").Abstraction<import("@webiny/api-workflows/features/workflowState/ListWorkflowStates/WorkflowStateFilter").IWorkflowStateFilter>;
+};
+export {};

package/features/EntryWorkflows/decorators/CmsWorkflowStateFilter.js

@@ -0,0 +1,45 @@
+import { FolderLevelPermissions } from "@webiny/api-aco/features/flp/FolderLevelPermissions/index.js";
+import { ROOT_FOLDER } from "@webiny/shared-aco/constants.js";
+import { WorkflowStateFilter } from "@webiny/api-workflows/features/workflowState/ListWorkflowStates/index.js";
+import { getModelIdFromAppName } from "../../../utils/appName.js";
+class CmsWorkflowStateFilterImpl {
+    constructor(flp, decoratee){
+        this.flp = flp;
+        this.decoratee = decoratee;
+    }
+    async filter(items) {
+        const filtered = await this.decoratee.filter(items);
+        if (!this.flp.canUseFolderLevelPermissions()) return filtered;
+        const cmsItems = filtered.filter((item)=>null !== getModelIdFromAppName(item.app));
+        if (0 === cmsItems.length) return filtered;
+        const folderIds = new Set();
+        for (const item of cmsItems){
+            const folderId = item.targetContext?.folderId;
+            if (folderId && folderId !== ROOT_FOLDER) folderIds.add(folderId);
+        }
+        const folderAccess = new Map();
+        for (const folderId of folderIds){
+            const permissions = await this.flp.getFolderLevelPermissions(folderId);
+            const canAccess = await this.flp.canAccessFolderContent({
+                permissions,
+                rwd: "r"
+            });
+            folderAccess.set(folderId, canAccess);
+        }
+        return filtered.filter((item)=>{
+            if (null === getModelIdFromAppName(item.app)) return true;
+            const folderId = item.targetContext?.folderId;
+            if (!folderId || folderId === ROOT_FOLDER) return true;
+            return true === folderAccess.get(folderId);
+        });
+    }
+}
+const CmsWorkflowStateFilter = WorkflowStateFilter.createDecorator({
+    decorator: CmsWorkflowStateFilterImpl,
+    dependencies: [
+        FolderLevelPermissions
+    ]
+});
+export { CmsWorkflowStateFilter };
+
+//# sourceMappingURL=CmsWorkflowStateFilter.js.map

package/features/EntryWorkflows/decorators/CmsWorkflowStateFilter.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"features/EntryWorkflows/decorators/CmsWorkflowStateFilter.js","sources":["../../../../src/features/EntryWorkflows/decorators/CmsWorkflowStateFilter.ts"],"sourcesContent":["import { FolderLevelPermissions } from \"@webiny/api-aco/features/flp/FolderLevelPermissions/index.js\";\nimport { ROOT_FOLDER } from \"@webiny/shared-aco/constants.js\";\nimport { WorkflowStateFilter } from \"@webiny/api-workflows/features/workflowState/ListWorkflowStates/index.js\";\nimport { getModelIdFromAppName } from \"~/utils/appName.js\";\nimport type { WorkflowState } from \"@webiny/api-workflows/domain/workflowState/WorkflowState.js\";\n\nclass CmsWorkflowStateFilterImpl implements WorkflowStateFilter.Interface {\n    constructor(\n        private flp: FolderLevelPermissions.Interface,\n        private decoratee: WorkflowStateFilter.Interface\n    ) {}\n\n    async filter(items: WorkflowState[]): Promise<WorkflowState[]> {\n        const filtered = await this.decoratee.filter(items);\n\n        if (!this.flp.canUseFolderLevelPermissions()) {\n            return filtered;\n        }\n\n        const cmsItems = filtered.filter(item => getModelIdFromAppName(item.app) !== null);\n        if (cmsItems.length === 0) {\n            return filtered;\n        }\n\n        const folderIds = new Set<string>();\n        for (const item of cmsItems) {\n            const folderId = item.targetContext?.folderId;\n            if (folderId && folderId !== ROOT_FOLDER) {\n                folderIds.add(folderId);\n            }\n        }\n\n        const folderAccess = new Map<string, boolean>();\n\n        for (const folderId of folderIds) {\n            const permissions = await this.flp.getFolderLevelPermissions(folderId);\n            const canAccess = await this.flp.canAccessFolderContent({\n                permissions,\n                rwd: \"r\"\n            });\n            folderAccess.set(folderId, canAccess);\n        }\n\n        return filtered.filter(item => {\n            if (getModelIdFromAppName(item.app) === null) {\n                return true;\n            }\n\n            const folderId = item.targetContext?.folderId;\n            if (!folderId || folderId === ROOT_FOLDER) {\n                return true;\n            }\n\n            return folderAccess.get(folderId) === true;\n        });\n    }\n}\n\nexport const CmsWorkflowStateFilter = WorkflowStateFilter.createDecorator({\n    decorator: CmsWorkflowStateFilterImpl,\n    dependencies: [FolderLevelPermissions]\n});\n"],"names":["CmsWorkflowStateFilterImpl","flp","decoratee","items","filtered","cmsItems","item","getModelIdFromAppName","folderIds","Set","folderId","ROOT_FOLDER","folderAccess","Map","permissions","canAccess","CmsWorkflowStateFilter","WorkflowStateFilter","FolderLevelPermissions"],"mappings":";;;;AAMA,MAAMA;IACF,YACYC,GAAqC,EACrCC,SAAwC,CAClD;aAFUD,GAAG,GAAHA;aACAC,SAAS,GAATA;IACT;IAEH,MAAM,OAAOC,KAAsB,EAA4B;QAC3D,MAAMC,WAAW,MAAM,IAAI,CAAC,SAAS,CAAC,MAAM,CAACD;QAE7C,IAAI,CAAC,IAAI,CAAC,GAAG,CAAC,4BAA4B,IACtC,OAAOC;QAGX,MAAMC,WAAWD,SAAS,MAAM,CAACE,CAAAA,OAAQC,AAAoC,SAApCA,sBAAsBD,KAAK,GAAG;QACvE,IAAID,AAAoB,MAApBA,SAAS,MAAM,EACf,OAAOD;QAGX,MAAMI,YAAY,IAAIC;QACtB,KAAK,MAAMH,QAAQD,SAAU;YACzB,MAAMK,WAAWJ,KAAK,aAAa,EAAE;YACrC,IAAII,YAAYA,aAAaC,aACzBH,UAAU,GAAG,CAACE;QAEtB;QAEA,MAAME,eAAe,IAAIC;QAEzB,KAAK,MAAMH,YAAYF,UAAW;YAC9B,MAAMM,cAAc,MAAM,IAAI,CAAC,GAAG,CAAC,yBAAyB,CAACJ;YAC7D,MAAMK,YAAY,MAAM,IAAI,CAAC,GAAG,CAAC,sBAAsB,CAAC;gBACpDD;gBACA,KAAK;YACT;YACAF,aAAa,GAAG,CAACF,UAAUK;QAC/B;QAEA,OAAOX,SAAS,MAAM,CAACE,CAAAA;YACnB,IAAIC,AAAoC,SAApCA,sBAAsBD,KAAK,GAAG,GAC9B,OAAO;YAGX,MAAMI,WAAWJ,KAAK,aAAa,EAAE;YACrC,IAAI,CAACI,YAAYA,aAAaC,aAC1B,OAAO;YAGX,OAAOC,AAA+B,SAA/BA,aAAa,GAAG,CAACF;QAC5B;IACJ;AACJ;AAEO,MAAMM,yBAAyBC,oBAAoB,eAAe,CAAC;IACtE,WAAWjB;IACX,cAAc;QAACkB;KAAuB;AAC1C"}

package/features/EntryWorkflows/errors.d.ts

@@ -0,0 +1,11 @@
+import { BaseError } from "@webiny/feature/api";
+export declare class EntryMoveBlockedByWorkflowStateError extends BaseError<{
+    app: string;
+    entryId: string;
+}> {
+    readonly code: "Workflows/Entry/MoveBlockedByActiveState";
+    constructor(data: {
+        app: string;
+        entryId: string;
+    });
+}

package/features/EntryWorkflows/errors.js

@@ -0,0 +1,12 @@
+import { BaseError } from "@webiny/feature/api";
+class EntryMoveBlockedByWorkflowStateError extends BaseError {
+    constructor(data){
+        super({
+            message: "Cannot move entry because it has an active content review. Cancel or complete the review first.",
+            data
+        }), this.code = "Workflows/Entry/MoveBlockedByActiveState";
+    }
+}
+export { EntryMoveBlockedByWorkflowStateError };
+
+//# sourceMappingURL=errors.js.map

package/features/EntryWorkflows/errors.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"features/EntryWorkflows/errors.js","sources":["../../../src/features/EntryWorkflows/errors.ts"],"sourcesContent":["import { BaseError } from \"@webiny/feature/api\";\n\nexport class EntryMoveBlockedByWorkflowStateError extends BaseError<{\n    app: string;\n    entryId: string;\n}> {\n    override readonly code = \"Workflows/Entry/MoveBlockedByActiveState\" as const;\n\n    constructor(data: { app: string; entryId: string }) {\n        super({\n            message:\n                \"Cannot move entry because it has an active content review. Cancel or complete the review first.\",\n            data\n        });\n    }\n}\n"],"names":["EntryMoveBlockedByWorkflowStateError","BaseError","data"],"mappings":";AAEO,MAAMA,6CAA6CC;IAMtD,YAAYC,IAAsC,CAAE;QAChD,KAAK,CAAC;YACF,SACI;YACJA;QACJ,SAPc,IAAI,GAAG;IAQzB;AACJ"}

package/features/EntryWorkflows/feature.d.ts

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

package/features/EntryWorkflows/feature.js

@@ -0,0 +1,29 @@
+import { createFeature } from "@webiny/feature/api";
+import { DeleteWorkflowsOnModelAfterDelete } from "./handlers/DeleteWorkflowsOnModelAfterDelete.js";
+import { DeleteWorkflowStateOnEntryAfterDelete } from "./handlers/DeleteWorkflowStateOnEntryAfterDelete.js";
+import { ValidateWorkflowStateOnEntryBeforePublish } from "./handlers/ValidateWorkflowStateOnEntryBeforePublish.js";
+import { UpdateEntryOnWorkflowStateAfterCreate } from "./handlers/UpdateEntryOnWorkflowStateAfterCreate.js";
+import { UpdateEntryOnWorkflowStateAfterUpdate } from "./handlers/UpdateEntryOnWorkflowStateAfterUpdate.js";
+import { ClearEntryStateOnWorkflowStateAfterDelete } from "./handlers/ClearEntryStateOnWorkflowStateAfterDelete.js";
+import { ClearEntryStateOnWorkflowStateCancel } from "./handlers/ClearEntryStateOnWorkflowStateCancel.js";
+import { BlockMoveOnActiveWorkflowState } from "./handlers/BlockMoveOnActiveWorkflowState.js";
+import { CmsWorkflowStateContextProvider } from "./decorators/CmsWorkflowStateContextProvider.js";
+import { CmsWorkflowStateFilter } from "./decorators/CmsWorkflowStateFilter.js";
+const EntryWorkflowsFeature = createFeature({
+    name: "EntryWorkflows",
+    register (container) {
+        container.register(DeleteWorkflowsOnModelAfterDelete);
+        container.register(DeleteWorkflowStateOnEntryAfterDelete);
+        container.register(ValidateWorkflowStateOnEntryBeforePublish);
+        container.register(UpdateEntryOnWorkflowStateAfterCreate);
+        container.register(UpdateEntryOnWorkflowStateAfterUpdate);
+        container.register(ClearEntryStateOnWorkflowStateAfterDelete);
+        container.register(ClearEntryStateOnWorkflowStateCancel);
+        container.register(BlockMoveOnActiveWorkflowState);
+        container.registerDecorator(CmsWorkflowStateContextProvider);
+        container.registerDecorator(CmsWorkflowStateFilter);
+    }
+});
+export { EntryWorkflowsFeature };
+
+//# sourceMappingURL=feature.js.map

package/features/EntryWorkflows/feature.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"features/EntryWorkflows/feature.js","sources":["../../../src/features/EntryWorkflows/feature.ts"],"sourcesContent":["import { createFeature } from \"@webiny/feature/api\";\nimport { DeleteWorkflowsOnModelAfterDelete } from \"./handlers/DeleteWorkflowsOnModelAfterDelete.js\";\nimport { DeleteWorkflowStateOnEntryAfterDelete } from \"./handlers/DeleteWorkflowStateOnEntryAfterDelete.js\";\nimport { ValidateWorkflowStateOnEntryBeforePublish } from \"./handlers/ValidateWorkflowStateOnEntryBeforePublish.js\";\nimport { UpdateEntryOnWorkflowStateAfterCreate } from \"./handlers/UpdateEntryOnWorkflowStateAfterCreate.js\";\nimport { UpdateEntryOnWorkflowStateAfterUpdate } from \"./handlers/UpdateEntryOnWorkflowStateAfterUpdate.js\";\nimport { ClearEntryStateOnWorkflowStateAfterDelete } from \"./handlers/ClearEntryStateOnWorkflowStateAfterDelete.js\";\nimport { ClearEntryStateOnWorkflowStateCancel } from \"./handlers/ClearEntryStateOnWorkflowStateCancel.js\";\nimport { BlockMoveOnActiveWorkflowState } from \"./handlers/BlockMoveOnActiveWorkflowState.js\";\nimport { CmsWorkflowStateContextProvider } from \"./decorators/CmsWorkflowStateContextProvider.js\";\nimport { CmsWorkflowStateFilter } from \"./decorators/CmsWorkflowStateFilter.js\";\n\nexport const EntryWorkflowsFeature = createFeature({\n    name: \"EntryWorkflows\",\n    register(container) {\n        container.register(DeleteWorkflowsOnModelAfterDelete);\n        container.register(DeleteWorkflowStateOnEntryAfterDelete);\n        container.register(ValidateWorkflowStateOnEntryBeforePublish);\n        container.register(UpdateEntryOnWorkflowStateAfterCreate);\n        container.register(UpdateEntryOnWorkflowStateAfterUpdate);\n        container.register(ClearEntryStateOnWorkflowStateAfterDelete);\n        container.register(ClearEntryStateOnWorkflowStateCancel);\n        container.register(BlockMoveOnActiveWorkflowState);\n        container.registerDecorator(CmsWorkflowStateContextProvider);\n        container.registerDecorator(CmsWorkflowStateFilter);\n    }\n});\n"],"names":["EntryWorkflowsFeature","createFeature","container","DeleteWorkflowsOnModelAfterDelete","DeleteWorkflowStateOnEntryAfterDelete","ValidateWorkflowStateOnEntryBeforePublish","UpdateEntryOnWorkflowStateAfterCreate","UpdateEntryOnWorkflowStateAfterUpdate","ClearEntryStateOnWorkflowStateAfterDelete","ClearEntryStateOnWorkflowStateCancel","BlockMoveOnActiveWorkflowState","CmsWorkflowStateContextProvider","CmsWorkflowStateFilter"],"mappings":";;;;;;;;;;;AAYO,MAAMA,wBAAwBC,cAAc;IAC/C,MAAM;IACN,UAASC,SAAS;QACdA,UAAU,QAAQ,CAACC;QACnBD,UAAU,QAAQ,CAACE;QACnBF,UAAU,QAAQ,CAACG;QACnBH,UAAU,QAAQ,CAACI;QACnBJ,UAAU,QAAQ,CAACK;QACnBL,UAAU,QAAQ,CAACM;QACnBN,UAAU,QAAQ,CAACO;QACnBP,UAAU,QAAQ,CAACQ;QACnBR,UAAU,iBAAiB,CAACS;QAC5BT,UAAU,iBAAiB,CAACU;IAChC;AACJ"}

package/features/EntryWorkflows/handlers/BlockMoveOnActiveWorkflowState.d.ts

@@ -0,0 +1,11 @@
+import { EntryBeforeMoveEventHandler } from "@webiny/api-headless-cms/features/contentEntry/MoveEntry/index.js";
+import { GetTargetWorkflowStateUseCase } from "@webiny/api-workflows/features/workflowState/GetTargetWorkflowState/index.js";
+declare class BlockMoveOnActiveWorkflowStateImpl implements EntryBeforeMoveEventHandler.Interface {
+    private getTargetState;
+    constructor(getTargetState: GetTargetWorkflowStateUseCase.Interface);
+    handle(event: EntryBeforeMoveEventHandler.Event): Promise<void>;
+}
+export declare const BlockMoveOnActiveWorkflowState: typeof BlockMoveOnActiveWorkflowStateImpl & {
+    __abstraction: import("@webiny/di").Abstraction<import("@webiny/api-core/features/eventPublisher/abstractions.js").IEventHandler<import("@webiny/api-headless-cms/features/contentEntry/MoveEntry/events.js").EntryBeforeMoveEvent>>;
+};
+export {};

package/features/EntryWorkflows/handlers/BlockMoveOnActiveWorkflowState.js

@@ -0,0 +1,37 @@
+import { EntryBeforeMoveEventHandler } from "@webiny/api-headless-cms/features/contentEntry/MoveEntry/index.js";
+import { createWorkflowAppName } from "../../../utils/appName.js";
+import { isModelAllowed } from "../../../utils/modelAllowed.js";
+import { GetTargetWorkflowStateUseCase } from "@webiny/api-workflows/features/workflowState/GetTargetWorkflowState/index.js";
+import { EntryMoveBlockedByWorkflowStateError } from "../errors.js";
+class BlockMoveOnActiveWorkflowStateImpl {
+    constructor(getTargetState){
+        this.getTargetState = getTargetState;
+    }
+    async handle(event) {
+        const { model, entry } = event.payload;
+        if (!isModelAllowed(model)) return;
+        const app = createWorkflowAppName({
+            model
+        });
+        const stateResult = await this.getTargetState.execute({
+            app,
+            targetRevisionId: entry.id
+        });
+        if (stateResult.isFail()) return;
+        const state = stateResult.value;
+        if (state.done) return;
+        throw new EntryMoveBlockedByWorkflowStateError({
+            app,
+            entryId: entry.id
+        });
+    }
+}
+const BlockMoveOnActiveWorkflowState = EntryBeforeMoveEventHandler.createImplementation({
+    implementation: BlockMoveOnActiveWorkflowStateImpl,
+    dependencies: [
+        GetTargetWorkflowStateUseCase
+    ]
+});
+export { BlockMoveOnActiveWorkflowState };
+
+//# sourceMappingURL=BlockMoveOnActiveWorkflowState.js.map

package/features/EntryWorkflows/handlers/BlockMoveOnActiveWorkflowState.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"features/EntryWorkflows/handlers/BlockMoveOnActiveWorkflowState.js","sources":["../../../../src/features/EntryWorkflows/handlers/BlockMoveOnActiveWorkflowState.ts"],"sourcesContent":["import { EntryBeforeMoveEventHandler } from \"@webiny/api-headless-cms/features/contentEntry/MoveEntry/index.js\";\nimport { createWorkflowAppName } from \"~/utils/appName.js\";\nimport { isModelAllowed } from \"~/utils/modelAllowed.js\";\nimport { GetTargetWorkflowStateUseCase } from \"@webiny/api-workflows/features/workflowState/GetTargetWorkflowState/index.js\";\nimport { EntryMoveBlockedByWorkflowStateError } from \"../errors.js\";\n\nclass BlockMoveOnActiveWorkflowStateImpl implements EntryBeforeMoveEventHandler.Interface {\n    constructor(private getTargetState: GetTargetWorkflowStateUseCase.Interface) {}\n\n    async handle(event: EntryBeforeMoveEventHandler.Event): Promise<void> {\n        const { model, entry } = event.payload;\n\n        if (!isModelAllowed(model)) {\n            return;\n        }\n\n        const app = createWorkflowAppName({ model });\n\n        const stateResult = await this.getTargetState.execute({\n            app,\n            targetRevisionId: entry.id\n        });\n\n        if (stateResult.isFail()) {\n            return;\n        }\n\n        const state = stateResult.value;\n\n        if (state.done) {\n            return;\n        }\n\n        throw new EntryMoveBlockedByWorkflowStateError({\n            app,\n            entryId: entry.id\n        });\n    }\n}\n\nexport const BlockMoveOnActiveWorkflowState = EntryBeforeMoveEventHandler.createImplementation({\n    implementation: BlockMoveOnActiveWorkflowStateImpl,\n    dependencies: [GetTargetWorkflowStateUseCase]\n});\n"],"names":["BlockMoveOnActiveWorkflowStateImpl","getTargetState","event","model","entry","isModelAllowed","app","createWorkflowAppName","stateResult","state","EntryMoveBlockedByWorkflowStateError","BlockMoveOnActiveWorkflowState","EntryBeforeMoveEventHandler","GetTargetWorkflowStateUseCase"],"mappings":";;;;;AAMA,MAAMA;IACF,YAAoBC,cAAuD,CAAE;aAAzDA,cAAc,GAAdA;IAA0D;IAE9E,MAAM,OAAOC,KAAwC,EAAiB;QAClE,MAAM,EAAEC,KAAK,EAAEC,KAAK,EAAE,GAAGF,MAAM,OAAO;QAEtC,IAAI,CAACG,eAAeF,QAChB;QAGJ,MAAMG,MAAMC,sBAAsB;YAAEJ;QAAM;QAE1C,MAAMK,cAAc,MAAM,IAAI,CAAC,cAAc,CAAC,OAAO,CAAC;YAClDF;YACA,kBAAkBF,MAAM,EAAE;QAC9B;QAEA,IAAII,YAAY,MAAM,IAClB;QAGJ,MAAMC,QAAQD,YAAY,KAAK;QAE/B,IAAIC,MAAM,IAAI,EACV;QAGJ,MAAM,IAAIC,qCAAqC;YAC3CJ;YACA,SAASF,MAAM,EAAE;QACrB;IACJ;AACJ;AAEO,MAAMO,iCAAiCC,4BAA4B,oBAAoB,CAAC;IAC3F,gBAAgBZ;IAChB,cAAc;QAACa;KAA8B;AACjD"}

package/features/EntryWorkflows/handlers/ClearEntryStateOnWorkflowStateAfterDelete.d.ts

@@ -0,0 +1,13 @@
+import { WorkflowStateAfterDeleteHandler } from "@webiny/api-workflows/features/workflowState/DeleteTargetWorkflowState/events.js";
+import { UpdateEntryUseCase } from "@webiny/api-headless-cms/features/contentEntry/UpdateEntry/index.js";
+import { GetModelUseCase } from "@webiny/api-headless-cms/features/contentModel/GetModel/index.js";
+declare class ClearEntryStateOnWorkflowStateAfterDeleteImpl implements WorkflowStateAfterDeleteHandler.Interface {
+    private getModel;
+    private updateEntry;
+    constructor(getModel: GetModelUseCase.Interface, updateEntry: UpdateEntryUseCase.Interface);
+    handle(event: WorkflowStateAfterDeleteHandler.Event): Promise<void>;
+}
+export declare const ClearEntryStateOnWorkflowStateAfterDelete: typeof ClearEntryStateOnWorkflowStateAfterDeleteImpl & {
+    __abstraction: import("@webiny/di").Abstraction<import("@webiny/api-core/features/eventPublisher").IEventHandler<import("@webiny/api-workflows/features/workflowState/DeleteTargetWorkflowState/events.js").WorkflowStateAfterDeleteEvent>>;
+};
+export {};

package/features/EntryWorkflows/handlers/ClearEntryStateOnWorkflowStateAfterDelete.js

@@ -0,0 +1,35 @@
+import { WorkflowStateAfterDeleteHandler } from "@webiny/api-workflows/features/workflowState/DeleteTargetWorkflowState/events.js";
+import { getModelIdFromAppName } from "../../../utils/appName.js";
+import { UpdateEntryUseCase } from "@webiny/api-headless-cms/features/contentEntry/UpdateEntry/index.js";
+import { GetModelUseCase } from "@webiny/api-headless-cms/features/contentModel/GetModel/index.js";
+class ClearEntryStateOnWorkflowStateAfterDeleteImpl {
+    constructor(getModel, updateEntry){
+        this.getModel = getModel;
+        this.updateEntry = updateEntry;
+    }
+    async handle(event) {
+        const { state } = event.payload;
+        const modelId = getModelIdFromAppName(state.app);
+        if (!modelId) return;
+        const modelResult = await this.getModel.execute(modelId);
+        if (modelResult.isFail()) return;
+        const model = modelResult.value;
+        await this.updateEntry.execute(model, state.targetRevisionId, {
+            system: {
+                workflow: null
+            }
+        }, {
+            skipValidation: true
+        });
+    }
+}
+const ClearEntryStateOnWorkflowStateAfterDelete = WorkflowStateAfterDeleteHandler.createImplementation({
+    implementation: ClearEntryStateOnWorkflowStateAfterDeleteImpl,
+    dependencies: [
+        GetModelUseCase,
+        UpdateEntryUseCase
+    ]
+});
+export { ClearEntryStateOnWorkflowStateAfterDelete };
+
+//# sourceMappingURL=ClearEntryStateOnWorkflowStateAfterDelete.js.map

package/features/EntryWorkflows/handlers/ClearEntryStateOnWorkflowStateAfterDelete.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"features/EntryWorkflows/handlers/ClearEntryStateOnWorkflowStateAfterDelete.js","sources":["../../../../src/features/EntryWorkflows/handlers/ClearEntryStateOnWorkflowStateAfterDelete.ts"],"sourcesContent":["import { WorkflowStateAfterDeleteHandler } from \"@webiny/api-workflows/features/workflowState/DeleteTargetWorkflowState/events.js\";\nimport { getModelIdFromAppName } from \"~/utils/appName.js\";\nimport { UpdateEntryUseCase } from \"@webiny/api-headless-cms/features/contentEntry/UpdateEntry/index.js\";\nimport { GetModelUseCase } from \"@webiny/api-headless-cms/features/contentModel/GetModel/index.js\";\n\nclass ClearEntryStateOnWorkflowStateAfterDeleteImpl\n    implements WorkflowStateAfterDeleteHandler.Interface\n{\n    constructor(\n        private getModel: GetModelUseCase.Interface,\n        private updateEntry: UpdateEntryUseCase.Interface\n    ) {}\n\n    async handle(event: WorkflowStateAfterDeleteHandler.Event): Promise<void> {\n        const { state } = event.payload;\n\n        const modelId = getModelIdFromAppName(state.app);\n        if (!modelId) {\n            return;\n        }\n\n        const modelResult = await this.getModel.execute(modelId);\n        if (modelResult.isFail()) {\n            return;\n        }\n\n        const model = modelResult.value;\n        await this.updateEntry.execute(\n            model,\n            state.targetRevisionId,\n            { system: { workflow: null } },\n            { skipValidation: true }\n        );\n    }\n}\n\nexport const ClearEntryStateOnWorkflowStateAfterDelete =\n    WorkflowStateAfterDeleteHandler.createImplementation({\n        implementation: ClearEntryStateOnWorkflowStateAfterDeleteImpl,\n        dependencies: [GetModelUseCase, UpdateEntryUseCase]\n    });\n"],"names":["ClearEntryStateOnWorkflowStateAfterDeleteImpl","getModel","updateEntry","event","state","modelId","getModelIdFromAppName","modelResult","model","ClearEntryStateOnWorkflowStateAfterDelete","WorkflowStateAfterDeleteHandler","GetModelUseCase","UpdateEntryUseCase"],"mappings":";;;;AAKA,MAAMA;IAGF,YACYC,QAAmC,EACnCC,WAAyC,CACnD;aAFUD,QAAQ,GAARA;aACAC,WAAW,GAAXA;IACT;IAEH,MAAM,OAAOC,KAA4C,EAAiB;QACtE,MAAM,EAAEC,KAAK,EAAE,GAAGD,MAAM,OAAO;QAE/B,MAAME,UAAUC,sBAAsBF,MAAM,GAAG;QAC/C,IAAI,CAACC,SACD;QAGJ,MAAME,cAAc,MAAM,IAAI,CAAC,QAAQ,CAAC,OAAO,CAACF;QAChD,IAAIE,YAAY,MAAM,IAClB;QAGJ,MAAMC,QAAQD,YAAY,KAAK;QAC/B,MAAM,IAAI,CAAC,WAAW,CAAC,OAAO,CAC1BC,OACAJ,MAAM,gBAAgB,EACtB;YAAE,QAAQ;gBAAE,UAAU;YAAK;QAAE,GAC7B;YAAE,gBAAgB;QAAK;IAE/B;AACJ;AAEO,MAAMK,4CACTC,gCAAgC,oBAAoB,CAAC;IACjD,gBAAgBV;IAChB,cAAc;QAACW;QAAiBC;KAAmB;AACvD"}

package/features/EntryWorkflows/handlers/ClearEntryStateOnWorkflowStateCancel.d.ts

@@ -0,0 +1,13 @@
+import { WorkflowStateCancelHandler } from "@webiny/api-workflows/features/workflowState/CancelWorkflowState/events.js";
+import { UpdateEntryUseCase } from "@webiny/api-headless-cms/features/contentEntry/UpdateEntry/index.js";
+import { GetModelUseCase } from "@webiny/api-headless-cms/features/contentModel/GetModel/index.js";
+declare class ClearEntryStateOnWorkflowStateCancelImpl implements WorkflowStateCancelHandler.Interface {
+    private getModel;
+    private updateEntry;
+    constructor(getModel: GetModelUseCase.Interface, updateEntry: UpdateEntryUseCase.Interface);
+    handle(event: WorkflowStateCancelHandler.Event): Promise<void>;
+}
+export declare const ClearEntryStateOnWorkflowStateCancel: typeof ClearEntryStateOnWorkflowStateCancelImpl & {
+    __abstraction: import("@webiny/di").Abstraction<import("@webiny/api-core/features/eventPublisher").IEventHandler<import("@webiny/api-workflows/features/workflowState/CancelWorkflowState/events.js").WorkflowStateCancelEvent>>;
+};
+export {};

package/features/EntryWorkflows/handlers/ClearEntryStateOnWorkflowStateCancel.js

@@ -0,0 +1,35 @@
+import { WorkflowStateCancelHandler } from "@webiny/api-workflows/features/workflowState/CancelWorkflowState/events.js";
+import { getModelIdFromAppName } from "../../../utils/appName.js";
+import { UpdateEntryUseCase } from "@webiny/api-headless-cms/features/contentEntry/UpdateEntry/index.js";
+import { GetModelUseCase } from "@webiny/api-headless-cms/features/contentModel/GetModel/index.js";
+class ClearEntryStateOnWorkflowStateCancelImpl {
+    constructor(getModel, updateEntry){
+        this.getModel = getModel;
+        this.updateEntry = updateEntry;
+    }
+    async handle(event) {
+        const { state } = event.payload;
+        const modelId = getModelIdFromAppName(state.app);
+        if (!modelId) return;
+        const modelResult = await this.getModel.execute(modelId);
+        if (modelResult.isFail()) return;
+        const model = modelResult.value;
+        await this.updateEntry.execute(model, state.targetRevisionId, {
+            system: {
+                workflow: null
+            }
+        }, {
+            skipValidation: true
+        });
+    }
+}
+const ClearEntryStateOnWorkflowStateCancel = WorkflowStateCancelHandler.createImplementation({
+    implementation: ClearEntryStateOnWorkflowStateCancelImpl,
+    dependencies: [
+        GetModelUseCase,
+        UpdateEntryUseCase
+    ]
+});
+export { ClearEntryStateOnWorkflowStateCancel };
+
+//# sourceMappingURL=ClearEntryStateOnWorkflowStateCancel.js.map

package/features/EntryWorkflows/handlers/ClearEntryStateOnWorkflowStateCancel.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"features/EntryWorkflows/handlers/ClearEntryStateOnWorkflowStateCancel.js","sources":["../../../../src/features/EntryWorkflows/handlers/ClearEntryStateOnWorkflowStateCancel.ts"],"sourcesContent":["import { WorkflowStateCancelHandler } from \"@webiny/api-workflows/features/workflowState/CancelWorkflowState/events.js\";\nimport { getModelIdFromAppName } from \"~/utils/appName.js\";\nimport { UpdateEntryUseCase } from \"@webiny/api-headless-cms/features/contentEntry/UpdateEntry/index.js\";\nimport { GetModelUseCase } from \"@webiny/api-headless-cms/features/contentModel/GetModel/index.js\";\n\nclass ClearEntryStateOnWorkflowStateCancelImpl implements WorkflowStateCancelHandler.Interface {\n    constructor(\n        private getModel: GetModelUseCase.Interface,\n        private updateEntry: UpdateEntryUseCase.Interface\n    ) {}\n\n    async handle(event: WorkflowStateCancelHandler.Event): Promise<void> {\n        const { state } = event.payload;\n\n        const modelId = getModelIdFromAppName(state.app);\n        if (!modelId) {\n            return;\n        }\n\n        const modelResult = await this.getModel.execute(modelId);\n        if (modelResult.isFail()) {\n            return;\n        }\n\n        const model = modelResult.value;\n        await this.updateEntry.execute(\n            model,\n            state.targetRevisionId,\n            { system: { workflow: null } },\n            { skipValidation: true }\n        );\n    }\n}\n\nexport const ClearEntryStateOnWorkflowStateCancel = WorkflowStateCancelHandler.createImplementation(\n    {\n        implementation: ClearEntryStateOnWorkflowStateCancelImpl,\n        dependencies: [GetModelUseCase, UpdateEntryUseCase]\n    }\n);\n"],"names":["ClearEntryStateOnWorkflowStateCancelImpl","getModel","updateEntry","event","state","modelId","getModelIdFromAppName","modelResult","model","ClearEntryStateOnWorkflowStateCancel","WorkflowStateCancelHandler","GetModelUseCase","UpdateEntryUseCase"],"mappings":";;;;AAKA,MAAMA;IACF,YACYC,QAAmC,EACnCC,WAAyC,CACnD;aAFUD,QAAQ,GAARA;aACAC,WAAW,GAAXA;IACT;IAEH,MAAM,OAAOC,KAAuC,EAAiB;QACjE,MAAM,EAAEC,KAAK,EAAE,GAAGD,MAAM,OAAO;QAE/B,MAAME,UAAUC,sBAAsBF,MAAM,GAAG;QAC/C,IAAI,CAACC,SACD;QAGJ,MAAME,cAAc,MAAM,IAAI,CAAC,QAAQ,CAAC,OAAO,CAACF;QAChD,IAAIE,YAAY,MAAM,IAClB;QAGJ,MAAMC,QAAQD,YAAY,KAAK;QAC/B,MAAM,IAAI,CAAC,WAAW,CAAC,OAAO,CAC1BC,OACAJ,MAAM,gBAAgB,EACtB;YAAE,QAAQ;gBAAE,UAAU;YAAK;QAAE,GAC7B;YAAE,gBAAgB;QAAK;IAE/B;AACJ;AAEO,MAAMK,uCAAuCC,2BAA2B,oBAAoB,CAC/F;IACI,gBAAgBV;IAChB,cAAc;QAACW;QAAiBC;KAAmB;AACvD"}

package/features/EntryWorkflows/handlers/DeleteWorkflowStateOnEntryAfterDelete.d.ts

@@ -0,0 +1,11 @@
+import { EntryAfterDeleteEventHandler } from "@webiny/api-headless-cms/features/contentEntry/DeleteEntry/events.js";
+import { DeleteTargetWorkflowStateUseCase } from "@webiny/api-workflows/features/workflowState/DeleteTargetWorkflowState/index.js";
+declare class DeleteWorkflowStateOnEntryAfterDeleteImpl implements EntryAfterDeleteEventHandler.Interface {
+    private deleteTargetState;
+    constructor(deleteTargetState: DeleteTargetWorkflowStateUseCase.Interface);
+    handle(event: EntryAfterDeleteEventHandler.Event): Promise<void>;
+}
+export declare const DeleteWorkflowStateOnEntryAfterDelete: typeof DeleteWorkflowStateOnEntryAfterDeleteImpl & {
+    __abstraction: import("@webiny/di").Abstraction<import("@webiny/api-core/features/eventPublisher").IEventHandler<import("@webiny/api-headless-cms/features/contentEntry/DeleteEntry/events.js").EntryAfterDeleteEvent>>;
+};
+export {};

package/features/EntryWorkflows/handlers/DeleteWorkflowStateOnEntryAfterDelete.js

@@ -0,0 +1,26 @@
+import { EntryAfterDeleteEventHandler } from "@webiny/api-headless-cms/features/contentEntry/DeleteEntry/events.js";
+import { createWorkflowAppName } from "../../../utils/appName.js";
+import { isModelAllowed } from "../../../utils/modelAllowed.js";
+import { DeleteTargetWorkflowStateUseCase } from "@webiny/api-workflows/features/workflowState/DeleteTargetWorkflowState/index.js";
+class DeleteWorkflowStateOnEntryAfterDeleteImpl {
+    constructor(deleteTargetState){
+        this.deleteTargetState = deleteTargetState;
+    }
+    async handle(event) {
+        const { model, entry, permanent } = event.payload;
+        if (!isModelAllowed(model) || !permanent) return;
+        const app = createWorkflowAppName({
+            model
+        });
+        await this.deleteTargetState.execute(app, entry.id);
+    }
+}
+const DeleteWorkflowStateOnEntryAfterDelete = EntryAfterDeleteEventHandler.createImplementation({
+    implementation: DeleteWorkflowStateOnEntryAfterDeleteImpl,
+    dependencies: [
+        DeleteTargetWorkflowStateUseCase
+    ]
+});
+export { DeleteWorkflowStateOnEntryAfterDelete };
+
+//# sourceMappingURL=DeleteWorkflowStateOnEntryAfterDelete.js.map

package/features/EntryWorkflows/handlers/DeleteWorkflowStateOnEntryAfterDelete.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"features/EntryWorkflows/handlers/DeleteWorkflowStateOnEntryAfterDelete.js","sources":["../../../../src/features/EntryWorkflows/handlers/DeleteWorkflowStateOnEntryAfterDelete.ts"],"sourcesContent":["import { EntryAfterDeleteEventHandler } from \"@webiny/api-headless-cms/features/contentEntry/DeleteEntry/events.js\";\nimport { createWorkflowAppName } from \"~/utils/appName.js\";\nimport { isModelAllowed } from \"~/utils/modelAllowed.js\";\nimport { DeleteTargetWorkflowStateUseCase } from \"@webiny/api-workflows/features/workflowState/DeleteTargetWorkflowState/index.js\";\n\nclass DeleteWorkflowStateOnEntryAfterDeleteImpl implements EntryAfterDeleteEventHandler.Interface {\n    constructor(private deleteTargetState: DeleteTargetWorkflowStateUseCase.Interface) {}\n\n    async handle(event: EntryAfterDeleteEventHandler.Event): Promise<void> {\n        const { model, entry, permanent } = event.payload;\n\n        if (!isModelAllowed(model) || !permanent) {\n            return;\n        }\n\n        const app = createWorkflowAppName({ model });\n        await this.deleteTargetState.execute(app, entry.id);\n    }\n}\n\nexport const DeleteWorkflowStateOnEntryAfterDelete =\n    EntryAfterDeleteEventHandler.createImplementation({\n        implementation: DeleteWorkflowStateOnEntryAfterDeleteImpl,\n        dependencies: [DeleteTargetWorkflowStateUseCase]\n    });\n"],"names":["DeleteWorkflowStateOnEntryAfterDeleteImpl","deleteTargetState","event","model","entry","permanent","isModelAllowed","app","createWorkflowAppName","DeleteWorkflowStateOnEntryAfterDelete","EntryAfterDeleteEventHandler","DeleteTargetWorkflowStateUseCase"],"mappings":";;;;AAKA,MAAMA;IACF,YAAoBC,iBAA6D,CAAE;aAA/DA,iBAAiB,GAAjBA;IAAgE;IAEpF,MAAM,OAAOC,KAAyC,EAAiB;QACnE,MAAM,EAAEC,KAAK,EAAEC,KAAK,EAAEC,SAAS,EAAE,GAAGH,MAAM,OAAO;QAEjD,IAAI,CAACI,eAAeH,UAAU,CAACE,WAC3B;QAGJ,MAAME,MAAMC,sBAAsB;YAAEL;QAAM;QAC1C,MAAM,IAAI,CAAC,iBAAiB,CAAC,OAAO,CAACI,KAAKH,MAAM,EAAE;IACtD;AACJ;AAEO,MAAMK,wCACTC,6BAA6B,oBAAoB,CAAC;IAC9C,gBAAgBV;IAChB,cAAc;QAACW;KAAiC;AACpD"}

package/features/EntryWorkflows/handlers/DeleteWorkflowsOnModelAfterDelete.d.ts

@@ -0,0 +1,13 @@
+import { ModelAfterDeleteEventHandler } from "@webiny/api-headless-cms/features/contentModel/DeleteModel/events.js";
+import { ListWorkflowsUseCase } from "@webiny/api-workflows/features/workflow/ListWorkflows/index.js";
+import { DeleteWorkflowUseCase } from "@webiny/api-workflows/features/workflow/DeleteWorkflow/index.js";
+declare class DeleteWorkflowsOnModelAfterDeleteImpl implements ModelAfterDeleteEventHandler.Interface {
+    private listWorkflows;
+    private deleteWorkflow;
+    constructor(listWorkflows: ListWorkflowsUseCase.Interface, deleteWorkflow: DeleteWorkflowUseCase.Interface);
+    handle(event: ModelAfterDeleteEventHandler.Event): Promise<void>;
+}
+export declare const DeleteWorkflowsOnModelAfterDelete: typeof DeleteWorkflowsOnModelAfterDeleteImpl & {
+    __abstraction: import("@webiny/di").Abstraction<import("@webiny/api-core/features/eventPublisher").IEventHandler<import("@webiny/api-headless-cms/features/contentModel/DeleteModel/events.js").ModelAfterDeleteEvent>>;
+};
+export {};

package/features/EntryWorkflows/handlers/DeleteWorkflowsOnModelAfterDelete.js

@@ -0,0 +1,41 @@
+import { ModelAfterDeleteEventHandler } from "@webiny/api-headless-cms/features/contentModel/DeleteModel/events.js";
+import { ListWorkflowsUseCase } from "@webiny/api-workflows/features/workflow/ListWorkflows/index.js";
+import { DeleteWorkflowUseCase } from "@webiny/api-workflows/features/workflow/DeleteWorkflow/index.js";
+import { createWorkflowAppName } from "../../../utils/appName.js";
+import { isModelAllowed } from "../../../utils/modelAllowed.js";
+class DeleteWorkflowsOnModelAfterDeleteImpl {
+    constructor(listWorkflows, deleteWorkflow){
+        this.listWorkflows = listWorkflows;
+        this.deleteWorkflow = deleteWorkflow;
+    }
+    async handle(event) {
+        const { model } = event.payload;
+        if (!isModelAllowed(model)) return;
+        const app = createWorkflowAppName({
+            model
+        });
+        const result = await this.listWorkflows.execute({
+            where: {
+                app
+            },
+            limit: 10000
+        });
+        const workflows = result.value.items;
+        for (const workflow of workflows)try {
+            await this.deleteWorkflow.execute({
+                app: workflow.app,
+                id: workflow.id
+            });
+        } catch  {}
+    }
+}
+const DeleteWorkflowsOnModelAfterDelete = ModelAfterDeleteEventHandler.createImplementation({
+    implementation: DeleteWorkflowsOnModelAfterDeleteImpl,
+    dependencies: [
+        ListWorkflowsUseCase,
+        DeleteWorkflowUseCase
+    ]
+});
+export { DeleteWorkflowsOnModelAfterDelete };
+
+//# sourceMappingURL=DeleteWorkflowsOnModelAfterDelete.js.map

package/features/EntryWorkflows/handlers/DeleteWorkflowsOnModelAfterDelete.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"features/EntryWorkflows/handlers/DeleteWorkflowsOnModelAfterDelete.js","sources":["../../../../src/features/EntryWorkflows/handlers/DeleteWorkflowsOnModelAfterDelete.ts"],"sourcesContent":["import { ModelAfterDeleteEventHandler } from \"@webiny/api-headless-cms/features/contentModel/DeleteModel/events.js\";\nimport { ListWorkflowsUseCase } from \"@webiny/api-workflows/features/workflow/ListWorkflows/index.js\";\nimport { DeleteWorkflowUseCase } from \"@webiny/api-workflows/features/workflow/DeleteWorkflow/index.js\";\nimport { createWorkflowAppName } from \"~/utils/appName.js\";\nimport { isModelAllowed } from \"~/utils/modelAllowed.js\";\n\nclass DeleteWorkflowsOnModelAfterDeleteImpl implements ModelAfterDeleteEventHandler.Interface {\n    constructor(\n        private listWorkflows: ListWorkflowsUseCase.Interface,\n        private deleteWorkflow: DeleteWorkflowUseCase.Interface\n    ) {}\n\n    async handle(event: ModelAfterDeleteEventHandler.Event): Promise<void> {\n        const { model } = event.payload;\n\n        if (!isModelAllowed(model)) {\n            return;\n        }\n\n        const app = createWorkflowAppName({ model });\n        const result = await this.listWorkflows.execute({\n            where: {\n                app\n            },\n            limit: 10000\n        });\n\n        const workflows = result.value.items;\n\n        for (const workflow of workflows) {\n            try {\n                await this.deleteWorkflow.execute({\n                    app: workflow.app,\n                    id: workflow.id\n                });\n            } catch {\n                // does not matter\n            }\n        }\n    }\n}\n\nexport const DeleteWorkflowsOnModelAfterDelete = ModelAfterDeleteEventHandler.createImplementation({\n    implementation: DeleteWorkflowsOnModelAfterDeleteImpl,\n    dependencies: [ListWorkflowsUseCase, DeleteWorkflowUseCase]\n});\n"],"names":["DeleteWorkflowsOnModelAfterDeleteImpl","listWorkflows","deleteWorkflow","event","model","isModelAllowed","app","createWorkflowAppName","result","workflows","workflow","DeleteWorkflowsOnModelAfterDelete","ModelAfterDeleteEventHandler","ListWorkflowsUseCase","DeleteWorkflowUseCase"],"mappings":";;;;;AAMA,MAAMA;IACF,YACYC,aAA6C,EAC7CC,cAA+C,CACzD;aAFUD,aAAa,GAAbA;aACAC,cAAc,GAAdA;IACT;IAEH,MAAM,OAAOC,KAAyC,EAAiB;QACnE,MAAM,EAAEC,KAAK,EAAE,GAAGD,MAAM,OAAO;QAE/B,IAAI,CAACE,eAAeD,QAChB;QAGJ,MAAME,MAAMC,sBAAsB;YAAEH;QAAM;QAC1C,MAAMI,SAAS,MAAM,IAAI,CAAC,aAAa,CAAC,OAAO,CAAC;YAC5C,OAAO;gBACHF;YACJ;YACA,OAAO;QACX;QAEA,MAAMG,YAAYD,OAAO,KAAK,CAAC,KAAK;QAEpC,KAAK,MAAME,YAAYD,UACnB,IAAI;YACA,MAAM,IAAI,CAAC,cAAc,CAAC,OAAO,CAAC;gBAC9B,KAAKC,SAAS,GAAG;gBACjB,IAAIA,SAAS,EAAE;YACnB;QACJ,EAAE,OAAM,CAER;IAER;AACJ;AAEO,MAAMC,oCAAoCC,6BAA6B,oBAAoB,CAAC;IAC/F,gBAAgBZ;IAChB,cAAc;QAACa;QAAsBC;KAAsB;AAC/D"}

package/features/EntryWorkflows/handlers/UpdateEntryOnWorkflowStateAfterCreate.d.ts

@@ -0,0 +1,13 @@
+import { GetModelUseCase } from "@webiny/api-headless-cms/features/contentModel/GetModel/index.js";
+import { UpdateEntryUseCase } from "@webiny/api-headless-cms/features/contentEntry/UpdateEntry/index.js";
+import { WorkflowStateAfterCreateHandler } from "@webiny/api-workflows/features/workflowState/CreateWorkflowState/events.js";
+declare class UpdateEntryOnWorkflowStateAfterCreateImpl implements WorkflowStateAfterCreateHandler.Interface {
+    private getModel;
+    private updateEntry;
+    constructor(getModel: GetModelUseCase.Interface, updateEntry: UpdateEntryUseCase.Interface);
+    handle(event: WorkflowStateAfterCreateHandler.Event): Promise<void>;
+}
+export declare const UpdateEntryOnWorkflowStateAfterCreate: typeof UpdateEntryOnWorkflowStateAfterCreateImpl & {
+    __abstraction: import("@webiny/di").Abstraction<import("@webiny/api-core/features/eventPublisher").IEventHandler<import("@webiny/api-workflows/features/workflowState/CreateWorkflowState/events.js").WorkflowStateAfterCreateEvent>>;
+};
+export {};

package/features/EntryWorkflows/handlers/UpdateEntryOnWorkflowStateAfterCreate.js

@@ -0,0 +1,37 @@
+import { GetModelUseCase } from "@webiny/api-headless-cms/features/contentModel/GetModel/index.js";
+import { UpdateEntryUseCase } from "@webiny/api-headless-cms/features/contentEntry/UpdateEntry/index.js";
+import { WorkflowStateAfterCreateHandler } from "@webiny/api-workflows/features/workflowState/CreateWorkflowState/events.js";
+import { getModelIdFromAppName } from "../../../utils/appName.js";
+import { getStateValues } from "../../../utils/state.js";
+class UpdateEntryOnWorkflowStateAfterCreateImpl {
+    constructor(getModel, updateEntry){
+        this.getModel = getModel;
+        this.updateEntry = updateEntry;
+    }
+    async handle(event) {
+        const { state } = event.payload;
+        const modelId = getModelIdFromAppName(state.app);
+        if (!modelId) return;
+        const values = getStateValues(state);
+        const modelResult = await this.getModel.execute(modelId);
+        if (modelResult.isFail()) return;
+        const model = modelResult.value;
+        await this.updateEntry.execute(model, state.targetRevisionId, {
+            system: {
+                workflow: values
+            }
+        }, {
+            skipValidation: true
+        });
+    }
+}
+const UpdateEntryOnWorkflowStateAfterCreate = WorkflowStateAfterCreateHandler.createImplementation({
+    implementation: UpdateEntryOnWorkflowStateAfterCreateImpl,
+    dependencies: [
+        GetModelUseCase,
+        UpdateEntryUseCase
+    ]
+});
+export { UpdateEntryOnWorkflowStateAfterCreate };
+
+//# sourceMappingURL=UpdateEntryOnWorkflowStateAfterCreate.js.map

package/features/EntryWorkflows/handlers/UpdateEntryOnWorkflowStateAfterCreate.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"features/EntryWorkflows/handlers/UpdateEntryOnWorkflowStateAfterCreate.js","sources":["../../../../src/features/EntryWorkflows/handlers/UpdateEntryOnWorkflowStateAfterCreate.ts"],"sourcesContent":["import { GetModelUseCase } from \"@webiny/api-headless-cms/features/contentModel/GetModel/index.js\";\nimport { UpdateEntryUseCase } from \"@webiny/api-headless-cms/features/contentEntry/UpdateEntry/index.js\";\nimport { WorkflowStateAfterCreateHandler } from \"@webiny/api-workflows/features/workflowState/CreateWorkflowState/events.js\";\nimport { getModelIdFromAppName } from \"~/utils/appName.js\";\nimport { getStateValues } from \"~/utils/state.js\";\n\nclass UpdateEntryOnWorkflowStateAfterCreateImpl\n    implements WorkflowStateAfterCreateHandler.Interface\n{\n    constructor(\n        private getModel: GetModelUseCase.Interface,\n        private updateEntry: UpdateEntryUseCase.Interface\n    ) {}\n\n    async handle(event: WorkflowStateAfterCreateHandler.Event): Promise<void> {\n        const { state } = event.payload;\n\n        const modelId = getModelIdFromAppName(state.app);\n        if (!modelId) {\n            return;\n        }\n\n        const values = getStateValues(state);\n\n        const modelResult = await this.getModel.execute(modelId);\n        if (modelResult.isFail()) {\n            return;\n        }\n\n        const model = modelResult.value;\n        await this.updateEntry.execute(\n            model,\n            state.targetRevisionId,\n            { system: { workflow: values } },\n            { skipValidation: true }\n        );\n    }\n}\n\nexport const UpdateEntryOnWorkflowStateAfterCreate =\n    WorkflowStateAfterCreateHandler.createImplementation({\n        implementation: UpdateEntryOnWorkflowStateAfterCreateImpl,\n        dependencies: [GetModelUseCase, UpdateEntryUseCase]\n    });\n"],"names":["UpdateEntryOnWorkflowStateAfterCreateImpl","getModel","updateEntry","event","state","modelId","getModelIdFromAppName","values","getStateValues","modelResult","model","UpdateEntryOnWorkflowStateAfterCreate","WorkflowStateAfterCreateHandler","GetModelUseCase","UpdateEntryUseCase"],"mappings":";;;;;AAMA,MAAMA;IAGF,YACYC,QAAmC,EACnCC,WAAyC,CACnD;aAFUD,QAAQ,GAARA;aACAC,WAAW,GAAXA;IACT;IAEH,MAAM,OAAOC,KAA4C,EAAiB;QACtE,MAAM,EAAEC,KAAK,EAAE,GAAGD,MAAM,OAAO;QAE/B,MAAME,UAAUC,sBAAsBF,MAAM,GAAG;QAC/C,IAAI,CAACC,SACD;QAGJ,MAAME,SAASC,eAAeJ;QAE9B,MAAMK,cAAc,MAAM,IAAI,CAAC,QAAQ,CAAC,OAAO,CAACJ;QAChD,IAAII,YAAY,MAAM,IAClB;QAGJ,MAAMC,QAAQD,YAAY,KAAK;QAC/B,MAAM,IAAI,CAAC,WAAW,CAAC,OAAO,CAC1BC,OACAN,MAAM,gBAAgB,EACtB;YAAE,QAAQ;gBAAE,UAAUG;YAAO;QAAE,GAC/B;YAAE,gBAAgB;QAAK;IAE/B;AACJ;AAEO,MAAMI,wCACTC,gCAAgC,oBAAoB,CAAC;IACjD,gBAAgBZ;IAChB,cAAc;QAACa;QAAiBC;KAAmB;AACvD"}

package/features/EntryWorkflows/handlers/UpdateEntryOnWorkflowStateAfterUpdate.d.ts

@@ -0,0 +1,13 @@
+import { GetModelUseCase } from "@webiny/api-headless-cms/features/contentModel/GetModel/index.js";
+import { UpdateEntryUseCase } from "@webiny/api-headless-cms/features/contentEntry/UpdateEntry/index.js";
+import { WorkflowStateAfterUpdateHandler } from "@webiny/api-workflows/features/workflowState/UpdateWorkflowState/events.js";
+declare class UpdateEntryOnWorkflowStateAfterUpdateImpl implements WorkflowStateAfterUpdateHandler.Interface {
+    private getModel;
+    private updateEntry;
+    constructor(getModel: GetModelUseCase.Interface, updateEntry: UpdateEntryUseCase.Interface);
+    handle(event: WorkflowStateAfterUpdateHandler.Event): Promise<void>;
+}
+export declare const UpdateEntryOnWorkflowStateAfterUpdate: typeof UpdateEntryOnWorkflowStateAfterUpdateImpl & {
+    __abstraction: import("@webiny/di").Abstraction<import("@webiny/api-core/features/eventPublisher").IEventHandler<import("@webiny/api-workflows/features/workflowState/UpdateWorkflowState/events.js").WorkflowStateAfterUpdateEvent>>;
+};
+export {};

package/features/EntryWorkflows/handlers/UpdateEntryOnWorkflowStateAfterUpdate.js

@@ -0,0 +1,36 @@
+import { GetModelUseCase } from "@webiny/api-headless-cms/features/contentModel/GetModel/index.js";
+import { UpdateEntryUseCase } from "@webiny/api-headless-cms/features/contentEntry/UpdateEntry/index.js";
+import { WorkflowStateAfterUpdateHandler } from "@webiny/api-workflows/features/workflowState/UpdateWorkflowState/events.js";
+import { getModelIdFromAppName } from "../../../utils/appName.js";
+import { getStateValues } from "../../../utils/state.js";
+class UpdateEntryOnWorkflowStateAfterUpdateImpl {
+    constructor(getModel, updateEntry){
+        this.getModel = getModel;
+        this.updateEntry = updateEntry;
+    }
+    async handle(event) {
+        const { state } = event.payload;
+        const modelId = getModelIdFromAppName(state.app);
+        if (!modelId) return;
+        const modelResult = await this.getModel.execute(modelId);
+        if (modelResult.isFail()) return;
+        const model = modelResult.value;
+        await this.updateEntry.execute(model, state.targetRevisionId, {
+            system: {
+                workflow: state.isActive ? getStateValues(state) : null
+            }
+        }, {
+            skipValidation: true
+        });
+    }
+}
+const UpdateEntryOnWorkflowStateAfterUpdate = WorkflowStateAfterUpdateHandler.createImplementation({
+    implementation: UpdateEntryOnWorkflowStateAfterUpdateImpl,
+    dependencies: [
+        GetModelUseCase,
+        UpdateEntryUseCase
+    ]
+});
+export { UpdateEntryOnWorkflowStateAfterUpdate };
+
+//# sourceMappingURL=UpdateEntryOnWorkflowStateAfterUpdate.js.map

package/features/EntryWorkflows/handlers/UpdateEntryOnWorkflowStateAfterUpdate.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"features/EntryWorkflows/handlers/UpdateEntryOnWorkflowStateAfterUpdate.js","sources":["../../../../src/features/EntryWorkflows/handlers/UpdateEntryOnWorkflowStateAfterUpdate.ts"],"sourcesContent":["import { GetModelUseCase } from \"@webiny/api-headless-cms/features/contentModel/GetModel/index.js\";\nimport { UpdateEntryUseCase } from \"@webiny/api-headless-cms/features/contentEntry/UpdateEntry/index.js\";\nimport { WorkflowStateAfterUpdateHandler } from \"@webiny/api-workflows/features/workflowState/UpdateWorkflowState/events.js\";\nimport { getModelIdFromAppName } from \"~/utils/appName.js\";\nimport { getStateValues } from \"~/utils/state.js\";\n\nclass UpdateEntryOnWorkflowStateAfterUpdateImpl\n    implements WorkflowStateAfterUpdateHandler.Interface\n{\n    constructor(\n        private getModel: GetModelUseCase.Interface,\n        private updateEntry: UpdateEntryUseCase.Interface\n    ) {}\n\n    async handle(event: WorkflowStateAfterUpdateHandler.Event): Promise<void> {\n        const { state } = event.payload;\n\n        const modelId = getModelIdFromAppName(state.app);\n        if (!modelId) {\n            return;\n        }\n\n        const modelResult = await this.getModel.execute(modelId);\n        if (modelResult.isFail()) {\n            return;\n        }\n\n        const model = modelResult.value;\n        await this.updateEntry.execute(\n            model,\n            state.targetRevisionId,\n            { system: { workflow: state.isActive ? getStateValues(state) : null } },\n            { skipValidation: true }\n        );\n    }\n}\n\nexport const UpdateEntryOnWorkflowStateAfterUpdate =\n    WorkflowStateAfterUpdateHandler.createImplementation({\n        implementation: UpdateEntryOnWorkflowStateAfterUpdateImpl,\n        dependencies: [GetModelUseCase, UpdateEntryUseCase]\n    });\n"],"names":["UpdateEntryOnWorkflowStateAfterUpdateImpl","getModel","updateEntry","event","state","modelId","getModelIdFromAppName","modelResult","model","getStateValues","UpdateEntryOnWorkflowStateAfterUpdate","WorkflowStateAfterUpdateHandler","GetModelUseCase","UpdateEntryUseCase"],"mappings":";;;;;AAMA,MAAMA;IAGF,YACYC,QAAmC,EACnCC,WAAyC,CACnD;aAFUD,QAAQ,GAARA;aACAC,WAAW,GAAXA;IACT;IAEH,MAAM,OAAOC,KAA4C,EAAiB;QACtE,MAAM,EAAEC,KAAK,EAAE,GAAGD,MAAM,OAAO;QAE/B,MAAME,UAAUC,sBAAsBF,MAAM,GAAG;QAC/C,IAAI,CAACC,SACD;QAGJ,MAAME,cAAc,MAAM,IAAI,CAAC,QAAQ,CAAC,OAAO,CAACF;QAChD,IAAIE,YAAY,MAAM,IAClB;QAGJ,MAAMC,QAAQD,YAAY,KAAK;QAC/B,MAAM,IAAI,CAAC,WAAW,CAAC,OAAO,CAC1BC,OACAJ,MAAM,gBAAgB,EACtB;YAAE,QAAQ;gBAAE,UAAUA,MAAM,QAAQ,GAAGK,eAAeL,SAAS;YAAK;QAAE,GACtE;YAAE,gBAAgB;QAAK;IAE/B;AACJ;AAEO,MAAMM,wCACTC,gCAAgC,oBAAoB,CAAC;IACjD,gBAAgBX;IAChB,cAAc;QAACY;QAAiBC;KAAmB;AACvD"}

package/features/EntryWorkflows/handlers/ValidateWorkflowStateOnEntryBeforePublish.d.ts

@@ -0,0 +1,11 @@
+import { EntryBeforePublishEventHandler } from "@webiny/api-headless-cms/features/contentEntry/PublishEntry/events.js";
+import { GetTargetWorkflowStateUseCase } from "@webiny/api-workflows/features/workflowState/GetTargetWorkflowState/index.js";
+declare class ValidateWorkflowStateOnEntryBeforePublishImpl implements EntryBeforePublishEventHandler.Interface {
+    private getTargetState;
+    constructor(getTargetState: GetTargetWorkflowStateUseCase.Interface);
+    handle(event: EntryBeforePublishEventHandler.Event): Promise<void>;
+}
+export declare const ValidateWorkflowStateOnEntryBeforePublish: typeof ValidateWorkflowStateOnEntryBeforePublishImpl & {
+    __abstraction: import("@webiny/di").Abstraction<import("@webiny/api-core/features/eventPublisher").IEventHandler<import("@webiny/api-headless-cms/features/contentEntry/PublishEntry/events.js").EntryBeforePublishEvent>>;
+};
+export {};

package/features/EntryWorkflows/handlers/ValidateWorkflowStateOnEntryBeforePublish.js

@@ -0,0 +1,46 @@
+import { WebinyError } from "@webiny/error";
+import { EntryBeforePublishEventHandler } from "@webiny/api-headless-cms/features/contentEntry/PublishEntry/events.js";
+import { createWorkflowAppName } from "../../../utils/appName.js";
+import { isModelAllowed } from "../../../utils/modelAllowed.js";
+import { GetTargetWorkflowStateUseCase } from "@webiny/api-workflows/features/workflowState/GetTargetWorkflowState/index.js";
+class ValidateWorkflowStateOnEntryBeforePublishImpl {
+    constructor(getTargetState){
+        this.getTargetState = getTargetState;
+    }
+    async handle(event) {
+        const { model, entry } = event.payload;
+        if (!isModelAllowed(model)) return;
+        const app = createWorkflowAppName({
+            model
+        });
+        const stateResult = await this.getTargetState.execute({
+            app,
+            targetRevisionId: entry.id
+        });
+        if (stateResult.isFail()) return;
+        const state = stateResult.value;
+        if (state?.done) {
+            entry.system = {
+                ...entry.system,
+                workflow: null
+            };
+            return;
+        }
+        throw new WebinyError("Cannot publish entry because its workflow state is not completed.", "WORKFLOW_STATE_NOT_COMPLETED", {
+            app,
+            entryId: entry.id,
+            state: {
+                ...state
+            }
+        });
+    }
+}
+const ValidateWorkflowStateOnEntryBeforePublish = EntryBeforePublishEventHandler.createImplementation({
+    implementation: ValidateWorkflowStateOnEntryBeforePublishImpl,
+    dependencies: [
+        GetTargetWorkflowStateUseCase
+    ]
+});
+export { ValidateWorkflowStateOnEntryBeforePublish };
+
+//# sourceMappingURL=ValidateWorkflowStateOnEntryBeforePublish.js.map

package/features/EntryWorkflows/handlers/ValidateWorkflowStateOnEntryBeforePublish.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"features/EntryWorkflows/handlers/ValidateWorkflowStateOnEntryBeforePublish.js","sources":["../../../../src/features/EntryWorkflows/handlers/ValidateWorkflowStateOnEntryBeforePublish.ts"],"sourcesContent":["import { WebinyError } from \"@webiny/error\";\nimport { EntryBeforePublishEventHandler } from \"@webiny/api-headless-cms/features/contentEntry/PublishEntry/events.js\";\nimport { createWorkflowAppName } from \"~/utils/appName.js\";\nimport { isModelAllowed } from \"~/utils/modelAllowed.js\";\nimport { GetTargetWorkflowStateUseCase } from \"@webiny/api-workflows/features/workflowState/GetTargetWorkflowState/index.js\";\n\nclass ValidateWorkflowStateOnEntryBeforePublishImpl\n    implements EntryBeforePublishEventHandler.Interface\n{\n    constructor(private getTargetState: GetTargetWorkflowStateUseCase.Interface) {}\n\n    async handle(event: EntryBeforePublishEventHandler.Event): Promise<void> {\n        const { model, entry } = event.payload;\n\n        if (!isModelAllowed(model)) {\n            return;\n        }\n\n        const app = createWorkflowAppName({ model });\n\n        const stateResult = await this.getTargetState.execute({ app, targetRevisionId: entry.id });\n\n        if (stateResult.isFail()) {\n            // If there's no state to deal with, exit early.\n            return;\n        }\n\n        const state = stateResult.value;\n\n        if (state?.done) {\n            entry.system = {\n                ...entry.system,\n                workflow: null\n            };\n            return;\n        }\n\n        throw new WebinyError(\n            \"Cannot publish entry because its workflow state is not completed.\",\n            \"WORKFLOW_STATE_NOT_COMPLETED\",\n            {\n                app,\n                entryId: entry.id,\n                state: {\n                    ...state\n                }\n            }\n        );\n    }\n}\n\nexport const ValidateWorkflowStateOnEntryBeforePublish =\n    EntryBeforePublishEventHandler.createImplementation({\n        implementation: ValidateWorkflowStateOnEntryBeforePublishImpl,\n        dependencies: [GetTargetWorkflowStateUseCase]\n    });\n"],"names":["ValidateWorkflowStateOnEntryBeforePublishImpl","getTargetState","event","model","entry","isModelAllowed","app","createWorkflowAppName","stateResult","state","WebinyError","ValidateWorkflowStateOnEntryBeforePublish","EntryBeforePublishEventHandler","GetTargetWorkflowStateUseCase"],"mappings":";;;;;AAMA,MAAMA;IAGF,YAAoBC,cAAuD,CAAE;aAAzDA,cAAc,GAAdA;IAA0D;IAE9E,MAAM,OAAOC,KAA2C,EAAiB;QACrE,MAAM,EAAEC,KAAK,EAAEC,KAAK,EAAE,GAAGF,MAAM,OAAO;QAEtC,IAAI,CAACG,eAAeF,QAChB;QAGJ,MAAMG,MAAMC,sBAAsB;YAAEJ;QAAM;QAE1C,MAAMK,cAAc,MAAM,IAAI,CAAC,cAAc,CAAC,OAAO,CAAC;YAAEF;YAAK,kBAAkBF,MAAM,EAAE;QAAC;QAExF,IAAII,YAAY,MAAM,IAElB;QAGJ,MAAMC,QAAQD,YAAY,KAAK;QAE/B,IAAIC,OAAO,MAAM;YACbL,MAAM,MAAM,GAAG;gBACX,GAAGA,MAAM,MAAM;gBACf,UAAU;YACd;YACA;QACJ;QAEA,MAAM,IAAIM,YACN,qEACA,gCACA;YACIJ;YACA,SAASF,MAAM,EAAE;YACjB,OAAO;gBACH,GAAGK,KAAK;YACZ;QACJ;IAER;AACJ;AAEO,MAAME,4CACTC,+BAA+B,oBAAoB,CAAC;IAChD,gBAAgBZ;IAChB,cAAc;QAACa;KAA8B;AACjD"}

package/features/EntryWorkflows/index.d.ts

@@ -0,0 +1 @@
+export { EntryWorkflowsFeature } from "./feature.js";

package/features/EntryWorkflows/index.js

@@ -0,0 +1 @@
+export { EntryWorkflowsFeature } from "./feature.js";

package/features/Workflows/feature.d.ts

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

package/features/Workflows/feature.js

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

package/features/Workflows/feature.js.map

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

package/features/Workflows/handlers/DisallowUnpublishableModelsOnBeforeCreate.d.ts

@@ -0,0 +1,11 @@
+import { WorkflowBeforeCreateHandler } from "@webiny/api-workflows/features/workflow/CreateWorkflow/events.js";
+import { GetModelUseCase } from "@webiny/api-headless-cms/features/contentModel/GetModel/index.js";
+declare class DisallowUnpublishableModelsOnBeforeCreateImpl implements WorkflowBeforeCreateHandler.Interface {
+    private getModelUseCase;
+    constructor(getModelUseCase: GetModelUseCase.Interface);
+    handle(event: WorkflowBeforeCreateHandler.Event): Promise<void>;
+}
+export declare const DisallowUnpublishableModelsOnBeforeCreate: typeof DisallowUnpublishableModelsOnBeforeCreateImpl & {
+    __abstraction: import("@webiny/di").Abstraction<import("@webiny/api-core/features/eventPublisher").IEventHandler<import("@webiny/api-workflows/features/workflow/CreateWorkflow/events.js").WorkflowBeforeCreateEvent>>;
+};
+export {};

package/features/Workflows/handlers/DisallowUnpublishableModelsOnBeforeCreate.js

@@ -0,0 +1,27 @@
+import { WorkflowBeforeCreateHandler } from "@webiny/api-workflows/features/workflow/CreateWorkflow/events.js";
+import { getModelIdFromAppName } from "../../../utils/appName.js";
+import { GetModelUseCase } from "@webiny/api-headless-cms/features/contentModel/GetModel/index.js";
+class DisallowUnpublishableModelsOnBeforeCreateImpl {
+    constructor(getModelUseCase){
+        this.getModelUseCase = getModelUseCase;
+    }
+    async handle(event) {
+        const { workflow } = event.payload;
+        const modelId = getModelIdFromAppName(workflow.app);
+        if (!modelId) return;
+        const model = await this.getModelUseCase.execute(modelId);
+        if (model.isFail()) return;
+        const tags = model.value.tags || [];
+        if (false === tags.includes("$publishing:false")) return;
+        throw new Error(`Cannot create a workflow for the model "${modelId}" because it is marked as unpublishable.`);
+    }
+}
+const DisallowUnpublishableModelsOnBeforeCreate = WorkflowBeforeCreateHandler.createImplementation({
+    implementation: DisallowUnpublishableModelsOnBeforeCreateImpl,
+    dependencies: [
+        GetModelUseCase
+    ]
+});
+export { DisallowUnpublishableModelsOnBeforeCreate };
+
+//# sourceMappingURL=DisallowUnpublishableModelsOnBeforeCreate.js.map

package/features/Workflows/handlers/DisallowUnpublishableModelsOnBeforeCreate.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"features/Workflows/handlers/DisallowUnpublishableModelsOnBeforeCreate.js","sources":["../../../../src/features/Workflows/handlers/DisallowUnpublishableModelsOnBeforeCreate.ts"],"sourcesContent":["import { WorkflowBeforeCreateHandler } from \"@webiny/api-workflows/features/workflow/CreateWorkflow/events.js\";\nimport { getModelIdFromAppName } from \"~/utils/appName.js\";\nimport { GetModelUseCase } from \"@webiny/api-headless-cms/features/contentModel/GetModel/index.js\";\n\nclass DisallowUnpublishableModelsOnBeforeCreateImpl\n    implements WorkflowBeforeCreateHandler.Interface\n{\n    public constructor(private getModelUseCase: GetModelUseCase.Interface) {}\n\n    public async handle(event: WorkflowBeforeCreateHandler.Event): Promise<void> {\n        const { workflow } = event.payload;\n        const modelId = getModelIdFromAppName(workflow.app);\n        if (!modelId) {\n            return;\n        }\n        const model = await this.getModelUseCase.execute(modelId);\n        if (model.isFail()) {\n            return;\n        }\n        const tags = model.value.tags || [];\n        if (tags.includes(\"$publishing:false\") === false) {\n            return;\n        }\n        throw new Error(\n            `Cannot create a workflow for the model \"${modelId}\" because it is marked as unpublishable.`\n        );\n    }\n}\n\nexport const DisallowUnpublishableModelsOnBeforeCreate =\n    WorkflowBeforeCreateHandler.createImplementation({\n        implementation: DisallowUnpublishableModelsOnBeforeCreateImpl,\n        dependencies: [GetModelUseCase]\n    });\n"],"names":["DisallowUnpublishableModelsOnBeforeCreateImpl","getModelUseCase","event","workflow","modelId","getModelIdFromAppName","model","tags","Error","DisallowUnpublishableModelsOnBeforeCreate","WorkflowBeforeCreateHandler","GetModelUseCase"],"mappings":";;;AAIA,MAAMA;IAGF,YAA2BC,eAA0C,CAAE;aAA5CA,eAAe,GAAfA;IAA6C;IAExE,MAAa,OAAOC,KAAwC,EAAiB;QACzE,MAAM,EAAEC,QAAQ,EAAE,GAAGD,MAAM,OAAO;QAClC,MAAME,UAAUC,sBAAsBF,SAAS,GAAG;QAClD,IAAI,CAACC,SACD;QAEJ,MAAME,QAAQ,MAAM,IAAI,CAAC,eAAe,CAAC,OAAO,CAACF;QACjD,IAAIE,MAAM,MAAM,IACZ;QAEJ,MAAMC,OAAOD,MAAM,KAAK,CAAC,IAAI,IAAI,EAAE;QACnC,IAAIC,AAAuC,UAAvCA,KAAK,QAAQ,CAAC,sBACd;QAEJ,MAAM,IAAIC,MACN,CAAC,wCAAwC,EAAEJ,QAAQ,wCAAwC,CAAC;IAEpG;AACJ;AAEO,MAAMK,4CACTC,4BAA4B,oBAAoB,CAAC;IAC7C,gBAAgBV;IAChB,cAAc;QAACW;KAAgB;AACnC"}

package/features/Workflows/index.d.ts

@@ -0,0 +1 @@
+export { WorkflowsFeature } from "./feature.js";

package/features/Workflows/index.js

@@ -0,0 +1 @@
+export { WorkflowsFeature } from "./feature.js";

package/graphql/entrySystemSchema.d.ts

@@ -0,0 +1,2 @@
+import { CmsGraphQLSchemaPlugin } from "@webiny/api-headless-cms/plugins/index.js";
+export declare const createEntrySystemSchemaExtension: () => CmsGraphQLSchemaPlugin<import("@webiny/api/types").Context>;

package/graphql/entrySystemSchema.js

@@ -0,0 +1,18 @@
+import { CmsGraphQLSchemaPlugin } from "@webiny/api-headless-cms/plugins/index.js";
+const createEntrySystemSchemaExtension = ()=>new CmsGraphQLSchemaPlugin({
+        typeDefs: `
+            type CmsEntrySystemWorkflow {
+                workflowId: String
+                stepId: ID
+                stepName: String
+                state: String
+            }
+
+            extend type CmsEntrySystem {
+                workflow: CmsEntrySystemWorkflow
+            }
+        `
+    });
+export { createEntrySystemSchemaExtension };
+
+//# sourceMappingURL=entrySystemSchema.js.map

package/graphql/entrySystemSchema.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"graphql/entrySystemSchema.js","sources":["../../src/graphql/entrySystemSchema.ts"],"sourcesContent":["import { CmsGraphQLSchemaPlugin } from \"@webiny/api-headless-cms/plugins/index.js\";\n\nexport const createEntrySystemSchemaExtension = () => {\n    return new CmsGraphQLSchemaPlugin({\n        typeDefs: /* GraphQL */ `\n            type CmsEntrySystemWorkflow {\n                workflowId: String\n                stepId: ID\n                stepName: String\n                state: String\n            }\n\n            extend type CmsEntrySystem {\n                workflow: CmsEntrySystemWorkflow\n            }\n        `\n    });\n};\n"],"names":["createEntrySystemSchemaExtension","CmsGraphQLSchemaPlugin"],"mappings":";AAEO,MAAMA,mCAAmC,IACrC,IAAIC,uBAAuB;QAC9B,UAAwB,CAAC;;;;;;;;;;;QAWzB,CAAC;IACL"}

package/index.d.ts

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

package/index.js

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

package/package.json

@@ -0,0 +1,47 @@
+{
+	"name": "@webiny/api-headless-cms-workflows",
+	"version": "0.0.0-unstable.0d717d18dd",
+	"type": "module",
+	"exports": {
+		".": "./index.js",
+		"./*": "./*"
+	},
+	"description": "Headless CMS Workflows",
+	"keywords": [
+		"api-headless-cms-workflows:base"
+	],
+	"repository": {
+		"type": "git",
+		"url": "https://github.com/webiny/webiny-js.git",
+		"directory": "packages/api-headless-cms-workflows"
+	},
+	"license": "MIT",
+	"dependencies": {
+		"@webiny/api": "0.0.0-unstable.0d717d18dd",
+		"@webiny/api-aco": "0.0.0-unstable.0d717d18dd",
+		"@webiny/api-core": "0.0.0-unstable.0d717d18dd",
+		"@webiny/api-headless-cms": "0.0.0-unstable.0d717d18dd",
+		"@webiny/api-workflows": "0.0.0-unstable.0d717d18dd",
+		"@webiny/error": "0.0.0-unstable.0d717d18dd",
+		"@webiny/feature": "0.0.0-unstable.0d717d18dd",
+		"@webiny/shared-aco": "0.0.0-unstable.0d717d18dd"
+	},
+	"devDependencies": {
+		"@webiny/api-core-testing": "0.0.0-unstable.0d717d18dd",
+		"@webiny/api-headless-cms-testing": "0.0.0-unstable.0d717d18dd",
+		"@webiny/api-opensearch": "0.0.0-unstable.0d717d18dd",
+		"@webiny/build-tools": "0.0.0-unstable.0d717d18dd",
+		"@webiny/handler": "0.0.0-unstable.0d717d18dd",
+		"@webiny/plugins": "0.0.0-unstable.0d717d18dd",
+		"@webiny/project-utils": "0.0.0-unstable.0d717d18dd",
+		"@webiny/wcp": "0.0.0-unstable.0d717d18dd",
+		"typescript": "7.0.2",
+		"vitest": "4.1.10"
+	},
+	"publishConfig": {
+		"access": "public"
+	},
+	"webiny": {
+		"publishFrom": "dist"
+	}
+}

package/utils/appName.d.ts

@@ -0,0 +1,7 @@
+import type { CmsModel } from "@webiny/api-headless-cms/types/index.js";
+interface IParams {
+    model: Pick<CmsModel, "modelId">;
+}
+export declare const createWorkflowAppName: ({ model }: IParams) => string;
+export declare const getModelIdFromAppName: (app: string) => string | null;
+export {};

package/utils/appName.js

@@ -0,0 +1,9 @@
+const createWorkflowAppName = ({ model })=>`cms.${model.modelId}`;
+const getModelIdFromAppName = (app)=>{
+    const matched = app.match(/^cms\.([a-zA-Z0-9_-]+)$/);
+    if (!matched) return null;
+    return matched ? matched[1] : null;
+};
+export { createWorkflowAppName, getModelIdFromAppName };
+
+//# sourceMappingURL=appName.js.map

package/utils/appName.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"utils/appName.js","sources":["../../src/utils/appName.ts"],"sourcesContent":["import type { CmsModel } from \"@webiny/api-headless-cms/types/index.js\";\n\ninterface IParams {\n    model: Pick<CmsModel, \"modelId\">;\n}\nexport const createWorkflowAppName = ({ model }: IParams): string => {\n    return `cms.${model.modelId}`;\n};\n\nexport const getModelIdFromAppName = (app: string): string | null => {\n    const matched = app.match(/^cms\\.([a-zA-Z0-9_-]+)$/);\n    if (!matched) {\n        return null;\n    }\n    return matched ? matched[1] : null;\n};\n"],"names":["createWorkflowAppName","model","getModelIdFromAppName","app","matched"],"mappings":"AAKO,MAAMA,wBAAwB,CAAC,EAAEC,KAAK,EAAW,GAC7C,CAAC,IAAI,EAAEA,MAAM,OAAO,EAAE;AAG1B,MAAMC,wBAAwB,CAACC;IAClC,MAAMC,UAAUD,IAAI,KAAK,CAAC;IAC1B,IAAI,CAACC,SACD,OAAO;IAEX,OAAOA,UAAUA,OAAO,CAAC,EAAE,GAAG;AAClC"}

package/utils/modelAllowed.d.ts

@@ -0,0 +1,2 @@
+import type { CmsModel } from "@webiny/api-headless-cms/types/index.js";
+export declare const isModelAllowed: (model: Pick<CmsModel, "isPrivate" | "tags">) => boolean;

package/utils/modelAllowed.js

@@ -0,0 +1,9 @@
+import { CMS_MODEL_SINGLETON_TAG } from "@webiny/api-headless-cms/constants.js";
+const isModelAllowed = (model)=>{
+    if (model.isPrivate) return false;
+    if (model.tags?.includes(CMS_MODEL_SINGLETON_TAG)) return false;
+    return true;
+};
+export { isModelAllowed };
+
+//# sourceMappingURL=modelAllowed.js.map

package/utils/modelAllowed.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"utils/modelAllowed.js","sources":["../../src/utils/modelAllowed.ts"],"sourcesContent":["import type { CmsModel } from \"@webiny/api-headless-cms/types/index.js\";\nimport { CMS_MODEL_SINGLETON_TAG } from \"@webiny/api-headless-cms/constants.js\";\n\nexport const isModelAllowed = (model: Pick<CmsModel, \"isPrivate\" | \"tags\">): boolean => {\n    if (model.isPrivate) {\n        return false;\n    }\n    // TODO remove when we allow singleton models to have workflows.\n    else if (model.tags?.includes(CMS_MODEL_SINGLETON_TAG)) {\n        return false;\n    }\n    return true;\n};\n"],"names":["isModelAllowed","model","CMS_MODEL_SINGLETON_TAG"],"mappings":";AAGO,MAAMA,iBAAiB,CAACC;IAC3B,IAAIA,MAAM,SAAS,EACf,OAAO;IAGN,IAAIA,MAAM,IAAI,EAAE,SAASC,0BAC1B,OAAO;IAEX,OAAO;AACX"}

package/utils/state.d.ts

@@ -0,0 +1,3 @@
+import type { ICmsEntryWorkflowState } from "@webiny/api-workflows/types.js";
+import type { WorkflowState } from "@webiny/api-workflows/domain/workflowState/WorkflowState.js";
+export declare const getStateValues: (state: WorkflowState) => ICmsEntryWorkflowState;

package/utils/state.js

@@ -0,0 +1,12 @@
+const getStateValues = (state)=>{
+    const activeStep = state.currentStep;
+    return {
+        workflowId: state.workflowId,
+        stepId: activeStep.id,
+        stepName: activeStep.title,
+        state: activeStep.state
+    };
+};
+export { getStateValues };
+
+//# sourceMappingURL=state.js.map

package/utils/state.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"utils/state.js","sources":["../../src/utils/state.ts"],"sourcesContent":["import type { ICmsEntryWorkflowState } from \"@webiny/api-workflows/types.js\";\nimport type { WorkflowState } from \"@webiny/api-workflows/domain/workflowState/WorkflowState.js\";\n\nexport const getStateValues = (state: WorkflowState): ICmsEntryWorkflowState => {\n    const activeStep = state.currentStep;\n\n    return {\n        workflowId: state.workflowId,\n        stepId: activeStep.id,\n        stepName: activeStep.title,\n        state: activeStep.state\n    };\n};\n"],"names":["getStateValues","state","activeStep"],"mappings":"AAGO,MAAMA,iBAAiB,CAACC;IAC3B,MAAMC,aAAaD,MAAM,WAAW;IAEpC,OAAO;QACH,YAAYA,MAAM,UAAU;QAC5B,QAAQC,WAAW,EAAE;QACrB,UAAUA,WAAW,KAAK;QAC1B,OAAOA,WAAW,KAAK;IAC3B;AACJ"}