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

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

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

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

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

package/features/workflowState/ApproveWorkflowStateStep/feature.js

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

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

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

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

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

package/features/workflowState/ApproveWorkflowStateStep/index.js

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

package/features/workflowState/CancelWorkflowState/CancelWorkflowStateUseCase.d.ts

@@ -0,0 +1,13 @@
+import { UpdateWorkflowStateUseCase } from "../UpdateWorkflowState/index.js";
+import { CancelWorkflowStateUseCase as UseCase } from "./abstractions.js";
+import { EventPublisher } from "@webiny/api-core/features/eventPublisher/index.js";
+declare class CancelWorkflowStateUseCaseImpl implements UseCase.Interface {
+    private updateWorkflowState;
+    private eventPublisher;
+    constructor(updateWorkflowState: UpdateWorkflowStateUseCase.Interface, eventPublisher: EventPublisher.Interface);
+    execute(id: string): UseCase.Return;
+}
+export declare const CancelWorkflowStateUseCase: typeof CancelWorkflowStateUseCaseImpl & {
+    __abstraction: import("@webiny/di").Abstraction<import("./abstractions.js").ICancelWorkflowStateUseCase>;
+};
+export {};

package/features/workflowState/CancelWorkflowState/CancelWorkflowStateUseCase.js

@@ -0,0 +1,31 @@
+import { UpdateWorkflowStateUseCase } from "../UpdateWorkflowState/index.js";
+import { CancelWorkflowStateUseCase } from "./abstractions.js";
+import { Result } from "@webiny/feature/api";
+import { EventPublisher } from "@webiny/api-core/features/eventPublisher/index.js";
+import { WorkflowStateCancelEvent } from "./events.js";
+class CancelWorkflowStateUseCaseImpl {
+    constructor(updateWorkflowState, eventPublisher){
+        this.updateWorkflowState = updateWorkflowState;
+        this.eventPublisher = eventPublisher;
+    }
+    async execute(id) {
+        const result = await this.updateWorkflowState.execute(id, {
+            isActive: false
+        });
+        if (result.isFail()) return Result.fail(result.error);
+        await this.eventPublisher.publish(new WorkflowStateCancelEvent({
+            state: result.value
+        }));
+        return result;
+    }
+}
+const CancelWorkflowStateUseCase_CancelWorkflowStateUseCase = CancelWorkflowStateUseCase.createImplementation({
+    implementation: CancelWorkflowStateUseCaseImpl,
+    dependencies: [
+        UpdateWorkflowStateUseCase,
+        EventPublisher
+    ]
+});
+export { CancelWorkflowStateUseCase_CancelWorkflowStateUseCase as CancelWorkflowStateUseCase };
+
+//# sourceMappingURL=CancelWorkflowStateUseCase.js.map

package/features/workflowState/CancelWorkflowState/CancelWorkflowStateUseCase.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"features/workflowState/CancelWorkflowState/CancelWorkflowStateUseCase.js","sources":["../../../../src/features/workflowState/CancelWorkflowState/CancelWorkflowStateUseCase.ts"],"sourcesContent":["import { UpdateWorkflowStateUseCase } from \"../UpdateWorkflowState/index.js\";\nimport { CancelWorkflowStateUseCase as UseCase } from \"./abstractions.js\";\nimport { Result } from \"@webiny/feature/api\";\nimport { EventPublisher } from \"@webiny/api-core/features/eventPublisher/index.js\";\nimport { WorkflowStateCancelEvent } from \"~/features/workflowState/CancelWorkflowState/events.js\";\n\nclass CancelWorkflowStateUseCaseImpl implements UseCase.Interface {\n    constructor(\n        private updateWorkflowState: UpdateWorkflowStateUseCase.Interface,\n        private eventPublisher: EventPublisher.Interface\n    ) {}\n\n    async execute(id: string): UseCase.Return {\n        const result = await this.updateWorkflowState.execute(id, {\n            isActive: false\n        });\n        if (result.isFail()) {\n            return Result.fail(result.error);\n        }\n\n        await this.eventPublisher.publish(\n            new WorkflowStateCancelEvent({\n                state: result.value\n            })\n        );\n\n        return result;\n    }\n}\n\nexport const CancelWorkflowStateUseCase = UseCase.createImplementation({\n    implementation: CancelWorkflowStateUseCaseImpl,\n    dependencies: [UpdateWorkflowStateUseCase, EventPublisher]\n});\n"],"names":["CancelWorkflowStateUseCaseImpl","updateWorkflowState","eventPublisher","id","result","Result","WorkflowStateCancelEvent","CancelWorkflowStateUseCase","UseCase","UpdateWorkflowStateUseCase","EventPublisher"],"mappings":";;;;;AAMA,MAAMA;IACF,YACYC,mBAAyD,EACzDC,cAAwC,CAClD;aAFUD,mBAAmB,GAAnBA;aACAC,cAAc,GAAdA;IACT;IAEH,MAAM,QAAQC,EAAU,EAAkB;QACtC,MAAMC,SAAS,MAAM,IAAI,CAAC,mBAAmB,CAAC,OAAO,CAACD,IAAI;YACtD,UAAU;QACd;QACA,IAAIC,OAAO,MAAM,IACb,OAAOC,OAAO,IAAI,CAACD,OAAO,KAAK;QAGnC,MAAM,IAAI,CAAC,cAAc,CAAC,OAAO,CAC7B,IAAIE,yBAAyB;YACzB,OAAOF,OAAO,KAAK;QACvB;QAGJ,OAAOA;IACX;AACJ;AAEO,MAAMG,wDAA6BC,2BAAAA,oBAA4B,CAAC;IACnE,gBAAgBR;IAChB,cAAc;QAACS;QAA4BC;KAAe;AAC9D"}

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

