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

package/features/workflowState/StartWorkflowStateStep/index.js

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

package/features/workflowState/TakeOverWorkflowStateStep/TakeOverWorkflowStateStepUseCase.d.ts

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

package/features/workflowState/TakeOverWorkflowStateStep/TakeOverWorkflowStateStepUseCase.js

@@ -0,0 +1,38 @@
+import { Result } from "@webiny/feature/api";
+import { GetWorkflowStateUseCase } from "../GetWorkflowState/index.js";
+import { UpdateWorkflowStateRepository } from "../UpdateWorkflowState/index.js";
+import { TakeOverWorkflowStateStepUseCase } from "./abstractions.js";
+import { EventPublisher } from "@webiny/api-core/features/eventPublisher/index.js";
+import { WorkflowStateTakeOverStepEvent } from "./events.js";
+class TakeOverWorkflowStateStepUseCaseImpl {
+    constructor(getWorkflowState, repository, eventPublisher){
+        this.getWorkflowState = getWorkflowState;
+        this.repository = repository;
+        this.eventPublisher = eventPublisher;
+    }
+    async execute(id) {
+        const stateResult = await this.getWorkflowState.execute(id);
+        if (stateResult.isFail()) return Result.fail(stateResult.error);
+        const state = stateResult.value;
+        const takeOverResult = state.takeOver();
+        if (takeOverResult.isFail()) return Result.fail(takeOverResult.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 WorkflowStateTakeOverStepEvent({
+            state
+        }));
+        return Result.ok(state);
+    }
+}
+const TakeOverWorkflowStateStepUseCase_TakeOverWorkflowStateStepUseCase = TakeOverWorkflowStateStepUseCase.createImplementation({
+    implementation: TakeOverWorkflowStateStepUseCaseImpl,
+    dependencies: [
+        GetWorkflowStateUseCase,
+        UpdateWorkflowStateRepository,
+        EventPublisher
+    ]
+});
+export { TakeOverWorkflowStateStepUseCase_TakeOverWorkflowStateStepUseCase as TakeOverWorkflowStateStepUseCase };
+
+//# sourceMappingURL=TakeOverWorkflowStateStepUseCase.js.map

package/features/workflowState/TakeOverWorkflowStateStep/TakeOverWorkflowStateStepUseCase.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"features/workflowState/TakeOverWorkflowStateStep/TakeOverWorkflowStateStepUseCase.js","sources":["../../../../src/features/workflowState/TakeOverWorkflowStateStep/TakeOverWorkflowStateStepUseCase.ts"],"sourcesContent":["import { Result } from \"@webiny/feature/api\";\nimport { GetWorkflowStateUseCase } from \"../GetWorkflowState/index.js\";\nimport { UpdateWorkflowStateRepository } from \"../UpdateWorkflowState/index.js\";\nimport { TakeOverWorkflowStateStepUseCase as UseCase } from \"./abstractions.js\";\nimport { EventPublisher } from \"@webiny/api-core/features/eventPublisher/index.js\";\nimport { WorkflowStateTakeOverStepEvent } from \"./events.js\";\n\nclass TakeOverWorkflowStateStepUseCaseImpl 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): 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 takeOverResult = state.takeOver();\n        if (takeOverResult.isFail()) {\n            return Result.fail(takeOverResult.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 WorkflowStateTakeOverStepEvent({\n                state\n            })\n        );\n\n        return Result.ok(state);\n    }\n}\n\nexport const TakeOverWorkflowStateStepUseCase = UseCase.createImplementation({\n    implementation: TakeOverWorkflowStateStepUseCaseImpl,\n    dependencies: [GetWorkflowStateUseCase, UpdateWorkflowStateRepository, EventPublisher]\n});\n"],"names":["TakeOverWorkflowStateStepUseCaseImpl","getWorkflowState","repository","eventPublisher","id","stateResult","Result","state","takeOverResult","updatedRecord","updateResult","WorkflowStateTakeOverStepEvent","TakeOverWorkflowStateStepUseCase","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,EAAkB;QACtC,MAAMC,cAAc,MAAM,IAAI,CAAC,gBAAgB,CAAC,OAAO,CAACD;QACxD,IAAIC,YAAY,MAAM,IAClB,OAAOC,OAAO,IAAI,CAACD,YAAY,KAAK;QAGxC,MAAME,QAAQF,YAAY,KAAK;QAE/B,MAAMG,iBAAiBD,MAAM,QAAQ;QACrC,IAAIC,eAAe,MAAM,IACrB,OAAOF,OAAO,IAAI,CAACE,eAAe,KAAK;QAG3C,MAAMC,gBAAgBF,MAAM,QAAQ;QAEpC,MAAMG,eAAe,MAAM,IAAI,CAAC,UAAU,CAAC,OAAO,CAACN,IAAIK;QACvD,IAAIC,aAAa,MAAM,IACnB,OAAOJ,OAAO,IAAI,CAACI,aAAa,KAAK;QAGzC,MAAM,IAAI,CAAC,cAAc,CAAC,OAAO,CAC7B,IAAIC,+BAA+B;YAC/BJ;QACJ;QAGJ,OAAOD,OAAO,EAAE,CAACC;IACrB;AACJ;AAEO,MAAMK,oEAAmCC,iCAAAA,oBAA4B,CAAC;IACzE,gBAAgBb;IAChB,cAAc;QAACc;QAAyBC;QAA+BC;KAAe;AAC1F"}

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

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

