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

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

@@ -0,0 +1,3 @@
+export { CreateWorkflowStateUseCase, CreateWorkflowStateRepository } from "./abstractions.js";
+export { WorkflowStateAfterCreateHandler } from "./events.js";
+export { WorkflowStateContextProvider } from "./WorkflowStateContextProvider.js";

package/features/workflowState/CreateWorkflowState/index.js

@@ -0,0 +1,3 @@
+export { CreateWorkflowStateRepository, CreateWorkflowStateUseCase } from "./abstractions.js";
+export { WorkflowStateAfterCreateHandler } from "./events.js";
+export { WorkflowStateContextProvider } from "./WorkflowStateContextProvider.js";

package/features/workflowState/DeleteTargetWorkflowState/DeleteTargetWorkflowStateUseCase.d.ts

@@ -0,0 +1,21 @@
+import { IdentityContext } from "@webiny/api-core/features/security/IdentityContext/index.js";
+import { GetUserTeamsUseCase } from "../../../features/internal/GetUserTeams/index.js";
+import { EventPublisher } from "@webiny/api-core/features/eventPublisher/index.js";
+import { GetWorkflowUseCase } from "../../../features/workflow/GetWorkflow/index.js";
+import { GetTargetWorkflowStateUseCase } from "../GetTargetWorkflowState/index.js";
+import { DeleteWorkflowStateRepository } from "../DeleteWorkflowState/index.js";
+import { DeleteTargetWorkflowStateUseCase as UseCase } from "./abstractions.js";
+declare class DeleteTargetWorkflowStateUseCaseImpl implements UseCase.Interface {
+    private identityContext;
+    private getUserTeams;
+    private eventPublisher;
+    private getWorkflow;
+    private getTargetWorkflowState;
+    private repository;
+    constructor(identityContext: IdentityContext.Interface, getUserTeams: GetUserTeamsUseCase.Interface, eventPublisher: EventPublisher.Interface, getWorkflow: GetWorkflowUseCase.Interface, getTargetWorkflowState: GetTargetWorkflowStateUseCase.Interface, repository: DeleteWorkflowStateRepository.Interface);
+    execute(app: string, targetRevisionId: string): UseCase.Return;
+}
+export declare const DeleteTargetWorkflowStateUseCase: typeof DeleteTargetWorkflowStateUseCaseImpl & {
+    __abstraction: import("@webiny/di").Abstraction<import("./abstractions.js").IDeleteTargetWorkflowStateUseCase>;
+};
+export {};

package/features/workflowState/DeleteTargetWorkflowState/DeleteTargetWorkflowStateUseCase.js

@@ -0,0 +1,61 @@
+import { Result } from "@webiny/feature/api";
+import { IdentityContext } from "@webiny/api-core/features/security/IdentityContext/index.js";
+import { GetUserTeamsUseCase } from "../../internal/GetUserTeams/index.js";
+import { EventPublisher } from "@webiny/api-core/features/eventPublisher/index.js";
+import { GetWorkflowUseCase } from "../../workflow/GetWorkflow/index.js";
+import { GetTargetWorkflowStateUseCase } from "../GetTargetWorkflowState/index.js";
+import { DeleteWorkflowStateRepository } from "../DeleteWorkflowState/index.js";
+import { DeleteTargetWorkflowStateUseCase } from "./abstractions.js";
+import { WorkflowStateAfterDeleteEvent } from "./events.js";
+import { WorkflowState } from "../../../domain/workflowState/WorkflowState.js";
+import { WorkflowNotFoundError } from "../../../domain/workflow/errors.js";
+class DeleteTargetWorkflowStateUseCaseImpl {
+    constructor(identityContext, getUserTeams, eventPublisher, getWorkflow, getTargetWorkflowState, repository){
+        this.identityContext = identityContext;
+        this.getUserTeams = getUserTeams;
+        this.eventPublisher = eventPublisher;
+        this.getWorkflow = getWorkflow;
+        this.getTargetWorkflowState = getTargetWorkflowState;
+        this.repository = repository;
+    }
+    async execute(app, targetRevisionId) {
+        const stateResult = await this.getTargetWorkflowState.execute({
+            app,
+            targetRevisionId
+        });
+        if (stateResult.isFail()) return Result.ok();
+        const record = stateResult.value;
+        const workflowResult = await this.getWorkflow.execute({
+            app: record.app,
+            id: record.workflowId
+        });
+        if (workflowResult.isFail()) return Result.fail(new WorkflowNotFoundError({
+            id: record.workflowId,
+            app: record.app
+        }));
+        const deleteResult = await this.repository.execute(record.id);
+        if (deleteResult.isFail()) return deleteResult;
+        const identity = this.identityContext.getIdentity();
+        const teamsResult = await this.getUserTeams.execute(identity.id);
+        const teams = teamsResult.value;
+        const state = new WorkflowState(record, teams, identity);
+        await this.eventPublisher.publish(new WorkflowStateAfterDeleteEvent({
+            state
+        }));
+        return Result.ok();
+    }
+}
+const DeleteTargetWorkflowStateUseCase_DeleteTargetWorkflowStateUseCase = DeleteTargetWorkflowStateUseCase.createImplementation({
+    implementation: DeleteTargetWorkflowStateUseCaseImpl,
+    dependencies: [
+        IdentityContext,
+        GetUserTeamsUseCase,
+        EventPublisher,
+        GetWorkflowUseCase,
+        GetTargetWorkflowStateUseCase,
+        DeleteWorkflowStateRepository
+    ]
+});
+export { DeleteTargetWorkflowStateUseCase_DeleteTargetWorkflowStateUseCase as DeleteTargetWorkflowStateUseCase };
+
+//# sourceMappingURL=DeleteTargetWorkflowStateUseCase.js.map