@@ -0,0 +1,26 @@
+import type { Result } from "@webiny/feature/api";
+import { type WorkflowStateNotFoundError, type WorkflowStatePersistenceError } from "../../../domain/workflowState/errors.js";
+import type { WorkflowNotFoundError } from "../../../domain/workflow/errors.js";
+import { WorkflowState } from "../../../domain/workflowState/WorkflowState.js";
+export interface WorkflowStateCancelPayload {
+    state: WorkflowState;
+}
+/**
+ * CancelWorkflowState use case interface - marks workflow state as inactive
+ */
+export interface ICancelWorkflowStateUseCase {
+    execute(id: string): Promise<Result<WorkflowState, UseCaseError>>;
+}
+export interface ICancelWorkflowStateUseCaseErrors {
+    notFound: WorkflowStateNotFoundError;
+    workflowNotFound: WorkflowNotFoundError;
+    persistence: WorkflowStatePersistenceError;
+}
+type UseCaseError = ICancelWorkflowStateUseCaseErrors[keyof ICancelWorkflowStateUseCaseErrors];
+export declare const CancelWorkflowStateUseCase: import("@webiny/di").Abstraction<ICancelWorkflowStateUseCase>;
+export declare namespace CancelWorkflowStateUseCase {
+    type Interface = ICancelWorkflowStateUseCase;
+    type Return = Promise<Result<WorkflowState, UseCaseError>>;
+    type Error = UseCaseError;
+}
+export {};

package/features/workflowState/CancelWorkflowState/abstractions.js

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"features/workflowState/CancelWorkflowState/abstractions.js","sources":["../../../../src/features/workflowState/CancelWorkflowState/abstractions.ts"],"sourcesContent":["import type { Result } from \"@webiny/feature/api\";\nimport { createAbstraction } from \"@webiny/feature/api\";\nimport {\n    type WorkflowStateNotFoundError,\n    type WorkflowStatePersistenceError\n} from \"~/domain/workflowState/errors.js\";\nimport type { WorkflowNotFoundError } from \"~/domain/workflow/errors.js\";\nimport { WorkflowState } from \"~/domain/workflowState/WorkflowState.js\";\n\nexport interface WorkflowStateCancelPayload {\n    state: WorkflowState;\n}\n\n/**\n * CancelWorkflowState use case interface - marks workflow state as inactive\n */\nexport interface ICancelWorkflowStateUseCase {\n    execute(id: string): Promise<Result<WorkflowState, UseCaseError>>;\n}\n\nexport interface ICancelWorkflowStateUseCaseErrors {\n    notFound: WorkflowStateNotFoundError;\n    workflowNotFound: WorkflowNotFoundError;\n    persistence: WorkflowStatePersistenceError;\n}\n\ntype UseCaseError = ICancelWorkflowStateUseCaseErrors[keyof ICancelWorkflowStateUseCaseErrors];\n\nexport const CancelWorkflowStateUseCase = createAbstraction<ICancelWorkflowStateUseCase>(\n    \"CancelWorkflowStateUseCase\"\n);\n\nexport namespace CancelWorkflowStateUseCase {\n    export type Interface = ICancelWorkflowStateUseCase;\n    export type Return = Promise<Result<WorkflowState, UseCaseError>>;\n    export type Error = UseCaseError;\n}\n"],"names":["CancelWorkflowStateUseCase","createAbstraction"],"mappings":";AA4BO,MAAMA,6BAA6BC,kBACtC"}

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

package/features/workflowState/CancelWorkflowState/events.js

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"features/workflowState/CancelWorkflowState/events.js","sources":["../../../../src/features/workflowState/CancelWorkflowState/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 { WorkflowStateCancelPayload } from \"./abstractions.js\";\n\nexport class WorkflowStateCancelEvent extends DomainEvent<WorkflowStateCancelPayload> {\n    eventType = \"workflowState.cancel\" as const;\n\n    getHandlerAbstraction() {\n        return WorkflowStateCancelHandler;\n    }\n}\n\nexport const WorkflowStateCancelHandler = createAbstraction<\n    IEventHandler<WorkflowStateCancelEvent>\n>(\"WorkflowStateCancelHandler\");\n\nexport namespace WorkflowStateCancelHandler {\n    export type Interface = IEventHandler<WorkflowStateCancelEvent>;\n    export type Event = WorkflowStateCancelEvent;\n}\n"],"names":["WorkflowStateCancelEvent","DomainEvent","WorkflowStateCancelHandler","createAbstraction"],"mappings":";;AAKO,MAAMA,iCAAiCC;IAG1C,wBAAwB;QACpB,OAAOC;IACX;;QALG,qBACH,SAAS,GAAG;;AAKhB;AAEO,MAAMA,6BAA6BC,kBAExC"}

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

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

package/features/workflowState/CancelWorkflowState/feature.js

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

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

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

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

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