package/features/workflowState/TakeOverWorkflowStateStep/abstractions.js

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"features/workflowState/TakeOverWorkflowStateStep/abstractions.js","sources":["../../../../src/features/workflowState/TakeOverWorkflowStateStep/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 WorkflowStateStepCannotTakeOverError\n} from \"~/domain/workflowState/errors.js\";\nimport type { WorkflowNotFoundError } from \"~/domain/workflow/errors.js\";\nimport { WorkflowState } from \"~/domain/workflowState/WorkflowState.js\";\n\nexport interface WorkflowStateTakeOverStepPayload {\n    state: WorkflowState;\n}\n\nexport interface ITakeOverWorkflowStateStepUseCase {\n    execute(id: string): Promise<Result<WorkflowState, UseCaseError>>;\n}\n\nexport interface ITakeOverWorkflowStateStepUseCaseErrors {\n    notFound: WorkflowStateNotFoundError;\n    workflowNotFound: WorkflowNotFoundError;\n    cannotReview: WorkflowStateStepCannotReviewError;\n    cannotTakeOver: WorkflowStateStepCannotTakeOverError;\n    workflowState: WorkflowState.Error;\n    persistence: WorkflowStatePersistenceError;\n}\n\ntype UseCaseError =\n    ITakeOverWorkflowStateStepUseCaseErrors[keyof ITakeOverWorkflowStateStepUseCaseErrors];\n\nexport const TakeOverWorkflowStateStepUseCase =\n    createAbstraction<ITakeOverWorkflowStateStepUseCase>(\"TakeOverWorkflowStateStepUseCase\");\n\nexport namespace TakeOverWorkflowStateStepUseCase {\n    export type Interface = ITakeOverWorkflowStateStepUseCase;\n    export type Return = Promise<Result<WorkflowState, UseCaseError>>;\n    export type Error = UseCaseError;\n}\n"],"names":["TakeOverWorkflowStateStepUseCase","createAbstraction"],"mappings":";AA+BO,MAAMA,mCACTC,kBAAqD"}

package/features/workflowState/TakeOverWorkflowStateStep/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 { WorkflowStateTakeOverStepPayload } from "./abstractions.js";
+export declare class WorkflowStateTakeOverStepEvent extends DomainEvent<WorkflowStateTakeOverStepPayload> {
+    eventType: "workflowState.takeOverStep";
+    getHandlerAbstraction(): import("@webiny/di").Abstraction<IEventHandler<WorkflowStateTakeOverStepEvent>>;
+}
+export declare const WorkflowStateTakeOverStepHandler: import("@webiny/di").Abstraction<IEventHandler<WorkflowStateTakeOverStepEvent>>;
+export declare namespace WorkflowStateTakeOverStepHandler {
+    type Interface = IEventHandler<WorkflowStateTakeOverStepEvent>;
+    type Event = WorkflowStateTakeOverStepEvent;
+}

package/features/workflowState/TakeOverWorkflowStateStep/events.js

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

package/features/workflowState/TakeOverWorkflowStateStep/events.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"features/workflowState/TakeOverWorkflowStateStep/events.js","sources":["../../../../src/features/workflowState/TakeOverWorkflowStateStep/events.ts"],"sourcesContent":["import { createAbstraction } from \"@webiny/feature/api\";\nimport type { IEventHandler } from \"@webiny/api-core/features/eventPublisher/index.js\";\nimport { DomainEvent } from \"@webiny/api-core/features/eventPublisher/index.js\";\nimport type { WorkflowStateTakeOverStepPayload } from \"./abstractions.js\";\n\nexport class WorkflowStateTakeOverStepEvent extends DomainEvent<WorkflowStateTakeOverStepPayload> {\n    eventType = \"workflowState.takeOverStep\" as const;\n\n    getHandlerAbstraction() {\n        return WorkflowStateTakeOverStepHandler;\n    }\n}\n\nexport const WorkflowStateTakeOverStepHandler = createAbstraction<\n    IEventHandler<WorkflowStateTakeOverStepEvent>\n>(\"WorkflowStateTakeOverStepHandler\");\n\nexport namespace WorkflowStateTakeOverStepHandler {\n    export type Interface = IEventHandler<WorkflowStateTakeOverStepEvent>;\n    export type Event = WorkflowStateTakeOverStepEvent;\n}\n"],"names":["WorkflowStateTakeOverStepEvent","DomainEvent","WorkflowStateTakeOverStepHandler","createAbstraction"],"mappings":";;AAKO,MAAMA,uCAAuCC;IAGhD,wBAAwB;QACpB,OAAOC;IACX;;QALG,qBACH,SAAS,GAAG;;AAKhB;AAEO,MAAMA,mCAAmCC,kBAE9C"}

package/features/workflowState/TakeOverWorkflowStateStep/feature.d.ts

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

package/features/workflowState/TakeOverWorkflowStateStep/feature.js

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

package/features/workflowState/TakeOverWorkflowStateStep/feature.js.map

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

package/features/workflowState/TakeOverWorkflowStateStep/index.d.ts

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

package/features/workflowState/TakeOverWorkflowStateStep/index.js

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

package/features/workflowState/UpdateWorkflowState/UpdateWorkflowStateRepository.d.ts

@@ -0,0 +1,17 @@
+import { UpdateEntryUseCase } from "@webiny/api-headless-cms/features/contentEntry/UpdateEntry/index.js";
+import { GetEntryByIdUseCase } from "@webiny/api-headless-cms/features/contentEntry/GetEntryById/index.js";
+import { WorkflowStateModel, WorkflowStateMapper } from "../../../domain/workflowState/abstractions.js";
+import { UpdateWorkflowStateRepository as Repository } from "./abstractions.js";
+import type { IUpdateWorkflowStateInput } from "./abstractions.js";
+declare class UpdateWorkflowStateRepositoryImpl implements Repository.Interface {
+    private getEntryById;
+    private updateEntry;
+    private model;
+    private mapper;
+    constructor(getEntryById: GetEntryByIdUseCase.Interface, updateEntry: UpdateEntryUseCase.Interface, model: WorkflowStateModel.Interface, mapper: WorkflowStateMapper.Interface);
+    execute(id: string, input: IUpdateWorkflowStateInput): Repository.Return;
+}
+export declare const UpdateWorkflowStateRepository: typeof UpdateWorkflowStateRepositoryImpl & {
+    __abstraction: import("@webiny/di").Abstraction<import("./abstractions.js").IUpdateWorkflowStateRepository>;
+};
+export {};

package/features/workflowState/UpdateWorkflowState/UpdateWorkflowStateRepository.js

