@webiny/api-workflows 0.0.0-unstable.61c048f412

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

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

package/features/workflowState/StartWorkflowStateStep/abstractions.js

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

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

@@ -0,0 +1 @@
+{"version":3,"names":["createAbstraction","StartWorkflowStateStepUseCase"],"sources":["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} from \"~/domain/workflowState/errors.js\";\nimport type { WorkflowNotFoundError } from \"~/domain/workflow/errors.js\";\nimport { WorkflowState } from \"~/domain/workflowState/WorkflowState.js\";\n\nexport interface WorkflowStateStartStepPayload {\n    state: WorkflowState;\n}\n\nexport interface IStartWorkflowStateStepUseCase {\n    execute(id: string): Promise<Result<WorkflowState, UseCaseError>>;\n}\n\nexport interface IStartWorkflowStateStepUseCaseErrors {\n    notFound: WorkflowStateNotFoundError;\n    workflowNotFound: WorkflowNotFoundError;\n    cannotReview: WorkflowStateStepCannotReviewError;\n    workflowState: WorkflowState.Error;\n    persistence: WorkflowStatePersistenceError;\n}\n\ntype UseCaseError =\n    IStartWorkflowStateStepUseCaseErrors[keyof IStartWorkflowStateStepUseCaseErrors];\n\nexport const StartWorkflowStateStepUseCase = createAbstraction<IStartWorkflowStateStepUseCase>(\n    \"StartWorkflowStateStepUseCase\"\n);\n\nexport namespace StartWorkflowStateStepUseCase {\n    export type Interface = IStartWorkflowStateStepUseCase;\n    export type Return = Promise<Result<WorkflowState, UseCaseError>>;\n    export type Error = UseCaseError;\n}\n"],"mappings":"AACA,SAASA,iBAAiB,QAAQ,qBAAqB;AA4BvD,OAAO,MAAMC,6BAA6B,GAAGD,iBAAiB,CAC1D,+BACJ,CAAC","ignoreList":[]}

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

@@ -0,0 +1,12 @@
+import type { IEventHandler } from "@webiny/api-core/features/EventPublisher";
+import { DomainEvent } from "@webiny/api-core/features/EventPublisher";
+import type { WorkflowStateStartStepPayload } from "./abstractions.js";
+export declare class WorkflowStateStartStepEvent extends DomainEvent<WorkflowStateStartStepPayload> {
+    eventType: "workflowState.startStep";
+    getHandlerAbstraction(): import("@webiny/di").Abstraction<IEventHandler<WorkflowStateStartStepEvent>>;
+}
+export declare const WorkflowStateStartStepHandler: import("@webiny/di").Abstraction<IEventHandler<WorkflowStateStartStepEvent>>;
+export declare namespace WorkflowStateStartStepHandler {
+    type Interface = IEventHandler<WorkflowStateStartStepEvent>;
+    type Event = WorkflowStateStartStepEvent;
+}

package/features/workflowState/StartWorkflowStateStep/events.js

@@ -0,0 +1,11 @@
+import { createAbstraction } from "@webiny/feature/api";
+import { DomainEvent } from "@webiny/api-core/features/EventPublisher";
+export class WorkflowStateStartStepEvent extends DomainEvent {
+  eventType = "workflowState.startStep";
+  getHandlerAbstraction() {
+    return WorkflowStateStartStepHandler;
+  }
+}
+export const WorkflowStateStartStepHandler = createAbstraction("WorkflowStateStartStepHandler");
+
+//# sourceMappingURL=events.js.map

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

