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

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

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

@@ -0,0 +1 @@
+{"version":3,"names":["createAbstraction","CreateWorkflowStateUseCase","CreateWorkflowStateRepository"],"sources":["abstractions.ts"],"sourcesContent":["import type { Result } from \"@webiny/feature/api\";\nimport { createAbstraction } from \"@webiny/feature/api\";\nimport type { IWorkflowStateRecord } from \"~/domain/workflowState/abstractions.js\";\nimport {\n    type 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"],"mappings":"AACA,SAASA,iBAAiB,QAAQ,qBAAqB;;AAsBvD;AACA;AACA;;AAgBA,OAAO,MAAMC,0BAA0B,GAAGD,iBAAiB,CACvD,4BACJ,CAAC;;AASD;AACA;AACA;;AAoBA,OAAO,MAAME,6BAA6B,GAAGF,iBAAiB,CAC1D,+BACJ,CAAC","ignoreList":[]}

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

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

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

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

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

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

package/features/workflowState/CreateWorkflowState/feature.js

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

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

@@ -0,0 +1 @@
+{"version":3,"names":["createFeature","CreateWorkflowStateUseCase","CreateWorkflowStateRepository","CreateWorkflowStateFeature","name","register","container","inSingletonScope"],"sources":["feature.ts"],"sourcesContent":["import { createFeature } from \"@webiny/feature/api\";\nimport { CreateWorkflowStateUseCase } from \"./CreateWorkflowStateUseCase.js\";\nimport { CreateWorkflowStateRepository } from \"./CreateWorkflowStateRepository.js\";\n\nexport const CreateWorkflowStateFeature = createFeature({\n    name: \"WorkflowState/CreateWorkflowState\",\n    register(container) {\n        container.register(CreateWorkflowStateRepository).inSingletonScope();\n        container.register(CreateWorkflowStateUseCase);\n    }\n});\n"],"mappings":"AAAA,SAASA,aAAa,QAAQ,qBAAqB;AACnD,SAASC,0BAA0B;AACnC,SAASC,6BAA6B;AAEtC,OAAO,MAAMC,0BAA0B,GAAGH,aAAa,CAAC;EACpDI,IAAI,EAAE,mCAAmC;EACzCC,QAAQA,CAACC,SAAS,EAAE;IAChBA,SAAS,CAACD,QAAQ,CAACH,6BAA6B,CAAC,CAACK,gBAAgB,CAAC,CAAC;IACpED,SAAS,CAACD,QAAQ,CAACJ,0BAA0B,CAAC;EAClD;AACJ,CAAC,CAAC","ignoreList":[]}

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

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

package/features/workflowState/CreateWorkflowState/index.js

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

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

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

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

@@ -0,0 +1,21 @@
+import { IdentityContext } from "@webiny/api-core/features/IdentityContext";
+import { GetUserTeamsUseCase } from "../../../features/internal/GetUserTeams/index.js";
+import { EventPublisher } from "@webiny/api-core/features/EventPublisher";
+import { GetWorkflowUseCase } from "../../../features/workflow/GetWorkflow/index.js";
+import { 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,59 @@
+import { Result } from "@webiny/feature/api";
+import { IdentityContext } from "@webiny/api-core/features/IdentityContext";
+import { GetUserTeamsUseCase } from "../../internal/GetUserTeams/index.js";
+import { EventPublisher } from "@webiny/api-core/features/EventPublisher";
+import { GetWorkflowUseCase } from "../../workflow/GetWorkflow/index.js";
+import { GetTargetWorkflowStateUseCase } from "../GetTargetWorkflowState/index.js";
+import { DeleteWorkflowStateRepository } from "../DeleteWorkflowState/index.js";
+import { DeleteTargetWorkflowStateUseCase as UseCase } 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();
+  }
+}
+export const DeleteTargetWorkflowStateUseCase = UseCase.createImplementation({
+  implementation: DeleteTargetWorkflowStateUseCaseImpl,
+  dependencies: [IdentityContext, GetUserTeamsUseCase, EventPublisher, GetWorkflowUseCase, GetTargetWorkflowStateUseCase, DeleteWorkflowStateRepository]
+});
+
+//# sourceMappingURL=DeleteTargetWorkflowStateUseCase.js.map

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