@@ -0,0 +1,50 @@
+import { Result } from "@webiny/feature/api";
+import { UpdateEntryUseCase } from "@webiny/api-headless-cms/features/contentEntry/UpdateEntry/index.js";
+import { GetEntryByIdUseCase } from "@webiny/api-headless-cms/features/contentEntry/GetEntryById/index.js";
+import { WorkflowStateMapper, WorkflowStateModel } from "../../../domain/workflowState/abstractions.js";
+import { WorkflowStateNotFoundError, WorkflowStatePersistenceError } from "../../../domain/workflowState/errors.js";
+import { UpdateWorkflowStateRepository } from "./abstractions.js";
+class UpdateWorkflowStateRepositoryImpl {
+    constructor(getEntryById, updateEntry, model, mapper){
+        this.getEntryById = getEntryById;
+        this.updateEntry = updateEntry;
+        this.model = model;
+        this.mapper = mapper;
+    }
+    async execute(id, input) {
+        const getResult = await this.getEntryById.execute(this.model, id);
+        if (getResult.isFail()) {
+            if ("Cms/Entry/NotFound" === getResult.error.code) return Result.fail(new WorkflowStateNotFoundError({
+                id
+            }));
+            return Result.fail(new WorkflowStatePersistenceError(getResult.error));
+        }
+        const originalRecord = this.mapper.fromCmsEntry(getResult.value);
+        const updatedValues = this.mapper.toCmsEntry({
+            ...originalRecord,
+            ...input
+        });
+        try {
+            const updateResult = await this.updateEntry.execute(this.model, id, {
+                values: updatedValues
+            });
+            if (updateResult.isFail()) return Result.fail(new WorkflowStatePersistenceError(updateResult.error));
+            const updatedRecord = this.mapper.fromCmsEntry(updateResult.value);
+            return Result.ok(updatedRecord);
+        } catch (error) {
+            return Result.fail(new WorkflowStatePersistenceError(error));
+        }
+    }
+}
+const UpdateWorkflowStateRepository_UpdateWorkflowStateRepository = UpdateWorkflowStateRepository.createImplementation({
+    implementation: UpdateWorkflowStateRepositoryImpl,
+    dependencies: [
+        GetEntryByIdUseCase,
+        UpdateEntryUseCase,
+        WorkflowStateModel,
+        WorkflowStateMapper
+    ]
+});
+export { UpdateWorkflowStateRepository_UpdateWorkflowStateRepository as UpdateWorkflowStateRepository };
+
+//# sourceMappingURL=UpdateWorkflowStateRepository.js.map

package/features/workflowState/UpdateWorkflowState/UpdateWorkflowStateRepository.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"features/workflowState/UpdateWorkflowState/UpdateWorkflowStateRepository.js","sources":["../../../../src/features/workflowState/UpdateWorkflowState/UpdateWorkflowStateRepository.ts"],"sourcesContent":["import { Result } from \"@webiny/feature/api\";\nimport { UpdateEntryUseCase } from \"@webiny/api-headless-cms/features/contentEntry/UpdateEntry/index.js\";\nimport { GetEntryByIdUseCase } from \"@webiny/api-headless-cms/features/contentEntry/GetEntryById/index.js\";\nimport { WorkflowStateModel, WorkflowStateMapper } from \"~/domain/workflowState/abstractions.js\";\nimport type { IWorkflowStateRecord } from \"~/domain/workflowState/abstractions.js\";\nimport {\n    WorkflowStateNotFoundError,\n    WorkflowStatePersistenceError\n} from \"~/domain/workflowState/errors.js\";\nimport { UpdateWorkflowStateRepository as Repository } from \"./abstractions.js\";\nimport type { IUpdateWorkflowStateInput } from \"./abstractions.js\";\n\nclass UpdateWorkflowStateRepositoryImpl implements Repository.Interface {\n    constructor(\n        private getEntryById: GetEntryByIdUseCase.Interface,\n        private updateEntry: UpdateEntryUseCase.Interface,\n        private model: WorkflowStateModel.Interface,\n        private mapper: WorkflowStateMapper.Interface\n    ) {}\n\n    async execute(id: string, input: IUpdateWorkflowStateInput): Repository.Return {\n        const getResult = await this.getEntryById.execute<Omit<IWorkflowStateRecord, \"id\">>(\n            this.model,\n            id\n        );\n\n        if (getResult.isFail()) {\n            if (getResult.error.code === \"Cms/Entry/NotFound\") {\n                return Result.fail(\n                    new WorkflowStateNotFoundError({\n                        id\n                    })\n                );\n            }\n            return Result.fail(new WorkflowStatePersistenceError(getResult.error));\n        }\n\n        const originalRecord = this.mapper.fromCmsEntry(getResult.value);\n\n        const updatedValues = this.mapper.toCmsEntry({\n            ...originalRecord,\n            ...input\n        });\n\n        try {\n            const updateResult = await this.updateEntry.execute<Repository.Input>(this.model, id, {\n                values: updatedValues\n            });\n\n            if (updateResult.isFail()) {\n                return Result.fail(new WorkflowStatePersistenceError(updateResult.error));\n            }\n\n            const updatedRecord = this.mapper.fromCmsEntry(updateResult.value);\n            return Result.ok(updatedRecord);\n        } catch (error) {\n            return Result.fail(new WorkflowStatePersistenceError(error as Error));\n        }\n    }\n}\n\nexport const UpdateWorkflowStateRepository = Repository.createImplementation({\n    implementation: UpdateWorkflowStateRepositoryImpl,\n    dependencies: [GetEntryByIdUseCase, UpdateEntryUseCase, WorkflowStateModel, WorkflowStateMapper]\n});\n"],"names":["UpdateWorkflowStateRepositoryImpl","getEntryById","updateEntry","model","mapper","id","input","getResult","Result","WorkflowStateNotFoundError","WorkflowStatePersistenceError","originalRecord","updatedValues","updateResult","updatedRecord","error","UpdateWorkflowStateRepository","Repository","GetEntryByIdUseCase","UpdateEntryUseCase","WorkflowStateModel","WorkflowStateMapper"],"mappings":";;;;;;AAYA,MAAMA;IACF,YACYC,YAA2C,EAC3CC,WAAyC,EACzCC,KAAmC,EACnCC,MAAqC,CAC/C;aAJUH,YAAY,GAAZA;aACAC,WAAW,GAAXA;aACAC,KAAK,GAALA;aACAC,MAAM,GAANA;IACT;IAEH,MAAM,QAAQC,EAAU,EAAEC,KAAgC,EAAqB;QAC3E,MAAMC,YAAY,MAAM,IAAI,CAAC,YAAY,CAAC,OAAO,CAC7C,IAAI,CAAC,KAAK,EACVF;QAGJ,IAAIE,UAAU,MAAM,IAAI;YACpB,IAAIA,AAAyB,yBAAzBA,UAAU,KAAK,CAAC,IAAI,EACpB,OAAOC,OAAO,IAAI,CACd,IAAIC,2BAA2B;gBAC3BJ;YACJ;YAGR,OAAOG,OAAO,IAAI,CAAC,IAAIE,8BAA8BH,UAAU,KAAK;QACxE;QAEA,MAAMI,iBAAiB,IAAI,CAAC,MAAM,CAAC,YAAY,CAACJ,UAAU,KAAK;QAE/D,MAAMK,gBAAgB,IAAI,CAAC,MAAM,CAAC,UAAU,CAAC;YACzC,GAAGD,cAAc;YACjB,GAAGL,KAAK;QACZ;QAEA,IAAI;YACA,MAAMO,eAAe,MAAM,IAAI,CAAC,WAAW,CAAC,OAAO,CAAmB,IAAI,CAAC,KAAK,EAAER,IAAI;gBAClF,QAAQO;YACZ;YAEA,IAAIC,aAAa,MAAM,IACnB,OAAOL,OAAO,IAAI,CAAC,IAAIE,8BAA8BG,aAAa,KAAK;YAG3E,MAAMC,gBAAgB,IAAI,CAAC,MAAM,CAAC,YAAY,CAACD,aAAa,KAAK;YACjE,OAAOL,OAAO,EAAE,CAACM;QACrB,EAAE,OAAOC,OAAO;YACZ,OAAOP,OAAO,IAAI,CAAC,IAAIE,8BAA8BK;QACzD;IACJ;AACJ;AAEO,MAAMC,8DAAgCC,8BAAAA,oBAA+B,CAAC;IACzE,gBAAgBjB;IAChB,cAAc;QAACkB;QAAqBC;QAAoBC;QAAoBC;KAAoB;AACpG"}

