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

package/features/workflowState/ListWorkflowStates/ListWorkflowStatesRepository.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"features/workflowState/ListWorkflowStates/ListWorkflowStatesRepository.js","sources":["../../../../src/features/workflowState/ListWorkflowStates/ListWorkflowStatesRepository.ts"],"sourcesContent":["import { Result } from \"@webiny/feature/api\";\nimport { ListLatestEntriesUseCase } from \"@webiny/api-headless-cms/features/contentEntry/ListEntries\";\nimport type { IWorkflowStateRecord } from \"~/domain/workflowState/abstractions.js\";\nimport { WorkflowStateMapper, WorkflowStateModel } from \"~/domain/workflowState/abstractions.js\";\nimport { WorkflowStatePersistenceError } from \"~/domain/workflowState/errors.js\";\nimport { ListWorkflowStatesRepository as Repository } from \"./abstractions.js\";\nimport { CmsWhereMapper } from \"@webiny/api-headless-cms\";\n\nclass ListWorkflowStatesRepositoryImpl implements Repository.Interface {\n    constructor(\n        private listEntries: ListLatestEntriesUseCase.Interface,\n        private model: WorkflowStateModel.Interface,\n        private mapper: WorkflowStateMapper.Interface,\n        private cmsWhereMapper: CmsWhereMapper.Interface\n    ) {}\n\n    async execute(params: Repository.Params = {}): Repository.Return {\n        const listResult = await this.listEntries.execute<Omit<IWorkflowStateRecord, \"id\">>(\n            this.model,\n            {\n                limit: 50,\n                sort: [\"createdOn_DESC\"],\n                ...params,\n                where: this.cmsWhereMapper.map({\n                    input: params.where,\n                    fields: this.model.fields\n                })\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        const records = entries.map(item => this.mapper.fromCmsEntry(item));\n\n        return Result.ok({\n            items: records,\n            meta\n        });\n    }\n}\n\nexport const ListWorkflowStatesRepository = Repository.createImplementation({\n    implementation: ListWorkflowStatesRepositoryImpl,\n    dependencies: [\n        ListLatestEntriesUseCase,\n        WorkflowStateModel,\n        WorkflowStateMapper,\n        CmsWhereMapper\n    ]\n});\n"],"names":["ListWorkflowStatesRepositoryImpl","listEntries","model","mapper","cmsWhereMapper","params","listResult","Result","WorkflowStatePersistenceError","entries","meta","records","item","ListWorkflowStatesRepository","Repository","ListLatestEntriesUseCase","WorkflowStateModel","WorkflowStateMapper","CmsWhereMapper"],"mappings":";;;;;;AAQA,MAAMA;IACF,YACYC,WAA+C,EAC/CC,KAAmC,EACnCC,MAAqC,EACrCC,cAAwC,CAClD;aAJUH,WAAW,GAAXA;aACAC,KAAK,GAALA;aACAC,MAAM,GAANA;aACAC,cAAc,GAAdA;IACT;IAEH,MAAM,QAAQC,SAA4B,CAAC,CAAC,EAAqB;QAC7D,MAAMC,aAAa,MAAM,IAAI,CAAC,WAAW,CAAC,OAAO,CAC7C,IAAI,CAAC,KAAK,EACV;YACI,OAAO;YACP,MAAM;gBAAC;aAAiB;YACxB,GAAGD,MAAM;YACT,OAAO,IAAI,CAAC,cAAc,CAAC,GAAG,CAAC;gBAC3B,OAAOA,OAAO,KAAK;gBACnB,QAAQ,IAAI,CAAC,KAAK,CAAC,MAAM;YAC7B;QACJ;QAGJ,IAAIC,WAAW,MAAM,IACjB,OAAOC,OAAO,IAAI,CAAC,IAAIC,8BAA8BF,WAAW,KAAK;QAGzE,MAAM,EAAEG,OAAO,EAAEC,IAAI,EAAE,GAAGJ,WAAW,KAAK;QAE1C,MAAMK,UAAUF,QAAQ,GAAG,CAACG,CAAAA,OAAQ,IAAI,CAAC,MAAM,CAAC,YAAY,CAACA;QAE7D,OAAOL,OAAO,EAAE,CAAC;YACb,OAAOI;YACPD;QACJ;IACJ;AACJ;AAEO,MAAMG,4DAA+BC,6BAAAA,oBAA+B,CAAC;IACxE,gBAAgBd;IAChB,cAAc;QACVe;QACAC;QACAC;QACAC;KACH;AACL"}

package/features/workflowState/ListWorkflowStates/ListWorkflowStatesUseCase.d.ts

@@ -0,0 +1,16 @@
+import { IdentityContext } from "@webiny/api-core/features/security/IdentityContext/index.js";
+import { GetUserTeamsUseCase } from "../../../features/internal/GetUserTeams/index.js";
+import { ListWorkflowStatesRepository, ListWorkflowStatesUseCase as UseCase } from "./abstractions.js";
+import { WorkflowStateFilter } from "./WorkflowStateFilter.js";
+declare class ListWorkflowStatesUseCaseImpl implements UseCase.Interface {
+    private identityContext;
+    private getUserTeams;
+    private repository;
+    private stateFilter;
+    constructor(identityContext: IdentityContext.Interface, getUserTeams: GetUserTeamsUseCase.Interface, repository: ListWorkflowStatesRepository.Interface, stateFilter: WorkflowStateFilter.Interface);
+    execute(params?: UseCase.Params): UseCase.Return;
+}
+export declare const ListWorkflowStatesUseCase: typeof ListWorkflowStatesUseCaseImpl & {
+    __abstraction: import("@webiny/di").Abstraction<import("./abstractions.js").IListWorkflowStatesUseCase>;
+};
+export {};

package/features/workflowState/ListWorkflowStates/ListWorkflowStatesUseCase.js