package/features/workflowState/DeleteTargetWorkflowState/DeleteTargetWorkflowStateUseCase.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"features/workflowState/DeleteTargetWorkflowState/DeleteTargetWorkflowStateUseCase.js","sources":["../../../../src/features/workflowState/DeleteTargetWorkflowState/DeleteTargetWorkflowStateUseCase.ts"],"sourcesContent":["import { Result } from \"@webiny/feature/api\";\nimport { IdentityContext } from \"@webiny/api-core/features/security/IdentityContext/index.js\";\nimport { GetUserTeamsUseCase } from \"~/features/internal/GetUserTeams/index.js\";\nimport { EventPublisher } from \"@webiny/api-core/features/eventPublisher/index.js\";\nimport { GetWorkflowUseCase } from \"~/features/workflow/GetWorkflow/index.js\";\nimport { GetTargetWorkflowStateUseCase } from \"../GetTargetWorkflowState/index.js\";\nimport { DeleteWorkflowStateRepository } from \"../DeleteWorkflowState/index.js\";\nimport { DeleteTargetWorkflowStateUseCase as UseCase } from \"./abstractions.js\";\nimport { WorkflowStateAfterDeleteEvent } from \"./events.js\";\nimport { WorkflowState } from \"~/domain/workflowState/WorkflowState.js\";\nimport { WorkflowNotFoundError } from \"~/domain/workflow/errors.js\";\n\nclass DeleteTargetWorkflowStateUseCaseImpl 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 getTargetWorkflowState: GetTargetWorkflowStateUseCase.Interface,\n        private repository: DeleteWorkflowStateRepository.Interface\n    ) {}\n\n    async execute(app: string, targetRevisionId: string): UseCase.Return {\n        const stateResult = await this.getTargetWorkflowState.execute({ app, targetRevisionId });\n        if (stateResult.isFail()) {\n            return Result.ok();\n        }\n\n        const record = stateResult.value;\n\n        const workflowResult = await this.getWorkflow.execute({\n            app: record.app,\n            id: record.workflowId\n        });\n\n        if (workflowResult.isFail()) {\n            return Result.fail(\n                new WorkflowNotFoundError({\n                    id: record.workflowId,\n                    app: record.app\n                })\n            );\n        }\n\n        const deleteResult = await this.repository.execute(record.id);\n        if (deleteResult.isFail()) {\n            return deleteResult;\n        }\n\n        const identity = this.identityContext.getIdentity();\n        const teamsResult = await this.getUserTeams.execute(identity.id);\n        const teams = teamsResult.value;\n        const state = new WorkflowState(record, teams, identity);\n\n        await this.eventPublisher.publish(\n            new WorkflowStateAfterDeleteEvent({\n                state\n            })\n        );\n\n        return Result.ok();\n    }\n}\n\nexport const DeleteTargetWorkflowStateUseCase = UseCase.createImplementation({\n    implementation: DeleteTargetWorkflowStateUseCaseImpl,\n    dependencies: [\n        IdentityContext,\n        GetUserTeamsUseCase,\n        EventPublisher,\n        GetWorkflowUseCase,\n        GetTargetWorkflowStateUseCase,\n        DeleteWorkflowStateRepository\n    ]\n});\n"],"names":["DeleteTargetWorkflowStateUseCaseImpl","identityContext","getUserTeams","eventPublisher","getWorkflow","getTargetWorkflowState","repository","app","targetRevisionId","stateResult","Result","record","workflowResult","WorkflowNotFoundError","deleteResult","identity","teamsResult","teams","state","WorkflowState","WorkflowStateAfterDeleteEvent","DeleteTargetWorkflowStateUseCase","UseCase","IdentityContext","GetUserTeamsUseCase","EventPublisher","GetWorkflowUseCase","GetTargetWorkflowStateUseCase","DeleteWorkflowStateRepository"],"mappings":";;;;;;;;;;;AAYA,MAAMA;IACF,YACYC,eAA0C,EAC1CC,YAA2C,EAC3CC,cAAwC,EACxCC,WAAyC,EACzCC,sBAA+D,EAC/DC,UAAmD,CAC7D;aANUL,eAAe,GAAfA;aACAC,YAAY,GAAZA;aACAC,cAAc,GAAdA;aACAC,WAAW,GAAXA;aACAC,sBAAsB,GAAtBA;aACAC,UAAU,GAAVA;IACT;IAEH,MAAM,QAAQC,GAAW,EAAEC,gBAAwB,EAAkB;QACjE,MAAMC,cAAc,MAAM,IAAI,CAAC,sBAAsB,CAAC,OAAO,CAAC;YAAEF;YAAKC;QAAiB;QACtF,IAAIC,YAAY,MAAM,IAClB,OAAOC,OAAO,EAAE;QAGpB,MAAMC,SAASF,YAAY,KAAK;QAEhC,MAAMG,iBAAiB,MAAM,IAAI,CAAC,WAAW,CAAC,OAAO,CAAC;YAClD,KAAKD,OAAO,GAAG;YACf,IAAIA,OAAO,UAAU;QACzB;QAEA,IAAIC,eAAe,MAAM,IACrB,OAAOF,OAAO,IAAI,CACd,IAAIG,sBAAsB;YACtB,IAAIF,OAAO,UAAU;YACrB,KAAKA,OAAO,GAAG;QACnB;QAIR,MAAMG,eAAe,MAAM,IAAI,CAAC,UAAU,CAAC,OAAO,CAACH,OAAO,EAAE;QAC5D,IAAIG,aAAa,MAAM,IACnB,OAAOA;QAGX,MAAMC,WAAW,IAAI,CAAC,eAAe,CAAC,WAAW;QACjD,MAAMC,cAAc,MAAM,IAAI,CAAC,YAAY,CAAC,OAAO,CAACD,SAAS,EAAE;QAC/D,MAAME,QAAQD,YAAY,KAAK;QAC/B,MAAME,QAAQ,IAAIC,cAAcR,QAAQM,OAAOF;QAE/C,MAAM,IAAI,CAAC,cAAc,CAAC,OAAO,CAC7B,IAAIK,8BAA8B;YAC9BF;QACJ;QAGJ,OAAOR,OAAO,EAAE;IACpB;AACJ;AAEO,MAAMW,oEAAmCC,iCAAAA,oBAA4B,CAAC;IACzE,gBAAgBtB;IAChB,cAAc;QACVuB;QACAC;QACAC;QACAC;QACAC;QACAC;KACH;AACL"}

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