package/features/workflowState/UpdateWorkflowState/UpdateWorkflowStateUseCase.d.ts

@@ -0,0 +1,20 @@
+import { IdentityContext } from "@webiny/api-core/features/security/IdentityContext/index.js";
+import { GetUserTeamsUseCase } from "../../../features/internal/GetUserTeams/index.js";
+import { EventPublisher } from "@webiny/api-core/features/eventPublisher/index.js";
+import { GetWorkflowUseCase } from "../../../features/workflow/GetWorkflow/index.js";
+import { GetWorkflowStateUseCase } from "../GetWorkflowState/index.js";
+import { UpdateWorkflowStateRepository, UpdateWorkflowStateUseCase as UseCase } from "./abstractions.js";
+declare class UpdateWorkflowStateUseCaseImpl implements UseCase.Interface {
+    private identityContext;
+    private getUserTeams;
+    private eventPublisher;
+    private getWorkflow;
+    private getWorkflowState;
+    private repository;
+    constructor(identityContext: IdentityContext.Interface, getUserTeams: GetUserTeamsUseCase.Interface, eventPublisher: EventPublisher.Interface, getWorkflow: GetWorkflowUseCase.Interface, getWorkflowState: GetWorkflowStateUseCase.Interface, repository: UpdateWorkflowStateRepository.Interface);
+    execute(id: string, input: UseCase.Input): UseCase.Return;
+}
+export declare const UpdateWorkflowStateUseCase: typeof UpdateWorkflowStateUseCaseImpl & {
+    __abstraction: import("@webiny/di").Abstraction<import("./abstractions.js").IUpdateWorkflowStateUseCase>;
+};
+export {};

package/features/workflowState/UpdateWorkflowState/UpdateWorkflowStateUseCase.js

@@ -0,0 +1,59 @@
+import { Result } from "@webiny/feature/api";
+import { IdentityContext } from "@webiny/api-core/features/security/IdentityContext/index.js";
+import { GetUserTeamsUseCase } from "../../internal/GetUserTeams/index.js";
+import { EventPublisher } from "@webiny/api-core/features/eventPublisher/index.js";
+import { GetWorkflowUseCase } from "../../workflow/GetWorkflow/index.js";
+import { GetWorkflowStateUseCase } from "../GetWorkflowState/index.js";
+import { UpdateWorkflowStateRepository, UpdateWorkflowStateUseCase } from "./abstractions.js";
+import { WorkflowStateAfterUpdateEvent } from "./events.js";
+import { WorkflowState } from "../../../domain/workflowState/WorkflowState.js";
+import { WorkflowNotFoundError } from "../../../domain/workflow/errors.js";
+class UpdateWorkflowStateUseCaseImpl {
+    constructor(identityContext, getUserTeams, eventPublisher, getWorkflow, getWorkflowState, repository){
+        this.identityContext = identityContext;
+        this.getUserTeams = getUserTeams;
+        this.eventPublisher = eventPublisher;
+        this.getWorkflow = getWorkflow;
+        this.getWorkflowState = getWorkflowState;
+        this.repository = repository;
+    }
+    async execute(id, input) {
+        const originalStateResult = await this.getWorkflowState.execute(id);
+        if (originalStateResult.isFail()) return Result.fail(originalStateResult.error);
+        const originalState = originalStateResult.value;
+        const workflowResult = await this.getWorkflow.execute({
+            app: originalState.app,
+            id: originalState.workflowId
+        });
+        if (workflowResult.isFail()) return Result.fail(new WorkflowNotFoundError({
+            id: originalState.workflowId,
+            app: originalState.app
+        }));
+        const updateResult = await this.repository.execute(id, input);
+        if (updateResult.isFail()) return Result.fail(updateResult.error);
+        const updatedRecord = updateResult.value;
+        const identity = this.identityContext.getIdentity();
+        const teamsResult = await this.getUserTeams.execute(identity.id);
+        const teams = teamsResult.value;
+        const updatedState = new WorkflowState(updatedRecord, teams, identity);
+        await this.eventPublisher.publish(new WorkflowStateAfterUpdateEvent({
+            state: updatedState,
+            original: originalState
+        }));
+        return Result.ok(updatedState);
+    }
+}
+const UpdateWorkflowStateUseCase_UpdateWorkflowStateUseCase = UpdateWorkflowStateUseCase.createImplementation({
+    implementation: UpdateWorkflowStateUseCaseImpl,
+    dependencies: [
+        IdentityContext,
+        GetUserTeamsUseCase,
+        EventPublisher,
+        GetWorkflowUseCase,
+        GetWorkflowStateUseCase,
+        UpdateWorkflowStateRepository
+    ]
+});
+export { UpdateWorkflowStateUseCase_UpdateWorkflowStateUseCase as UpdateWorkflowStateUseCase };
+
+//# sourceMappingURL=UpdateWorkflowStateUseCase.js.map