@@ -0,0 +1,67 @@
+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 { ListWorkflowStatesRepository, ListWorkflowStatesUseCase } from "./abstractions.js";
+import { WorkflowState } from "../../../domain/workflowState/WorkflowState.js";
+import { WorkflowStateFilter } from "./WorkflowStateFilter.js";
+class ListWorkflowStatesUseCaseImpl {
+    constructor(identityContext, getUserTeams, repository, stateFilter){
+        this.identityContext = identityContext;
+        this.getUserTeams = getUserTeams;
+        this.repository = repository;
+        this.stateFilter = stateFilter;
+    }
+    async execute(params = {}) {
+        const identity = this.identityContext.getIdentity();
+        const teamsResult = await this.getUserTeams.execute(identity.id);
+        const teams = teamsResult.value;
+        const requestedLimit = params.limit || 50;
+        const accumulated = [];
+        let cursor = params.after || null;
+        let totalCount = 0;
+        let totalRemoved = 0;
+        let hasMoreItems = false;
+        while(accumulated.length < requestedLimit){
+            const recordsResult = await this.repository.execute({
+                ...params,
+                limit: requestedLimit,
+                after: cursor || void 0
+            });
+            if (recordsResult.isFail()) return Result.fail(recordsResult.error);
+            const { items: records, meta } = recordsResult.value;
+            totalCount = meta.totalCount;
+            const items = records.map((record)=>new WorkflowState(record, teams, identity));
+            const filtered = await this.stateFilter.filter(items);
+            totalRemoved += items.length - filtered.length;
+            accumulated.push(...filtered);
+            if (!meta.hasMoreItems) {
+                hasMoreItems = accumulated.length > requestedLimit;
+                cursor = null;
+                break;
+            }
+            cursor = meta.cursor;
+            hasMoreItems = true;
+        }
+        const items = accumulated.slice(0, requestedLimit);
+        return Result.ok({
+            items,
+            meta: {
+                totalCount: Math.max(0, totalCount - totalRemoved),
+                hasMoreItems,
+                cursor
+            }
+        });
+    }
+}
+const ListWorkflowStatesUseCase_ListWorkflowStatesUseCase = ListWorkflowStatesUseCase.createImplementation({
+    implementation: ListWorkflowStatesUseCaseImpl,
+    dependencies: [
+        IdentityContext,
+        GetUserTeamsUseCase,
+        ListWorkflowStatesRepository,
+        WorkflowStateFilter
+    ]
+});
+export { ListWorkflowStatesUseCase_ListWorkflowStatesUseCase as ListWorkflowStatesUseCase };
+
+//# sourceMappingURL=ListWorkflowStatesUseCase.js.map

package/features/workflowState/ListWorkflowStates/ListWorkflowStatesUseCase.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"features/workflowState/ListWorkflowStates/ListWorkflowStatesUseCase.js","sources":["../../../../src/features/workflowState/ListWorkflowStates/ListWorkflowStatesUseCase.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 {\n    ListWorkflowStatesRepository,\n    ListWorkflowStatesUseCase as UseCase\n} from \"./abstractions.js\";\nimport { WorkflowState } from \"~/domain/workflowState/WorkflowState.js\";\nimport { WorkflowStateFilter } from \"./WorkflowStateFilter.js\";\n\nclass ListWorkflowStatesUseCaseImpl implements UseCase.Interface {\n    constructor(\n        private identityContext: IdentityContext.Interface,\n        private getUserTeams: GetUserTeamsUseCase.Interface,\n        private repository: ListWorkflowStatesRepository.Interface,\n        private stateFilter: WorkflowStateFilter.Interface\n    ) {}\n\n    async execute(params: UseCase.Params = {}): UseCase.Return {\n        const identity = this.identityContext.getIdentity();\n\n        const teamsResult = await this.getUserTeams.execute(identity.id);\n        const teams = teamsResult.value;\n\n        const requestedLimit = params.limit || 50;\n        const accumulated: WorkflowState[] = [];\n        let cursor: string | null = params.after || null;\n        let totalCount = 0;\n        let totalRemoved = 0;\n        let hasMoreItems = false;\n\n        while (accumulated.length < requestedLimit) {\n            const recordsResult = await this.repository.execute({\n                ...params,\n                limit: requestedLimit,\n                after: cursor || undefined\n            });\n\n            if (recordsResult.isFail()) {\n                return Result.fail(recordsResult.error);\n            }\n\n            const { items: records, meta } = recordsResult.value;\n            totalCount = meta.totalCount;\n\n            const items = records.map(record => new WorkflowState(record, teams, identity));\n            const filtered = await this.stateFilter.filter(items);\n\n            totalRemoved += items.length - filtered.length;\n            accumulated.push(...filtered);\n\n            if (!meta.hasMoreItems) {\n                hasMoreItems = accumulated.length > requestedLimit;\n                cursor = null;\n                break;\n            }\n\n            cursor = meta.cursor;\n            hasMoreItems = true;\n        }\n\n        const items = accumulated.slice(0, requestedLimit);\n\n        return Result.ok({\n            items,\n            meta: {\n                totalCount: Math.max(0, totalCount - totalRemoved),\n                hasMoreItems,\n                cursor\n            }\n        });\n    }\n}\n\nexport const ListWorkflowStatesUseCase = UseCase.createImplementation({\n    implementation: ListWorkflowStatesUseCaseImpl,\n    dependencies: [\n        IdentityContext,\n        GetUserTeamsUseCase,\n        ListWorkflowStatesRepository,\n        WorkflowStateFilter\n    ]\n});\n"],"names":["ListWorkflowStatesUseCaseImpl","identityContext","getUserTeams","repository","stateFilter","params","identity","teamsResult","teams","requestedLimit","accumulated","cursor","totalCount","totalRemoved","hasMoreItems","recordsResult","undefined","Result","records","meta","items","record","WorkflowState","filtered","Math","ListWorkflowStatesUseCase","UseCase","IdentityContext","GetUserTeamsUseCase","ListWorkflowStatesRepository","WorkflowStateFilter"],"mappings":";;;;;;AAUA,MAAMA;IACF,YACYC,eAA0C,EAC1CC,YAA2C,EAC3CC,UAAkD,EAClDC,WAA0C,CACpD;aAJUH,eAAe,GAAfA;aACAC,YAAY,GAAZA;aACAC,UAAU,GAAVA;aACAC,WAAW,GAAXA;IACT;IAEH,MAAM,QAAQC,SAAyB,CAAC,CAAC,EAAkB;QACvD,MAAMC,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,iBAAiBJ,OAAO,KAAK,IAAI;QACvC,MAAMK,cAA+B,EAAE;QACvC,IAAIC,SAAwBN,OAAO,KAAK,IAAI;QAC5C,IAAIO,aAAa;QACjB,IAAIC,eAAe;QACnB,IAAIC,eAAe;QAEnB,MAAOJ,YAAY,MAAM,GAAGD,eAAgB;YACxC,MAAMM,gBAAgB,MAAM,IAAI,CAAC,UAAU,CAAC,OAAO,CAAC;gBAChD,GAAGV,MAAM;gBACT,OAAOI;gBACP,OAAOE,UAAUK;YACrB;YAEA,IAAID,cAAc,MAAM,IACpB,OAAOE,OAAO,IAAI,CAACF,cAAc,KAAK;YAG1C,MAAM,EAAE,OAAOG,OAAO,EAAEC,IAAI,EAAE,GAAGJ,cAAc,KAAK;YACpDH,aAAaO,KAAK,UAAU;YAE5B,MAAMC,QAAQF,QAAQ,GAAG,CAACG,CAAAA,SAAU,IAAIC,cAAcD,QAAQb,OAAOF;YACrE,MAAMiB,WAAW,MAAM,IAAI,CAAC,WAAW,CAAC,MAAM,CAACH;YAE/CP,gBAAgBO,MAAM,MAAM,GAAGG,SAAS,MAAM;YAC9Cb,YAAY,IAAI,IAAIa;YAEpB,IAAI,CAACJ,KAAK,YAAY,EAAE;gBACpBL,eAAeJ,YAAY,MAAM,GAAGD;gBACpCE,SAAS;gBACT;YACJ;YAEAA,SAASQ,KAAK,MAAM;YACpBL,eAAe;QACnB;QAEA,MAAMM,QAAQV,YAAY,KAAK,CAAC,GAAGD;QAEnC,OAAOQ,OAAO,EAAE,CAAC;YACbG;YACA,MAAM;gBACF,YAAYI,KAAK,GAAG,CAAC,GAAGZ,aAAaC;gBACrCC;gBACAH;YACJ;QACJ;IACJ;AACJ;AAEO,MAAMc,sDAA4BC,0BAAAA,oBAA4B,CAAC;IAClE,gBAAgB1B;IAChB,cAAc;QACV2B;QACAC;QACAC;QACAC;KACH;AACL"}