@@ -0,0 +1,23 @@
+import type { Result } from "@webiny/feature/api";
+import { type WorkflowStateNotFoundError, WorkflowStatePersistenceError } from "../../../domain/workflowState/errors.js";
+import type { WorkflowNotFoundError } from "../../../domain/workflow/errors.js";
+import type { WorkflowState } from "../../../domain/workflowState/WorkflowState.js";
+export interface WorkflowStateAfterDeletePayload {
+    state: WorkflowState;
+}
+export interface IDeleteTargetWorkflowStateUseCase {
+    execute(app: string, targetRevisionId: string): Promise<Result<void, UseCaseError>>;
+}
+export interface IDeleteTargetWorkflowStateUseCaseErrors {
+    notFound: WorkflowStateNotFoundError;
+    workflowNotFound: WorkflowNotFoundError;
+    persistence: WorkflowStatePersistenceError;
+}
+type UseCaseError = IDeleteTargetWorkflowStateUseCaseErrors[keyof IDeleteTargetWorkflowStateUseCaseErrors];
+export declare const DeleteTargetWorkflowStateUseCase: import("@webiny/di").Abstraction<IDeleteTargetWorkflowStateUseCase>;
+export declare namespace DeleteTargetWorkflowStateUseCase {
+    type Interface = IDeleteTargetWorkflowStateUseCase;
+    type Return = Promise<Result<void, UseCaseError>>;
+    type Error = UseCaseError;
+}
+export {};

package/features/workflowState/DeleteTargetWorkflowState/abstractions.js

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"features/workflowState/DeleteTargetWorkflowState/abstractions.js","sources":["../../../../src/features/workflowState/DeleteTargetWorkflowState/abstractions.ts"],"sourcesContent":["import type { Result } from \"@webiny/feature/api\";\nimport { createAbstraction } from \"@webiny/feature/api\";\nimport {\n    type WorkflowStateNotFoundError,\n    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 interface WorkflowStateAfterDeletePayload {\n    state: WorkflowState;\n}\n\nexport interface IDeleteTargetWorkflowStateUseCase {\n    execute(app: string, targetRevisionId: string): Promise<Result<void, UseCaseError>>;\n}\n\nexport interface IDeleteTargetWorkflowStateUseCaseErrors {\n    notFound: WorkflowStateNotFoundError;\n    workflowNotFound: WorkflowNotFoundError;\n    persistence: WorkflowStatePersistenceError;\n}\n\ntype UseCaseError =\n    IDeleteTargetWorkflowStateUseCaseErrors[keyof IDeleteTargetWorkflowStateUseCaseErrors];\n\nexport const DeleteTargetWorkflowStateUseCase =\n    createAbstraction<IDeleteTargetWorkflowStateUseCase>(\"DeleteTargetWorkflowStateUseCase\");\n\nexport namespace DeleteTargetWorkflowStateUseCase {\n    export type Interface = IDeleteTargetWorkflowStateUseCase;\n    export type Return = Promise<Result<void, UseCaseError>>;\n    export type Error = UseCaseError;\n}\n"],"names":["DeleteTargetWorkflowStateUseCase","createAbstraction"],"mappings":";AA0BO,MAAMA,mCACTC,kBAAqD"}

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

package/features/workflowState/DeleteTargetWorkflowState/events.js

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

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

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

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

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

package/features/workflowState/DeleteTargetWorkflowState/feature.js

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

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

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

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

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

package/features/workflowState/DeleteTargetWorkflowState/index.js

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

package/features/workflowState/DeleteWorkflowState/DeleteWorkflowStateRepository.d.ts

@@ -0,0 +1,13 @@
+import { DeleteEntryUseCase } from "@webiny/api-headless-cms/features/contentEntry/DeleteEntry/index.js";
+import { WorkflowStateModel } from "../../../domain/workflowState/abstractions.js";
+import { DeleteWorkflowStateRepository as Repository } from "./abstractions.js";
+declare class DeleteWorkflowStateRepositoryImpl implements Repository.Interface {
+    private deleteEntry;
+    private model;
+    constructor(deleteEntry: DeleteEntryUseCase.Interface, model: WorkflowStateModel.Interface);
+    execute(id: string): Repository.Return;
+}
+export declare const DeleteWorkflowStateRepository: typeof DeleteWorkflowStateRepositoryImpl & {
+    __abstraction: import("@webiny/di").Abstraction<import("./abstractions.js").IDeleteWorkflowStateRepository>;
+};
+export {};

package/features/workflowState/DeleteWorkflowState/DeleteWorkflowStateRepository.js

@@ -0,0 +1,24 @@
+import { Result } from "@webiny/feature/api";
+import { DeleteEntryUseCase } from "@webiny/api-headless-cms/features/contentEntry/DeleteEntry/index.js";
+import { WorkflowStateModel } from "../../../domain/workflowState/abstractions.js";
+import { DeleteWorkflowStateRepository } from "./abstractions.js";
+class DeleteWorkflowStateRepositoryImpl {
+    constructor(deleteEntry, model){
+        this.deleteEntry = deleteEntry;
+        this.model = model;
+    }
+    async execute(id) {
+        await this.deleteEntry.execute(this.model, id);
+        return Result.ok();
+    }
+}
+const DeleteWorkflowStateRepository_DeleteWorkflowStateRepository = DeleteWorkflowStateRepository.createImplementation({
+    implementation: DeleteWorkflowStateRepositoryImpl,
+    dependencies: [
+        DeleteEntryUseCase,
+        WorkflowStateModel
+    ]
+});
+export { DeleteWorkflowStateRepository_DeleteWorkflowStateRepository as DeleteWorkflowStateRepository };
+
+//# sourceMappingURL=DeleteWorkflowStateRepository.js.map

package/features/workflowState/DeleteWorkflowState/DeleteWorkflowStateRepository.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"features/workflowState/DeleteWorkflowState/DeleteWorkflowStateRepository.js","sources":["../../../../src/features/workflowState/DeleteWorkflowState/DeleteWorkflowStateRepository.ts"],"sourcesContent":["import { Result } from \"@webiny/feature/api\";\nimport { DeleteEntryUseCase } from \"@webiny/api-headless-cms/features/contentEntry/DeleteEntry/index.js\";\nimport { WorkflowStateModel } from \"~/domain/workflowState/abstractions.js\";\nimport { DeleteWorkflowStateRepository as Repository } from \"./abstractions.js\";\n\nclass DeleteWorkflowStateRepositoryImpl implements Repository.Interface {\n    constructor(\n        private deleteEntry: DeleteEntryUseCase.Interface,\n        private model: WorkflowStateModel.Interface\n    ) {}\n\n    async execute(id: string): Repository.Return {\n        await this.deleteEntry.execute(this.model, id);\n\n        return Result.ok();\n    }\n}\n\nexport const DeleteWorkflowStateRepository = Repository.createImplementation({\n    implementation: DeleteWorkflowStateRepositoryImpl,\n    dependencies: [DeleteEntryUseCase, WorkflowStateModel]\n});\n"],"names":["DeleteWorkflowStateRepositoryImpl","deleteEntry","model","id","Result","DeleteWorkflowStateRepository","Repository","DeleteEntryUseCase","WorkflowStateModel"],"mappings":";;;;AAKA,MAAMA;IACF,YACYC,WAAyC,EACzCC,KAAmC,CAC7C;aAFUD,WAAW,GAAXA;aACAC,KAAK,GAALA;IACT;IAEH,MAAM,QAAQC,EAAU,EAAqB;QACzC,MAAM,IAAI,CAAC,WAAW,CAAC,OAAO,CAAC,IAAI,CAAC,KAAK,EAAEA;QAE3C,OAAOC,OAAO,EAAE;IACpB;AACJ;AAEO,MAAMC,8DAAgCC,8BAAAA,oBAA+B,CAAC;IACzE,gBAAgBN;IAChB,cAAc;QAACO;QAAoBC;KAAmB;AAC1D"}

