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

package/features/workflow/ListWorkflows/index.js

@@ -0,0 +1 @@
+export * from "./abstractions.js";

package/features/workflow/StoreWorkflow/StoreWorkflowUseCase.d.ts

@@ -0,0 +1,15 @@
+import { GetWorkflowUseCase } from "../GetWorkflow/index.js";
+import { CreateWorkflowUseCase } from "../CreateWorkflow/index.js";
+import { UpdateWorkflowUseCase } from "../UpdateWorkflow/index.js";
+import { StoreWorkflowUseCase as UseCase } from "./abstractions.js";
+declare class StoreWorkflowUseCaseImpl implements UseCase.Interface {
+    private getWorkflow;
+    private createWorkflow;
+    private updateWorkflow;
+    constructor(getWorkflow: GetWorkflowUseCase.Interface, createWorkflow: CreateWorkflowUseCase.Interface, updateWorkflow: UpdateWorkflowUseCase.Interface);
+    execute(input: UseCase.Input): UseCase.Return;
+}
+export declare const StoreWorkflowUseCase: typeof StoreWorkflowUseCaseImpl & {
+    __abstraction: import("@webiny/di").Abstraction<import("./abstractions.js").IStoreWorkflowUseCase>;
+};
+export {};

package/features/workflow/StoreWorkflow/StoreWorkflowUseCase.js

@@ -0,0 +1,35 @@
+import { Result } from "@webiny/feature/api";
+import { GetWorkflowUseCase } from "../GetWorkflow/index.js";
+import { CreateWorkflowUseCase } from "../CreateWorkflow/index.js";
+import { UpdateWorkflowUseCase } from "../UpdateWorkflow/index.js";
+import { StoreWorkflowUseCase } from "./abstractions.js";
+class StoreWorkflowUseCaseImpl {
+    constructor(getWorkflow, createWorkflow, updateWorkflow){
+        this.getWorkflow = getWorkflow;
+        this.createWorkflow = createWorkflow;
+        this.updateWorkflow = updateWorkflow;
+    }
+    async execute(input) {
+        const existingResult = await this.getWorkflow.execute({
+            app: input.app,
+            id: input.id
+        });
+        if (existingResult.isFail()) {
+            if ("Workflows/Workflow/NotFound" !== existingResult.error.code) return Result.fail(existingResult.error);
+        }
+        const existing = existingResult.isOk() ? existingResult.value : null;
+        if (!existing) return this.createWorkflow.execute(input);
+        return this.updateWorkflow.execute(input, existing);
+    }
+}
+const StoreWorkflowUseCase_StoreWorkflowUseCase = StoreWorkflowUseCase.createImplementation({
+    implementation: StoreWorkflowUseCaseImpl,
+    dependencies: [
+        GetWorkflowUseCase,
+        CreateWorkflowUseCase,
+        UpdateWorkflowUseCase
+    ]
+});
+export { StoreWorkflowUseCase_StoreWorkflowUseCase as StoreWorkflowUseCase };
+
+//# sourceMappingURL=StoreWorkflowUseCase.js.map

package/features/workflow/StoreWorkflow/StoreWorkflowUseCase.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"features/workflow/StoreWorkflow/StoreWorkflowUseCase.js","sources":["../../../../src/features/workflow/StoreWorkflow/StoreWorkflowUseCase.ts"],"sourcesContent":["import { Result } from \"@webiny/feature/api\";\nimport { GetWorkflowUseCase } from \"../GetWorkflow/index.js\";\nimport { CreateWorkflowUseCase } from \"../CreateWorkflow/index.js\";\nimport { UpdateWorkflowUseCase } from \"../UpdateWorkflow/index.js\";\nimport { StoreWorkflowUseCase as UseCase } from \"./abstractions.js\";\n\nclass StoreWorkflowUseCaseImpl implements UseCase.Interface {\n    constructor(\n        private getWorkflow: GetWorkflowUseCase.Interface,\n        private createWorkflow: CreateWorkflowUseCase.Interface,\n        private updateWorkflow: UpdateWorkflowUseCase.Interface\n    ) {}\n\n    async execute(input: UseCase.Input): UseCase.Return {\n        const existingResult = await this.getWorkflow.execute({\n            app: input.app,\n            id: input.id\n        });\n\n        // If getWorkflow fails with anything other than NotFound, propagate error\n        if (existingResult.isFail()) {\n            if (existingResult.error.code !== \"Workflows/Workflow/NotFound\") {\n                return Result.fail(existingResult.error);\n            }\n        }\n\n        const existing = existingResult.isOk() ? existingResult.value : null;\n\n        if (!existing) {\n            return this.createWorkflow.execute(input);\n        } else {\n            return this.updateWorkflow.execute(input, existing);\n        }\n    }\n}\n\nexport const StoreWorkflowUseCase = UseCase.createImplementation({\n    implementation: StoreWorkflowUseCaseImpl,\n    dependencies: [GetWorkflowUseCase, CreateWorkflowUseCase, UpdateWorkflowUseCase]\n});\n"],"names":["StoreWorkflowUseCaseImpl","getWorkflow","createWorkflow","updateWorkflow","input","existingResult","Result","existing","StoreWorkflowUseCase","UseCase","GetWorkflowUseCase","CreateWorkflowUseCase","UpdateWorkflowUseCase"],"mappings":";;;;;AAMA,MAAMA;IACF,YACYC,WAAyC,EACzCC,cAA+C,EAC/CC,cAA+C,CACzD;aAHUF,WAAW,GAAXA;aACAC,cAAc,GAAdA;aACAC,cAAc,GAAdA;IACT;IAEH,MAAM,QAAQC,KAAoB,EAAkB;QAChD,MAAMC,iBAAiB,MAAM,IAAI,CAAC,WAAW,CAAC,OAAO,CAAC;YAClD,KAAKD,MAAM,GAAG;YACd,IAAIA,MAAM,EAAE;QAChB;QAGA,IAAIC,eAAe,MAAM,IACrB;YAAA,IAAIA,AAA8B,kCAA9BA,eAAe,KAAK,CAAC,IAAI,EACzB,OAAOC,OAAO,IAAI,CAACD,eAAe,KAAK;QAC3C;QAGJ,MAAME,WAAWF,eAAe,IAAI,KAAKA,eAAe,KAAK,GAAG;QAEhE,IAAI,CAACE,UACD,OAAO,IAAI,CAAC,cAAc,CAAC,OAAO,CAACH;QAEnC,OAAO,IAAI,CAAC,cAAc,CAAC,OAAO,CAACA,OAAOG;IAElD;AACJ;AAEO,MAAMC,4CAAuBC,qBAAAA,oBAA4B,CAAC;IAC7D,gBAAgBT;IAChB,cAAc;QAACU;QAAoBC;QAAuBC;KAAsB;AACpF"}

package/features/workflow/StoreWorkflow/abstractions.d.ts