package/features/workflowState/ListWorkflowStates/WorkflowStateFilter.d.ts

@@ -0,0 +1,8 @@
+import type { WorkflowState } from "../../../domain/workflowState/WorkflowState.js";
+export interface IWorkflowStateFilter {
+    filter(items: WorkflowState[]): Promise<WorkflowState[]>;
+}
+export declare const WorkflowStateFilter: import("@webiny/di").Abstraction<IWorkflowStateFilter>;
+export declare namespace WorkflowStateFilter {
+    type Interface = IWorkflowStateFilter;
+}

package/features/workflowState/ListWorkflowStates/WorkflowStateFilter.js

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

package/features/workflowState/ListWorkflowStates/WorkflowStateFilter.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"features/workflowState/ListWorkflowStates/WorkflowStateFilter.js","sources":["../../../../src/features/workflowState/ListWorkflowStates/WorkflowStateFilter.ts"],"sourcesContent":["import { createAbstraction } from \"@webiny/feature/api\";\nimport type { WorkflowState } from \"~/domain/workflowState/WorkflowState.js\";\n\nexport interface IWorkflowStateFilter {\n    filter(items: WorkflowState[]): Promise<WorkflowState[]>;\n}\n\nexport const WorkflowStateFilter = createAbstraction<IWorkflowStateFilter>(\"WorkflowStateFilter\");\n\nexport namespace WorkflowStateFilter {\n    export type Interface = IWorkflowStateFilter;\n}\n"],"names":["WorkflowStateFilter","createAbstraction"],"mappings":";AAOO,MAAMA,sBAAsBC,kBAAwC"}

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