package/features/workflowState/DeleteWorkflowState/DeleteWorkflowStateUseCase.d.ts

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

package/features/workflowState/DeleteWorkflowState/DeleteWorkflowStateUseCase.js

@@ -0,0 +1,33 @@
+import { Result } from "@webiny/feature/api";
+import { GetWorkflowStateUseCase } from "../GetWorkflowState/index.js";
+import { DeleteWorkflowStateRepository, DeleteWorkflowStateUseCase } from "./abstractions.js";
+import { WorkflowStateAfterDeleteEvent } from "../DeleteTargetWorkflowState/events.js";
+import { EventPublisher } from "@webiny/api-core/features/eventPublisher/index.js";
+class DeleteWorkflowStateUseCaseImpl {
+    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 result = await this.repository.execute(id);
+        if (result.isFail()) return result;
+        await this.eventPublisher.publish(new WorkflowStateAfterDeleteEvent({
+            state: stateResult.value
+        }));
+        return Result.ok();
+    }
+}
+const DeleteWorkflowStateUseCase_DeleteWorkflowStateUseCase = DeleteWorkflowStateUseCase.createImplementation({
+    implementation: DeleteWorkflowStateUseCaseImpl,
+    dependencies: [
+        GetWorkflowStateUseCase,
+        DeleteWorkflowStateRepository,
+        EventPublisher
+    ]
+});
+export { DeleteWorkflowStateUseCase_DeleteWorkflowStateUseCase as DeleteWorkflowStateUseCase };
+
+//# sourceMappingURL=DeleteWorkflowStateUseCase.js.map

package/features/workflowState/DeleteWorkflowState/DeleteWorkflowStateUseCase.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"features/workflowState/DeleteWorkflowState/DeleteWorkflowStateUseCase.js","sources":["../../../../src/features/workflowState/DeleteWorkflowState/DeleteWorkflowStateUseCase.ts"],"sourcesContent":["import { Result } from \"@webiny/feature/api\";\nimport { GetWorkflowStateUseCase } from \"../GetWorkflowState/index.js\";\nimport {\n    DeleteWorkflowStateRepository,\n    DeleteWorkflowStateUseCase as UseCase\n} from \"./abstractions.js\";\nimport { WorkflowStateAfterDeleteEvent } from \"~/features/workflowState/DeleteTargetWorkflowState/events.js\";\nimport { EventPublisher } from \"@webiny/api-core/features/eventPublisher/index.js\";\n\nclass DeleteWorkflowStateUseCaseImpl implements UseCase.Interface {\n    constructor(\n        private getWorkflowState: GetWorkflowStateUseCase.Interface,\n        private repository: DeleteWorkflowStateRepository.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 result = await this.repository.execute(id);\n        if (result.isFail()) {\n            return result;\n        }\n\n        await this.eventPublisher.publish(\n            new WorkflowStateAfterDeleteEvent({\n                state: stateResult.value\n            })\n        );\n\n        return Result.ok();\n    }\n}\n\nexport const DeleteWorkflowStateUseCase = UseCase.createImplementation({\n    implementation: DeleteWorkflowStateUseCaseImpl,\n    dependencies: [GetWorkflowStateUseCase, DeleteWorkflowStateRepository, EventPublisher]\n});\n"],"names":["DeleteWorkflowStateUseCaseImpl","getWorkflowState","repository","eventPublisher","id","stateResult","Result","result","WorkflowStateAfterDeleteEvent","DeleteWorkflowStateUseCase","UseCase","GetWorkflowStateUseCase","DeleteWorkflowStateRepository","EventPublisher"],"mappings":";;;;;AASA,MAAMA;IACF,YACYC,gBAAmD,EACnDC,UAAmD,EACnDC,cAAwC,CAClD;aAHUF,gBAAgB,GAAhBA;aACAC,UAAU,GAAVA;aACAC,cAAc,GAAdA;IACT;IAEH,MAAM,QAAQC,EAAU,EAAkB;QACtC,MAAMC,cAAc,MAAM,IAAI,CAAC,gBAAgB,CAAC,OAAO,CAACD;QACxD,IAAIC,YAAY,MAAM,IAClB,OAAOC,OAAO,IAAI,CAACD,YAAY,KAAK;QAGxC,MAAME,SAAS,MAAM,IAAI,CAAC,UAAU,CAAC,OAAO,CAACH;QAC7C,IAAIG,OAAO,MAAM,IACb,OAAOA;QAGX,MAAM,IAAI,CAAC,cAAc,CAAC,OAAO,CAC7B,IAAIC,8BAA8B;YAC9B,OAAOH,YAAY,KAAK;QAC5B;QAGJ,OAAOC,OAAO,EAAE;IACpB;AACJ;AAEO,MAAMG,wDAA6BC,2BAAAA,oBAA4B,CAAC;IACnE,gBAAgBV;IAChB,cAAc;QAACW;QAAyBC;QAA+BC;KAAe;AAC1F"}

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