package/features/workflowState/CancelWorkflowState/index.js

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

package/features/workflowState/CreateWorkflowState/CreateWorkflowStateRepository.d.ts

@@ -0,0 +1,14 @@
+import { CreateEntryUseCase } from "@webiny/api-headless-cms/features/contentEntry/CreateEntry/index.js";
+import { WorkflowStateMapper, WorkflowStateModel } from "../../../domain/workflowState/abstractions.js";
+import { CreateWorkflowStateRepository as Repository } from "./abstractions.js";
+declare class CreateWorkflowStateRepositoryImpl implements Repository.Interface {
+    private createEntry;
+    private model;
+    private mapper;
+    constructor(createEntry: CreateEntryUseCase.Interface, model: WorkflowStateModel.Interface, mapper: WorkflowStateMapper.Interface);
+    execute(input: Repository.Input): Repository.Return;
+}
+export declare const CreateWorkflowStateRepository: typeof CreateWorkflowStateRepositoryImpl & {
+    __abstraction: import("@webiny/di").Abstraction<import("./abstractions.js").ICreateWorkflowStateRepository>;
+};
+export {};

package/features/workflowState/CreateWorkflowState/CreateWorkflowStateRepository.js

@@ -0,0 +1,35 @@
+import { Result } from "@webiny/feature/api";
+import { CreateEntryUseCase } from "@webiny/api-headless-cms/features/contentEntry/CreateEntry/index.js";
+import { WorkflowStateMapper, WorkflowStateModel } from "../../../domain/workflowState/abstractions.js";
+import { WorkflowStatePersistenceError } from "../../../domain/workflowState/errors.js";
+import { CreateWorkflowStateRepository } from "./abstractions.js";
+class CreateWorkflowStateRepositoryImpl {
+    constructor(createEntry, model, mapper){
+        this.createEntry = createEntry;
+        this.model = model;
+        this.mapper = mapper;
+    }
+    async execute(input) {
+        try {
+            const createResult = await this.createEntry.execute(this.model, {
+                values: input
+            });
+            if (createResult.isFail()) return Result.fail(new WorkflowStatePersistenceError(createResult.error));
+            const record = this.mapper.fromCmsEntry(createResult.value);
+            return Result.ok(record);
+        } catch (error) {
+            return Result.fail(new WorkflowStatePersistenceError(error));
+        }
+    }
+}
+const CreateWorkflowStateRepository_CreateWorkflowStateRepository = CreateWorkflowStateRepository.createImplementation({
+    implementation: CreateWorkflowStateRepositoryImpl,
+    dependencies: [
+        CreateEntryUseCase,
+        WorkflowStateModel,
+        WorkflowStateMapper
+    ]
+});
+export { CreateWorkflowStateRepository_CreateWorkflowStateRepository as CreateWorkflowStateRepository };
+
+//# sourceMappingURL=CreateWorkflowStateRepository.js.map

package/features/workflowState/CreateWorkflowState/CreateWorkflowStateRepository.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"features/workflowState/CreateWorkflowState/CreateWorkflowStateRepository.js","sources":["../../../../src/features/workflowState/CreateWorkflowState/CreateWorkflowStateRepository.ts"],"sourcesContent":["import { Result } from \"@webiny/feature/api\";\nimport { CreateEntryUseCase } from \"@webiny/api-headless-cms/features/contentEntry/CreateEntry/index.js\";\nimport { WorkflowStateMapper, WorkflowStateModel } from \"~/domain/workflowState/abstractions.js\";\nimport { WorkflowStatePersistenceError } from \"~/domain/workflowState/errors.js\";\nimport { CreateWorkflowStateRepository as Repository } from \"./abstractions.js\";\n\nclass CreateWorkflowStateRepositoryImpl implements Repository.Interface {\n    constructor(\n        private createEntry: CreateEntryUseCase.Interface,\n        private model: WorkflowStateModel.Interface,\n        private mapper: WorkflowStateMapper.Interface\n    ) {}\n\n    async execute(input: Repository.Input): Repository.Return {\n        try {\n            const createResult = await this.createEntry.execute<Repository.Input>(this.model, {\n                values: input\n            });\n\n            if (createResult.isFail()) {\n                return Result.fail(new WorkflowStatePersistenceError(createResult.error));\n            }\n\n            const record = this.mapper.fromCmsEntry(createResult.value);\n            return Result.ok(record);\n        } catch (error) {\n            return Result.fail(new WorkflowStatePersistenceError(error as Error));\n        }\n    }\n}\n\nexport const CreateWorkflowStateRepository = Repository.createImplementation({\n    implementation: CreateWorkflowStateRepositoryImpl,\n    dependencies: [CreateEntryUseCase, WorkflowStateModel, WorkflowStateMapper]\n});\n"],"names":["CreateWorkflowStateRepositoryImpl","createEntry","model","mapper","input","createResult","Result","WorkflowStatePersistenceError","record","error","CreateWorkflowStateRepository","Repository","CreateEntryUseCase","WorkflowStateModel","WorkflowStateMapper"],"mappings":";;;;;AAMA,MAAMA;IACF,YACYC,WAAyC,EACzCC,KAAmC,EACnCC,MAAqC,CAC/C;aAHUF,WAAW,GAAXA;aACAC,KAAK,GAALA;aACAC,MAAM,GAANA;IACT;IAEH,MAAM,QAAQC,KAAuB,EAAqB;QACtD,IAAI;YACA,MAAMC,eAAe,MAAM,IAAI,CAAC,WAAW,CAAC,OAAO,CAAmB,IAAI,CAAC,KAAK,EAAE;gBAC9E,QAAQD;YACZ;YAEA,IAAIC,aAAa,MAAM,IACnB,OAAOC,OAAO,IAAI,CAAC,IAAIC,8BAA8BF,aAAa,KAAK;YAG3E,MAAMG,SAAS,IAAI,CAAC,MAAM,CAAC,YAAY,CAACH,aAAa,KAAK;YAC1D,OAAOC,OAAO,EAAE,CAACE;QACrB,EAAE,OAAOC,OAAO;YACZ,OAAOH,OAAO,IAAI,CAAC,IAAIC,8BAA8BE;QACzD;IACJ;AACJ;AAEO,MAAMC,8DAAgCC,8BAAAA,oBAA+B,CAAC;IACzE,gBAAgBX;IAChB,cAAc;QAACY;QAAoBC;QAAoBC;KAAoB;AAC/E"}