@@ -0,0 +1 @@
+{"version":3,"names":["createAbstraction","DomainEvent","WorkflowStateStartStepEvent","eventType","getHandlerAbstraction","WorkflowStateStartStepHandler"],"sources":["events.ts"],"sourcesContent":["import { createAbstraction } from \"@webiny/feature/api\";\nimport type { IEventHandler } from \"@webiny/api-core/features/EventPublisher\";\nimport { DomainEvent } from \"@webiny/api-core/features/EventPublisher\";\nimport type { WorkflowStateStartStepPayload } from \"./abstractions.js\";\n\nexport class WorkflowStateStartStepEvent extends DomainEvent<WorkflowStateStartStepPayload> {\n    eventType = \"workflowState.startStep\" as const;\n\n    getHandlerAbstraction() {\n        return WorkflowStateStartStepHandler;\n    }\n}\n\nexport const WorkflowStateStartStepHandler = createAbstraction<\n    IEventHandler<WorkflowStateStartStepEvent>\n>(\"WorkflowStateStartStepHandler\");\n\nexport namespace WorkflowStateStartStepHandler {\n    export type Interface = IEventHandler<WorkflowStateStartStepEvent>;\n    export type Event = WorkflowStateStartStepEvent;\n}\n"],"mappings":"AAAA,SAASA,iBAAiB,QAAQ,qBAAqB;AAEvD,SAASC,WAAW,QAAQ,0CAA0C;AAGtE,OAAO,MAAMC,2BAA2B,SAASD,WAAW,CAAgC;EACxFE,SAAS,GAAG,yBAAyB;EAErCC,qBAAqBA,CAAA,EAAG;IACpB,OAAOC,6BAA6B;EACxC;AACJ;AAEA,OAAO,MAAMA,6BAA6B,GAAGL,iBAAiB,CAE5D,+BAA+B,CAAC","ignoreList":[]}

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

@@ -0,0 +1 @@
+export declare const StartWorkflowStateStepFeature: import("@webiny/feature/api/createFeature.js").FeatureDefinition<unknown>;

package/features/workflowState/StartWorkflowStateStep/feature.js

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

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

@@ -0,0 +1 @@
+{"version":3,"names":["createFeature","StartWorkflowStateStepUseCase","StartWorkflowStateStepFeature","name","register","container"],"sources":["feature.ts"],"sourcesContent":["import { createFeature } from \"@webiny/feature/api\";\nimport { StartWorkflowStateStepUseCase } from \"./StartWorkflowStateStepUseCase.js\";\n\nexport const StartWorkflowStateStepFeature = createFeature({\n    name: \"WorkflowState/StartWorkflowStateStep\",\n    register(container) {\n        container.register(StartWorkflowStateStepUseCase);\n    }\n});\n"],"mappings":"AAAA,SAASA,aAAa,QAAQ,qBAAqB;AACnD,SAASC,6BAA6B;AAEtC,OAAO,MAAMC,6BAA6B,GAAGF,aAAa,CAAC;EACvDG,IAAI,EAAE,sCAAsC;EAC5CC,QAAQA,CAACC,SAAS,EAAE;IAChBA,SAAS,CAACD,QAAQ,CAACH,6BAA6B,CAAC;EACrD;AACJ,CAAC,CAAC","ignoreList":[]}

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

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

package/features/workflowState/StartWorkflowStateStep/index.js

@@ -0,0 +1,4 @@
+export { StartWorkflowStateStepUseCase } from "./abstractions.js";
+export { WorkflowStateStartStepEvent } from "./events.js";
+
+//# sourceMappingURL=index.js.map

package/features/workflowState/StartWorkflowStateStep/index.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["StartWorkflowStateStepUseCase","WorkflowStateStartStepEvent"],"sources":["index.ts"],"sourcesContent":["export { StartWorkflowStateStepUseCase } from \"./abstractions.js\";\nexport { WorkflowStateStartStepEvent } from \"./events.js\";\n"],"mappings":"AAAA,SAASA,6BAA6B;AACtC,SAASC,2BAA2B","ignoreList":[]}

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,39 @@
+import { Result } from "@webiny/feature/api";
+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";
+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);
+  }
+}
+export const TakeOverWorkflowStateStepUseCase = UseCase.createImplementation({
+  implementation: TakeOverWorkflowStateStepUseCaseImpl,
+  dependencies: [GetWorkflowStateUseCase, UpdateWorkflowStateRepository, EventPublisher]
+});
+
+//# sourceMappingURL=TakeOverWorkflowStateStepUseCase.js.map

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