@@ -0,0 +1,25 @@
+import type { Result } from "@webiny/feature/api";
+import { type WorkflowStateNotFoundError, WorkflowStatePersistenceError } from "../../../domain/workflowState/errors.js";
+export interface IDeleteWorkflowStateUseCase {
+    execute(id: string): Promise<Result<void, UseCaseError>>;
+}
+export interface IDeleteWorkflowStateUseCaseErrors {
+    notFound: WorkflowStateNotFoundError;
+    persistence: WorkflowStatePersistenceError;
+}
+type UseCaseError = IDeleteWorkflowStateUseCaseErrors[keyof IDeleteWorkflowStateUseCaseErrors];
+export declare const DeleteWorkflowStateUseCase: import("@webiny/di").Abstraction<IDeleteWorkflowStateUseCase>;
+export declare namespace DeleteWorkflowStateUseCase {
+    type Interface = IDeleteWorkflowStateUseCase;
+    type Return = Promise<Result<void, UseCaseError>>;
+    type Error = UseCaseError;
+}
+export interface IDeleteWorkflowStateRepository {
+    execute(id: string): Promise<Result<void, never>>;
+}
+export declare const DeleteWorkflowStateRepository: import("@webiny/di").Abstraction<IDeleteWorkflowStateRepository>;
+export declare namespace DeleteWorkflowStateRepository {
+    type Interface = IDeleteWorkflowStateRepository;
+    type Return = Promise<Result<void, never>>;
+}
+export {};

package/features/workflowState/DeleteWorkflowState/abstractions.js

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"features/workflowState/DeleteWorkflowState/abstractions.js","sources":["../../../../src/features/workflowState/DeleteWorkflowState/abstractions.ts"],"sourcesContent":["import { createAbstraction } from \"@webiny/feature/api\";\nimport type { Result } from \"@webiny/feature/api\";\nimport {\n    type WorkflowStateNotFoundError,\n    WorkflowStatePersistenceError\n} from \"~/domain/workflowState/errors.js\";\n\nexport interface IDeleteWorkflowStateUseCase {\n    execute(id: string): Promise<Result<void, UseCaseError>>;\n}\n\nexport interface IDeleteWorkflowStateUseCaseErrors {\n    notFound: WorkflowStateNotFoundError;\n    persistence: WorkflowStatePersistenceError;\n}\n\ntype UseCaseError = IDeleteWorkflowStateUseCaseErrors[keyof IDeleteWorkflowStateUseCaseErrors];\n\nexport const DeleteWorkflowStateUseCase = createAbstraction<IDeleteWorkflowStateUseCase>(\n    \"DeleteWorkflowStateUseCase\"\n);\n\nexport namespace DeleteWorkflowStateUseCase {\n    export type Interface = IDeleteWorkflowStateUseCase;\n    export type Return = Promise<Result<void, UseCaseError>>;\n    export type Error = UseCaseError;\n}\n\nexport interface IDeleteWorkflowStateRepository {\n    execute(id: string): Promise<Result<void, never>>;\n}\n\nexport const DeleteWorkflowStateRepository = createAbstraction<IDeleteWorkflowStateRepository>(\n    \"DeleteWorkflowStateRepository\"\n);\n\nexport namespace DeleteWorkflowStateRepository {\n    export type Interface = IDeleteWorkflowStateRepository;\n    export type Return = Promise<Result<void, never>>;\n}\n"],"names":["DeleteWorkflowStateUseCase","createAbstraction","DeleteWorkflowStateRepository"],"mappings":";AAkBO,MAAMA,6BAA6BC,kBACtC;AAaG,MAAMC,gCAAgCD,kBACzC"}

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

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

package/features/workflowState/DeleteWorkflowState/feature.js

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

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

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

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

@@ -0,0 +1 @@
+export { DeleteWorkflowStateUseCase, DeleteWorkflowStateRepository } from "./abstractions.js";

package/features/workflowState/DeleteWorkflowState/index.js

@@ -0,0 +1 @@
+export { DeleteWorkflowStateRepository, DeleteWorkflowStateUseCase } from "./abstractions.js";

package/features/workflowState/GetTargetWorkflowState/GetTargetWorkflowStateRepository.d.ts

@@ -0,0 +1,14 @@
+import { ListLatestEntriesUseCase } from "@webiny/api-headless-cms/features/contentEntry/ListEntries";
+import { WorkflowStateModel, WorkflowStateMapper } from "../../../domain/workflowState/abstractions.js";
+import { GetTargetWorkflowStateRepository as Repository } from "./abstractions.js";
+declare class GetTargetWorkflowStateRepositoryImpl implements Repository.Interface {
+    private listEntries;
+    private model;
+    private mapper;
+    constructor(listEntries: ListLatestEntriesUseCase.Interface, model: WorkflowStateModel.Interface, mapper: WorkflowStateMapper.Interface);
+    execute(input: Repository.Params): Repository.Return;
+}
+export declare const GetTargetWorkflowStateRepository: typeof GetTargetWorkflowStateRepositoryImpl & {
+    __abstraction: import("@webiny/di").Abstraction<import("./abstractions.js").IGetTargetWorkflowStateRepository>;
+};
+export {};

package/features/workflowState/GetTargetWorkflowState/GetTargetWorkflowStateRepository.js

@@ -0,0 +1,48 @@
+import { Result } from "@webiny/feature/api";
+import { ListLatestEntriesUseCase } from "@webiny/api-headless-cms/features/contentEntry/ListEntries";
+import { WorkflowStateMapper, WorkflowStateModel } from "../../../domain/workflowState/abstractions.js";
+import { MultipleWorkflowsFoundError, WorkflowStateNotFoundError, WorkflowStatePersistenceError } from "../../../domain/workflowState/errors.js";
+import { GetTargetWorkflowStateRepository } from "./abstractions.js";
+class GetTargetWorkflowStateRepositoryImpl {
+    constructor(listEntries, model, mapper){
+        this.listEntries = listEntries;
+        this.model = model;
+        this.mapper = mapper;
+    }
+    async execute(input) {
+        const listResult = await this.listEntries.execute(this.model, {
+            where: {
+                values: {
+                    app: input.app,
+                    targetRevisionId: input.targetRevisionId,
+                    isActive: true
+                }
+            },
+            limit: 1
+        });
+        if (listResult.isFail()) return Result.fail(new WorkflowStatePersistenceError(listResult.error));
+        const { entries, meta } = listResult.value;
+        if (0 === entries.length) return Result.fail(new WorkflowStateNotFoundError({
+            app: input.app,
+            targetRevisionId: input.targetRevisionId
+        }));
+        if (meta.totalCount > 1) return Result.fail(new MultipleWorkflowsFoundError({
+            app: input.app,
+            targetRevisionId: input.targetRevisionId,
+            items: entries
+        }));
+        const record = this.mapper.fromCmsEntry(entries[0]);
+        return Result.ok(record);
+    }
+}
+const GetTargetWorkflowStateRepository_GetTargetWorkflowStateRepository = GetTargetWorkflowStateRepository.createImplementation({
+    implementation: GetTargetWorkflowStateRepositoryImpl,
+    dependencies: [
+        ListLatestEntriesUseCase,
+        WorkflowStateModel,
+        WorkflowStateMapper
+    ]
+});
+export { GetTargetWorkflowStateRepository_GetTargetWorkflowStateRepository as GetTargetWorkflowStateRepository };
+
+//# sourceMappingURL=GetTargetWorkflowStateRepository.js.map