package/features/workflowState/UpdateWorkflowState/UpdateWorkflowStateUseCase.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"features/workflowState/UpdateWorkflowState/UpdateWorkflowStateUseCase.js","sources":["../../../../src/features/workflowState/UpdateWorkflowState/UpdateWorkflowStateUseCase.ts"],"sourcesContent":["import { Result } from \"@webiny/feature/api\";\nimport { IdentityContext } from \"@webiny/api-core/features/security/IdentityContext/index.js\";\nimport { GetUserTeamsUseCase } from \"~/features/internal/GetUserTeams/index.js\";\nimport { EventPublisher } from \"@webiny/api-core/features/eventPublisher/index.js\";\nimport { GetWorkflowUseCase } from \"~/features/workflow/GetWorkflow/index.js\";\nimport { GetWorkflowStateUseCase } from \"../GetWorkflowState/index.js\";\nimport {\n    UpdateWorkflowStateRepository,\n    UpdateWorkflowStateUseCase as UseCase\n} from \"./abstractions.js\";\nimport { WorkflowStateAfterUpdateEvent } from \"./events.js\";\nimport { WorkflowState } from \"~/domain/workflowState/WorkflowState.js\";\nimport { WorkflowNotFoundError } from \"~/domain/workflow/errors.js\";\n\nclass UpdateWorkflowStateUseCaseImpl implements UseCase.Interface {\n    constructor(\n        private identityContext: IdentityContext.Interface,\n        private getUserTeams: GetUserTeamsUseCase.Interface,\n        private eventPublisher: EventPublisher.Interface,\n        private getWorkflow: GetWorkflowUseCase.Interface,\n        private getWorkflowState: GetWorkflowStateUseCase.Interface,\n        private repository: UpdateWorkflowStateRepository.Interface\n    ) {}\n\n    async execute(id: string, input: UseCase.Input): UseCase.Return {\n        const originalStateResult = await this.getWorkflowState.execute(id);\n        if (originalStateResult.isFail()) {\n            return Result.fail(originalStateResult.error);\n        }\n\n        const originalState = originalStateResult.value;\n\n        const workflowResult = await this.getWorkflow.execute({\n            app: originalState.app,\n            id: originalState.workflowId\n        });\n\n        if (workflowResult.isFail()) {\n            return Result.fail(\n                new WorkflowNotFoundError({\n                    id: originalState.workflowId,\n                    app: originalState.app\n                })\n            );\n        }\n\n        const updateResult = await this.repository.execute(id, input);\n        if (updateResult.isFail()) {\n            return Result.fail(updateResult.error);\n        }\n\n        const updatedRecord = updateResult.value;\n\n        const identity = this.identityContext.getIdentity();\n        const teamsResult = await this.getUserTeams.execute(identity.id);\n        const teams = teamsResult.value;\n        const updatedState = new WorkflowState(updatedRecord, teams, identity);\n\n        await this.eventPublisher.publish(\n            new WorkflowStateAfterUpdateEvent({\n                state: updatedState,\n                original: originalState\n            })\n        );\n\n        return Result.ok(updatedState);\n    }\n}\n\nexport const UpdateWorkflowStateUseCase = UseCase.createImplementation({\n    implementation: UpdateWorkflowStateUseCaseImpl,\n    dependencies: [\n        IdentityContext,\n        GetUserTeamsUseCase,\n        EventPublisher,\n        GetWorkflowUseCase,\n        GetWorkflowStateUseCase,\n        UpdateWorkflowStateRepository\n    ]\n});\n"],"names":["UpdateWorkflowStateUseCaseImpl","identityContext","getUserTeams","eventPublisher","getWorkflow","getWorkflowState","repository","id","input","originalStateResult","Result","originalState","workflowResult","WorkflowNotFoundError","updateResult","updatedRecord","identity","teamsResult","teams","updatedState","WorkflowState","WorkflowStateAfterUpdateEvent","UpdateWorkflowStateUseCase","UseCase","IdentityContext","GetUserTeamsUseCase","EventPublisher","GetWorkflowUseCase","GetWorkflowStateUseCase","UpdateWorkflowStateRepository"],"mappings":";;;;;;;;;;AAcA,MAAMA;IACF,YACYC,eAA0C,EAC1CC,YAA2C,EAC3CC,cAAwC,EACxCC,WAAyC,EACzCC,gBAAmD,EACnDC,UAAmD,CAC7D;aANUL,eAAe,GAAfA;aACAC,YAAY,GAAZA;aACAC,cAAc,GAAdA;aACAC,WAAW,GAAXA;aACAC,gBAAgB,GAAhBA;aACAC,UAAU,GAAVA;IACT;IAEH,MAAM,QAAQC,EAAU,EAAEC,KAAoB,EAAkB;QAC5D,MAAMC,sBAAsB,MAAM,IAAI,CAAC,gBAAgB,CAAC,OAAO,CAACF;QAChE,IAAIE,oBAAoB,MAAM,IAC1B,OAAOC,OAAO,IAAI,CAACD,oBAAoB,KAAK;QAGhD,MAAME,gBAAgBF,oBAAoB,KAAK;QAE/C,MAAMG,iBAAiB,MAAM,IAAI,CAAC,WAAW,CAAC,OAAO,CAAC;YAClD,KAAKD,cAAc,GAAG;YACtB,IAAIA,cAAc,UAAU;QAChC;QAEA,IAAIC,eAAe,MAAM,IACrB,OAAOF,OAAO,IAAI,CACd,IAAIG,sBAAsB;YACtB,IAAIF,cAAc,UAAU;YAC5B,KAAKA,cAAc,GAAG;QAC1B;QAIR,MAAMG,eAAe,MAAM,IAAI,CAAC,UAAU,CAAC,OAAO,CAACP,IAAIC;QACvD,IAAIM,aAAa,MAAM,IACnB,OAAOJ,OAAO,IAAI,CAACI,aAAa,KAAK;QAGzC,MAAMC,gBAAgBD,aAAa,KAAK;QAExC,MAAME,WAAW,IAAI,CAAC,eAAe,CAAC,WAAW;QACjD,MAAMC,cAAc,MAAM,IAAI,CAAC,YAAY,CAAC,OAAO,CAACD,SAAS,EAAE;QAC/D,MAAME,QAAQD,YAAY,KAAK;QAC/B,MAAME,eAAe,IAAIC,cAAcL,eAAeG,OAAOF;QAE7D,MAAM,IAAI,CAAC,cAAc,CAAC,OAAO,CAC7B,IAAIK,8BAA8B;YAC9B,OAAOF;YACP,UAAUR;QACd;QAGJ,OAAOD,OAAO,EAAE,CAACS;IACrB;AACJ;AAEO,MAAMG,wDAA6BC,2BAAAA,oBAA4B,CAAC;IACnE,gBAAgBvB;IAChB,cAAc;QACVwB;QACAC;QACAC;QACAC;QACAC;QACAC;KACH;AACL"}

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