package/features/workflowState/CreateWorkflowState/CreateWorkflowStateUseCase.d.ts

@@ -0,0 +1,22 @@
+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 { ListWorkflowsUseCase } from "../../../features/workflow/ListWorkflows/index.js";
+import { GetTargetWorkflowStateUseCase } from "../GetTargetWorkflowState/index.js";
+import { CreateWorkflowStateRepository, CreateWorkflowStateUseCase as UseCase } from "./abstractions.js";
+import { WorkflowStateContextProvider } from "./WorkflowStateContextProvider.js";
+declare class CreateWorkflowStateUseCaseImpl implements UseCase.Interface {
+    private identityContext;
+    private getUserTeams;
+    private eventPublisher;
+    private listWorkflows;
+    private getTargetState;
+    private repository;
+    private targetContextProvider;
+    constructor(identityContext: IdentityContext.Interface, getUserTeams: GetUserTeamsUseCase.Interface, eventPublisher: EventPublisher.Interface, listWorkflows: ListWorkflowsUseCase.Interface, getTargetState: GetTargetWorkflowStateUseCase.Interface, repository: CreateWorkflowStateRepository.Interface, targetContextProvider: WorkflowStateContextProvider.Interface);
+    execute(input: UseCase.Input): UseCase.Return;
+}
+export declare const CreateWorkflowStateUseCase: typeof CreateWorkflowStateUseCaseImpl & {
+    __abstraction: import("@webiny/di").Abstraction<import("./abstractions.js").ICreateWorkflowStateUseCase>;
+};
+export {};

package/features/workflowState/CreateWorkflowState/CreateWorkflowStateUseCase.js

@@ -0,0 +1,104 @@
+import { Result } from "@webiny/feature/api";
+import { parseIdentifier } from "@webiny/utils/parseIdentifier.js";
+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 { ListWorkflowsUseCase } from "../../workflow/ListWorkflows/index.js";
+import { GetTargetWorkflowStateUseCase } from "../GetTargetWorkflowState/index.js";
+import { CreateWorkflowStateRepository, CreateWorkflowStateUseCase } from "./abstractions.js";
+import { WorkflowStateAfterCreateEvent } from "./events.js";
+import { WorkflowStateContextProvider } from "./WorkflowStateContextProvider.js";
+import { WorkflowState } from "../../../domain/workflowState/WorkflowState.js";
+import { WorkflowStateRecordState } from "../../../domain/workflowState/abstractions.js";
+import { ActiveStateExistsError, MultipleWorkflowsFoundError, WorkflowStatePersistenceError, WorkflowStateValidationError } from "../../../domain/workflowState/errors.js";
+import { WorkflowNotFoundError } from "../../../domain/workflow/errors.js";
+class CreateWorkflowStateUseCaseImpl {
+    constructor(identityContext, getUserTeams, eventPublisher, listWorkflows, getTargetState, repository, targetContextProvider){
+        this.identityContext = identityContext;
+        this.getUserTeams = getUserTeams;
+        this.eventPublisher = eventPublisher;
+        this.listWorkflows = listWorkflows;
+        this.getTargetState = getTargetState;
+        this.repository = repository;
+        this.targetContextProvider = targetContextProvider;
+    }
+    async execute(input) {
+        const { id: targetId, version } = parseIdentifier(input.targetRevisionId);
+        if (!version) return Result.fail(new WorkflowStateValidationError("Cannot create a workflow state without version of a target record."));
+        const workflowsResult = await this.listWorkflows.execute({
+            where: {
+                app: input.app
+            },
+            limit: 1
+        });
+        if (workflowsResult.isFail()) return Result.fail(new WorkflowStatePersistenceError(workflowsResult.error));
+        const { items: workflows, meta } = workflowsResult.value;
+        const workflow = workflows[0];
+        if (!workflow) return Result.fail(new WorkflowNotFoundError({
+            id: "",
+            app: input.app
+        }));
+        if (meta.totalCount > 1) return Result.fail(new MultipleWorkflowsFoundError({
+            app: input.app,
+            targetRevisionId: input.targetRevisionId,
+            workflows,
+            meta
+        }));
+        const existingStateResult = await this.getTargetState.execute({
+            app: input.app,
+            targetRevisionId: input.targetRevisionId
+        });
+        if (existingStateResult.isOk()) return Result.fail(new ActiveStateExistsError({
+            app: input.app,
+            targetRevisionId: input.targetRevisionId
+        }));
+        if (0 === workflow.steps.length) return Result.fail(new WorkflowStateValidationError("Cannot create a workflow state for a workflow that has no steps defined."));
+        const identity = this.identityContext.getIdentity();
+        const targetContext = await this.targetContextProvider.provide({
+            app: input.app,
+            targetRevisionId: input.targetRevisionId
+        });
+        const record = {
+            workflowId: workflow.id,
+            comment: void 0,
+            state: WorkflowStateRecordState.pending,
+            app: input.app,
+            title: input.title,
+            targetId,
+            isActive: true,
+            targetRevisionId: input.targetRevisionId,
+            targetContext,
+            steps: workflow.steps.map((step)=>({
+                    ...step,
+                    state: WorkflowStateRecordState.pending,
+                    savedBy: null,
+                    comment: null
+                }))
+        };
+        const createResult = await this.repository.execute(record);
+        if (createResult.isFail()) return Result.fail(createResult.error);
+        const createdRecord = createResult.value;
+        const teamsResult = await this.getUserTeams.execute(identity.id);
+        const teams = teamsResult.value;
+        const workflowState = new WorkflowState(createdRecord, teams, identity);
+        await this.eventPublisher.publish(new WorkflowStateAfterCreateEvent({
+            state: workflowState
+        }));
+        return Result.ok(workflowState);
+    }
+}
+const CreateWorkflowStateUseCase_CreateWorkflowStateUseCase = CreateWorkflowStateUseCase.createImplementation({
+    implementation: CreateWorkflowStateUseCaseImpl,
+    dependencies: [
+        IdentityContext,
+        GetUserTeamsUseCase,
+        EventPublisher,
+        ListWorkflowsUseCase,
+        GetTargetWorkflowStateUseCase,
+        CreateWorkflowStateRepository,
+        WorkflowStateContextProvider
+    ]
+});
+export { CreateWorkflowStateUseCase_CreateWorkflowStateUseCase as CreateWorkflowStateUseCase };
+
+//# sourceMappingURL=CreateWorkflowStateUseCase.js.map