@@ -0,0 +1,71 @@
+import type { Result } from "@webiny/feature/api";
+import type { CmsEntryListSort, CmsEntryListWhere } from "@webiny/api-headless-cms/types/index.js";
+import { type IWorkflowStateRecord, WorkflowStateRecordState } from "../../../domain/workflowState/abstractions.js";
+import type { WorkflowStatePersistenceError } from "../../../domain/workflowState/errors.js";
+import type { WorkflowState } from "../../../domain/workflowState/WorkflowState.js";
+import type { IMeta } from "../../../types.js";
+export interface IListWorkflowStatesParamsWhere extends CmsEntryListWhere {
+    app?: string;
+    app_in?: string[];
+    targetRevisionId?: string;
+    targetRevisionId_in?: string[];
+    state?: WorkflowStateRecordState;
+    state_in?: WorkflowStateRecordState[];
+    workflowId?: string;
+    workflowId_in?: string[];
+    targetId?: string;
+    targetId_in?: string[];
+    savedBy?: string;
+    createdBy?: string;
+    isActive?: boolean;
+}
+export interface IListWorkflowStatesParams {
+    where?: IListWorkflowStatesParamsWhere;
+    sort?: CmsEntryListSort;
+    limit?: number;
+    after?: string;
+}
+export interface IListWorkflowStatesResponse {
+    items: WorkflowState[];
+    meta: IMeta;
+}
+export interface IListWorkflowStatesRecordResponse {
+    items: IWorkflowStateRecord[];
+    meta: IMeta;
+}
+/**
+ * ListWorkflowStates use case interface
+ */
+export interface IListWorkflowStatesUseCase {
+    execute(params?: IListWorkflowStatesParams): Promise<Result<IListWorkflowStatesResponse, UseCaseError>>;
+}
+export interface IListWorkflowStatesUseCaseErrors {
+    persistence: WorkflowStatePersistenceError;
+}
+type UseCaseError = IListWorkflowStatesUseCaseErrors[keyof IListWorkflowStatesUseCaseErrors];
+export declare const ListWorkflowStatesUseCase: import("@webiny/di").Abstraction<IListWorkflowStatesUseCase>;
+export declare namespace ListWorkflowStatesUseCase {
+    type Interface = IListWorkflowStatesUseCase;
+    type Params = IListWorkflowStatesParams;
+    type Response = IListWorkflowStatesResponse;
+    type Return = Promise<Result<IListWorkflowStatesResponse, UseCaseError>>;
+    type Error = UseCaseError;
+}
+/**
+ * ListWorkflowStates repository interface
+ */
+export interface IListWorkflowStatesRepository {
+    execute(params?: IListWorkflowStatesParams): Promise<Result<IListWorkflowStatesRecordResponse, RepositoryError>>;
+}
+export interface IListWorkflowStatesRepositoryErrors {
+    persistence: WorkflowStatePersistenceError;
+}
+type RepositoryError = IListWorkflowStatesRepositoryErrors[keyof IListWorkflowStatesRepositoryErrors];
+export declare const ListWorkflowStatesRepository: import("@webiny/di").Abstraction<IListWorkflowStatesRepository>;
+export declare namespace ListWorkflowStatesRepository {
+    type Interface = IListWorkflowStatesRepository;
+    type Params = IListWorkflowStatesParams;
+    type Return = Promise<Result<IListWorkflowStatesRecordResponse, RepositoryError>>;
+    type Error = RepositoryError;
+}
+export {};

package/features/workflowState/ListWorkflowStates/abstractions.js

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"features/workflowState/ListWorkflowStates/abstractions.js","sources":["../../../../src/features/workflowState/ListWorkflowStates/abstractions.ts"],"sourcesContent":["import { createAbstraction } from \"@webiny/feature/api\";\nimport type { Result } from \"@webiny/feature/api\";\nimport type { CmsEntryListSort, CmsEntryListWhere } from \"@webiny/api-headless-cms/types/index.js\";\nimport {\n    type IWorkflowStateRecord,\n    WorkflowStateRecordState\n} from \"~/domain/workflowState/abstractions.js\";\nimport type { WorkflowStatePersistenceError } from \"~/domain/workflowState/errors.js\";\nimport type { WorkflowState } from \"~/domain/workflowState/WorkflowState.js\";\nimport type { IMeta } from \"~/types.js\";\n\nexport interface IListWorkflowStatesParamsWhere extends CmsEntryListWhere {\n    app?: string;\n    app_in?: string[];\n    targetRevisionId?: string;\n    targetRevisionId_in?: string[];\n    state?: WorkflowStateRecordState;\n    state_in?: WorkflowStateRecordState[];\n    workflowId?: string;\n    workflowId_in?: string[];\n    targetId?: string;\n    targetId_in?: string[];\n    savedBy?: string;\n    createdBy?: string;\n    isActive?: boolean;\n}\n\nexport interface IListWorkflowStatesParams {\n    where?: IListWorkflowStatesParamsWhere;\n    sort?: CmsEntryListSort;\n    limit?: number;\n    after?: string;\n}\n\nexport interface IListWorkflowStatesResponse {\n    items: WorkflowState[];\n    meta: IMeta;\n}\n\nexport interface IListWorkflowStatesRecordResponse {\n    items: IWorkflowStateRecord[];\n    meta: IMeta;\n}\n\n/**\n * ListWorkflowStates use case interface\n */\nexport interface IListWorkflowStatesUseCase {\n    execute(\n        params?: IListWorkflowStatesParams\n    ): Promise<Result<IListWorkflowStatesResponse, UseCaseError>>;\n}\n\nexport interface IListWorkflowStatesUseCaseErrors {\n    persistence: WorkflowStatePersistenceError;\n}\n\ntype UseCaseError = IListWorkflowStatesUseCaseErrors[keyof IListWorkflowStatesUseCaseErrors];\n\nexport const ListWorkflowStatesUseCase = createAbstraction<IListWorkflowStatesUseCase>(\n    \"ListWorkflowStatesUseCase\"\n);\n\nexport namespace ListWorkflowStatesUseCase {\n    export type Interface = IListWorkflowStatesUseCase;\n    export type Params = IListWorkflowStatesParams;\n    export type Response = IListWorkflowStatesResponse;\n    export type Return = Promise<Result<IListWorkflowStatesResponse, UseCaseError>>;\n    export type Error = UseCaseError;\n}\n\n/**\n * ListWorkflowStates repository interface\n */\nexport interface IListWorkflowStatesRepository {\n    execute(\n        params?: IListWorkflowStatesParams\n    ): Promise<Result<IListWorkflowStatesRecordResponse, RepositoryError>>;\n}\n\nexport interface IListWorkflowStatesRepositoryErrors {\n    persistence: WorkflowStatePersistenceError;\n}\n\ntype RepositoryError =\n    IListWorkflowStatesRepositoryErrors[keyof IListWorkflowStatesRepositoryErrors];\n\nexport const ListWorkflowStatesRepository = createAbstraction<IListWorkflowStatesRepository>(\n    \"ListWorkflowStatesRepository\"\n);\n\nexport namespace ListWorkflowStatesRepository {\n    export type Interface = IListWorkflowStatesRepository;\n    export type Params = IListWorkflowStatesParams;\n    export type Return = Promise<Result<IListWorkflowStatesRecordResponse, RepositoryError>>;\n    export type Error = RepositoryError;\n}\n"],"names":["ListWorkflowStatesUseCase","createAbstraction","ListWorkflowStatesRepository"],"mappings":";AA2DO,MAAMA,4BAA4BC,kBACrC;AA2BG,MAAMC,+BAA+BD,kBACxC"}

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

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