@@ -0,0 +1,32 @@
+import type { Result } from "@webiny/feature/api";
+import type { IWorkflow } from "../../../domain/workflow/abstractions.js";
+import type { NonEmptyArray } from "@webiny/api/types.js";
+import { type WorkflowNotFoundError, type WorkflowNotAuthorizedError, type WorkflowPersistenceError, type WorkflowValidationError } from "../../../domain/workflow/errors.js";
+import type { IWorkflowStepInput } from "../../../features/shared/abstractions.js";
+export interface IStoreWorkflowInput {
+    app: string;
+    id: string;
+    name: string;
+    steps: NonEmptyArray<IWorkflowStepInput>;
+}
+/**
+ * StoreWorkflow use case interface - delegates to CreateWorkflow or UpdateWorkflow
+ */
+export interface IStoreWorkflowUseCase {
+    execute(input: IStoreWorkflowInput): Promise<Result<IWorkflow, UseCaseError>>;
+}
+export interface IStoreWorkflowUseCaseErrors {
+    notFound: WorkflowNotFoundError;
+    notAuthorized: WorkflowNotAuthorizedError;
+    persistence: WorkflowPersistenceError;
+    validation: WorkflowValidationError;
+}
+type UseCaseError = IStoreWorkflowUseCaseErrors[keyof IStoreWorkflowUseCaseErrors];
+export declare const StoreWorkflowUseCase: import("@webiny/di").Abstraction<IStoreWorkflowUseCase>;
+export declare namespace StoreWorkflowUseCase {
+    type Interface = IStoreWorkflowUseCase;
+    type Input = IStoreWorkflowInput;
+    type Return = Promise<Result<IWorkflow, UseCaseError>>;
+    type Error = UseCaseError;
+}
+export {};

package/features/workflow/StoreWorkflow/abstractions.js

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

package/features/workflow/StoreWorkflow/abstractions.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"features/workflow/StoreWorkflow/abstractions.js","sources":["../../../../src/features/workflow/StoreWorkflow/abstractions.ts"],"sourcesContent":["import { createAbstraction } from \"@webiny/feature/api\";\nimport type { Result } from \"@webiny/feature/api\";\nimport type { IWorkflow } from \"~/domain/workflow/abstractions.js\";\nimport type { NonEmptyArray } from \"@webiny/api/types.js\";\nimport {\n    type WorkflowNotFoundError,\n    type WorkflowNotAuthorizedError,\n    type WorkflowPersistenceError,\n    type WorkflowValidationError\n} from \"~/domain/workflow/errors.js\";\nimport type { IWorkflowStepInput } from \"~/features/shared/abstractions.js\";\n\n// Input types (from context/abstractions/WorkflowsContext.ts)\nexport interface IStoreWorkflowInput {\n    app: string;\n    id: string;\n    name: string;\n    steps: NonEmptyArray<IWorkflowStepInput>;\n}\n\n/**\n * StoreWorkflow use case interface - delegates to CreateWorkflow or UpdateWorkflow\n */\nexport interface IStoreWorkflowUseCase {\n    execute(input: IStoreWorkflowInput): Promise<Result<IWorkflow, UseCaseError>>;\n}\n\nexport interface IStoreWorkflowUseCaseErrors {\n    notFound: WorkflowNotFoundError;\n    notAuthorized: WorkflowNotAuthorizedError;\n    persistence: WorkflowPersistenceError;\n    validation: WorkflowValidationError;\n}\n\ntype UseCaseError = IStoreWorkflowUseCaseErrors[keyof IStoreWorkflowUseCaseErrors];\n\nexport const StoreWorkflowUseCase =\n    createAbstraction<IStoreWorkflowUseCase>(\"StoreWorkflowUseCase\");\n\nexport namespace StoreWorkflowUseCase {\n    export type Interface = IStoreWorkflowUseCase;\n    export type Input = IStoreWorkflowInput;\n    export type Return = Promise<Result<IWorkflow, UseCaseError>>;\n    export type Error = UseCaseError;\n}\n"],"names":["StoreWorkflowUseCase","createAbstraction"],"mappings":";AAoCO,MAAMA,uBACTC,kBAAyC"}

package/features/workflow/StoreWorkflow/feature.d.ts

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

package/features/workflow/StoreWorkflow/feature.js

@@ -0,0 +1,15 @@
+import { createFeature } from "@webiny/feature/api";
+import { StoreWorkflowUseCase } from "./StoreWorkflowUseCase.js";
+import { CreateWorkflowFeature } from "../CreateWorkflow/index.js";
+import { UpdateWorkflowFeature } from "../UpdateWorkflow/index.js";
+const StoreWorkflowFeature = createFeature({
+    name: "Workflows/StoreWorkflow",
+    register (container) {
+        CreateWorkflowFeature.register(container);
+        UpdateWorkflowFeature.register(container);
+        container.register(StoreWorkflowUseCase);
+    }
+});
+export { StoreWorkflowFeature };
+
+//# sourceMappingURL=feature.js.map

package/features/workflow/StoreWorkflow/feature.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"features/workflow/StoreWorkflow/feature.js","sources":["../../../../src/features/workflow/StoreWorkflow/feature.ts"],"sourcesContent":["import { createFeature } from \"@webiny/feature/api\";\nimport { StoreWorkflowUseCase } from \"./StoreWorkflowUseCase.js\";\nimport { CreateWorkflowFeature } from \"../CreateWorkflow/index.js\";\nimport { UpdateWorkflowFeature } from \"../UpdateWorkflow/index.js\";\n\nexport const StoreWorkflowFeature = createFeature({\n    name: \"Workflows/StoreWorkflow\",\n    register(container) {\n        // Register dependencies\n        CreateWorkflowFeature.register(container);\n        UpdateWorkflowFeature.register(container);\n\n        // Register StoreWorkflow use case\n        container.register(StoreWorkflowUseCase);\n    }\n});\n"],"names":["StoreWorkflowFeature","createFeature","container","CreateWorkflowFeature","UpdateWorkflowFeature","StoreWorkflowUseCase"],"mappings":";;;;AAKO,MAAMA,uBAAuBC,cAAc;IAC9C,MAAM;IACN,UAASC,SAAS;QAEdC,sBAAsB,QAAQ,CAACD;QAC/BE,sBAAsB,QAAQ,CAACF;QAG/BA,UAAU,QAAQ,CAACG;IACvB;AACJ"}

package/features/workflow/StoreWorkflow/index.d.ts

@@ -0,0 +1,3 @@
+export { StoreWorkflowFeature } from "./feature.js";
+export { StoreWorkflowUseCase } from "./abstractions.js";
+export type { IStoreWorkflowInput } from "./abstractions.js";

package/features/workflow/StoreWorkflow/index.js

@@ -0,0 +1,2 @@
+export { StoreWorkflowFeature } from "./feature.js";
+export { StoreWorkflowUseCase } from "./abstractions.js";

package/features/workflow/UpdateWorkflow/UpdateWorkflowRepository.d.ts

@@ -0,0 +1,15 @@
+import { UpdateEntryUseCase } from "@webiny/api-headless-cms/features/contentEntry/UpdateEntry/index.js";
+import { WorkflowMapper, WorkflowModel } from "../../../domain/workflow/abstractions.js";
+import type { IUpdateWorkflowInput } from "./abstractions.js";
+import { UpdateWorkflowRepository as Repository } from "./abstractions.js";
+declare class UpdateWorkflowRepositoryImpl implements Repository.Interface {
+    private updateEntry;
+    private model;
+    private mapper;
+    constructor(updateEntry: UpdateEntryUseCase.Interface, model: WorkflowModel.Interface, mapper: WorkflowMapper.Interface);
+    execute(input: IUpdateWorkflowInput): Repository.Return;
+}
+export declare const UpdateWorkflowRepository: typeof UpdateWorkflowRepositoryImpl & {
+    __abstraction: import("@webiny/di").Abstraction<import("./abstractions.js").IUpdateWorkflowRepository>;
+};
+export {};