@@ -0,0 +1 @@
+{"version":3,"names":["Result","GetWorkflowStateUseCase","UpdateWorkflowStateRepository","TakeOverWorkflowStateStepUseCase","UseCase","EventPublisher","WorkflowStateTakeOverStepEvent","TakeOverWorkflowStateStepUseCaseImpl","constructor","getWorkflowState","repository","eventPublisher","execute","id","stateResult","isFail","fail","error","state","value","takeOverResult","takeOver","updatedRecord","toRecord","updateResult","publish","ok","createImplementation","implementation","dependencies"],"sources":["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"],"mappings":"AAAA,SAASA,MAAM,QAAQ,qBAAqB;AAC5C,SAASC,uBAAuB;AAChC,SAASC,6BAA6B;AACtC,SAASC,gCAAgC,IAAIC,OAAO;AACpD,SAASC,cAAc,QAAQ,mDAAmD;AAClF,SAASC,8BAA8B;AAEvC,MAAMC,oCAAoC,CAA8B;EACpEC,WAAWA,CACCC,gBAAmD,EACnDC,UAAmD,EACnDC,cAAwC,EAClD;IAAA,KAHUF,gBAAmD,GAAnDA,gBAAmD;IAAA,KACnDC,UAAmD,GAAnDA,UAAmD;IAAA,KACnDC,cAAwC,GAAxCA,cAAwC;EACjD;EAEH,MAAMC,OAAOA,CAACC,EAAU,EAAkB;IACtC,MAAMC,WAAW,GAAG,MAAM,IAAI,CAACL,gBAAgB,CAACG,OAAO,CAACC,EAAE,CAAC;IAC3D,IAAIC,WAAW,CAACC,MAAM,CAAC,CAAC,EAAE;MACtB,OAAOf,MAAM,CAACgB,IAAI,CAACF,WAAW,CAACG,KAAK,CAAC;IACzC;IAEA,MAAMC,KAAK,GAAGJ,WAAW,CAACK,KAAK;IAE/B,MAAMC,cAAc,GAAGF,KAAK,CAACG,QAAQ,CAAC,CAAC;IACvC,IAAID,cAAc,CAACL,MAAM,CAAC,CAAC,EAAE;MACzB,OAAOf,MAAM,CAACgB,IAAI,CAACI,cAAc,CAACH,KAAK,CAAC;IAC5C;IAEA,MAAMK,aAAa,GAAGJ,KAAK,CAACK,QAAQ,CAAC,CAAC;IAEtC,MAAMC,YAAY,GAAG,MAAM,IAAI,CAACd,UAAU,CAACE,OAAO,CAACC,EAAE,EAAES,aAAa,CAAC;IACrE,IAAIE,YAAY,CAACT,MAAM,CAAC,CAAC,EAAE;MACvB,OAAOf,MAAM,CAACgB,IAAI,CAACQ,YAAY,CAACP,KAAK,CAAC;IAC1C;IAEA,MAAM,IAAI,CAACN,cAAc,CAACc,OAAO,CAC7B,IAAInB,8BAA8B,CAAC;MAC/BY;IACJ,CAAC,CACL,CAAC;IAED,OAAOlB,MAAM,CAAC0B,EAAE,CAACR,KAAK,CAAC;EAC3B;AACJ;AAEA,OAAO,MAAMf,gCAAgC,GAAGC,OAAO,CAACuB,oBAAoB,CAAC;EACzEC,cAAc,EAAErB,oCAAoC;EACpDsB,YAAY,EAAE,CAAC5B,uBAAuB,EAAEC,6BAA6B,EAAEG,cAAc;AACzF,CAAC,CAAC","ignoreList":[]}

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,4 @@
+import { createAbstraction } from "@webiny/feature/api";
+export const TakeOverWorkflowStateStepUseCase = createAbstraction("TakeOverWorkflowStateStepUseCase");
+
+//# sourceMappingURL=abstractions.js.map

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

@@ -0,0 +1 @@
+{"version":3,"names":["createAbstraction","TakeOverWorkflowStateStepUseCase"],"sources":["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"],"mappings":"AACA,SAASA,iBAAiB,QAAQ,qBAAqB;AA8BvD,OAAO,MAAMC,gCAAgC,GACzCD,iBAAiB,CAAoC,kCAAkC,CAAC","ignoreList":[]}

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

@@ -0,0 +1,12 @@
+import type { IEventHandler } from "@webiny/api-core/features/EventPublisher";
+import { DomainEvent } from "@webiny/api-core/features/EventPublisher";
+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,11 @@
+import { createAbstraction } from "@webiny/feature/api";
+import { DomainEvent } from "@webiny/api-core/features/EventPublisher";
+export class WorkflowStateTakeOverStepEvent extends DomainEvent {
+  eventType = "workflowState.takeOverStep";
+  getHandlerAbstraction() {
+    return WorkflowStateTakeOverStepHandler;
+  }
+}
+export const WorkflowStateTakeOverStepHandler = createAbstraction("WorkflowStateTakeOverStepHandler");
+
+//# sourceMappingURL=events.js.map

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