package/features/workflowState/ListWorkflowStates/feature.js

@@ -0,0 +1,15 @@
+import { createFeature } from "@webiny/feature/api";
+import { ListWorkflowStatesUseCase } from "./ListWorkflowStatesUseCase.js";
+import { ListWorkflowStatesRepository } from "./ListWorkflowStatesRepository.js";
+import { DefaultWorkflowStateFilter } from "./DefaultWorkflowStateFilter.js";
+const ListWorkflowStatesFeature = createFeature({
+    name: "WorkflowState/ListWorkflowStates",
+    register (container) {
+        container.register(ListWorkflowStatesRepository).inSingletonScope();
+        container.register(DefaultWorkflowStateFilter);
+        container.register(ListWorkflowStatesUseCase);
+    }
+});
+export { ListWorkflowStatesFeature };
+
+//# sourceMappingURL=feature.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"features/workflowState/ListWorkflowStates/feature.js","sources":["../../../../src/features/workflowState/ListWorkflowStates/feature.ts"],"sourcesContent":["import { createFeature } from \"@webiny/feature/api\";\nimport { ListWorkflowStatesUseCase } from \"./ListWorkflowStatesUseCase.js\";\nimport { ListWorkflowStatesRepository } from \"./ListWorkflowStatesRepository.js\";\nimport { DefaultWorkflowStateFilter } from \"./DefaultWorkflowStateFilter.js\";\n\nexport const ListWorkflowStatesFeature = createFeature({\n    name: \"WorkflowState/ListWorkflowStates\",\n    register(container) {\n        container.register(ListWorkflowStatesRepository).inSingletonScope();\n        container.register(DefaultWorkflowStateFilter);\n        container.register(ListWorkflowStatesUseCase);\n    }\n});\n"],"names":["ListWorkflowStatesFeature","createFeature","container","ListWorkflowStatesRepository","DefaultWorkflowStateFilter","ListWorkflowStatesUseCase"],"mappings":";;;;AAKO,MAAMA,4BAA4BC,cAAc;IACnD,MAAM;IACN,UAASC,SAAS;QACdA,UAAU,QAAQ,CAACC,8BAA8B,gBAAgB;QACjED,UAAU,QAAQ,CAACE;QACnBF,UAAU,QAAQ,CAACG;IACvB;AACJ"}

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

@@ -0,0 +1,2 @@
+export { ListWorkflowStatesUseCase, ListWorkflowStatesRepository } from "./abstractions.js";
+export { WorkflowStateFilter } from "./WorkflowStateFilter.js";

package/features/workflowState/ListWorkflowStates/index.js

@@ -0,0 +1,2 @@
+export { ListWorkflowStatesRepository, ListWorkflowStatesUseCase } from "./abstractions.js";
+export { WorkflowStateFilter } from "./WorkflowStateFilter.js";

package/features/workflowState/README.md

@@ -0,0 +1,8 @@
+# Similar Methods
+
+Method "Delete Target Workflow State" and "Delete Workflow State" basically does the same thing:
+
+- Delete Target Workflow State: Deletes a workflow state based on the target ID (full id, with revision).
+- Delete Workflow State: Deletes a workflow state by its ID.
+
+Both methods trigger same event.

package/features/workflowState/RejectWorkflowStateStep/RejectWorkflowStateStepUseCase.d.ts

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

package/features/workflowState/RejectWorkflowStateStep/RejectWorkflowStateStepUseCase.js

@@ -0,0 +1,38 @@
+import { Result } from "@webiny/feature/api";
+import { GetWorkflowStateUseCase } from "../GetWorkflowState/index.js";
+import { UpdateWorkflowStateRepository } from "../UpdateWorkflowState/index.js";
+import { RejectWorkflowStateStepUseCase } from "./abstractions.js";
+import { WorkflowStateRejectEvent } from "./events.js";
+import { EventPublisher } from "@webiny/api-core/features/eventPublisher/index.js";
+class RejectWorkflowStateStepUseCaseImpl {
+    constructor(getWorkflowState, repository, eventPublisher){
+        this.getWorkflowState = getWorkflowState;
+        this.repository = repository;
+        this.eventPublisher = eventPublisher;
+    }
+    async execute(id, comment) {
+        const stateResult = await this.getWorkflowState.execute(id);
+        if (stateResult.isFail()) return Result.fail(stateResult.error);
+        const state = stateResult.value;
+        const rejectResult = state.reject(comment);
+        if (rejectResult.isFail()) return Result.fail(rejectResult.error);
+        const updatedRecord = state.toRecord();
+        const updateResult = await this.repository.execute(id, updatedRecord);
+        if (updateResult.isFail()) return Result.fail(updateResult.error);
+        await this.eventPublisher.publish(new WorkflowStateRejectEvent({
+            state
+        }));
+        return Result.ok(state);
+    }
+}
+const RejectWorkflowStateStepUseCase_RejectWorkflowStateStepUseCase = RejectWorkflowStateStepUseCase.createImplementation({
+    implementation: RejectWorkflowStateStepUseCaseImpl,
+    dependencies: [
+        GetWorkflowStateUseCase,
+        UpdateWorkflowStateRepository,
+        EventPublisher
+    ]
+});
+export { RejectWorkflowStateStepUseCase_RejectWorkflowStateStepUseCase as RejectWorkflowStateStepUseCase };
+
+//# sourceMappingURL=RejectWorkflowStateStepUseCase.js.map