package/features/workflow/UpdateWorkflow/UpdateWorkflowRepository.js

@@ -0,0 +1,50 @@
+import { Result } from "@webiny/feature/api";
+import { parseIdentifier } from "@webiny/utils/parseIdentifier.js";
+import { createIdentifier } from "@webiny/utils";
+import { UpdateEntryUseCase } from "@webiny/api-headless-cms/features/contentEntry/UpdateEntry/index.js";
+import { WorkflowMapper, WorkflowModel } from "../../../domain/workflow/abstractions.js";
+import { WorkflowPersistenceError } from "../../../domain/workflow/errors.js";
+import { UpdateWorkflowRepository } from "./abstractions.js";
+class UpdateWorkflowRepositoryImpl {
+    constructor(updateEntry, model, mapper){
+        this.updateEntry = updateEntry;
+        this.model = model;
+        this.mapper = mapper;
+    }
+    async execute(input) {
+        const { id } = parseIdentifier(input.id);
+        const values = this.mapper.toCmsEntry({
+            id,
+            app: input.app,
+            name: input.name,
+            steps: input.steps
+        });
+        const workflowId = createIdentifier({
+            id,
+            version: 1
+        });
+        try {
+            const updateResult = await this.updateEntry.execute(this.model, workflowId, {
+                values
+            });
+            if (updateResult.isFail()) return Result.fail(new WorkflowPersistenceError(updateResult.error));
+            return Result.ok({
+                ...values,
+                id
+            });
+        } catch (error) {
+            return Result.fail(new WorkflowPersistenceError(error));
+        }
+    }
+}
+const UpdateWorkflowRepository_UpdateWorkflowRepository = UpdateWorkflowRepository.createImplementation({
+    implementation: UpdateWorkflowRepositoryImpl,
+    dependencies: [
+        UpdateEntryUseCase,
+        WorkflowModel,
+        WorkflowMapper
+    ]
+});
+export { UpdateWorkflowRepository_UpdateWorkflowRepository as UpdateWorkflowRepository };
+
+//# sourceMappingURL=UpdateWorkflowRepository.js.map

package/features/workflow/UpdateWorkflow/UpdateWorkflowRepository.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"features/workflow/UpdateWorkflow/UpdateWorkflowRepository.js","sources":["../../../../src/features/workflow/UpdateWorkflow/UpdateWorkflowRepository.ts"],"sourcesContent":["import { Result } from \"@webiny/feature/api\";\nimport { parseIdentifier } from \"@webiny/utils/parseIdentifier.js\";\nimport { createIdentifier } from \"@webiny/utils\";\nimport { UpdateEntryUseCase } from \"@webiny/api-headless-cms/features/contentEntry/UpdateEntry/index.js\";\nimport { type IWorkflow, WorkflowMapper, WorkflowModel } from \"~/domain/workflow/abstractions.js\";\nimport { WorkflowPersistenceError } from \"~/domain/workflow/errors.js\";\nimport type { IUpdateWorkflowInput } from \"./abstractions.js\";\nimport { UpdateWorkflowRepository as Repository } from \"./abstractions.js\";\n\nclass UpdateWorkflowRepositoryImpl implements Repository.Interface {\n    constructor(\n        private updateEntry: UpdateEntryUseCase.Interface,\n        private model: WorkflowModel.Interface,\n        private mapper: WorkflowMapper.Interface\n    ) {}\n\n    async execute(input: IUpdateWorkflowInput): Repository.Return {\n        const { id } = parseIdentifier(input.id);\n\n        const values = this.mapper.toCmsEntry({\n            id,\n            app: input.app,\n            name: input.name,\n            steps: input.steps\n        });\n\n        const workflowId = createIdentifier({\n            id,\n            version: 1\n        });\n\n        try {\n            const updateResult = await this.updateEntry.execute<IWorkflow>(this.model, workflowId, {\n                values\n            });\n\n            if (updateResult.isFail()) {\n                return Result.fail(new WorkflowPersistenceError(updateResult.error));\n            }\n\n            return Result.ok({\n                ...values,\n                id\n            });\n        } catch (error) {\n            return Result.fail(new WorkflowPersistenceError(error as Error));\n        }\n    }\n}\n\nexport const UpdateWorkflowRepository = Repository.createImplementation({\n    implementation: UpdateWorkflowRepositoryImpl,\n    dependencies: [UpdateEntryUseCase, WorkflowModel, WorkflowMapper]\n});\n"],"names":["UpdateWorkflowRepositoryImpl","updateEntry","model","mapper","input","id","parseIdentifier","values","workflowId","createIdentifier","updateResult","Result","WorkflowPersistenceError","error","UpdateWorkflowRepository","Repository","UpdateEntryUseCase","WorkflowModel","WorkflowMapper"],"mappings":";;;;;;;AASA,MAAMA;IACF,YACYC,WAAyC,EACzCC,KAA8B,EAC9BC,MAAgC,CAC1C;aAHUF,WAAW,GAAXA;aACAC,KAAK,GAALA;aACAC,MAAM,GAANA;IACT;IAEH,MAAM,QAAQC,KAA2B,EAAqB;QAC1D,MAAM,EAAEC,EAAE,EAAE,GAAGC,gBAAgBF,MAAM,EAAE;QAEvC,MAAMG,SAAS,IAAI,CAAC,MAAM,CAAC,UAAU,CAAC;YAClCF;YACA,KAAKD,MAAM,GAAG;YACd,MAAMA,MAAM,IAAI;YAChB,OAAOA,MAAM,KAAK;QACtB;QAEA,MAAMI,aAAaC,iBAAiB;YAChCJ;YACA,SAAS;QACb;QAEA,IAAI;YACA,MAAMK,eAAe,MAAM,IAAI,CAAC,WAAW,CAAC,OAAO,CAAY,IAAI,CAAC,KAAK,EAAEF,YAAY;gBACnFD;YACJ;YAEA,IAAIG,aAAa,MAAM,IACnB,OAAOC,OAAO,IAAI,CAAC,IAAIC,yBAAyBF,aAAa,KAAK;YAGtE,OAAOC,OAAO,EAAE,CAAC;gBACb,GAAGJ,MAAM;gBACTF;YACJ;QACJ,EAAE,OAAOQ,OAAO;YACZ,OAAOF,OAAO,IAAI,CAAC,IAAIC,yBAAyBC;QACpD;IACJ;AACJ;AAEO,MAAMC,oDAA2BC,yBAAAA,oBAA+B,CAAC;IACpE,gBAAgBf;IAChB,cAAc;QAACgB;QAAoBC;QAAeC;KAAe;AACrE"}

package/features/workflow/UpdateWorkflow/UpdateWorkflowUseCase.d.ts

@@ -0,0 +1,15 @@
+import { IdentityContext } from "@webiny/api-core/features/security/IdentityContext/index.js";
+import { EventPublisher } from "@webiny/api-core/features/eventPublisher/index.js";
+import { UpdateWorkflowRepository, UpdateWorkflowUseCase as UseCase } from "./abstractions.js";
+declare class UpdateWorkflowUseCaseImpl implements UseCase.Interface {
+    private identityContext;
+    private eventPublisher;
+    private repository;
+    constructor(identityContext: IdentityContext.Interface, eventPublisher: EventPublisher.Interface, repository: UpdateWorkflowRepository.Interface);
+    execute(input: UseCase.Input, original: UseCase.Input): UseCase.Return;
+    private ensureManageAccess;
+}
+export declare const UpdateWorkflowUseCase: typeof UpdateWorkflowUseCaseImpl & {
+    __abstraction: import("@webiny/di").Abstraction<import("./abstractions.js").IUpdateWorkflowUseCase>;
+};
+export {};