package/features/workflowState/CreateWorkflowState/CreateWorkflowStateUseCase.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"features/workflowState/CreateWorkflowState/CreateWorkflowStateUseCase.js","sources":["../../../../src/features/workflowState/CreateWorkflowState/CreateWorkflowStateUseCase.ts"],"sourcesContent":["import { Result } from \"@webiny/feature/api\";\nimport { parseIdentifier } from \"@webiny/utils/parseIdentifier.js\";\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 { ListWorkflowsUseCase } from \"~/features/workflow/ListWorkflows/index.js\";\nimport { GetTargetWorkflowStateUseCase } from \"../GetTargetWorkflowState/index.js\";\nimport {\n    CreateWorkflowStateRepository,\n    CreateWorkflowStateUseCase as UseCase\n} from \"./abstractions.js\";\nimport { WorkflowStateAfterCreateEvent } from \"./events.js\";\nimport { WorkflowStateContextProvider } from \"./WorkflowStateContextProvider.js\";\nimport { WorkflowState } from \"~/domain/workflowState/WorkflowState.js\";\nimport { WorkflowStateRecordState } from \"~/domain/workflowState/abstractions.js\";\nimport {\n    WorkflowStateValidationError,\n    ActiveStateExistsError,\n    MultipleWorkflowsFoundError,\n    WorkflowStatePersistenceError\n} from \"~/domain/workflowState/errors.js\";\nimport { WorkflowNotFoundError } from \"~/domain/workflow/errors.js\";\n\nclass CreateWorkflowStateUseCaseImpl implements UseCase.Interface {\n    constructor(\n        private identityContext: IdentityContext.Interface,\n        private getUserTeams: GetUserTeamsUseCase.Interface,\n        private eventPublisher: EventPublisher.Interface,\n        private listWorkflows: ListWorkflowsUseCase.Interface,\n        private getTargetState: GetTargetWorkflowStateUseCase.Interface,\n        private repository: CreateWorkflowStateRepository.Interface,\n        private targetContextProvider: WorkflowStateContextProvider.Interface\n    ) {}\n\n    async execute(input: UseCase.Input): UseCase.Return {\n        const { id: targetId, version } = parseIdentifier(input.targetRevisionId);\n        if (!version) {\n            return Result.fail(\n                new WorkflowStateValidationError(\n                    \"Cannot create a workflow state without version of a target record.\"\n                )\n            );\n        }\n\n        const workflowsResult = await this.listWorkflows.execute({\n            where: {\n                app: input.app\n            },\n            limit: 1\n        });\n\n        if (workflowsResult.isFail()) {\n            return Result.fail(new WorkflowStatePersistenceError(workflowsResult.error));\n        }\n\n        const { items: workflows, meta } = workflowsResult.value;\n        const workflow = workflows[0];\n\n        if (!workflow) {\n            return Result.fail(\n                new WorkflowNotFoundError({\n                    id: \"\",\n                    app: input.app\n                })\n            );\n        }\n\n        if (meta.totalCount > 1) {\n            return Result.fail(\n                new MultipleWorkflowsFoundError({\n                    app: input.app,\n                    targetRevisionId: input.targetRevisionId,\n                    workflows,\n                    meta\n                })\n            );\n        }\n\n        const existingStateResult = await this.getTargetState.execute({\n            app: input.app,\n            targetRevisionId: input.targetRevisionId\n        });\n\n        if (existingStateResult.isOk()) {\n            return Result.fail(\n                new ActiveStateExistsError({\n                    app: input.app,\n                    targetRevisionId: input.targetRevisionId\n                })\n            );\n        }\n\n        if (workflow.steps.length === 0) {\n            return Result.fail(\n                new WorkflowStateValidationError(\n                    \"Cannot create a workflow state for a workflow that has no steps defined.\"\n                )\n            );\n        }\n\n        const identity = this.identityContext.getIdentity();\n\n        const targetContext = await this.targetContextProvider.provide({\n            app: input.app,\n            targetRevisionId: input.targetRevisionId\n        });\n\n        const record: CreateWorkflowStateRepository.Input = {\n            workflowId: workflow.id,\n            comment: undefined,\n            state: WorkflowStateRecordState.pending,\n            app: input.app,\n            title: input.title,\n            targetId,\n            isActive: true,\n            targetRevisionId: input.targetRevisionId,\n            targetContext,\n            steps: workflow.steps.map(step => ({\n                ...step,\n                state: WorkflowStateRecordState.pending,\n                savedBy: null,\n                comment: null\n            }))\n        };\n\n        const createResult = await this.repository.execute(record);\n        if (createResult.isFail()) {\n            return Result.fail(createResult.error);\n        }\n\n        const createdRecord = createResult.value;\n\n        const teamsResult = await this.getUserTeams.execute(identity.id);\n        const teams = teamsResult.value;\n        const workflowState = new WorkflowState(createdRecord, teams, identity);\n\n        await this.eventPublisher.publish(\n            new WorkflowStateAfterCreateEvent({\n                state: workflowState\n            })\n        );\n\n        return Result.ok(workflowState);\n    }\n}\n\nexport const CreateWorkflowStateUseCase = UseCase.createImplementation({\n    implementation: CreateWorkflowStateUseCaseImpl,\n    dependencies: [\n        IdentityContext,\n        GetUserTeamsUseCase,\n        EventPublisher,\n        ListWorkflowsUseCase,\n        GetTargetWorkflowStateUseCase,\n        CreateWorkflowStateRepository,\n        WorkflowStateContextProvider\n    ]\n});\n"],"names":["CreateWorkflowStateUseCaseImpl","identityContext","getUserTeams","eventPublisher","listWorkflows","getTargetState","repository","targetContextProvider","input","targetId","version","parseIdentifier","Result","WorkflowStateValidationError","workflowsResult","WorkflowStatePersistenceError","workflows","meta","workflow","WorkflowNotFoundError","MultipleWorkflowsFoundError","existingStateResult","ActiveStateExistsError","identity","targetContext","record","undefined","WorkflowStateRecordState","step","createResult","createdRecord","teamsResult","teams","workflowState","WorkflowState","WorkflowStateAfterCreateEvent","CreateWorkflowStateUseCase","UseCase","IdentityContext","GetUserTeamsUseCase","EventPublisher","ListWorkflowsUseCase","GetTargetWorkflowStateUseCase","CreateWorkflowStateRepository","WorkflowStateContextProvider"],"mappings":"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"}