@@ -0,0 +1 @@
+{"version":3,"names":["createAbstraction","DomainEvent","WorkflowStateTakeOverStepEvent","eventType","getHandlerAbstraction","WorkflowStateTakeOverStepHandler"],"sources":["events.ts"],"sourcesContent":["import { createAbstraction } from \"@webiny/feature/api\";\nimport type { IEventHandler } from \"@webiny/api-core/features/EventPublisher\";\nimport { DomainEvent } from \"@webiny/api-core/features/EventPublisher\";\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"],"mappings":"AAAA,SAASA,iBAAiB,QAAQ,qBAAqB;AAEvD,SAASC,WAAW,QAAQ,0CAA0C;AAGtE,OAAO,MAAMC,8BAA8B,SAASD,WAAW,CAAmC;EAC9FE,SAAS,GAAG,4BAA4B;EAExCC,qBAAqBA,CAAA,EAAG;IACpB,OAAOC,gCAAgC;EAC3C;AACJ;AAEA,OAAO,MAAMA,gCAAgC,GAAGL,iBAAiB,CAE/D,kCAAkC,CAAC","ignoreList":[]}

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

@@ -0,0 +1 @@
+export declare const TakeOverWorkflowStateStepFeature: import("@webiny/feature/api/createFeature.js").FeatureDefinition<unknown>;

package/features/workflowState/TakeOverWorkflowStateStep/feature.js

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

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

@@ -0,0 +1 @@
+{"version":3,"names":["createFeature","TakeOverWorkflowStateStepUseCase","TakeOverWorkflowStateStepFeature","name","register","container"],"sources":["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"],"mappings":"AAAA,SAASA,aAAa,QAAQ,qBAAqB;AACnD,SAASC,gCAAgC;AAEzC,OAAO,MAAMC,gCAAgC,GAAGF,aAAa,CAAC;EAC1DG,IAAI,EAAE,yCAAyC;EAC/CC,QAAQA,CAACC,SAAS,EAAE;IAChBA,SAAS,CAACD,QAAQ,CAACH,gCAAgC,CAAC;EACxD;AACJ,CAAC,CAAC","ignoreList":[]}

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,4 @@
+export { TakeOverWorkflowStateStepUseCase } from "./abstractions.js";
+export { WorkflowStateTakeOverStepEvent } from "./events.js";
+
+//# sourceMappingURL=index.js.map

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

@@ -0,0 +1 @@
+{"version":3,"names":["TakeOverWorkflowStateStepUseCase","WorkflowStateTakeOverStepEvent"],"sources":["index.ts"],"sourcesContent":["export { TakeOverWorkflowStateStepUseCase } from \"./abstractions.js\";\nexport { WorkflowStateTakeOverStepEvent } from \"./events.js\";\n"],"mappings":"AAAA,SAASA,gCAAgC;AACzC,SAASC,8BAA8B","ignoreList":[]}

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,48 @@
+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 { WorkflowStateModel, WorkflowStateMapper } from "../../../domain/workflowState/abstractions.js";
+import { WorkflowStateNotFoundError, WorkflowStatePersistenceError } from "../../../domain/workflowState/errors.js";
+import { UpdateWorkflowStateRepository as Repository } 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 (getResult.error.code === "Cms/Entry/NotFound") {
+        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));
+    }
+  }
+}
+export const UpdateWorkflowStateRepository = Repository.createImplementation({
+  implementation: UpdateWorkflowStateRepositoryImpl,
+  dependencies: [GetEntryByIdUseCase, UpdateEntryUseCase, WorkflowStateModel, WorkflowStateMapper]
+});
+
+//# sourceMappingURL=UpdateWorkflowStateRepository.js.map

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