package/features/workflow/UpdateWorkflow/UpdateWorkflowUseCase.js

@@ -0,0 +1,54 @@
+import { Result } from "@webiny/feature/api";
+import { IdentityContext } from "@webiny/api-core/features/security/IdentityContext/index.js";
+import { EventPublisher } from "@webiny/api-core/features/eventPublisher/index.js";
+import { UpdateWorkflowRepository, UpdateWorkflowUseCase } from "./abstractions.js";
+import { WorkflowAfterUpdateEvent, WorkflowBeforeUpdateEvent } from "./events.js";
+import { WorkflowNotAuthorizedError } from "../../../domain/workflow/errors.js";
+import { WORKFLOWS_PERMISSION } from "../../../constants.js";
+class UpdateWorkflowUseCaseImpl {
+    constructor(identityContext, eventPublisher, repository){
+        this.identityContext = identityContext;
+        this.eventPublisher = eventPublisher;
+        this.repository = repository;
+    }
+    async execute(input, original) {
+        const hasAccess = await this.ensureManageAccess();
+        if (hasAccess.isFail()) return Result.fail(hasAccess.error);
+        const workflow = {
+            id: input.id,
+            app: input.app,
+            name: input.name,
+            steps: input.steps
+        };
+        await this.eventPublisher.publish(new WorkflowBeforeUpdateEvent({
+            workflow,
+            original,
+            input
+        }));
+        const result = await this.repository.execute(input);
+        if (result.isFail()) return result;
+        await this.eventPublisher.publish(new WorkflowAfterUpdateEvent({
+            workflow: result.value,
+            original,
+            input
+        }));
+        return Result.ok(result.value);
+    }
+    async ensureManageAccess() {
+        const permissions = await this.identityContext.getPermissions(WORKFLOWS_PERMISSION);
+        for (const permission of permissions)if ("*" === permission.name) return Result.ok();
+        else if (permission.editor) return Result.ok();
+        return Result.fail(new WorkflowNotAuthorizedError("You cannot manage workflows."));
+    }
+}
+const UpdateWorkflowUseCase_UpdateWorkflowUseCase = UpdateWorkflowUseCase.createImplementation({
+    implementation: UpdateWorkflowUseCaseImpl,
+    dependencies: [
+        IdentityContext,
+        EventPublisher,
+        UpdateWorkflowRepository
+    ]
+});
+export { UpdateWorkflowUseCase_UpdateWorkflowUseCase as UpdateWorkflowUseCase };
+
+//# sourceMappingURL=UpdateWorkflowUseCase.js.map

package/features/workflow/UpdateWorkflow/UpdateWorkflowUseCase.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"features/workflow/UpdateWorkflow/UpdateWorkflowUseCase.js","sources":["../../../../src/features/workflow/UpdateWorkflow/UpdateWorkflowUseCase.ts"],"sourcesContent":["import { Result } from \"@webiny/feature/api\";\nimport { IdentityContext } from \"@webiny/api-core/features/security/IdentityContext/index.js\";\nimport { EventPublisher } from \"@webiny/api-core/features/eventPublisher/index.js\";\nimport { UpdateWorkflowRepository, UpdateWorkflowUseCase as UseCase } from \"./abstractions.js\";\nimport { WorkflowAfterUpdateEvent, WorkflowBeforeUpdateEvent } from \"./events.js\";\nimport { WorkflowNotAuthorizedError } from \"~/domain/workflow/errors.js\";\nimport { WORKFLOWS_PERMISSION } from \"~/constants.js\";\nimport type { IWorkflowsSecurityPermission } from \"~/types.js\";\n\nclass UpdateWorkflowUseCaseImpl implements UseCase.Interface {\n    constructor(\n        private identityContext: IdentityContext.Interface,\n        private eventPublisher: EventPublisher.Interface,\n        private repository: UpdateWorkflowRepository.Interface\n    ) {}\n\n    async execute(input: UseCase.Input, original: UseCase.Input): UseCase.Return {\n        const hasAccess = await this.ensureManageAccess();\n        if (hasAccess.isFail()) {\n            return Result.fail(hasAccess.error);\n        }\n\n        const workflow = {\n            id: input.id,\n            app: input.app,\n            name: input.name,\n            steps: input.steps\n        };\n\n        await this.eventPublisher.publish(\n            new WorkflowBeforeUpdateEvent({\n                workflow,\n                original,\n                input\n            })\n        );\n\n        const result = await this.repository.execute(input);\n        if (result.isFail()) {\n            return result;\n        }\n\n        await this.eventPublisher.publish(\n            new WorkflowAfterUpdateEvent({\n                workflow: result.value,\n                original,\n                input\n            })\n        );\n\n        return Result.ok(result.value);\n    }\n\n    private async ensureManageAccess(): Promise<Result<void, WorkflowNotAuthorizedError>> {\n        const permissions =\n            await this.identityContext.getPermissions<IWorkflowsSecurityPermission>(\n                WORKFLOWS_PERMISSION\n            );\n\n        for (const permission of permissions) {\n            if (permission.name === \"*\") {\n                return Result.ok();\n            } else if (permission.editor) {\n                return Result.ok();\n            }\n        }\n\n        return Result.fail(new WorkflowNotAuthorizedError(\"You cannot manage workflows.\"));\n    }\n}\n\nexport const UpdateWorkflowUseCase = UseCase.createImplementation({\n    implementation: UpdateWorkflowUseCaseImpl,\n    dependencies: [IdentityContext, EventPublisher, UpdateWorkflowRepository]\n});\n"],"names":["UpdateWorkflowUseCaseImpl","identityContext","eventPublisher","repository","input","original","hasAccess","Result","workflow","WorkflowBeforeUpdateEvent","result","WorkflowAfterUpdateEvent","permissions","WORKFLOWS_PERMISSION","permission","WorkflowNotAuthorizedError","UpdateWorkflowUseCase","UseCase","IdentityContext","EventPublisher","UpdateWorkflowRepository"],"mappings":";;;;;;;AASA,MAAMA;IACF,YACYC,eAA0C,EAC1CC,cAAwC,EACxCC,UAA8C,CACxD;aAHUF,eAAe,GAAfA;aACAC,cAAc,GAAdA;aACAC,UAAU,GAAVA;IACT;IAEH,MAAM,QAAQC,KAAoB,EAAEC,QAAuB,EAAkB;QACzE,MAAMC,YAAY,MAAM,IAAI,CAAC,kBAAkB;QAC/C,IAAIA,UAAU,MAAM,IAChB,OAAOC,OAAO,IAAI,CAACD,UAAU,KAAK;QAGtC,MAAME,WAAW;YACb,IAAIJ,MAAM,EAAE;YACZ,KAAKA,MAAM,GAAG;YACd,MAAMA,MAAM,IAAI;YAChB,OAAOA,MAAM,KAAK;QACtB;QAEA,MAAM,IAAI,CAAC,cAAc,CAAC,OAAO,CAC7B,IAAIK,0BAA0B;YAC1BD;YACAH;YACAD;QACJ;QAGJ,MAAMM,SAAS,MAAM,IAAI,CAAC,UAAU,CAAC,OAAO,CAACN;QAC7C,IAAIM,OAAO,MAAM,IACb,OAAOA;QAGX,MAAM,IAAI,CAAC,cAAc,CAAC,OAAO,CAC7B,IAAIC,yBAAyB;YACzB,UAAUD,OAAO,KAAK;YACtBL;YACAD;QACJ;QAGJ,OAAOG,OAAO,EAAE,CAACG,OAAO,KAAK;IACjC;IAEA,MAAc,qBAAwE;QAClF,MAAME,cACF,MAAM,IAAI,CAAC,eAAe,CAAC,cAAc,CACrCC;QAGR,KAAK,MAAMC,cAAcF,YACrB,IAAIE,AAAoB,QAApBA,WAAW,IAAI,EACf,OAAOP,OAAO,EAAE;aACb,IAAIO,WAAW,MAAM,EACxB,OAAOP,OAAO,EAAE;QAIxB,OAAOA,OAAO,IAAI,CAAC,IAAIQ,2BAA2B;IACtD;AACJ;AAEO,MAAMC,8CAAwBC,sBAAAA,oBAA4B,CAAC;IAC9D,gBAAgBjB;IAChB,cAAc;QAACkB;QAAiBC;QAAgBC;KAAyB;AAC7E"}