package/features/workflowState/RejectWorkflowStateStep/RejectWorkflowStateStepUseCase.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"features/workflowState/RejectWorkflowStateStep/RejectWorkflowStateStepUseCase.js","sources":["../../../../src/features/workflowState/RejectWorkflowStateStep/RejectWorkflowStateStepUseCase.ts"],"sourcesContent":["import { Result } from \"@webiny/feature/api\";\nimport { GetWorkflowStateUseCase } from \"../GetWorkflowState/index.js\";\nimport { UpdateWorkflowStateRepository } from \"../UpdateWorkflowState/index.js\";\nimport { RejectWorkflowStateStepUseCase as UseCase } from \"./abstractions.js\";\nimport { WorkflowStateRejectEvent } from \"./events.js\";\nimport { EventPublisher } from \"@webiny/api-core/features/eventPublisher/index.js\";\n\nclass RejectWorkflowStateStepUseCaseImpl implements UseCase.Interface {\n    constructor(\n        private getWorkflowState: GetWorkflowStateUseCase.Interface,\n        private repository: UpdateWorkflowStateRepository.Interface,\n        private eventPublisher: EventPublisher.Interface\n    ) {}\n\n    async execute(id: string, comment: string): UseCase.Return {\n        const stateResult = await this.getWorkflowState.execute(id);\n        if (stateResult.isFail()) {\n            return Result.fail(stateResult.error);\n        }\n\n        const state = stateResult.value;\n\n        const rejectResult = state.reject(comment);\n        if (rejectResult.isFail()) {\n            return Result.fail(rejectResult.error);\n        }\n\n        const updatedRecord = state.toRecord();\n\n        const updateResult = await this.repository.execute(id, updatedRecord);\n        if (updateResult.isFail()) {\n            return Result.fail(updateResult.error);\n        }\n\n        await this.eventPublisher.publish(\n            new WorkflowStateRejectEvent({\n                state\n            })\n        );\n\n        return Result.ok(state);\n    }\n}\n\nexport const RejectWorkflowStateStepUseCase = UseCase.createImplementation({\n    implementation: RejectWorkflowStateStepUseCaseImpl,\n    dependencies: [GetWorkflowStateUseCase, UpdateWorkflowStateRepository, EventPublisher]\n});\n"],"names":["RejectWorkflowStateStepUseCaseImpl","getWorkflowState","repository","eventPublisher","id","comment","stateResult","Result","state","rejectResult","updatedRecord","updateResult","WorkflowStateRejectEvent","RejectWorkflowStateStepUseCase","UseCase","GetWorkflowStateUseCase","UpdateWorkflowStateRepository","EventPublisher"],"mappings":";;;;;;AAOA,MAAMA;IACF,YACYC,gBAAmD,EACnDC,UAAmD,EACnDC,cAAwC,CAClD;aAHUF,gBAAgB,GAAhBA;aACAC,UAAU,GAAVA;aACAC,cAAc,GAAdA;IACT;IAEH,MAAM,QAAQC,EAAU,EAAEC,OAAe,EAAkB;QACvD,MAAMC,cAAc,MAAM,IAAI,CAAC,gBAAgB,CAAC,OAAO,CAACF;QACxD,IAAIE,YAAY,MAAM,IAClB,OAAOC,OAAO,IAAI,CAACD,YAAY,KAAK;QAGxC,MAAME,QAAQF,YAAY,KAAK;QAE/B,MAAMG,eAAeD,MAAM,MAAM,CAACH;QAClC,IAAII,aAAa,MAAM,IACnB,OAAOF,OAAO,IAAI,CAACE,aAAa,KAAK;QAGzC,MAAMC,gBAAgBF,MAAM,QAAQ;QAEpC,MAAMG,eAAe,MAAM,IAAI,CAAC,UAAU,CAAC,OAAO,CAACP,IAAIM;QACvD,IAAIC,aAAa,MAAM,IACnB,OAAOJ,OAAO,IAAI,CAACI,aAAa,KAAK;QAGzC,MAAM,IAAI,CAAC,cAAc,CAAC,OAAO,CAC7B,IAAIC,yBAAyB;YACzBJ;QACJ;QAGJ,OAAOD,OAAO,EAAE,CAACC;IACrB;AACJ;AAEO,MAAMK,gEAAiCC,+BAAAA,oBAA4B,CAAC;IACvE,gBAAgBd;IAChB,cAAc;QAACe;QAAyBC;QAA+BC;KAAe;AAC1F"}

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

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