@@ -0,0 +1 @@
+{"version":3,"names":["Result","UpdateEntryUseCase","GetEntryByIdUseCase","WorkflowStateModel","WorkflowStateMapper","WorkflowStateNotFoundError","WorkflowStatePersistenceError","UpdateWorkflowStateRepository","Repository","UpdateWorkflowStateRepositoryImpl","constructor","getEntryById","updateEntry","model","mapper","execute","id","input","getResult","isFail","error","code","fail","originalRecord","fromCmsEntry","value","updatedValues","toCmsEntry","updateResult","values","updatedRecord","ok","createImplementation","implementation","dependencies"],"sources":["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"],"mappings":"AAAA,SAASA,MAAM,QAAQ,qBAAqB;AAC5C,SAASC,kBAAkB,QAAQ,qEAAqE;AACxG,SAASC,mBAAmB,QAAQ,sEAAsE;AAC1G,SAASC,kBAAkB,EAAEC,mBAAmB;AAEhD,SACIC,0BAA0B,EAC1BC,6BAA6B;AAEjC,SAASC,6BAA6B,IAAIC,UAAU;AAGpD,MAAMC,iCAAiC,CAAiC;EACpEC,WAAWA,CACCC,YAA2C,EAC3CC,WAAyC,EACzCC,KAAmC,EACnCC,MAAqC,EAC/C;IAAA,KAJUH,YAA2C,GAA3CA,YAA2C;IAAA,KAC3CC,WAAyC,GAAzCA,WAAyC;IAAA,KACzCC,KAAmC,GAAnCA,KAAmC;IAAA,KACnCC,MAAqC,GAArCA,MAAqC;EAC9C;EAEH,MAAMC,OAAOA,CAACC,EAAU,EAAEC,KAAgC,EAAqB;IAC3E,MAAMC,SAAS,GAAG,MAAM,IAAI,CAACP,YAAY,CAACI,OAAO,CAC7C,IAAI,CAACF,KAAK,EACVG,EACJ,CAAC;IAED,IAAIE,SAAS,CAACC,MAAM,CAAC,CAAC,EAAE;MACpB,IAAID,SAAS,CAACE,KAAK,CAACC,IAAI,KAAK,oBAAoB,EAAE;QAC/C,OAAOrB,MAAM,CAACsB,IAAI,CACd,IAAIjB,0BAA0B,CAAC;UAC3BW;QACJ,CAAC,CACL,CAAC;MACL;MACA,OAAOhB,MAAM,CAACsB,IAAI,CAAC,IAAIhB,6BAA6B,CAACY,SAAS,CAACE,KAAK,CAAC,CAAC;IAC1E;IAEA,MAAMG,cAAc,GAAG,IAAI,CAACT,MAAM,CAACU,YAAY,CAACN,SAAS,CAACO,KAAK,CAAC;IAEhE,MAAMC,aAAa,GAAG,IAAI,CAACZ,MAAM,CAACa,UAAU,CAAC;MACzC,GAAGJ,cAAc;MACjB,GAAGN;IACP,CAAC,CAAC;IAEF,IAAI;MACA,MAAMW,YAAY,GAAG,MAAM,IAAI,CAAChB,WAAW,CAACG,OAAO,CAAmB,IAAI,CAACF,KAAK,EAAEG,EAAE,EAAE;QAClFa,MAAM,EAAEH;MACZ,CAAC,CAAC;MAEF,IAAIE,YAAY,CAACT,MAAM,CAAC,CAAC,EAAE;QACvB,OAAOnB,MAAM,CAACsB,IAAI,CAAC,IAAIhB,6BAA6B,CAACsB,YAAY,CAACR,KAAK,CAAC,CAAC;MAC7E;MAEA,MAAMU,aAAa,GAAG,IAAI,CAAChB,MAAM,CAACU,YAAY,CAACI,YAAY,CAACH,KAAK,CAAC;MAClE,OAAOzB,MAAM,CAAC+B,EAAE,CAACD,aAAa,CAAC;IACnC,CAAC,CAAC,OAAOV,KAAK,EAAE;MACZ,OAAOpB,MAAM,CAACsB,IAAI,CAAC,IAAIhB,6BAA6B,CAACc,KAAc,CAAC,CAAC;IACzE;EACJ;AACJ;AAEA,OAAO,MAAMb,6BAA6B,GAAGC,UAAU,CAACwB,oBAAoB,CAAC;EACzEC,cAAc,EAAExB,iCAAiC;EACjDyB,YAAY,EAAE,CAAChC,mBAAmB,EAAED,kBAAkB,EAAEE,kBAAkB,EAAEC,mBAAmB;AACnG,CAAC,CAAC","ignoreList":[]}

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