package/features/workflow/UpdateWorkflow/abstractions.d.ts

@@ -0,0 +1,57 @@
+import type { Result } from "@webiny/feature/api";
+import type { IWorkflow } from "../../../domain/workflow/abstractions.js";
+import type { NonEmptyArray } from "@webiny/api/types.js";
+import { type WorkflowNotAuthorizedError, type WorkflowPersistenceError, type WorkflowValidationError } from "../../../domain/workflow/errors.js";
+import type { IWorkflowStepInput } from "../../../features/shared/abstractions.js";
+export interface IUpdateWorkflowInput {
+    app: string;
+    id: string;
+    name: string;
+    steps: NonEmptyArray<IWorkflowStepInput>;
+}
+export interface WorkflowBeforeUpdatePayload {
+    workflow: IWorkflow;
+    original: IWorkflow;
+    input: IUpdateWorkflowInput;
+}
+export interface WorkflowAfterUpdatePayload {
+    workflow: IWorkflow;
+    original: IWorkflow;
+    input: IUpdateWorkflowInput;
+}
+/**
+ * UpdateWorkflow use case interface
+ */
+export interface IUpdateWorkflowUseCase {
+    execute(input: IUpdateWorkflowInput, original: IWorkflow): Promise<Result<IWorkflow, UseCaseError>>;
+}
+export interface IUpdateWorkflowUseCaseErrors {
+    notAuthorized: WorkflowNotAuthorizedError;
+    persistence: WorkflowPersistenceError;
+    validation: WorkflowValidationError;
+}
+type UseCaseError = IUpdateWorkflowUseCaseErrors[keyof IUpdateWorkflowUseCaseErrors];
+export declare const UpdateWorkflowUseCase: import("@webiny/di").Abstraction<IUpdateWorkflowUseCase>;
+export declare namespace UpdateWorkflowUseCase {
+    type Interface = IUpdateWorkflowUseCase;
+    type Input = IUpdateWorkflowInput;
+    type Return = Promise<Result<IWorkflow, UseCaseError>>;
+    type Error = UseCaseError;
+}
+/**
+ * UpdateWorkflow repository interface
+ */
+export interface IUpdateWorkflowRepository {
+    execute(input: IUpdateWorkflowInput): Promise<Result<IWorkflow, RepositoryError>>;
+}
+export interface IUpdateWorkflowRepositoryErrors {
+    persistence: WorkflowPersistenceError;
+}
+type RepositoryError = IUpdateWorkflowRepositoryErrors[keyof IUpdateWorkflowRepositoryErrors];
+export declare const UpdateWorkflowRepository: import("@webiny/di").Abstraction<IUpdateWorkflowRepository>;
+export declare namespace UpdateWorkflowRepository {
+    type Interface = IUpdateWorkflowRepository;
+    type Return = Promise<Result<IWorkflow, RepositoryError>>;
+    type Error = RepositoryError;
+}
+export {};

package/features/workflow/UpdateWorkflow/abstractions.js

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

package/features/workflow/UpdateWorkflow/abstractions.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"features/workflow/UpdateWorkflow/abstractions.js","sources":["../../../../src/features/workflow/UpdateWorkflow/abstractions.ts"],"sourcesContent":["import { createAbstraction } from \"@webiny/feature/api\";\nimport type { Result } from \"@webiny/feature/api\";\nimport type { IWorkflow } from \"~/domain/workflow/abstractions.js\";\nimport type { NonEmptyArray } from \"@webiny/api/types.js\";\nimport {\n    type WorkflowNotAuthorizedError,\n    type WorkflowPersistenceError,\n    type WorkflowValidationError\n} from \"~/domain/workflow/errors.js\";\nimport type { IWorkflowStepInput } from \"~/features/shared/abstractions.js\";\n\n// Input types\nexport interface IUpdateWorkflowInput {\n    app: string;\n    id: string;\n    name: string;\n    steps: NonEmptyArray<IWorkflowStepInput>;\n}\n\n// Event payloads\nexport interface WorkflowBeforeUpdatePayload {\n    workflow: IWorkflow;\n    original: IWorkflow;\n    input: IUpdateWorkflowInput;\n}\n\nexport interface WorkflowAfterUpdatePayload {\n    workflow: IWorkflow;\n    original: IWorkflow;\n    input: IUpdateWorkflowInput;\n}\n\n/**\n * UpdateWorkflow use case interface\n */\nexport interface IUpdateWorkflowUseCase {\n    execute(\n        input: IUpdateWorkflowInput,\n        original: IWorkflow\n    ): Promise<Result<IWorkflow, UseCaseError>>;\n}\n\nexport interface IUpdateWorkflowUseCaseErrors {\n    notAuthorized: WorkflowNotAuthorizedError;\n    persistence: WorkflowPersistenceError;\n    validation: WorkflowValidationError;\n}\n\ntype UseCaseError = IUpdateWorkflowUseCaseErrors[keyof IUpdateWorkflowUseCaseErrors];\n\nexport const UpdateWorkflowUseCase =\n    createAbstraction<IUpdateWorkflowUseCase>(\"UpdateWorkflowUseCase\");\n\nexport namespace UpdateWorkflowUseCase {\n    export type Interface = IUpdateWorkflowUseCase;\n    export type Input = IUpdateWorkflowInput;\n    export type Return = Promise<Result<IWorkflow, UseCaseError>>;\n    export type Error = UseCaseError;\n}\n\n/**\n * UpdateWorkflow repository interface\n */\nexport interface IUpdateWorkflowRepository {\n    execute(input: IUpdateWorkflowInput): Promise<Result<IWorkflow, RepositoryError>>;\n}\n\nexport interface IUpdateWorkflowRepositoryErrors {\n    persistence: WorkflowPersistenceError;\n}\n\ntype RepositoryError = IUpdateWorkflowRepositoryErrors[keyof IUpdateWorkflowRepositoryErrors];\n\nexport const UpdateWorkflowRepository = createAbstraction<IUpdateWorkflowRepository>(\n    \"UpdateWorkflowRepository\"\n);\n\nexport namespace UpdateWorkflowRepository {\n    export type Interface = IUpdateWorkflowRepository;\n    export type Return = Promise<Result<IWorkflow, RepositoryError>>;\n    export type Error = RepositoryError;\n}\n"],"names":["UpdateWorkflowUseCase","createAbstraction","UpdateWorkflowRepository"],"mappings":";AAkDO,MAAMA,wBACTC,kBAA0C;AAsBvC,MAAMC,2BAA2BD,kBACpC"}