@@ -0,0 +1,48 @@
+import type { Result } from "@webiny/feature/api";
+import type { IWorkflowStateRecord } from "../../../domain/workflowState/abstractions.js";
+import { type WorkflowStateNotFoundError, type WorkflowStatePersistenceError } from "../../../domain/workflowState/errors.js";
+import type { WorkflowNotFoundError } from "../../../domain/workflow/errors.js";
+import type { WorkflowState } from "../../../domain/workflowState/WorkflowState.js";
+export type IUpdateWorkflowStateInput = Omit<IWorkflowStateRecord, "id" | "savedBy" | "savedOn" | "createdOn" | "createdBy">;
+export interface WorkflowStateAfterUpdatePayload {
+    state: WorkflowState;
+    original: WorkflowState;
+}
+/**
+ * UpdateWorkflowState use case interface
+ */
+export interface IUpdateWorkflowStateUseCase {
+    execute(id: string, input: Partial<IUpdateWorkflowStateInput>): Promise<Result<WorkflowState, UseCaseError>>;
+}
+export interface IUpdateWorkflowStateUseCaseErrors {
+    notFound: WorkflowStateNotFoundError;
+    workflowNotFound: WorkflowNotFoundError;
+    persistence: WorkflowStatePersistenceError;
+}
+type UseCaseError = IUpdateWorkflowStateUseCaseErrors[keyof IUpdateWorkflowStateUseCaseErrors];
+export declare const UpdateWorkflowStateUseCase: import("@webiny/di").Abstraction<IUpdateWorkflowStateUseCase>;
+export declare namespace UpdateWorkflowStateUseCase {
+    type Interface = IUpdateWorkflowStateUseCase;
+    type Input = IUpdateWorkflowStateInput;
+    type Return = Promise<Result<WorkflowState, UseCaseError>>;
+    type Error = UseCaseError;
+}
+/**
+ * UpdateWorkflowState repository interface
+ */
+export interface IUpdateWorkflowStateRepository {
+    execute(id: string, input: IUpdateWorkflowStateInput): Promise<Result<IWorkflowStateRecord, RepositoryError>>;
+}
+export interface IUpdateWorkflowStateRepositoryErrors {
+    notFound: WorkflowStateNotFoundError;
+    persistence: WorkflowStatePersistenceError;
+}
+type RepositoryError = IUpdateWorkflowStateRepositoryErrors[keyof IUpdateWorkflowStateRepositoryErrors];
+export declare const UpdateWorkflowStateRepository: import("@webiny/di").Abstraction<IUpdateWorkflowStateRepository>;
+export declare namespace UpdateWorkflowStateRepository {
+    type Interface = IUpdateWorkflowStateRepository;
+    type Input = IUpdateWorkflowStateInput;
+    type Return = Promise<Result<IWorkflowStateRecord, RepositoryError>>;
+    type Error = RepositoryError;
+}
+export {};

package/features/workflowState/UpdateWorkflowState/abstractions.js

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"features/workflowState/UpdateWorkflowState/abstractions.js","sources":["../../../../src/features/workflowState/UpdateWorkflowState/abstractions.ts"],"sourcesContent":["import type { Result } from \"@webiny/feature/api\";\nimport { createAbstraction } from \"@webiny/feature/api\";\nimport type { IWorkflowStateRecord } from \"~/domain/workflowState/abstractions.js\";\nimport {\n    type WorkflowStateNotFoundError,\n    type WorkflowStatePersistenceError\n} from \"~/domain/workflowState/errors.js\";\nimport type { WorkflowNotFoundError } from \"~/domain/workflow/errors.js\";\nimport type { WorkflowState } from \"~/domain/workflowState/WorkflowState.js\";\n\nexport type IUpdateWorkflowStateInput = Omit<\n    IWorkflowStateRecord,\n    \"id\" | \"savedBy\" | \"savedOn\" | \"createdOn\" | \"createdBy\"\n>;\n\nexport interface WorkflowStateAfterUpdatePayload {\n    state: WorkflowState;\n    original: WorkflowState;\n}\n\n/**\n * UpdateWorkflowState use case interface\n */\nexport interface IUpdateWorkflowStateUseCase {\n    execute(\n        id: string,\n        input: Partial<IUpdateWorkflowStateInput>\n    ): Promise<Result<WorkflowState, UseCaseError>>;\n}\n\nexport interface IUpdateWorkflowStateUseCaseErrors {\n    notFound: WorkflowStateNotFoundError;\n    workflowNotFound: WorkflowNotFoundError;\n    persistence: WorkflowStatePersistenceError;\n}\n\ntype UseCaseError = IUpdateWorkflowStateUseCaseErrors[keyof IUpdateWorkflowStateUseCaseErrors];\n\nexport const UpdateWorkflowStateUseCase = createAbstraction<IUpdateWorkflowStateUseCase>(\n    \"UpdateWorkflowStateUseCase\"\n);\n\nexport namespace UpdateWorkflowStateUseCase {\n    export type Interface = IUpdateWorkflowStateUseCase;\n    export type Input = IUpdateWorkflowStateInput;\n    export type Return = Promise<Result<WorkflowState, UseCaseError>>;\n    export type Error = UseCaseError;\n}\n\n/**\n * UpdateWorkflowState repository interface\n */\nexport interface IUpdateWorkflowStateRepository {\n    execute(\n        id: string,\n        input: IUpdateWorkflowStateInput\n    ): Promise<Result<IWorkflowStateRecord, RepositoryError>>;\n}\n\nexport interface IUpdateWorkflowStateRepositoryErrors {\n    notFound: WorkflowStateNotFoundError;\n    persistence: WorkflowStatePersistenceError;\n}\n\ntype RepositoryError =\n    IUpdateWorkflowStateRepositoryErrors[keyof IUpdateWorkflowStateRepositoryErrors];\n\nexport const UpdateWorkflowStateRepository = createAbstraction<IUpdateWorkflowStateRepository>(\n    \"UpdateWorkflowStateRepository\"\n);\n\nexport namespace UpdateWorkflowStateRepository {\n    export type Interface = IUpdateWorkflowStateRepository;\n    export type Input = IUpdateWorkflowStateInput;\n    export type Return = Promise<Result<IWorkflowStateRecord, RepositoryError>>;\n    export type Error = RepositoryError;\n}\n"],"names":["UpdateWorkflowStateUseCase","createAbstraction","UpdateWorkflowStateRepository"],"mappings":";AAsCO,MAAMA,6BAA6BC,kBACtC;AA4BG,MAAMC,gCAAgCD,kBACzC"}

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

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