@@ -0,0 +1,20 @@
+import { IdentityContext } from "@webiny/api-core/features/IdentityContext";
+import { GetUserTeamsUseCase } from "../../../features/internal/GetUserTeams/index.js";
+import { EventPublisher } from "@webiny/api-core/features/EventPublisher";
+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,57 @@
+import { Result } from "@webiny/feature/api";
+import { IdentityContext } from "@webiny/api-core/features/IdentityContext";
+import { GetUserTeamsUseCase } from "../../internal/GetUserTeams/index.js";
+import { EventPublisher } from "@webiny/api-core/features/EventPublisher";
+import { GetWorkflowUseCase } from "../../workflow/GetWorkflow/index.js";
+import { GetWorkflowStateUseCase } from "../GetWorkflowState/index.js";
+import { UpdateWorkflowStateRepository, UpdateWorkflowStateUseCase as UseCase } 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);
+  }
+}
+export const UpdateWorkflowStateUseCase = UseCase.createImplementation({
+  implementation: UpdateWorkflowStateUseCaseImpl,
+  dependencies: [IdentityContext, GetUserTeamsUseCase, EventPublisher, GetWorkflowUseCase, GetWorkflowStateUseCase, UpdateWorkflowStateRepository]
+});
+
+//# sourceMappingURL=UpdateWorkflowStateUseCase.js.map

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