package/features/workflowState/RejectWorkflowStateStep/abstractions.js

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"features/workflowState/RejectWorkflowStateStep/abstractions.js","sources":["../../../../src/features/workflowState/RejectWorkflowStateStep/abstractions.ts"],"sourcesContent":["import type { Result } from \"@webiny/feature/api\";\nimport { createAbstraction } from \"@webiny/feature/api\";\nimport {\n    type WorkflowStateNotFoundError,\n    WorkflowStatePersistenceError,\n    type WorkflowStateStepCannotReviewError,\n    type WorkflowStateStepNotStepOwnerError\n} from \"~/domain/workflowState/errors.js\";\nimport type { WorkflowNotFoundError } from \"~/domain/workflow/errors.js\";\nimport { WorkflowState } from \"~/domain/workflowState/WorkflowState.js\";\n\nexport interface WorkflowStateRejectPayload {\n    state: WorkflowState;\n}\n\nexport interface IRejectWorkflowStateStepUseCase {\n    execute(id: string, comment: string): Promise<Result<WorkflowState, UseCaseError>>;\n}\n\nexport interface IRejectWorkflowStateStepUseCaseErrors {\n    notFound: WorkflowStateNotFoundError;\n    workflowNotFound: WorkflowNotFoundError;\n    cannotReview: WorkflowStateStepCannotReviewError;\n    notStepOwner: WorkflowStateStepNotStepOwnerError;\n    workflowState: WorkflowState.Error;\n    persistence: WorkflowStatePersistenceError;\n}\n\ntype UseCaseError =\n    IRejectWorkflowStateStepUseCaseErrors[keyof IRejectWorkflowStateStepUseCaseErrors];\n\nexport const RejectWorkflowStateStepUseCase = createAbstraction<IRejectWorkflowStateStepUseCase>(\n    \"RejectWorkflowStateStepUseCase\"\n);\n\nexport namespace RejectWorkflowStateStepUseCase {\n    export type Interface = IRejectWorkflowStateStepUseCase;\n    export type Return = Promise<Result<WorkflowState, UseCaseError>>;\n    export type Error = UseCaseError;\n}\n"],"names":["RejectWorkflowStateStepUseCase","createAbstraction"],"mappings":";AA+BO,MAAMA,iCAAiCC,kBAC1C"}

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

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

package/features/workflowState/RejectWorkflowStateStep/events.js

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"features/workflowState/RejectWorkflowStateStep/events.js","sources":["../../../../src/features/workflowState/RejectWorkflowStateStep/events.ts"],"sourcesContent":["import { createAbstraction } from \"@webiny/feature/api\";\nimport type { IEventHandler } from \"@webiny/api-core/features/eventPublisher/index.js\";\nimport { DomainEvent } from \"@webiny/api-core/features/eventPublisher/index.js\";\nimport type { WorkflowStateRejectPayload } from \"./abstractions.js\";\n\nexport class WorkflowStateRejectEvent extends DomainEvent<WorkflowStateRejectPayload> {\n    eventType = \"workflowState.reject\" as const;\n\n    getHandlerAbstraction() {\n        return WorkflowStateRejectHandler;\n    }\n}\n\nexport const WorkflowStateRejectHandler = createAbstraction<\n    IEventHandler<WorkflowStateRejectEvent>\n>(\"WorkflowStateRejectHandler\");\n\nexport namespace WorkflowStateRejectHandler {\n    export type Interface = IEventHandler<WorkflowStateRejectEvent>;\n    export type Event = WorkflowStateRejectEvent;\n}\n"],"names":["WorkflowStateRejectEvent","DomainEvent","WorkflowStateRejectHandler","createAbstraction"],"mappings":";;AAKO,MAAMA,iCAAiCC;IAG1C,wBAAwB;QACpB,OAAOC;IACX;;QALG,qBACH,SAAS,GAAG;;AAKhB;AAEO,MAAMA,6BAA6BC,kBAExC"}

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

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

package/features/workflowState/RejectWorkflowStateStep/feature.js

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

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

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

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

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

package/features/workflowState/RejectWorkflowStateStep/index.js

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

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

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

package/features/workflowState/StartWorkflowStateStep/StartWorkflowStateStepUseCase.js