package/features/workflowState/UpdateWorkflowState/events.js

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

package/features/workflowState/UpdateWorkflowState/events.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"features/workflowState/UpdateWorkflowState/events.js","sources":["../../../../src/features/workflowState/UpdateWorkflowState/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 { WorkflowStateAfterUpdatePayload } from \"./abstractions.js\";\n\nexport class WorkflowStateAfterUpdateEvent extends DomainEvent<WorkflowStateAfterUpdatePayload> {\n    eventType = \"workflowState.afterUpdate\" as const;\n\n    getHandlerAbstraction() {\n        return WorkflowStateAfterUpdateHandler;\n    }\n}\n\nexport const WorkflowStateAfterUpdateHandler = createAbstraction<\n    IEventHandler<WorkflowStateAfterUpdateEvent>\n>(\"WorkflowStateAfterUpdateHandler\");\n\nexport namespace WorkflowStateAfterUpdateHandler {\n    export type Interface = IEventHandler<WorkflowStateAfterUpdateEvent>;\n    export type Event = WorkflowStateAfterUpdateEvent;\n}\n"],"names":["WorkflowStateAfterUpdateEvent","DomainEvent","WorkflowStateAfterUpdateHandler","createAbstraction"],"mappings":";;AAKO,MAAMA,sCAAsCC;IAG/C,wBAAwB;QACpB,OAAOC;IACX;;QALG,qBACH,SAAS,GAAG;;AAKhB;AAEO,MAAMA,kCAAkCC,kBAE7C"}

package/features/workflowState/UpdateWorkflowState/feature.d.ts

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

package/features/workflowState/UpdateWorkflowState/feature.js

@@ -0,0 +1,13 @@
+import { createFeature } from "@webiny/feature/api";
+import { UpdateWorkflowStateUseCase } from "./UpdateWorkflowStateUseCase.js";
+import { UpdateWorkflowStateRepository } from "./UpdateWorkflowStateRepository.js";
+const UpdateWorkflowStateFeature = createFeature({
+    name: "WorkflowState/UpdateWorkflowState",
+    register (container) {
+        container.register(UpdateWorkflowStateRepository).inSingletonScope();
+        container.register(UpdateWorkflowStateUseCase);
+    }
+});
+export { UpdateWorkflowStateFeature };
+
+//# sourceMappingURL=feature.js.map

package/features/workflowState/UpdateWorkflowState/feature.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"features/workflowState/UpdateWorkflowState/feature.js","sources":["../../../../src/features/workflowState/UpdateWorkflowState/feature.ts"],"sourcesContent":["import { createFeature } from \"@webiny/feature/api\";\nimport { UpdateWorkflowStateUseCase } from \"./UpdateWorkflowStateUseCase.js\";\nimport { UpdateWorkflowStateRepository } from \"./UpdateWorkflowStateRepository.js\";\n\nexport const UpdateWorkflowStateFeature = createFeature({\n    name: \"WorkflowState/UpdateWorkflowState\",\n    register(container) {\n        container.register(UpdateWorkflowStateRepository).inSingletonScope();\n        container.register(UpdateWorkflowStateUseCase);\n    }\n});\n"],"names":["UpdateWorkflowStateFeature","createFeature","container","UpdateWorkflowStateRepository","UpdateWorkflowStateUseCase"],"mappings":";;;AAIO,MAAMA,6BAA6BC,cAAc;IACpD,MAAM;IACN,UAASC,SAAS;QACdA,UAAU,QAAQ,CAACC,+BAA+B,gBAAgB;QAClED,UAAU,QAAQ,CAACE;IACvB;AACJ"}

package/features/workflowState/UpdateWorkflowState/index.d.ts

@@ -0,0 +1,2 @@
+export { UpdateWorkflowStateUseCase, UpdateWorkflowStateRepository } from "./abstractions.js";
+export { WorkflowStateAfterUpdateHandler } from "./events.js";

package/features/workflowState/UpdateWorkflowState/index.js

@@ -0,0 +1,2 @@
+export { UpdateWorkflowStateRepository, UpdateWorkflowStateUseCase } from "./abstractions.js";
+export { WorkflowStateAfterUpdateHandler } from "./events.js";

package/graphql/notifications.d.ts

@@ -0,0 +1,2 @@
+import type { IGraphQLSchemaBuilder } from "@webiny/api-graphql/features/GraphQLSchemaBuilder/abstractions.js";
+export declare const addNotificationsSchema: (builder: IGraphQLSchemaBuilder) => void;

package/graphql/notifications.js

@@ -0,0 +1,49 @@
+import { resolveList } from "@webiny/api-graphql";
+import { ListNotificationTypesUseCase } from "../features/notifications/ListNotificationTypes/index.js";
+const addNotificationsSchema = (builder)=>{
+    builder.addTypeDefs(`
+        type WorkflowNotificationTypeError {
+            message: String!
+            code: String
+            data: JSON
+            stack: String
+        }
+
+        type WorkflowNotificationType {
+            id: String!
+            title: String!
+        }
+
+        type ListWorkflowNotificationTypesResponse {
+            data: [WorkflowNotificationType!]
+            error: WorkflowNotificationTypeError
+        }
+
+        extend type WorkflowsQuery {
+            listWorkflowNotificationTypes: ListWorkflowNotificationTypesResponse!
+        }
+    `);
+    builder.addResolver({
+        path: "WorkflowsQuery.listWorkflowNotificationTypes",
+        dependencies: [
+            ListNotificationTypesUseCase
+        ],
+        resolver (listNotificationTypes) {
+            return ()=>resolveList(async ()=>{
+                    const results = await listNotificationTypes.execute();
+                    if (results.isFail()) throw results.error;
+                    return {
+                        items: results.value,
+                        meta: {
+                            totalCount: results.value.length,
+                            cursor: null,
+                            hasMoreItems: false
+                        }
+                    };
+                });
+        }
+    });
+};
+export { addNotificationsSchema };
+
+//# sourceMappingURL=notifications.js.map