@@ -0,0 +1 @@
+{"version":3,"names":["Result","IdentityContext","GetUserTeamsUseCase","EventPublisher","GetWorkflowUseCase","GetWorkflowStateUseCase","UpdateWorkflowStateRepository","UpdateWorkflowStateUseCase","UseCase","WorkflowStateAfterUpdateEvent","WorkflowState","WorkflowNotFoundError","UpdateWorkflowStateUseCaseImpl","constructor","identityContext","getUserTeams","eventPublisher","getWorkflow","getWorkflowState","repository","execute","id","input","originalStateResult","isFail","fail","error","originalState","value","workflowResult","app","workflowId","updateResult","updatedRecord","identity","getIdentity","teamsResult","teams","updatedState","publish","state","original","ok","createImplementation","implementation","dependencies"],"sources":["UpdateWorkflowStateUseCase.ts"],"sourcesContent":["import { Result } from \"@webiny/feature/api\";\nimport { IdentityContext } from \"@webiny/api-core/features/IdentityContext\";\nimport { GetUserTeamsUseCase } from \"~/features/internal/GetUserTeams/index.js\";\nimport { EventPublisher } from \"@webiny/api-core/features/EventPublisher\";\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"],"mappings":"AAAA,SAASA,MAAM,QAAQ,qBAAqB;AAC5C,SAASC,eAAe,QAAQ,2CAA2C;AAC3E,SAASC,mBAAmB;AAC5B,SAASC,cAAc,QAAQ,0CAA0C;AACzE,SAASC,kBAAkB;AAC3B,SAASC,uBAAuB;AAChC,SACIC,6BAA6B,EAC7BC,0BAA0B,IAAIC,OAAO;AAEzC,SAASC,6BAA6B;AACtC,SAASC,aAAa;AACtB,SAASC,qBAAqB;AAE9B,MAAMC,8BAA8B,CAA8B;EAC9DC,WAAWA,CACCC,eAA0C,EAC1CC,YAA2C,EAC3CC,cAAwC,EACxCC,WAAyC,EACzCC,gBAAmD,EACnDC,UAAmD,EAC7D;IAAA,KANUL,eAA0C,GAA1CA,eAA0C;IAAA,KAC1CC,YAA2C,GAA3CA,YAA2C;IAAA,KAC3CC,cAAwC,GAAxCA,cAAwC;IAAA,KACxCC,WAAyC,GAAzCA,WAAyC;IAAA,KACzCC,gBAAmD,GAAnDA,gBAAmD;IAAA,KACnDC,UAAmD,GAAnDA,UAAmD;EAC5D;EAEH,MAAMC,OAAOA,CAACC,EAAU,EAAEC,KAAoB,EAAkB;IAC5D,MAAMC,mBAAmB,GAAG,MAAM,IAAI,CAACL,gBAAgB,CAACE,OAAO,CAACC,EAAE,CAAC;IACnE,IAAIE,mBAAmB,CAACC,MAAM,CAAC,CAAC,EAAE;MAC9B,OAAOxB,MAAM,CAACyB,IAAI,CAACF,mBAAmB,CAACG,KAAK,CAAC;IACjD;IAEA,MAAMC,aAAa,GAAGJ,mBAAmB,CAACK,KAAK;IAE/C,MAAMC,cAAc,GAAG,MAAM,IAAI,CAACZ,WAAW,CAACG,OAAO,CAAC;MAClDU,GAAG,EAAEH,aAAa,CAACG,GAAG;MACtBT,EAAE,EAAEM,aAAa,CAACI;IACtB,CAAC,CAAC;IAEF,IAAIF,cAAc,CAACL,MAAM,CAAC,CAAC,EAAE;MACzB,OAAOxB,MAAM,CAACyB,IAAI,CACd,IAAId,qBAAqB,CAAC;QACtBU,EAAE,EAAEM,aAAa,CAACI,UAAU;QAC5BD,GAAG,EAAEH,aAAa,CAACG;MACvB,CAAC,CACL,CAAC;IACL;IAEA,MAAME,YAAY,GAAG,MAAM,IAAI,CAACb,UAAU,CAACC,OAAO,CAACC,EAAE,EAAEC,KAAK,CAAC;IAC7D,IAAIU,YAAY,CAACR,MAAM,CAAC,CAAC,EAAE;MACvB,OAAOxB,MAAM,CAACyB,IAAI,CAACO,YAAY,CAACN,KAAK,CAAC;IAC1C;IAEA,MAAMO,aAAa,GAAGD,YAAY,CAACJ,KAAK;IAExC,MAAMM,QAAQ,GAAG,IAAI,CAACpB,eAAe,CAACqB,WAAW,CAAC,CAAC;IACnD,MAAMC,WAAW,GAAG,MAAM,IAAI,CAACrB,YAAY,CAACK,OAAO,CAACc,QAAQ,CAACb,EAAE,CAAC;IAChE,MAAMgB,KAAK,GAAGD,WAAW,CAACR,KAAK;IAC/B,MAAMU,YAAY,GAAG,IAAI5B,aAAa,CAACuB,aAAa,EAAEI,KAAK,EAAEH,QAAQ,CAAC;IAEtE,MAAM,IAAI,CAAClB,cAAc,CAACuB,OAAO,CAC7B,IAAI9B,6BAA6B,CAAC;MAC9B+B,KAAK,EAAEF,YAAY;MACnBG,QAAQ,EAAEd;IACd,CAAC,CACL,CAAC;IAED,OAAO3B,MAAM,CAAC0C,EAAE,CAACJ,YAAY,CAAC;EAClC;AACJ;AAEA,OAAO,MAAM/B,0BAA0B,GAAGC,OAAO,CAACmC,oBAAoB,CAAC;EACnEC,cAAc,EAAEhC,8BAA8B;EAC9CiC,YAAY,EAAE,CACV5C,eAAe,EACfC,mBAAmB,EACnBC,cAAc,EACdC,kBAAkB,EAClBC,uBAAuB,EACvBC,6BAA6B;AAErC,CAAC,CAAC","ignoreList":[]}

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,15 @@
+import { createAbstraction } from "@webiny/feature/api";
+
+/**
+ * UpdateWorkflowState use case interface
+ */
+
+export const UpdateWorkflowStateUseCase = createAbstraction("UpdateWorkflowStateUseCase");
+
+/**
+ * UpdateWorkflowState repository interface
+ */
+
+export const UpdateWorkflowStateRepository = createAbstraction("UpdateWorkflowStateRepository");
+
+//# sourceMappingURL=abstractions.js.map

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

@@ -0,0 +1 @@
+{"version":3,"names":["createAbstraction","UpdateWorkflowStateUseCase","UpdateWorkflowStateRepository"],"sources":["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"],"mappings":"AACA,SAASA,iBAAiB,QAAQ,qBAAqB;;AAmBvD;AACA;AACA;;AAgBA,OAAO,MAAMC,0BAA0B,GAAGD,iBAAiB,CACvD,4BACJ,CAAC;;AASD;AACA;AACA;;AAgBA,OAAO,MAAME,6BAA6B,GAAGF,iBAAiB,CAC1D,+BACJ,CAAC","ignoreList":[]}

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