package/features/workflowState/CreateWorkflowState/DefaultWorkflowStateContextProvider.d.ts

@@ -0,0 +1,9 @@
+import { type IWorkflowStateContextProvider } from "./WorkflowStateContextProvider.js";
+import type { GenericRecord } from "@webiny/api/types.js";
+declare class DefaultWorkflowStateContextProviderImpl implements IWorkflowStateContextProvider {
+    provide(): Promise<GenericRecord>;
+}
+export declare const DefaultContextProvider: typeof DefaultWorkflowStateContextProviderImpl & {
+    __abstraction: import("@webiny/di").Abstraction<IWorkflowStateContextProvider>;
+};
+export {};

package/features/workflowState/CreateWorkflowState/DefaultWorkflowStateContextProvider.js

@@ -0,0 +1,13 @@
+import { WorkflowStateContextProvider } from "./WorkflowStateContextProvider.js";
+class DefaultWorkflowStateContextProviderImpl {
+    async provide() {
+        return {};
+    }
+}
+const DefaultContextProvider = WorkflowStateContextProvider.createImplementation({
+    implementation: DefaultWorkflowStateContextProviderImpl,
+    dependencies: []
+});
+export { DefaultContextProvider };
+
+//# sourceMappingURL=DefaultWorkflowStateContextProvider.js.map