package/features/workflowState/GetTargetWorkflowState/GetTargetWorkflowStateRepository.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"features/workflowState/GetTargetWorkflowState/GetTargetWorkflowStateRepository.js","sources":["../../../../src/features/workflowState/GetTargetWorkflowState/GetTargetWorkflowStateRepository.ts"],"sourcesContent":["import { Result } from \"@webiny/feature/api\";\nimport { ListLatestEntriesUseCase } from \"@webiny/api-headless-cms/features/contentEntry/ListEntries\";\nimport { WorkflowStateModel, WorkflowStateMapper } from \"~/domain/workflowState/abstractions.js\";\nimport type { IWorkflowStateRecord } from \"~/domain/workflowState/abstractions.js\";\nimport {\n    WorkflowStateNotFoundError,\n    WorkflowStatePersistenceError,\n    MultipleWorkflowsFoundError\n} from \"~/domain/workflowState/errors.js\";\nimport { GetTargetWorkflowStateRepository as Repository } from \"./abstractions.js\";\n\nclass GetTargetWorkflowStateRepositoryImpl implements Repository.Interface {\n    constructor(\n        private listEntries: ListLatestEntriesUseCase.Interface,\n        private model: WorkflowStateModel.Interface,\n        private mapper: WorkflowStateMapper.Interface\n    ) {}\n\n    async execute(input: Repository.Params): Repository.Return {\n        const listResult = await this.listEntries.execute<Omit<IWorkflowStateRecord, \"id\">>(\n            this.model,\n            {\n                where: {\n                    values: {\n                        app: input.app,\n                        targetRevisionId: input.targetRevisionId,\n                        isActive: true\n                    }\n                },\n                limit: 1\n            }\n        );\n\n        if (listResult.isFail()) {\n            return Result.fail(new WorkflowStatePersistenceError(listResult.error));\n        }\n\n        const { entries, meta } = listResult.value;\n\n        if (entries.length === 0) {\n            return Result.fail(\n                new WorkflowStateNotFoundError({\n                    app: input.app,\n                    targetRevisionId: input.targetRevisionId\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                    items: entries\n                })\n            );\n        }\n\n        const record = this.mapper.fromCmsEntry(entries[0]);\n        return Result.ok(record);\n    }\n}\n\nexport const GetTargetWorkflowStateRepository = Repository.createImplementation({\n    implementation: GetTargetWorkflowStateRepositoryImpl,\n    dependencies: [ListLatestEntriesUseCase, WorkflowStateModel, WorkflowStateMapper]\n});\n"],"names":["GetTargetWorkflowStateRepositoryImpl","listEntries","model","mapper","input","listResult","Result","WorkflowStatePersistenceError","entries","meta","WorkflowStateNotFoundError","MultipleWorkflowsFoundError","record","GetTargetWorkflowStateRepository","Repository","ListLatestEntriesUseCase","WorkflowStateModel","WorkflowStateMapper"],"mappings":";;;;;AAWA,MAAMA;IACF,YACYC,WAA+C,EAC/CC,KAAmC,EACnCC,MAAqC,CAC/C;aAHUF,WAAW,GAAXA;aACAC,KAAK,GAALA;aACAC,MAAM,GAANA;IACT;IAEH,MAAM,QAAQC,KAAwB,EAAqB;QACvD,MAAMC,aAAa,MAAM,IAAI,CAAC,WAAW,CAAC,OAAO,CAC7C,IAAI,CAAC,KAAK,EACV;YACI,OAAO;gBACH,QAAQ;oBACJ,KAAKD,MAAM,GAAG;oBACd,kBAAkBA,MAAM,gBAAgB;oBACxC,UAAU;gBACd;YACJ;YACA,OAAO;QACX;QAGJ,IAAIC,WAAW,MAAM,IACjB,OAAOC,OAAO,IAAI,CAAC,IAAIC,8BAA8BF,WAAW,KAAK;QAGzE,MAAM,EAAEG,OAAO,EAAEC,IAAI,EAAE,GAAGJ,WAAW,KAAK;QAE1C,IAAIG,AAAmB,MAAnBA,QAAQ,MAAM,EACd,OAAOF,OAAO,IAAI,CACd,IAAII,2BAA2B;YAC3B,KAAKN,MAAM,GAAG;YACd,kBAAkBA,MAAM,gBAAgB;QAC5C;QAIR,IAAIK,KAAK,UAAU,GAAG,GAClB,OAAOH,OAAO,IAAI,CACd,IAAIK,4BAA4B;YAC5B,KAAKP,MAAM,GAAG;YACd,kBAAkBA,MAAM,gBAAgB;YACxC,OAAOI;QACX;QAIR,MAAMI,SAAS,IAAI,CAAC,MAAM,CAAC,YAAY,CAACJ,OAAO,CAAC,EAAE;QAClD,OAAOF,OAAO,EAAE,CAACM;IACrB;AACJ;AAEO,MAAMC,oEAAmCC,iCAAAA,oBAA+B,CAAC;IAC5E,gBAAgBd;IAChB,cAAc;QAACe;QAA0BC;QAAoBC;KAAoB;AACrF"}

package/features/workflowState/GetTargetWorkflowState/GetTargetWorkflowStateUseCase.d.ts