@@ -0,0 +1,12 @@
+import { DomainEvent } from "@webiny/api-core/features/EventPublisher";
+import type { IEventHandler } from "@webiny/api-core/features/EventPublisher";
+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,11 @@
+import { createAbstraction } from "@webiny/feature/api";
+import { DomainEvent } from "@webiny/api-core/features/EventPublisher";
+export class WorkflowStateAfterUpdateEvent extends DomainEvent {
+  eventType = "workflowState.afterUpdate";
+  getHandlerAbstraction() {
+    return WorkflowStateAfterUpdateHandler;
+  }
+}
+export const WorkflowStateAfterUpdateHandler = createAbstraction("WorkflowStateAfterUpdateHandler");
+
+//# sourceMappingURL=events.js.map

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

@@ -0,0 +1 @@
+{"version":3,"names":["createAbstraction","DomainEvent","WorkflowStateAfterUpdateEvent","eventType","getHandlerAbstraction","WorkflowStateAfterUpdateHandler"],"sources":["events.ts"],"sourcesContent":["import { createAbstraction } from \"@webiny/feature/api\";\nimport { DomainEvent } from \"@webiny/api-core/features/EventPublisher\";\nimport type { IEventHandler } from \"@webiny/api-core/features/EventPublisher\";\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"],"mappings":"AAAA,SAASA,iBAAiB,QAAQ,qBAAqB;AACvD,SAASC,WAAW,QAAQ,0CAA0C;AAItE,OAAO,MAAMC,6BAA6B,SAASD,WAAW,CAAkC;EAC5FE,SAAS,GAAG,2BAA2B;EAEvCC,qBAAqBA,CAAA,EAAG;IACpB,OAAOC,+BAA+B;EAC1C;AACJ;AAEA,OAAO,MAAMA,+BAA+B,GAAGL,iBAAiB,CAE9D,iCAAiC,CAAC","ignoreList":[]}

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

@@ -0,0 +1 @@
+export declare const UpdateWorkflowStateFeature: import("@webiny/feature/api/createFeature.js").FeatureDefinition<unknown>;

package/features/workflowState/UpdateWorkflowState/feature.js

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

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

@@ -0,0 +1 @@
+{"version":3,"names":["createFeature","UpdateWorkflowStateUseCase","UpdateWorkflowStateRepository","UpdateWorkflowStateFeature","name","register","container","inSingletonScope"],"sources":["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"],"mappings":"AAAA,SAASA,aAAa,QAAQ,qBAAqB;AACnD,SAASC,0BAA0B;AACnC,SAASC,6BAA6B;AAEtC,OAAO,MAAMC,0BAA0B,GAAGH,aAAa,CAAC;EACpDI,IAAI,EAAE,mCAAmC;EACzCC,QAAQA,CAACC,SAAS,EAAE;IAChBA,SAAS,CAACD,QAAQ,CAACH,6BAA6B,CAAC,CAACK,gBAAgB,CAAC,CAAC;IACpED,SAAS,CAACD,QAAQ,CAACJ,0BAA0B,CAAC;EAClD;AACJ,CAAC,CAAC","ignoreList":[]}

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,4 @@
+export { UpdateWorkflowStateUseCase, UpdateWorkflowStateRepository } from "./abstractions.js";
+export { WorkflowStateAfterUpdateHandler } from "./events.js";
+
+//# sourceMappingURL=index.js.map

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

@@ -0,0 +1 @@
+{"version":3,"names":["UpdateWorkflowStateUseCase","UpdateWorkflowStateRepository","WorkflowStateAfterUpdateHandler"],"sources":["index.ts"],"sourcesContent":["export { UpdateWorkflowStateUseCase, UpdateWorkflowStateRepository } from \"./abstractions.js\";\nexport { WorkflowStateAfterUpdateHandler } from \"./events.js\";\n"],"mappings":"AAAA,SAASA,0BAA0B,EAAEC,6BAA6B;AAClE,SAASC,+BAA+B","ignoreList":[]}