package/features/workflowState/CreateWorkflowState/DefaultWorkflowStateContextProvider.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"features/workflowState/CreateWorkflowState/DefaultWorkflowStateContextProvider.js","sources":["../../../../src/features/workflowState/CreateWorkflowState/DefaultWorkflowStateContextProvider.ts"],"sourcesContent":["import {\n    WorkflowStateContextProvider,\n    type IWorkflowStateContextProvider\n} from \"./WorkflowStateContextProvider.js\";\nimport type { GenericRecord } from \"@webiny/api/types.js\";\n\nclass DefaultWorkflowStateContextProviderImpl implements IWorkflowStateContextProvider {\n    async provide(): Promise<GenericRecord> {\n        return {};\n    }\n}\n\nexport const DefaultContextProvider = WorkflowStateContextProvider.createImplementation({\n    implementation: DefaultWorkflowStateContextProviderImpl,\n    dependencies: []\n});\n"],"names":["DefaultWorkflowStateContextProviderImpl","DefaultContextProvider","WorkflowStateContextProvider"],"mappings":";AAMA,MAAMA;IACF,MAAM,UAAkC;QACpC,OAAO,CAAC;IACZ;AACJ;AAEO,MAAMC,yBAAyBC,6BAA6B,oBAAoB,CAAC;IACpF,gBAAgBF;IAChB,cAAc,EAAE;AACpB"}

package/features/workflowState/CreateWorkflowState/WorkflowStateContextProvider.d.ts

@@ -0,0 +1,13 @@
+import type { GenericRecord } from "@webiny/api/types.js";
+export interface IWorkflowStateContextProviderParams {
+    app: string;
+    targetRevisionId: string;
+}
+export interface IWorkflowStateContextProvider {
+    provide(params: IWorkflowStateContextProviderParams): Promise<GenericRecord>;
+}
+export declare const WorkflowStateContextProvider: import("@webiny/di").Abstraction<IWorkflowStateContextProvider>;
+export declare namespace WorkflowStateContextProvider {
+    type Interface = IWorkflowStateContextProvider;
+    type Params = IWorkflowStateContextProviderParams;
+}

package/features/workflowState/CreateWorkflowState/WorkflowStateContextProvider.js

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

package/features/workflowState/CreateWorkflowState/WorkflowStateContextProvider.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"features/workflowState/CreateWorkflowState/WorkflowStateContextProvider.js","sources":["../../../../src/features/workflowState/CreateWorkflowState/WorkflowStateContextProvider.ts"],"sourcesContent":["import { createAbstraction } from \"@webiny/feature/api\";\nimport type { GenericRecord } from \"@webiny/api/types.js\";\n\nexport interface IWorkflowStateContextProviderParams {\n    app: string;\n    targetRevisionId: string;\n}\n\nexport interface IWorkflowStateContextProvider {\n    provide(params: IWorkflowStateContextProviderParams): Promise<GenericRecord>;\n}\n\nexport const WorkflowStateContextProvider = createAbstraction<IWorkflowStateContextProvider>(\n    \"WorkflowStateContextProvider\"\n);\n\nexport namespace WorkflowStateContextProvider {\n    export type Interface = IWorkflowStateContextProvider;\n    export type Params = IWorkflowStateContextProviderParams;\n}\n"],"names":["WorkflowStateContextProvider","createAbstraction"],"mappings":";AAYO,MAAMA,+BAA+BC,kBACxC"}

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

@@ -0,0 +1,54 @@
+import type { Result } from "@webiny/feature/api";
+import type { IWorkflowStateRecord } from "../../../domain/workflowState/abstractions.js";
+import { type ActiveStateExistsError, MultipleWorkflowsFoundError, type WorkflowStateNotFoundError, type WorkflowStatePersistenceError, type WorkflowStateValidationError } from "../../../domain/workflowState/errors.js";
+import type { WorkflowNotFoundError } from "../../../domain/workflow/errors.js";
+import type { WorkflowState } from "../../../domain/workflowState/WorkflowState.js";
+export interface ICreateWorkflowStateUseCaseInput {
+    app: string;
+    targetRevisionId: string;
+    title: string;
+}
+export interface WorkflowStateAfterCreatePayload {
+    state: WorkflowState;
+}
+/**
+ * CreateWorkflowState use case interface
+ */
+export interface ICreateWorkflowStateUseCase {
+    execute(input: ICreateWorkflowStateUseCaseInput): Promise<Result<WorkflowState, UseCaseError>>;
+}
+export interface ICreateWorkflowStateUseCaseErrors {
+    notFound: WorkflowStateNotFoundError;
+    workflowNotFound: WorkflowNotFoundError;
+    multipleWorkflows: MultipleWorkflowsFoundError;
+    activeExists: ActiveStateExistsError;
+    validation: WorkflowStateValidationError;
+    persistence: WorkflowStatePersistenceError;
+}
+type UseCaseError = ICreateWorkflowStateUseCaseErrors[keyof ICreateWorkflowStateUseCaseErrors];
+export declare const CreateWorkflowStateUseCase: import("@webiny/di").Abstraction<ICreateWorkflowStateUseCase>;
+export declare namespace CreateWorkflowStateUseCase {
+    type Interface = ICreateWorkflowStateUseCase;
+    type Input = ICreateWorkflowStateUseCaseInput;
+    type Return = Promise<Result<WorkflowState, UseCaseError>>;
+    type Error = UseCaseError;
+}
+/**
+ * CreateWorkflowState repository interface
+ */
+export type ICreateWorkflowStateRepositoryInput = Omit<IWorkflowStateRecord, "id" | "savedBy" | "createdOn" | "savedOn" | "createdBy">;
+export interface ICreateWorkflowStateRepository {
+    execute(input: ICreateWorkflowStateRepositoryInput): Promise<Result<IWorkflowStateRecord, RepositoryError>>;
+}
+export interface ICreateWorkflowStateRepositoryErrors {
+    persistence: WorkflowStatePersistenceError;
+}
+type RepositoryError = ICreateWorkflowStateRepositoryErrors[keyof ICreateWorkflowStateRepositoryErrors];
+export declare const CreateWorkflowStateRepository: import("@webiny/di").Abstraction<ICreateWorkflowStateRepository>;
+export declare namespace CreateWorkflowStateRepository {
+    type Interface = ICreateWorkflowStateRepository;
+    type Input = ICreateWorkflowStateRepositoryInput;
+    type Return = Promise<Result<IWorkflowStateRecord, RepositoryError>>;
+    type Error = RepositoryError;
+}
+export {};