@@ -0,0 +1 @@
+{"version":3,"names":["Result","IdentityContext","GetUserTeamsUseCase","EventPublisher","GetWorkflowUseCase","GetTargetWorkflowStateUseCase","DeleteWorkflowStateRepository","DeleteTargetWorkflowStateUseCase","UseCase","WorkflowStateAfterDeleteEvent","WorkflowState","WorkflowNotFoundError","DeleteTargetWorkflowStateUseCaseImpl","constructor","identityContext","getUserTeams","eventPublisher","getWorkflow","getTargetWorkflowState","repository","execute","app","targetRevisionId","stateResult","isFail","ok","record","value","workflowResult","id","workflowId","fail","deleteResult","identity","getIdentity","teamsResult","teams","state","publish","createImplementation","implementation","dependencies"],"sources":["DeleteTargetWorkflowStateUseCase.ts"],"sourcesContent":["import { Result } from \"@webiny/feature/api\";\nimport { IdentityContext } from \"@webiny/api-core/features/IdentityContext\";\nimport { GetUserTeamsUseCase } from \"~/features/internal/GetUserTeams/index.js\";\nimport { EventPublisher } from \"@webiny/api-core/features/EventPublisher\";\nimport { GetWorkflowUseCase } from \"~/features/workflow/GetWorkflow/index.js\";\nimport { 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"],"mappings":"AAAA,SAASA,MAAM,QAAQ,qBAAqB;AAC5C,SAASC,eAAe,QAAQ,2CAA2C;AAC3E,SAASC,mBAAmB;AAC5B,SAASC,cAAc,QAAQ,0CAA0C;AACzE,SAASC,kBAAkB;AAC3B,SAASC,6BAA6B;AACtC,SAASC,6BAA6B;AACtC,SAASC,gCAAgC,IAAIC,OAAO;AACpD,SAASC,6BAA6B;AACtC,SAASC,aAAa;AACtB,SAASC,qBAAqB;AAE9B,MAAMC,oCAAoC,CAA8B;EACpEC,WAAWA,CACCC,eAA0C,EAC1CC,YAA2C,EAC3CC,cAAwC,EACxCC,WAAyC,EACzCC,sBAA+D,EAC/DC,UAAmD,EAC7D;IAAA,KANUL,eAA0C,GAA1CA,eAA0C;IAAA,KAC1CC,YAA2C,GAA3CA,YAA2C;IAAA,KAC3CC,cAAwC,GAAxCA,cAAwC;IAAA,KACxCC,WAAyC,GAAzCA,WAAyC;IAAA,KACzCC,sBAA+D,GAA/DA,sBAA+D;IAAA,KAC/DC,UAAmD,GAAnDA,UAAmD;EAC5D;EAEH,MAAMC,OAAOA,CAACC,GAAW,EAAEC,gBAAwB,EAAkB;IACjE,MAAMC,WAAW,GAAG,MAAM,IAAI,CAACL,sBAAsB,CAACE,OAAO,CAAC;MAAEC,GAAG;MAAEC;IAAiB,CAAC,CAAC;IACxF,IAAIC,WAAW,CAACC,MAAM,CAAC,CAAC,EAAE;MACtB,OAAOxB,MAAM,CAACyB,EAAE,CAAC,CAAC;IACtB;IAEA,MAAMC,MAAM,GAAGH,WAAW,CAACI,KAAK;IAEhC,MAAMC,cAAc,GAAG,MAAM,IAAI,CAACX,WAAW,CAACG,OAAO,CAAC;MAClDC,GAAG,EAAEK,MAAM,CAACL,GAAG;MACfQ,EAAE,EAAEH,MAAM,CAACI;IACf,CAAC,CAAC;IAEF,IAAIF,cAAc,CAACJ,MAAM,CAAC,CAAC,EAAE;MACzB,OAAOxB,MAAM,CAAC+B,IAAI,CACd,IAAIpB,qBAAqB,CAAC;QACtBkB,EAAE,EAAEH,MAAM,CAACI,UAAU;QACrBT,GAAG,EAAEK,MAAM,CAACL;MAChB,CAAC,CACL,CAAC;IACL;IAEA,MAAMW,YAAY,GAAG,MAAM,IAAI,CAACb,UAAU,CAACC,OAAO,CAACM,MAAM,CAACG,EAAE,CAAC;IAC7D,IAAIG,YAAY,CAACR,MAAM,CAAC,CAAC,EAAE;MACvB,OAAOQ,YAAY;IACvB;IAEA,MAAMC,QAAQ,GAAG,IAAI,CAACnB,eAAe,CAACoB,WAAW,CAAC,CAAC;IACnD,MAAMC,WAAW,GAAG,MAAM,IAAI,CAACpB,YAAY,CAACK,OAAO,CAACa,QAAQ,CAACJ,EAAE,CAAC;IAChE,MAAMO,KAAK,GAAGD,WAAW,CAACR,KAAK;IAC/B,MAAMU,KAAK,GAAG,IAAI3B,aAAa,CAACgB,MAAM,EAAEU,KAAK,EAAEH,QAAQ,CAAC;IAExD,MAAM,IAAI,CAACjB,cAAc,CAACsB,OAAO,CAC7B,IAAI7B,6BAA6B,CAAC;MAC9B4B;IACJ,CAAC,CACL,CAAC;IAED,OAAOrC,MAAM,CAACyB,EAAE,CAAC,CAAC;EACtB;AACJ;AAEA,OAAO,MAAMlB,gCAAgC,GAAGC,OAAO,CAAC+B,oBAAoB,CAAC;EACzEC,cAAc,EAAE5B,oCAAoC;EACpD6B,YAAY,EAAE,CACVxC,eAAe,EACfC,mBAAmB,EACnBC,cAAc,EACdC,kBAAkB,EAClBC,6BAA6B,EAC7BC,6BAA6B;AAErC,CAAC,CAAC","ignoreList":[]}

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

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

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

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

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

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

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

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

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