@@ -0,0 +1,38 @@
+import { Result } from "@webiny/feature/api";
+import { GetWorkflowStateUseCase } from "../GetWorkflowState/index.js";
+import { UpdateWorkflowStateRepository } from "../UpdateWorkflowState/index.js";
+import { StartWorkflowStateStepUseCase } from "./abstractions.js";
+import { WorkflowStateStartStepEvent } from "./events.js";
+import { EventPublisher } from "@webiny/api-core/features/eventPublisher/index.js";
+class StartWorkflowStateStepUseCaseImpl {
+    constructor(getWorkflowState, repository, eventPublisher){
+        this.getWorkflowState = getWorkflowState;
+        this.repository = repository;
+        this.eventPublisher = eventPublisher;
+    }
+    async execute(id) {
+        const stateResult = await this.getWorkflowState.execute(id);
+        if (stateResult.isFail()) return Result.fail(stateResult.error);
+        const state = stateResult.value;
+        const startResult = state.start();
+        if (startResult.isFail()) return Result.fail(startResult.error);
+        const updatedRecord = state.toRecord();
+        const updateResult = await this.repository.execute(id, updatedRecord);
+        if (updateResult.isFail()) return Result.fail(updateResult.error);
+        await this.eventPublisher.publish(new WorkflowStateStartStepEvent({
+            state
+        }));
+        return Result.ok(state);
+    }
+}
+const StartWorkflowStateStepUseCase_StartWorkflowStateStepUseCase = StartWorkflowStateStepUseCase.createImplementation({
+    implementation: StartWorkflowStateStepUseCaseImpl,
+    dependencies: [
+        GetWorkflowStateUseCase,
+        UpdateWorkflowStateRepository,
+        EventPublisher
+    ]
+});
+export { StartWorkflowStateStepUseCase_StartWorkflowStateStepUseCase as StartWorkflowStateStepUseCase };
+
+//# sourceMappingURL=StartWorkflowStateStepUseCase.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"features/workflowState/StartWorkflowStateStep/StartWorkflowStateStepUseCase.js","sources":["../../../../src/features/workflowState/StartWorkflowStateStep/StartWorkflowStateStepUseCase.ts"],"sourcesContent":["import { Result } from \"@webiny/feature/api\";\nimport { GetWorkflowStateUseCase } from \"../GetWorkflowState/index.js\";\nimport { UpdateWorkflowStateRepository } from \"../UpdateWorkflowState/index.js\";\nimport { StartWorkflowStateStepUseCase as UseCase } from \"./abstractions.js\";\nimport { WorkflowStateStartStepEvent } from \"./events.js\";\nimport { EventPublisher } from \"@webiny/api-core/features/eventPublisher/index.js\";\n\nclass StartWorkflowStateStepUseCaseImpl implements UseCase.Interface {\n    constructor(\n        private getWorkflowState: GetWorkflowStateUseCase.Interface,\n        private repository: UpdateWorkflowStateRepository.Interface,\n        private eventPublisher: EventPublisher.Interface\n    ) {}\n\n    async execute(id: string): UseCase.Return {\n        const stateResult = await this.getWorkflowState.execute(id);\n        if (stateResult.isFail()) {\n            return Result.fail(stateResult.error);\n        }\n\n        const state = stateResult.value;\n\n        const startResult = state.start();\n        if (startResult.isFail()) {\n            return Result.fail(startResult.error);\n        }\n\n        const updatedRecord = state.toRecord();\n\n        const updateResult = await this.repository.execute(id, updatedRecord);\n        if (updateResult.isFail()) {\n            return Result.fail(updateResult.error);\n        }\n\n        await this.eventPublisher.publish(\n            new WorkflowStateStartStepEvent({\n                state\n            })\n        );\n\n        return Result.ok(state);\n    }\n}\n\nexport const StartWorkflowStateStepUseCase = UseCase.createImplementation({\n    implementation: StartWorkflowStateStepUseCaseImpl,\n    dependencies: [GetWorkflowStateUseCase, UpdateWorkflowStateRepository, EventPublisher]\n});\n"],"names":["StartWorkflowStateStepUseCaseImpl","getWorkflowState","repository","eventPublisher","id","stateResult","Result","state","startResult","updatedRecord","updateResult","WorkflowStateStartStepEvent","StartWorkflowStateStepUseCase","UseCase","GetWorkflowStateUseCase","UpdateWorkflowStateRepository","EventPublisher"],"mappings":";;;;;;AAOA,MAAMA;IACF,YACYC,gBAAmD,EACnDC,UAAmD,EACnDC,cAAwC,CAClD;aAHUF,gBAAgB,GAAhBA;aACAC,UAAU,GAAVA;aACAC,cAAc,GAAdA;IACT;IAEH,MAAM,QAAQC,EAAU,EAAkB;QACtC,MAAMC,cAAc,MAAM,IAAI,CAAC,gBAAgB,CAAC,OAAO,CAACD;QACxD,IAAIC,YAAY,MAAM,IAClB,OAAOC,OAAO,IAAI,CAACD,YAAY,KAAK;QAGxC,MAAME,QAAQF,YAAY,KAAK;QAE/B,MAAMG,cAAcD,MAAM,KAAK;QAC/B,IAAIC,YAAY,MAAM,IAClB,OAAOF,OAAO,IAAI,CAACE,YAAY,KAAK;QAGxC,MAAMC,gBAAgBF,MAAM,QAAQ;QAEpC,MAAMG,eAAe,MAAM,IAAI,CAAC,UAAU,CAAC,OAAO,CAACN,IAAIK;QACvD,IAAIC,aAAa,MAAM,IACnB,OAAOJ,OAAO,IAAI,CAACI,aAAa,KAAK;QAGzC,MAAM,IAAI,CAAC,cAAc,CAAC,OAAO,CAC7B,IAAIC,4BAA4B;YAC5BJ;QACJ;QAGJ,OAAOD,OAAO,EAAE,CAACC;IACrB;AACJ;AAEO,MAAMK,8DAAgCC,8BAAAA,oBAA4B,CAAC;IACtE,gBAAgBb;IAChB,cAAc;QAACc;QAAyBC;QAA+BC;KAAe;AAC1F"}

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

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

package/features/workflowState/StartWorkflowStateStep/abstractions.js

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"features/workflowState/StartWorkflowStateStep/abstractions.js","sources":["../../../../src/features/workflowState/StartWorkflowStateStep/abstractions.ts"],"sourcesContent":["import type { Result } from \"@webiny/feature/api\";\nimport { createAbstraction } from \"@webiny/feature/api\";\nimport {\n    type WorkflowStateNotFoundError,\n    WorkflowStatePersistenceError,\n    type WorkflowStateStepCannotReviewError\n} from \"~/domain/workflowState/errors.js\";\nimport type { WorkflowNotFoundError } from \"~/domain/workflow/errors.js\";\nimport { WorkflowState } from \"~/domain/workflowState/WorkflowState.js\";\n\nexport interface WorkflowStateStartStepPayload {\n    state: WorkflowState;\n}\n\nexport interface IStartWorkflowStateStepUseCase {\n    execute(id: string): Promise<Result<WorkflowState, UseCaseError>>;\n}\n\nexport interface IStartWorkflowStateStepUseCaseErrors {\n    notFound: WorkflowStateNotFoundError;\n    workflowNotFound: WorkflowNotFoundError;\n    cannotReview: WorkflowStateStepCannotReviewError;\n    workflowState: WorkflowState.Error;\n    persistence: WorkflowStatePersistenceError;\n}\n\ntype UseCaseError =\n    IStartWorkflowStateStepUseCaseErrors[keyof IStartWorkflowStateStepUseCaseErrors];\n\nexport const StartWorkflowStateStepUseCase = createAbstraction<IStartWorkflowStateStepUseCase>(\n    \"StartWorkflowStateStepUseCase\"\n);\n\nexport namespace StartWorkflowStateStepUseCase {\n    export type Interface = IStartWorkflowStateStepUseCase;\n    export type Return = Promise<Result<WorkflowState, UseCaseError>>;\n    export type Error = UseCaseError;\n}\n"],"names":["StartWorkflowStateStepUseCase","createAbstraction"],"mappings":";AA6BO,MAAMA,gCAAgCC,kBACzC"}

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

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

package/features/workflowState/StartWorkflowStateStep/events.js

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

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

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

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

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

package/features/workflowState/StartWorkflowStateStep/feature.js

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

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

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

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

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