package/features/workflowState/CreateWorkflowState/abstractions.js

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"features/workflowState/CreateWorkflowState/abstractions.js","sources":["../../../../src/features/workflowState/CreateWorkflowState/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 ActiveStateExistsError,\n    MultipleWorkflowsFoundError,\n    type WorkflowStateNotFoundError,\n    type WorkflowStatePersistenceError,\n    type WorkflowStateValidationError\n} from \"~/domain/workflowState/errors.js\";\nimport type { WorkflowNotFoundError } from \"~/domain/workflow/errors.js\";\nimport type { WorkflowState } from \"~/domain/workflowState/WorkflowState.js\";\n\nexport interface ICreateWorkflowStateUseCaseInput {\n    app: string;\n    targetRevisionId: string;\n    title: string;\n}\n\nexport interface WorkflowStateAfterCreatePayload {\n    state: WorkflowState;\n}\n\n/**\n * CreateWorkflowState use case interface\n */\nexport interface ICreateWorkflowStateUseCase {\n    execute(input: ICreateWorkflowStateUseCaseInput): Promise<Result<WorkflowState, UseCaseError>>;\n}\n\nexport interface ICreateWorkflowStateUseCaseErrors {\n    notFound: WorkflowStateNotFoundError;\n    workflowNotFound: WorkflowNotFoundError;\n    multipleWorkflows: MultipleWorkflowsFoundError;\n    activeExists: ActiveStateExistsError;\n    validation: WorkflowStateValidationError;\n    persistence: WorkflowStatePersistenceError;\n}\n\ntype UseCaseError = ICreateWorkflowStateUseCaseErrors[keyof ICreateWorkflowStateUseCaseErrors];\n\nexport const CreateWorkflowStateUseCase = createAbstraction<ICreateWorkflowStateUseCase>(\n    \"CreateWorkflowStateUseCase\"\n);\n\nexport namespace CreateWorkflowStateUseCase {\n    export type Interface = ICreateWorkflowStateUseCase;\n    export type Input = ICreateWorkflowStateUseCaseInput;\n    export type Return = Promise<Result<WorkflowState, UseCaseError>>;\n    export type Error = UseCaseError;\n}\n\n/**\n * CreateWorkflowState repository interface\n */\n\nexport type ICreateWorkflowStateRepositoryInput = Omit<\n    IWorkflowStateRecord,\n    \"id\" | \"savedBy\" | \"createdOn\" | \"savedOn\" | \"createdBy\"\n>;\n\nexport interface ICreateWorkflowStateRepository {\n    execute(\n        input: ICreateWorkflowStateRepositoryInput\n    ): Promise<Result<IWorkflowStateRecord, RepositoryError>>;\n}\n\nexport interface ICreateWorkflowStateRepositoryErrors {\n    persistence: WorkflowStatePersistenceError;\n}\n\ntype RepositoryError =\n    ICreateWorkflowStateRepositoryErrors[keyof ICreateWorkflowStateRepositoryErrors];\n\nexport const CreateWorkflowStateRepository = createAbstraction<ICreateWorkflowStateRepository>(\n    \"CreateWorkflowStateRepository\"\n);\n\nexport namespace CreateWorkflowStateRepository {\n    export type Interface = ICreateWorkflowStateRepository;\n    export type Input = ICreateWorkflowStateRepositoryInput;\n    export type Return = Promise<Result<IWorkflowStateRecord, RepositoryError>>;\n    export type Error = RepositoryError;\n}\n"],"names":["CreateWorkflowStateUseCase","createAbstraction","CreateWorkflowStateRepository"],"mappings":";AAyCO,MAAMA,6BAA6BC,kBACtC;AAgCG,MAAMC,gCAAgCD,kBACzC"}

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

package/features/workflowState/CreateWorkflowState/events.js

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

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

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

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

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

package/features/workflowState/CreateWorkflowState/feature.js

@@ -0,0 +1,15 @@
+import { createFeature } from "@webiny/feature/api";
+import { CreateWorkflowStateUseCase } from "./CreateWorkflowStateUseCase.js";
+import { CreateWorkflowStateRepository } from "./CreateWorkflowStateRepository.js";
+import { DefaultContextProvider } from "./DefaultWorkflowStateContextProvider.js";
+const CreateWorkflowStateFeature = createFeature({
+    name: "WorkflowState/CreateWorkflowState",
+    register (container) {
+        container.register(CreateWorkflowStateRepository).inSingletonScope();
+        container.register(DefaultContextProvider);
+        container.register(CreateWorkflowStateUseCase);
+    }
+});
+export { CreateWorkflowStateFeature };
+
+//# sourceMappingURL=feature.js.map

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

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