package/features/workflowState/DeleteTargetWorkflowState/feature.js

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

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

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

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

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

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

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,20 @@
+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 as Repository } 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();
+  }
+}
+export const DeleteWorkflowStateRepository = Repository.createImplementation({
+  implementation: DeleteWorkflowStateRepositoryImpl,
+  dependencies: [DeleteEntryUseCase, WorkflowStateModel]
+});
+
+//# sourceMappingURL=DeleteWorkflowStateRepository.js.map

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

@@ -0,0 +1 @@
+{"version":3,"names":["Result","DeleteEntryUseCase","WorkflowStateModel","DeleteWorkflowStateRepository","Repository","DeleteWorkflowStateRepositoryImpl","constructor","deleteEntry","model","execute","id","ok","createImplementation","implementation","dependencies"],"sources":["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"],"mappings":"AAAA,SAASA,MAAM,QAAQ,qBAAqB;AAC5C,SAASC,kBAAkB,QAAQ,qEAAqE;AACxG,SAASC,kBAAkB;AAC3B,SAASC,6BAA6B,IAAIC,UAAU;AAEpD,MAAMC,iCAAiC,CAAiC;EACpEC,WAAWA,CACCC,WAAyC,EACzCC,KAAmC,EAC7C;IAAA,KAFUD,WAAyC,GAAzCA,WAAyC;IAAA,KACzCC,KAAmC,GAAnCA,KAAmC;EAC5C;EAEH,MAAMC,OAAOA,CAACC,EAAU,EAAqB;IACzC,MAAM,IAAI,CAACH,WAAW,CAACE,OAAO,CAAC,IAAI,CAACD,KAAK,EAAEE,EAAE,CAAC;IAE9C,OAAOV,MAAM,CAACW,EAAE,CAAC,CAAC;EACtB;AACJ;AAEA,OAAO,MAAMR,6BAA6B,GAAGC,UAAU,CAACQ,oBAAoB,CAAC;EACzEC,cAAc,EAAER,iCAAiC;EACjDS,YAAY,EAAE,CAACb,kBAAkB,EAAEC,kBAAkB;AACzD,CAAC,CAAC","ignoreList":[]}

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,32 @@
+import { Result } from "@webiny/feature/api";
+import { GetWorkflowStateUseCase } from "../GetWorkflowState/index.js";
+import { DeleteWorkflowStateRepository, DeleteWorkflowStateUseCase as UseCase } 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();
+  }
+}
+export const DeleteWorkflowStateUseCase = UseCase.createImplementation({
+  implementation: DeleteWorkflowStateUseCaseImpl,
+  dependencies: [GetWorkflowStateUseCase, DeleteWorkflowStateRepository, EventPublisher]
+});
+
+//# sourceMappingURL=DeleteWorkflowStateUseCase.js.map

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