@@ -0,0 +1,14 @@
+import { IdentityContext } from "@webiny/api-core/features/security/IdentityContext/index.js";
+import { GetUserTeamsUseCase } from "../../../features/internal/GetUserTeams/index.js";
+import { GetTargetWorkflowStateRepository, GetTargetWorkflowStateUseCase as UseCase } from "./abstractions.js";
+declare class GetTargetWorkflowStateUseCaseImpl implements UseCase.Interface {
+    private identityContext;
+    private getUserTeams;
+    private repository;
+    constructor(identityContext: IdentityContext.Interface, getUserTeams: GetUserTeamsUseCase.Interface, repository: GetTargetWorkflowStateRepository.Interface);
+    execute(input: UseCase.Params): UseCase.Return;
+}
+export declare const GetTargetWorkflowStateUseCase: typeof GetTargetWorkflowStateUseCaseImpl & {
+    __abstraction: import("@webiny/di").Abstraction<import("./abstractions.js").IGetTargetWorkflowStateUseCase>;
+};
+export {};

package/features/workflowState/GetTargetWorkflowState/GetTargetWorkflowStateUseCase.js

@@ -0,0 +1,37 @@
+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 { GetTargetWorkflowStateRepository, GetTargetWorkflowStateUseCase } from "./abstractions.js";
+import { WorkflowState } from "../../../domain/workflowState/WorkflowState.js";
+import { WorkflowStateValidationError } from "../../../domain/workflowState/errors.js";
+class GetTargetWorkflowStateUseCaseImpl {
+    constructor(identityContext, getUserTeams, repository){
+        this.identityContext = identityContext;
+        this.getUserTeams = getUserTeams;
+        this.repository = repository;
+    }
+    async execute(input) {
+        const { version } = parseIdentifier(input.targetRevisionId);
+        if (!version) return Result.fail(new WorkflowStateValidationError("Cannot get a workflow state without version of a target record."));
+        const recordResult = await this.repository.execute(input);
+        if (recordResult.isFail()) return Result.fail(recordResult.error);
+        const record = recordResult.value;
+        const identity = this.identityContext.getIdentity();
+        const teamsResult = await this.getUserTeams.execute(identity.id);
+        const teams = teamsResult.value;
+        const workflowState = new WorkflowState(record, teams, identity);
+        return Result.ok(workflowState);
+    }
+}
+const GetTargetWorkflowStateUseCase_GetTargetWorkflowStateUseCase = GetTargetWorkflowStateUseCase.createImplementation({
+    implementation: GetTargetWorkflowStateUseCaseImpl,
+    dependencies: [
+        IdentityContext,
+        GetUserTeamsUseCase,
+        GetTargetWorkflowStateRepository
+    ]
+});
+export { GetTargetWorkflowStateUseCase_GetTargetWorkflowStateUseCase as GetTargetWorkflowStateUseCase };
+
+//# sourceMappingURL=GetTargetWorkflowStateUseCase.js.map

package/features/workflowState/GetTargetWorkflowState/GetTargetWorkflowStateUseCase.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"features/workflowState/GetTargetWorkflowState/GetTargetWorkflowStateUseCase.js","sources":["../../../../src/features/workflowState/GetTargetWorkflowState/GetTargetWorkflowStateUseCase.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 {\n    GetTargetWorkflowStateRepository,\n    GetTargetWorkflowStateUseCase as UseCase\n} from \"./abstractions.js\";\nimport { WorkflowState } from \"~/domain/workflowState/WorkflowState.js\";\nimport { WorkflowStateValidationError } from \"~/domain/workflowState/errors.js\";\n\nclass GetTargetWorkflowStateUseCaseImpl implements UseCase.Interface {\n    constructor(\n        private identityContext: IdentityContext.Interface,\n        private getUserTeams: GetUserTeamsUseCase.Interface,\n        private repository: GetTargetWorkflowStateRepository.Interface\n    ) {}\n\n    async execute(input: UseCase.Params): UseCase.Return {\n        const { version } = parseIdentifier(input.targetRevisionId);\n        if (!version) {\n            return Result.fail(\n                new WorkflowStateValidationError(\n                    \"Cannot get a workflow state without version of a target record.\"\n                )\n            );\n        }\n\n        const recordResult = await this.repository.execute(input);\n\n        if (recordResult.isFail()) {\n            return Result.fail(recordResult.error);\n        }\n\n        const record = recordResult.value;\n\n        const identity = this.identityContext.getIdentity();\n\n        const teamsResult = await this.getUserTeams.execute(identity.id);\n        const teams = teamsResult.value;\n\n        const workflowState = new WorkflowState(record, teams, identity);\n\n        return Result.ok(workflowState);\n    }\n}\n\nexport const GetTargetWorkflowStateUseCase = UseCase.createImplementation({\n    implementation: GetTargetWorkflowStateUseCaseImpl,\n    dependencies: [IdentityContext, GetUserTeamsUseCase, GetTargetWorkflowStateRepository]\n});\n"],"names":["GetTargetWorkflowStateUseCaseImpl","identityContext","getUserTeams","repository","input","version","parseIdentifier","Result","WorkflowStateValidationError","recordResult","record","identity","teamsResult","teams","workflowState","WorkflowState","GetTargetWorkflowStateUseCase","UseCase","IdentityContext","GetUserTeamsUseCase","GetTargetWorkflowStateRepository"],"mappings":";;;;;;;AAWA,MAAMA;IACF,YACYC,eAA0C,EAC1CC,YAA2C,EAC3CC,UAAsD,CAChE;aAHUF,eAAe,GAAfA;aACAC,YAAY,GAAZA;aACAC,UAAU,GAAVA;IACT;IAEH,MAAM,QAAQC,KAAqB,EAAkB;QACjD,MAAM,EAAEC,OAAO,EAAE,GAAGC,gBAAgBF,MAAM,gBAAgB;QAC1D,IAAI,CAACC,SACD,OAAOE,OAAO,IAAI,CACd,IAAIC,6BACA;QAKZ,MAAMC,eAAe,MAAM,IAAI,CAAC,UAAU,CAAC,OAAO,CAACL;QAEnD,IAAIK,aAAa,MAAM,IACnB,OAAOF,OAAO,IAAI,CAACE,aAAa,KAAK;QAGzC,MAAMC,SAASD,aAAa,KAAK;QAEjC,MAAME,WAAW,IAAI,CAAC,eAAe,CAAC,WAAW;QAEjD,MAAMC,cAAc,MAAM,IAAI,CAAC,YAAY,CAAC,OAAO,CAACD,SAAS,EAAE;QAC/D,MAAME,QAAQD,YAAY,KAAK;QAE/B,MAAME,gBAAgB,IAAIC,cAAcL,QAAQG,OAAOF;QAEvD,OAAOJ,OAAO,EAAE,CAACO;IACrB;AACJ;AAEO,MAAME,8DAAgCC,8BAAAA,oBAA4B,CAAC;IACtE,gBAAgBjB;IAChB,cAAc;QAACkB;QAAiBC;QAAqBC;KAAiC;AAC1F"}