package/features/workflow/UpdateWorkflow/events.d.ts

@@ -0,0 +1,21 @@
+import { DomainEvent } from "@webiny/api-core/features/eventPublisher/index.js";
+import type { IEventHandler } from "@webiny/api-core/features/eventPublisher/index.js";
+import type { WorkflowBeforeUpdatePayload, WorkflowAfterUpdatePayload } from "./abstractions.js";
+export declare class WorkflowBeforeUpdateEvent extends DomainEvent<WorkflowBeforeUpdatePayload> {
+    eventType: "workflow.beforeUpdate";
+    getHandlerAbstraction(): import("@webiny/di").Abstraction<IEventHandler<WorkflowBeforeUpdateEvent>>;
+}
+export declare const WorkflowBeforeUpdateHandler: import("@webiny/di").Abstraction<IEventHandler<WorkflowBeforeUpdateEvent>>;
+export declare namespace WorkflowBeforeUpdateHandler {
+    type Interface = IEventHandler<WorkflowBeforeUpdateEvent>;
+    type Event = WorkflowBeforeUpdateEvent;
+}
+export declare class WorkflowAfterUpdateEvent extends DomainEvent<WorkflowAfterUpdatePayload> {
+    eventType: "workflow.afterUpdate";
+    getHandlerAbstraction(): import("@webiny/di").Abstraction<IEventHandler<WorkflowAfterUpdateEvent>>;
+}
+export declare const WorkflowAfterUpdateHandler: import("@webiny/di").Abstraction<IEventHandler<WorkflowAfterUpdateEvent>>;
+export declare namespace WorkflowAfterUpdateHandler {
+    type Interface = IEventHandler<WorkflowAfterUpdateEvent>;
+    type Event = WorkflowAfterUpdateEvent;
+}

package/features/workflow/UpdateWorkflow/events.js

@@ -0,0 +1,23 @@
+import { createAbstraction } from "@webiny/feature/api";
+import { DomainEvent } from "@webiny/api-core/features/eventPublisher/index.js";
+class WorkflowBeforeUpdateEvent extends DomainEvent {
+    getHandlerAbstraction() {
+        return WorkflowBeforeUpdateHandler;
+    }
+    constructor(...args){
+        super(...args), this.eventType = "workflow.beforeUpdate";
+    }
+}
+const WorkflowBeforeUpdateHandler = createAbstraction("WorkflowBeforeUpdateHandler");
+class WorkflowAfterUpdateEvent extends DomainEvent {
+    getHandlerAbstraction() {
+        return WorkflowAfterUpdateHandler;
+    }
+    constructor(...args){
+        super(...args), this.eventType = "workflow.afterUpdate";
+    }
+}
+const WorkflowAfterUpdateHandler = createAbstraction("WorkflowAfterUpdateHandler");
+export { WorkflowAfterUpdateEvent, WorkflowAfterUpdateHandler, WorkflowBeforeUpdateEvent, WorkflowBeforeUpdateHandler };
+
+//# sourceMappingURL=events.js.map

package/features/workflow/UpdateWorkflow/events.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"features/workflow/UpdateWorkflow/events.js","sources":["../../../../src/features/workflow/UpdateWorkflow/events.ts"],"sourcesContent":["import { createAbstraction } from \"@webiny/feature/api\";\nimport { DomainEvent } from \"@webiny/api-core/features/eventPublisher/index.js\";\nimport type { IEventHandler } from \"@webiny/api-core/features/eventPublisher/index.js\";\nimport type { WorkflowBeforeUpdatePayload, WorkflowAfterUpdatePayload } from \"./abstractions.js\";\n\n// Before update event\nexport class WorkflowBeforeUpdateEvent extends DomainEvent<WorkflowBeforeUpdatePayload> {\n    eventType = \"workflow.beforeUpdate\" as const;\n\n    getHandlerAbstraction() {\n        return WorkflowBeforeUpdateHandler;\n    }\n}\n\nexport const WorkflowBeforeUpdateHandler = createAbstraction<\n    IEventHandler<WorkflowBeforeUpdateEvent>\n>(\"WorkflowBeforeUpdateHandler\");\n\nexport namespace WorkflowBeforeUpdateHandler {\n    export type Interface = IEventHandler<WorkflowBeforeUpdateEvent>;\n    export type Event = WorkflowBeforeUpdateEvent;\n}\n\n// After update event\nexport class WorkflowAfterUpdateEvent extends DomainEvent<WorkflowAfterUpdatePayload> {\n    eventType = \"workflow.afterUpdate\" as const;\n\n    getHandlerAbstraction() {\n        return WorkflowAfterUpdateHandler;\n    }\n}\n\nexport const WorkflowAfterUpdateHandler = createAbstraction<\n    IEventHandler<WorkflowAfterUpdateEvent>\n>(\"WorkflowAfterUpdateHandler\");\n\nexport namespace WorkflowAfterUpdateHandler {\n    export type Interface = IEventHandler<WorkflowAfterUpdateEvent>;\n    export type Event = WorkflowAfterUpdateEvent;\n}\n"],"names":["WorkflowBeforeUpdateEvent","DomainEvent","WorkflowBeforeUpdateHandler","createAbstraction","WorkflowAfterUpdateEvent","WorkflowAfterUpdateHandler"],"mappings":";;AAMO,MAAMA,kCAAkCC;IAG3C,wBAAwB;QACpB,OAAOC;IACX;;QALG,qBACH,SAAS,GAAG;;AAKhB;AAEO,MAAMA,8BAA8BC,kBAEzC;AAQK,MAAMC,iCAAiCH;IAG1C,wBAAwB;QACpB,OAAOI;IACX;;QALG,qBACH,SAAS,GAAG;;AAKhB;AAEO,MAAMA,6BAA6BF,kBAExC"}

package/features/workflow/UpdateWorkflow/feature.d.ts

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

package/features/workflow/UpdateWorkflow/feature.js

@@ -0,0 +1,13 @@
+import { createFeature } from "@webiny/feature/api";
+import { UpdateWorkflowUseCase } from "./UpdateWorkflowUseCase.js";
+import { UpdateWorkflowRepository } from "./UpdateWorkflowRepository.js";
+const UpdateWorkflowFeature = createFeature({
+    name: "Workflows/UpdateWorkflow",
+    register (container) {
+        container.register(UpdateWorkflowRepository).inSingletonScope();
+        container.register(UpdateWorkflowUseCase);
+    }
+});
+export { UpdateWorkflowFeature };
+
+//# sourceMappingURL=feature.js.map