@@ -0,0 +1 @@
+{"version":3,"names":["Result","GetWorkflowStateUseCase","DeleteWorkflowStateRepository","DeleteWorkflowStateUseCase","UseCase","WorkflowStateAfterDeleteEvent","EventPublisher","DeleteWorkflowStateUseCaseImpl","constructor","getWorkflowState","repository","eventPublisher","execute","id","stateResult","isFail","fail","error","result","publish","state","value","ok","createImplementation","implementation","dependencies"],"sources":["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"],"mappings":"AAAA,SAASA,MAAM,QAAQ,qBAAqB;AAC5C,SAASC,uBAAuB;AAChC,SACIC,6BAA6B,EAC7BC,0BAA0B,IAAIC,OAAO;AAEzC,SAASC,6BAA6B;AACtC,SAASC,cAAc,QAAQ,mDAAmD;AAElF,MAAMC,8BAA8B,CAA8B;EAC9DC,WAAWA,CACCC,gBAAmD,EACnDC,UAAmD,EACnDC,cAAwC,EAClD;IAAA,KAHUF,gBAAmD,GAAnDA,gBAAmD;IAAA,KACnDC,UAAmD,GAAnDA,UAAmD;IAAA,KACnDC,cAAwC,GAAxCA,cAAwC;EACjD;EAEH,MAAMC,OAAOA,CAACC,EAAU,EAAkB;IACtC,MAAMC,WAAW,GAAG,MAAM,IAAI,CAACL,gBAAgB,CAACG,OAAO,CAACC,EAAE,CAAC;IAC3D,IAAIC,WAAW,CAACC,MAAM,CAAC,CAAC,EAAE;MACtB,OAAOf,MAAM,CAACgB,IAAI,CAACF,WAAW,CAACG,KAAK,CAAC;IACzC;IAEA,MAAMC,MAAM,GAAG,MAAM,IAAI,CAACR,UAAU,CAACE,OAAO,CAACC,EAAE,CAAC;IAChD,IAAIK,MAAM,CAACH,MAAM,CAAC,CAAC,EAAE;MACjB,OAAOG,MAAM;IACjB;IAEA,MAAM,IAAI,CAACP,cAAc,CAACQ,OAAO,CAC7B,IAAId,6BAA6B,CAAC;MAC9Be,KAAK,EAAEN,WAAW,CAACO;IACvB,CAAC,CACL,CAAC;IAED,OAAOrB,MAAM,CAACsB,EAAE,CAAC,CAAC;EACtB;AACJ;AAEA,OAAO,MAAMnB,0BAA0B,GAAGC,OAAO,CAACmB,oBAAoB,CAAC;EACnEC,cAAc,EAAEjB,8BAA8B;EAC9CkB,YAAY,EAAE,CAACxB,uBAAuB,EAAEC,6BAA6B,EAAEI,cAAc;AACzF,CAAC,CAAC","ignoreList":[]}

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

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

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

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

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

package/features/workflowState/DeleteWorkflowState/feature.js

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

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

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

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

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

package/features/workflowState/DeleteWorkflowState/index.js

@@ -0,0 +1,3 @@
+export { DeleteWorkflowStateUseCase, DeleteWorkflowStateRepository } from "./abstractions.js";
+
+//# sourceMappingURL=index.js.map

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

@@ -0,0 +1 @@
+{"version":3,"names":["DeleteWorkflowStateUseCase","DeleteWorkflowStateRepository"],"sources":["index.ts"],"sourcesContent":["export { DeleteWorkflowStateUseCase, DeleteWorkflowStateRepository } from \"./abstractions.js\";\n"],"mappings":"AAAA,SAASA,0BAA0B,EAAEC,6BAA6B","ignoreList":[]}

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,52 @@
+import { Result } from "@webiny/feature/api";
+import { ListLatestEntriesUseCase } from "@webiny/api-headless-cms/features/contentEntry/ListEntries";
+import { WorkflowStateModel, WorkflowStateMapper } from "../../../domain/workflowState/abstractions.js";
+import { WorkflowStateNotFoundError, WorkflowStatePersistenceError, MultipleWorkflowsFoundError } from "../../../domain/workflowState/errors.js";
+import { GetTargetWorkflowStateRepository as Repository } 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 (entries.length === 0) {
+      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);
+  }
+}
+export const GetTargetWorkflowStateRepository = Repository.createImplementation({
+  implementation: GetTargetWorkflowStateRepositoryImpl,
+  dependencies: [ListLatestEntriesUseCase, WorkflowStateModel, WorkflowStateMapper]
+});
+
+//# sourceMappingURL=GetTargetWorkflowStateRepository.js.map