package/features/workflowState/GetTargetWorkflowState/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, type MultipleWorkflowsFoundError, WorkflowStateValidationError } from "../../../domain/workflowState/errors.js";
+import type { WorkflowState } from "../../../domain/workflowState/WorkflowState.js";
+export interface IGetTargetWorkflowStateParams {
+    app: string;
+    targetRevisionId: string;
+}
+/**
+ * GetTargetWorkflowState use case interface
+ */
+export interface IGetTargetWorkflowStateUseCase {
+    execute(input: IGetTargetWorkflowStateParams): Promise<Result<WorkflowState, UseCaseError>>;
+}
+export interface IGetTargetWorkflowStateUseCaseErrors {
+    notFound: WorkflowStateNotFoundError;
+    persistence: WorkflowStatePersistenceError;
+    multipleFound: MultipleWorkflowsFoundError;
+    validation: WorkflowStateValidationError;
+}
+type UseCaseError = IGetTargetWorkflowStateUseCaseErrors[keyof IGetTargetWorkflowStateUseCaseErrors];
+export declare const GetTargetWorkflowStateUseCase: import("@webiny/di").Abstraction<IGetTargetWorkflowStateUseCase>;
+export declare namespace GetTargetWorkflowStateUseCase {
+    type Interface = IGetTargetWorkflowStateUseCase;
+    type Params = IGetTargetWorkflowStateParams;
+    type Return = Promise<Result<WorkflowState, UseCaseError>>;
+    type Error = UseCaseError;
+}
+/**
+ * GetTargetWorkflowState repository interface
+ */
+export interface IGetTargetWorkflowStateRepository {
+    execute(input: IGetTargetWorkflowStateParams): Promise<Result<IWorkflowStateRecord, RepositoryError>>;
+}
+export interface IGetTargetWorkflowStateRepositoryErrors {
+    notFound: WorkflowStateNotFoundError;
+    persistence: WorkflowStatePersistenceError;
+    multipleFound: MultipleWorkflowsFoundError;
+}
+type RepositoryError = IGetTargetWorkflowStateRepositoryErrors[keyof IGetTargetWorkflowStateRepositoryErrors];
+export declare const GetTargetWorkflowStateRepository: import("@webiny/di").Abstraction<IGetTargetWorkflowStateRepository>;
+export declare namespace GetTargetWorkflowStateRepository {
+    type Interface = IGetTargetWorkflowStateRepository;
+    type Params = IGetTargetWorkflowStateParams;
+    type Return = Promise<Result<IWorkflowStateRecord, RepositoryError>>;
+    type Error = RepositoryError;
+}
+export {};

package/features/workflowState/GetTargetWorkflowState/abstractions.js

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"features/workflowState/GetTargetWorkflowState/abstractions.js","sources":["../../../../src/features/workflowState/GetTargetWorkflowState/abstractions.ts"],"sourcesContent":["import { createAbstraction } from \"@webiny/feature/api\";\nimport type { Result } from \"@webiny/feature/api\";\nimport type { IWorkflowStateRecord } from \"~/domain/workflowState/abstractions.js\";\nimport {\n    type WorkflowStateNotFoundError,\n    type WorkflowStatePersistenceError,\n    type MultipleWorkflowsFoundError,\n    WorkflowStateValidationError\n} from \"~/domain/workflowState/errors.js\";\nimport type { WorkflowState } from \"~/domain/workflowState/WorkflowState.js\";\n\nexport interface IGetTargetWorkflowStateParams {\n    app: string;\n    targetRevisionId: string;\n}\n\n/**\n * GetTargetWorkflowState use case interface\n */\nexport interface IGetTargetWorkflowStateUseCase {\n    execute(input: IGetTargetWorkflowStateParams): Promise<Result<WorkflowState, UseCaseError>>;\n}\n\nexport interface IGetTargetWorkflowStateUseCaseErrors {\n    notFound: WorkflowStateNotFoundError;\n    persistence: WorkflowStatePersistenceError;\n    multipleFound: MultipleWorkflowsFoundError;\n    validation: WorkflowStateValidationError;\n}\n\ntype UseCaseError =\n    IGetTargetWorkflowStateUseCaseErrors[keyof IGetTargetWorkflowStateUseCaseErrors];\n\nexport const GetTargetWorkflowStateUseCase = createAbstraction<IGetTargetWorkflowStateUseCase>(\n    \"GetTargetWorkflowStateUseCase\"\n);\n\nexport namespace GetTargetWorkflowStateUseCase {\n    export type Interface = IGetTargetWorkflowStateUseCase;\n    export type Params = IGetTargetWorkflowStateParams;\n    export type Return = Promise<Result<WorkflowState, UseCaseError>>;\n    export type Error = UseCaseError;\n}\n\n/**\n * GetTargetWorkflowState repository interface\n */\nexport interface IGetTargetWorkflowStateRepository {\n    execute(\n        input: IGetTargetWorkflowStateParams\n    ): Promise<Result<IWorkflowStateRecord, RepositoryError>>;\n}\n\nexport interface IGetTargetWorkflowStateRepositoryErrors {\n    notFound: WorkflowStateNotFoundError;\n    persistence: WorkflowStatePersistenceError;\n    multipleFound: MultipleWorkflowsFoundError;\n}\n\ntype RepositoryError =\n    IGetTargetWorkflowStateRepositoryErrors[keyof IGetTargetWorkflowStateRepositoryErrors];\n\nexport const GetTargetWorkflowStateRepository =\n    createAbstraction<IGetTargetWorkflowStateRepository>(\"GetTargetWorkflowStateRepository\");\n\nexport namespace GetTargetWorkflowStateRepository {\n    export type Interface = IGetTargetWorkflowStateRepository;\n    export type Params = IGetTargetWorkflowStateParams;\n    export type Return = Promise<Result<IWorkflowStateRecord, RepositoryError>>;\n    export type Error = RepositoryError;\n}\n"],"names":["GetTargetWorkflowStateUseCase","createAbstraction","GetTargetWorkflowStateRepository"],"mappings":";AAiCO,MAAMA,gCAAgCC,kBACzC;AA4BG,MAAMC,mCACTD,kBAAqD"}

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

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