package/features/workflow/UpdateWorkflow/feature.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"features/workflow/UpdateWorkflow/feature.js","sources":["../../../../src/features/workflow/UpdateWorkflow/feature.ts"],"sourcesContent":["import { createFeature } from \"@webiny/feature/api\";\nimport { UpdateWorkflowUseCase } from \"./UpdateWorkflowUseCase.js\";\nimport { UpdateWorkflowRepository } from \"./UpdateWorkflowRepository.js\";\n\nexport const UpdateWorkflowFeature = createFeature({\n    name: \"Workflows/UpdateWorkflow\",\n    register(container) {\n        container.register(UpdateWorkflowRepository).inSingletonScope();\n        container.register(UpdateWorkflowUseCase);\n    }\n});\n"],"names":["UpdateWorkflowFeature","createFeature","container","UpdateWorkflowRepository","UpdateWorkflowUseCase"],"mappings":";;;AAIO,MAAMA,wBAAwBC,cAAc;IAC/C,MAAM;IACN,UAASC,SAAS;QACdA,UAAU,QAAQ,CAACC,0BAA0B,gBAAgB;QAC7DD,UAAU,QAAQ,CAACE;IACvB;AACJ"}

package/features/workflow/UpdateWorkflow/index.d.ts

@@ -0,0 +1,4 @@
+export { UpdateWorkflowFeature } from "./feature.js";
+export { UpdateWorkflowUseCase, UpdateWorkflowRepository } from "./abstractions.js";
+export type { IUpdateWorkflowInput } from "./abstractions.js";
+export { WorkflowBeforeUpdateEvent, WorkflowAfterUpdateEvent, WorkflowBeforeUpdateHandler, WorkflowAfterUpdateHandler } from "./events.js";

package/features/workflow/UpdateWorkflow/index.js

@@ -0,0 +1,3 @@
+export { UpdateWorkflowFeature } from "./feature.js";
+export { UpdateWorkflowRepository, UpdateWorkflowUseCase } from "./abstractions.js";
+export { WorkflowAfterUpdateEvent, WorkflowAfterUpdateHandler, WorkflowBeforeUpdateEvent, WorkflowBeforeUpdateHandler } from "./events.js";

package/features/workflowState/ApproveWorkflowStateStep/ApproveWorkflowStateStepUseCase.d.ts

@@ -0,0 +1,15 @@
+import { GetWorkflowStateUseCase } from "../GetWorkflowState/index.js";
+import { UpdateWorkflowStateRepository } from "../UpdateWorkflowState/index.js";
+import { ApproveWorkflowStateStepUseCase as UseCase } from "./abstractions.js";
+import { EventPublisher } from "@webiny/api-core/features/eventPublisher/index.js";
+declare class ApproveWorkflowStateStepUseCaseImpl implements UseCase.Interface {
+    private getWorkflowState;
+    private repository;
+    private eventPublisher;
+    constructor(getWorkflowState: GetWorkflowStateUseCase.Interface, repository: UpdateWorkflowStateRepository.Interface, eventPublisher: EventPublisher.Interface);
+    execute(id: string, comment?: string): UseCase.Return;
+}
+export declare const ApproveWorkflowStateStepUseCase: typeof ApproveWorkflowStateStepUseCaseImpl & {
+    __abstraction: import("@webiny/di").Abstraction<import("./abstractions.js").IApproveWorkflowStateStepUseCase>;
+};
+export {};

package/features/workflowState/ApproveWorkflowStateStep/ApproveWorkflowStateStepUseCase.js

@@ -0,0 +1,38 @@
+import { Result } from "@webiny/feature/api";
+import { GetWorkflowStateUseCase } from "../GetWorkflowState/index.js";
+import { UpdateWorkflowStateRepository } from "../UpdateWorkflowState/index.js";
+import { ApproveWorkflowStateStepUseCase } from "./abstractions.js";
+import { EventPublisher } from "@webiny/api-core/features/eventPublisher/index.js";
+import { WorkflowStateApproveStepEvent } from "./events.js";
+class ApproveWorkflowStateStepUseCaseImpl {
+    constructor(getWorkflowState, repository, eventPublisher){
+        this.getWorkflowState = getWorkflowState;
+        this.repository = repository;
+        this.eventPublisher = eventPublisher;
+    }
+    async execute(id, comment) {
+        const stateResult = await this.getWorkflowState.execute(id);
+        if (stateResult.isFail()) return Result.fail(stateResult.error);
+        const state = stateResult.value;
+        const approveResult = state.approve(comment);
+        if (approveResult.isFail()) return Result.fail(approveResult.error);
+        const updatedRecord = state.toRecord();
+        const updateResult = await this.repository.execute(id, updatedRecord);
+        if (updateResult.isFail()) return Result.fail(updateResult.error);
+        await this.eventPublisher.publish(new WorkflowStateApproveStepEvent({
+            state
+        }));
+        return Result.ok(state);
+    }
+}
+const ApproveWorkflowStateStepUseCase_ApproveWorkflowStateStepUseCase = ApproveWorkflowStateStepUseCase.createImplementation({
+    implementation: ApproveWorkflowStateStepUseCaseImpl,
+    dependencies: [
+        GetWorkflowStateUseCase,
+        UpdateWorkflowStateRepository,
+        EventPublisher
+    ]
+});
+export { ApproveWorkflowStateStepUseCase_ApproveWorkflowStateStepUseCase as ApproveWorkflowStateStepUseCase };
+
+//# sourceMappingURL=ApproveWorkflowStateStepUseCase.js.map

package/features/workflowState/ApproveWorkflowStateStep/ApproveWorkflowStateStepUseCase.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"features/workflowState/ApproveWorkflowStateStep/ApproveWorkflowStateStepUseCase.js","sources":["../../../../src/features/workflowState/ApproveWorkflowStateStep/ApproveWorkflowStateStepUseCase.ts"],"sourcesContent":["import { Result } from \"@webiny/feature/api\";\nimport { GetWorkflowStateUseCase } from \"../GetWorkflowState/index.js\";\nimport { UpdateWorkflowStateRepository } from \"../UpdateWorkflowState/index.js\";\nimport { ApproveWorkflowStateStepUseCase as UseCase } from \"./abstractions.js\";\nimport { EventPublisher } from \"@webiny/api-core/features/eventPublisher/index.js\";\nimport { WorkflowStateApproveStepEvent } from \"./events.js\";\n\nclass ApproveWorkflowStateStepUseCaseImpl implements UseCase.Interface {\n    constructor(\n        private getWorkflowState: GetWorkflowStateUseCase.Interface,\n        private repository: UpdateWorkflowStateRepository.Interface,\n        private eventPublisher: EventPublisher.Interface\n    ) {}\n\n    async execute(id: string, comment?: string): UseCase.Return {\n        const stateResult = await this.getWorkflowState.execute(id);\n        if (stateResult.isFail()) {\n            return Result.fail(stateResult.error);\n        }\n\n        const state = stateResult.value;\n\n        const approveResult = state.approve(comment);\n        if (approveResult.isFail()) {\n            return Result.fail(approveResult.error);\n        }\n\n        const updatedRecord = state.toRecord();\n\n        const updateResult = await this.repository.execute(id, updatedRecord);\n        if (updateResult.isFail()) {\n            return Result.fail(updateResult.error);\n        }\n\n        await this.eventPublisher.publish(\n            new WorkflowStateApproveStepEvent({\n                state\n            })\n        );\n\n        return Result.ok(state);\n    }\n}\n\nexport const ApproveWorkflowStateStepUseCase = UseCase.createImplementation({\n    implementation: ApproveWorkflowStateStepUseCaseImpl,\n    dependencies: [GetWorkflowStateUseCase, UpdateWorkflowStateRepository, EventPublisher]\n});\n"],"names":["ApproveWorkflowStateStepUseCaseImpl","getWorkflowState","repository","eventPublisher","id","comment","stateResult","Result","state","approveResult","updatedRecord","updateResult","WorkflowStateApproveStepEvent","ApproveWorkflowStateStepUseCase","UseCase","GetWorkflowStateUseCase","UpdateWorkflowStateRepository","EventPublisher"],"mappings":";;;;;;AAOA,MAAMA;IACF,YACYC,gBAAmD,EACnDC,UAAmD,EACnDC,cAAwC,CAClD;aAHUF,gBAAgB,GAAhBA;aACAC,UAAU,GAAVA;aACAC,cAAc,GAAdA;IACT;IAEH,MAAM,QAAQC,EAAU,EAAEC,OAAgB,EAAkB;QACxD,MAAMC,cAAc,MAAM,IAAI,CAAC,gBAAgB,CAAC,OAAO,CAACF;QACxD,IAAIE,YAAY,MAAM,IAClB,OAAOC,OAAO,IAAI,CAACD,YAAY,KAAK;QAGxC,MAAME,QAAQF,YAAY,KAAK;QAE/B,MAAMG,gBAAgBD,MAAM,OAAO,CAACH;QACpC,IAAII,cAAc,MAAM,IACpB,OAAOF,OAAO,IAAI,CAACE,cAAc,KAAK;QAG1C,MAAMC,gBAAgBF,MAAM,QAAQ;QAEpC,MAAMG,eAAe,MAAM,IAAI,CAAC,UAAU,CAAC,OAAO,CAACP,IAAIM;QACvD,IAAIC,aAAa,MAAM,IACnB,OAAOJ,OAAO,IAAI,CAACI,aAAa,KAAK;QAGzC,MAAM,IAAI,CAAC,cAAc,CAAC,OAAO,CAC7B,IAAIC,8BAA8B;YAC9BJ;QACJ;QAGJ,OAAOD,OAAO,EAAE,CAACC;IACrB;AACJ;AAEO,MAAMK,kEAAkCC,gCAAAA,oBAA4B,CAAC;IACxE,gBAAgBd;IAChB,cAAc;QAACe;QAAyBC;QAA+BC;KAAe;AAC1F"}