package/graphql/notifications.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"graphql/notifications.js","sources":["../../src/graphql/notifications.ts"],"sourcesContent":["import { resolveList } from \"@webiny/api-graphql\";\nimport type { IGraphQLSchemaBuilder } from \"@webiny/api-graphql/features/GraphQLSchemaBuilder/abstractions.js\";\nimport { ListNotificationTypesUseCase } from \"~/features/notifications/ListNotificationTypes/index.js\";\n\nexport const addNotificationsSchema = (builder: IGraphQLSchemaBuilder): void => {\n    builder.addTypeDefs(`\n        type WorkflowNotificationTypeError {\n            message: String!\n            code: String\n            data: JSON\n            stack: String\n        }\n\n        type WorkflowNotificationType {\n            id: String!\n            title: String!\n        }\n\n        type ListWorkflowNotificationTypesResponse {\n            data: [WorkflowNotificationType!]\n            error: WorkflowNotificationTypeError\n        }\n\n        extend type WorkflowsQuery {\n            listWorkflowNotificationTypes: ListWorkflowNotificationTypesResponse!\n        }\n    `);\n\n    builder.addResolver({\n        path: \"WorkflowsQuery.listWorkflowNotificationTypes\",\n        dependencies: [ListNotificationTypesUseCase],\n        resolver(listNotificationTypes) {\n            return () =>\n                resolveList(async () => {\n                    const results = await listNotificationTypes.execute();\n\n                    if (results.isFail()) {\n                        throw results.error;\n                    }\n                    return {\n                        items: results.value,\n                        meta: {\n                            totalCount: results.value.length,\n                            cursor: null,\n                            hasMoreItems: false\n                        }\n                    };\n                });\n        }\n    });\n};\n"],"names":["addNotificationsSchema","builder","ListNotificationTypesUseCase","listNotificationTypes","resolveList","results"],"mappings":";;AAIO,MAAMA,yBAAyB,CAACC;IACnCA,QAAQ,WAAW,CAAC,CAAC;;;;;;;;;;;;;;;;;;;;;IAqBrB,CAAC;IAEDA,QAAQ,WAAW,CAAC;QAChB,MAAM;QACN,cAAc;YAACC;SAA6B;QAC5C,UAASC,qBAAqB;YAC1B,OAAO,IACHC,YAAY;oBACR,MAAMC,UAAU,MAAMF,sBAAsB,OAAO;oBAEnD,IAAIE,QAAQ,MAAM,IACd,MAAMA,QAAQ,KAAK;oBAEvB,OAAO;wBACH,OAAOA,QAAQ,KAAK;wBACpB,MAAM;4BACF,YAAYA,QAAQ,KAAK,CAAC,MAAM;4BAChC,QAAQ;4BACR,cAAc;wBAClB;oBACJ;gBACJ;QACR;IACJ;AACJ"}

package/graphql/validation/approveWorkflowState.d.ts

@@ -0,0 +1,5 @@
+import zod from "zod";
+export declare const approveWorkflowStateValidation: zod.ZodObject<{
+    id: zod.ZodString;
+    comment: zod.ZodOptional<zod.ZodString>;
+}, zod.core.$strip>;

package/graphql/validation/approveWorkflowState.js

@@ -0,0 +1,8 @@
+import zod from "zod";
+const approveWorkflowStateValidation = zod.object({
+    id: zod.string().min(1, "ID is required."),
+    comment: zod.string().optional()
+});
+export { approveWorkflowStateValidation };
+
+//# sourceMappingURL=approveWorkflowState.js.map

package/graphql/validation/approveWorkflowState.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"graphql/validation/approveWorkflowState.js","sources":["../../../src/graphql/validation/approveWorkflowState.ts"],"sourcesContent":["import zod from \"zod\";\n\nexport const approveWorkflowStateValidation = zod.object({\n    id: zod.string().min(1, \"ID is required.\"),\n    comment: zod.string().optional()\n});\n"],"names":["approveWorkflowStateValidation","zod"],"mappings":";AAEO,MAAMA,iCAAiCC,IAAI,MAAM,CAAC;IACrD,IAAIA,IAAI,MAAM,GAAG,GAAG,CAAC,GAAG;IACxB,SAASA,IAAI,MAAM,GAAG,QAAQ;AAClC"}

package/graphql/validation/cancelWorkflowState.d.ts

@@ -0,0 +1,4 @@
+import zod from "zod";
+export declare const cancelWorkflowStateValidation: zod.ZodObject<{
+    id: zod.ZodString;
+}, zod.core.$strip>;

package/graphql/validation/cancelWorkflowState.js

@@ -0,0 +1,7 @@
+import zod from "zod";
+const cancelWorkflowStateValidation = zod.object({
+    id: zod.string().min(1, "ID is required.")
+});
+export { cancelWorkflowStateValidation };
+
+//# sourceMappingURL=cancelWorkflowState.js.map

package/graphql/validation/cancelWorkflowState.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"graphql/validation/cancelWorkflowState.js","sources":["../../../src/graphql/validation/cancelWorkflowState.ts"],"sourcesContent":["import zod from \"zod\";\n\nexport const cancelWorkflowStateValidation = zod.object({\n    id: zod.string().min(1, \"ID is required.\")\n});\n"],"names":["cancelWorkflowStateValidation","zod"],"mappings":";AAEO,MAAMA,gCAAgCC,IAAI,MAAM,CAAC;IACpD,IAAIA,IAAI,MAAM,GAAG,GAAG,CAAC,GAAG;AAC5B"}

package/graphql/validation/createWorkflowState.d.ts

@@ -0,0 +1,6 @@
+import zod from "zod";
+export declare const createWorkflowStateValidation: zod.ZodObject<{
+    app: zod.ZodString;
+    targetRevisionId: zod.ZodString;
+    title: zod.ZodString;
+}, zod.core.$strip>;