package/features/workflowState/ApproveWorkflowStateStep/abstractions.d.ts

@@ -0,0 +1,26 @@
+import type { Result } from "@webiny/feature/api";
+import { type WorkflowStateNotFoundError, WorkflowStatePersistenceError, type WorkflowStateStepCannotReviewError, type WorkflowStateStepNotStepOwnerError } from "../../../domain/workflowState/errors.js";
+import type { WorkflowNotFoundError } from "../../../domain/workflow/errors.js";
+import { WorkflowState } from "../../../domain/workflowState/WorkflowState.js";
+export interface WorkflowStateApproveStepPayload {
+    state: WorkflowState;
+}
+export interface IApproveWorkflowStateStepUseCase {
+    execute(id: string, comment?: string): Promise<Result<WorkflowState, UseCaseError>>;
+}
+export interface IApproveWorkflowStateStepUseCaseErrors {
+    notFound: WorkflowStateNotFoundError;
+    workflowNotFound: WorkflowNotFoundError;
+    cannotReview: WorkflowStateStepCannotReviewError;
+    notStepOwner: WorkflowStateStepNotStepOwnerError;
+    workflowState: WorkflowState.Error;
+    persistence: WorkflowStatePersistenceError;
+}
+type UseCaseError = IApproveWorkflowStateStepUseCaseErrors[keyof IApproveWorkflowStateStepUseCaseErrors];
+export declare const ApproveWorkflowStateStepUseCase: import("@webiny/di").Abstraction<IApproveWorkflowStateStepUseCase>;
+export declare namespace ApproveWorkflowStateStepUseCase {
+    type Interface = IApproveWorkflowStateStepUseCase;
+    type Return = Promise<Result<WorkflowState, UseCaseError>>;
+    type Error = UseCaseError;
+}
+export {};

package/features/workflowState/ApproveWorkflowStateStep/abstractions.js

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

package/features/workflowState/ApproveWorkflowStateStep/abstractions.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"features/workflowState/ApproveWorkflowStateStep/abstractions.js","sources":["../../../../src/features/workflowState/ApproveWorkflowStateStep/abstractions.ts"],"sourcesContent":["import type { Result } from \"@webiny/feature/api\";\nimport { createAbstraction } from \"@webiny/feature/api\";\nimport {\n    type WorkflowStateNotFoundError,\n    WorkflowStatePersistenceError,\n    type WorkflowStateStepCannotReviewError,\n    type WorkflowStateStepNotStepOwnerError\n} from \"~/domain/workflowState/errors.js\";\nimport type { WorkflowNotFoundError } from \"~/domain/workflow/errors.js\";\nimport { WorkflowState } from \"~/domain/workflowState/WorkflowState.js\";\n\nexport interface WorkflowStateApproveStepPayload {\n    state: WorkflowState;\n}\n\nexport interface IApproveWorkflowStateStepUseCase {\n    execute(id: string, comment?: string): Promise<Result<WorkflowState, UseCaseError>>;\n}\n\nexport interface IApproveWorkflowStateStepUseCaseErrors {\n    notFound: WorkflowStateNotFoundError;\n    workflowNotFound: WorkflowNotFoundError;\n    cannotReview: WorkflowStateStepCannotReviewError;\n    notStepOwner: WorkflowStateStepNotStepOwnerError;\n    workflowState: WorkflowState.Error;\n    persistence: WorkflowStatePersistenceError;\n}\n\ntype UseCaseError =\n    IApproveWorkflowStateStepUseCaseErrors[keyof IApproveWorkflowStateStepUseCaseErrors];\n\nexport const ApproveWorkflowStateStepUseCase = createAbstraction<IApproveWorkflowStateStepUseCase>(\n    \"ApproveWorkflowStateStepUseCase\"\n);\n\nexport namespace ApproveWorkflowStateStepUseCase {\n    export type Interface = IApproveWorkflowStateStepUseCase;\n    export type Return = Promise<Result<WorkflowState, UseCaseError>>;\n    export type Error = UseCaseError;\n}\n"],"names":["ApproveWorkflowStateStepUseCase","createAbstraction"],"mappings":";AA+BO,MAAMA,kCAAkCC,kBAC3C"}

package/features/workflowState/ApproveWorkflowStateStep/events.d.ts

@@ -0,0 +1,12 @@
+import type { IEventHandler } from "@webiny/api-core/features/eventPublisher/index.js";
+import { DomainEvent } from "@webiny/api-core/features/eventPublisher/index.js";
+import type { WorkflowStateApproveStepPayload } from "./abstractions.js";
+export declare class WorkflowStateApproveStepEvent extends DomainEvent<WorkflowStateApproveStepPayload> {
+    eventType: "workflowState.approveStep";
+    getHandlerAbstraction(): import("@webiny/di").Abstraction<IEventHandler<WorkflowStateApproveStepEvent>>;
+}
+export declare const WorkflowStateApproveStepHandler: import("@webiny/di").Abstraction<IEventHandler<WorkflowStateApproveStepEvent>>;
+export declare namespace WorkflowStateApproveStepHandler {
+    type Interface = IEventHandler<WorkflowStateApproveStepEvent>;
+    type Event = WorkflowStateApproveStepEvent;
+}

package/features/workflowState/ApproveWorkflowStateStep/events.js

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