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

package/features/workflowState/GetTargetWorkflowState/feature.js

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

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

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

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

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

package/features/workflowState/GetTargetWorkflowState/index.js

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

package/features/workflowState/GetWorkflowState/GetWorkflowStateRepository.d.ts

@@ -0,0 +1,14 @@
+import { GetEntryByIdUseCase } from "@webiny/api-headless-cms/features/contentEntry/GetEntryById/index.js";
+import { WorkflowStateModel, WorkflowStateMapper } from "../../../domain/workflowState/abstractions.js";
+import { GetWorkflowStateRepository as Repository } from "./abstractions.js";
+declare class GetWorkflowStateRepositoryImpl implements Repository.Interface {
+    private getEntryById;
+    private model;
+    private mapper;
+    constructor(getEntryById: GetEntryByIdUseCase.Interface, model: WorkflowStateModel.Interface, mapper: WorkflowStateMapper.Interface);
+    execute(id: string): Repository.Return;
+}
+export declare const GetWorkflowStateRepository: typeof GetWorkflowStateRepositoryImpl & {
+    __abstraction: import("@webiny/di").Abstraction<import("./abstractions.js").IGetWorkflowStateRepository>;
+};
+export {};

package/features/workflowState/GetWorkflowState/GetWorkflowStateRepository.js

@@ -0,0 +1,35 @@
+import { Result } from "@webiny/feature/api";
+import { GetEntryByIdUseCase } from "@webiny/api-headless-cms/features/contentEntry/GetEntryById/index.js";
+import { WorkflowStateMapper, WorkflowStateModel } from "../../../domain/workflowState/abstractions.js";
+import { WorkflowStateNotFoundError, WorkflowStatePersistenceError } from "../../../domain/workflowState/errors.js";
+import { GetWorkflowStateRepository } from "./abstractions.js";
+class GetWorkflowStateRepositoryImpl {
+    constructor(getEntryById, model, mapper){
+        this.getEntryById = getEntryById;
+        this.model = model;
+        this.mapper = mapper;
+    }
+    async execute(id) {
+        const entryResult = await this.getEntryById.execute(this.model, id);
+        if (entryResult.isFail()) {
+            if ("Cms/Entry/NotFound" === entryResult.error.code) return Result.fail(new WorkflowStateNotFoundError({
+                id
+            }));
+            return Result.fail(new WorkflowStatePersistenceError(entryResult.error));
+        }
+        const entry = entryResult.value;
+        const record = this.mapper.fromCmsEntry(entry);
+        return Result.ok(record);
+    }
+}
+const GetWorkflowStateRepository_GetWorkflowStateRepository = GetWorkflowStateRepository.createImplementation({
+    implementation: GetWorkflowStateRepositoryImpl,
+    dependencies: [
+        GetEntryByIdUseCase,
+        WorkflowStateModel,
+        WorkflowStateMapper
+    ]
+});
+export { GetWorkflowStateRepository_GetWorkflowStateRepository as GetWorkflowStateRepository };
+
+//# sourceMappingURL=GetWorkflowStateRepository.js.map

package/features/workflowState/GetWorkflowState/GetWorkflowStateRepository.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"features/workflowState/GetWorkflowState/GetWorkflowStateRepository.js","sources":["../../../../src/features/workflowState/GetWorkflowState/GetWorkflowStateRepository.ts"],"sourcesContent":["import { Result } from \"@webiny/feature/api\";\nimport { GetEntryByIdUseCase } from \"@webiny/api-headless-cms/features/contentEntry/GetEntryById/index.js\";\nimport { WorkflowStateModel, WorkflowStateMapper } from \"~/domain/workflowState/abstractions.js\";\nimport type { IWorkflowStateRecord } from \"~/domain/workflowState/abstractions.js\";\nimport {\n    WorkflowStateNotFoundError,\n    WorkflowStatePersistenceError\n} from \"~/domain/workflowState/errors.js\";\nimport { GetWorkflowStateRepository as Repository } from \"./abstractions.js\";\n\nclass GetWorkflowStateRepositoryImpl implements Repository.Interface {\n    constructor(\n        private getEntryById: GetEntryByIdUseCase.Interface,\n        private model: WorkflowStateModel.Interface,\n        private mapper: WorkflowStateMapper.Interface\n    ) {}\n\n    async execute(id: string): Repository.Return {\n        const entryResult = await this.getEntryById.execute<Omit<IWorkflowStateRecord, \"id\">>(\n            this.model,\n            id\n        );\n\n        if (entryResult.isFail()) {\n            if (entryResult.error.code === \"Cms/Entry/NotFound\") {\n                return Result.fail(new WorkflowStateNotFoundError({ id }));\n            }\n\n            return Result.fail(new WorkflowStatePersistenceError(entryResult.error));\n        }\n\n        const entry = entryResult.value;\n\n        const record = this.mapper.fromCmsEntry(entry);\n        return Result.ok(record);\n    }\n}\n\nexport const GetWorkflowStateRepository = Repository.createImplementation({\n    implementation: GetWorkflowStateRepositoryImpl,\n    dependencies: [GetEntryByIdUseCase, WorkflowStateModel, WorkflowStateMapper]\n});\n"],"names":["GetWorkflowStateRepositoryImpl","getEntryById","model","mapper","id","entryResult","Result","WorkflowStateNotFoundError","WorkflowStatePersistenceError","entry","record","GetWorkflowStateRepository","Repository","GetEntryByIdUseCase","WorkflowStateModel","WorkflowStateMapper"],"mappings":";;;;;AAUA,MAAMA;IACF,YACYC,YAA2C,EAC3CC,KAAmC,EACnCC,MAAqC,CAC/C;aAHUF,YAAY,GAAZA;aACAC,KAAK,GAALA;aACAC,MAAM,GAANA;IACT;IAEH,MAAM,QAAQC,EAAU,EAAqB;QACzC,MAAMC,cAAc,MAAM,IAAI,CAAC,YAAY,CAAC,OAAO,CAC/C,IAAI,CAAC,KAAK,EACVD;QAGJ,IAAIC,YAAY,MAAM,IAAI;YACtB,IAAIA,AAA2B,yBAA3BA,YAAY,KAAK,CAAC,IAAI,EACtB,OAAOC,OAAO,IAAI,CAAC,IAAIC,2BAA2B;gBAAEH;YAAG;YAG3D,OAAOE,OAAO,IAAI,CAAC,IAAIE,8BAA8BH,YAAY,KAAK;QAC1E;QAEA,MAAMI,QAAQJ,YAAY,KAAK;QAE/B,MAAMK,SAAS,IAAI,CAAC,MAAM,CAAC,YAAY,CAACD;QACxC,OAAOH,OAAO,EAAE,CAACI;IACrB;AACJ;AAEO,MAAMC,wDAA6BC,2BAAAA,oBAA+B,CAAC;IACtE,gBAAgBZ;IAChB,cAAc;QAACa;QAAqBC;QAAoBC;KAAoB;AAChF"}

package/features/workflowState/GetWorkflowState/GetWorkflowStateUseCase.d.ts

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

package/features/workflowState/GetWorkflowState/GetWorkflowStateUseCase.js

@@ -0,0 +1,33 @@
+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 { GetWorkflowStateRepository, GetWorkflowStateUseCase } from "./abstractions.js";
+import { WorkflowState } from "../../../domain/workflowState/WorkflowState.js";
+class GetWorkflowStateUseCaseImpl {
+    constructor(identityContext, getUserTeams, repository){
+        this.identityContext = identityContext;
+        this.getUserTeams = getUserTeams;
+        this.repository = repository;
+    }
+    async execute(id) {
+        const recordResult = await this.repository.execute(id);
+        if (recordResult.isFail()) return Result.fail(recordResult.error);
+        const record = recordResult.value;
+        const identity = this.identityContext.getIdentity();
+        const teamsResult = await this.getUserTeams.execute(identity.id);
+        const teams = teamsResult.value;
+        const workflowState = new WorkflowState(record, teams, identity);
+        return Result.ok(workflowState);
+    }
+}
+const GetWorkflowStateUseCase_GetWorkflowStateUseCase = GetWorkflowStateUseCase.createImplementation({
+    implementation: GetWorkflowStateUseCaseImpl,
+    dependencies: [
+        IdentityContext,
+        GetUserTeamsUseCase,
+        GetWorkflowStateRepository
+    ]
+});
+export { GetWorkflowStateUseCase_GetWorkflowStateUseCase as GetWorkflowStateUseCase };
+
+//# sourceMappingURL=GetWorkflowStateUseCase.js.map

package/features/workflowState/GetWorkflowState/GetWorkflowStateUseCase.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"features/workflowState/GetWorkflowState/GetWorkflowStateUseCase.js","sources":["../../../../src/features/workflowState/GetWorkflowState/GetWorkflowStateUseCase.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 { GetWorkflowStateRepository, GetWorkflowStateUseCase as UseCase } from \"./abstractions.js\";\nimport { WorkflowState } from \"~/domain/workflowState/WorkflowState.js\";\n\nclass GetWorkflowStateUseCaseImpl implements UseCase.Interface {\n    constructor(\n        private identityContext: IdentityContext.Interface,\n        private getUserTeams: GetUserTeamsUseCase.Interface,\n        private repository: GetWorkflowStateRepository.Interface\n    ) {}\n\n    async execute(id: string): UseCase.Return {\n        const recordResult = await this.repository.execute(id);\n\n        if (recordResult.isFail()) {\n            return Result.fail(recordResult.error);\n        }\n\n        const record = recordResult.value;\n\n        const identity = this.identityContext.getIdentity();\n\n        const teamsResult = await this.getUserTeams.execute(identity.id);\n        const teams = teamsResult.value;\n\n        const workflowState = new WorkflowState(record, teams, identity);\n\n        return Result.ok(workflowState);\n    }\n}\n\nexport const GetWorkflowStateUseCase = UseCase.createImplementation({\n    implementation: GetWorkflowStateUseCaseImpl,\n    dependencies: [IdentityContext, GetUserTeamsUseCase, GetWorkflowStateRepository]\n});\n"],"names":["GetWorkflowStateUseCaseImpl","identityContext","getUserTeams","repository","id","recordResult","Result","record","identity","teamsResult","teams","workflowState","WorkflowState","GetWorkflowStateUseCase","UseCase","IdentityContext","GetUserTeamsUseCase","GetWorkflowStateRepository"],"mappings":";;;;;AAMA,MAAMA;IACF,YACYC,eAA0C,EAC1CC,YAA2C,EAC3CC,UAAgD,CAC1D;aAHUF,eAAe,GAAfA;aACAC,YAAY,GAAZA;aACAC,UAAU,GAAVA;IACT;IAEH,MAAM,QAAQC,EAAU,EAAkB;QACtC,MAAMC,eAAe,MAAM,IAAI,CAAC,UAAU,CAAC,OAAO,CAACD;QAEnD,IAAIC,aAAa,MAAM,IACnB,OAAOC,OAAO,IAAI,CAACD,aAAa,KAAK;QAGzC,MAAME,SAASF,aAAa,KAAK;QAEjC,MAAMG,WAAW,IAAI,CAAC,eAAe,CAAC,WAAW;QAEjD,MAAMC,cAAc,MAAM,IAAI,CAAC,YAAY,CAAC,OAAO,CAACD,SAAS,EAAE;QAC/D,MAAME,QAAQD,YAAY,KAAK;QAE/B,MAAME,gBAAgB,IAAIC,cAAcL,QAAQG,OAAOF;QAEvD,OAAOF,OAAO,EAAE,CAACK;IACrB;AACJ;AAEO,MAAME,kDAA0BC,wBAAAA,oBAA4B,CAAC;IAChE,gBAAgBd;IAChB,cAAc;QAACe;QAAiBC;QAAqBC;KAA2B;AACpF"}

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

@@ -0,0 +1,39 @@
+import type { Result } from "@webiny/feature/api";
+import type { IWorkflowStateRecord } from "../../../domain/workflowState/abstractions.js";
+import { type WorkflowStateNotFoundError, type WorkflowStatePersistenceError } from "../../../domain/workflowState/errors.js";
+import type { WorkflowState } from "../../../domain/workflowState/WorkflowState.js";
+/**
+ * GetWorkflowState use case interface
+ */
+export interface IGetWorkflowStateUseCase {
+    execute(id: string): Promise<Result<WorkflowState, UseCaseError>>;
+}
+export interface IGetWorkflowStateUseCaseErrors {
+    notFound: WorkflowStateNotFoundError;
+    persistence: WorkflowStatePersistenceError;
+}
+type UseCaseError = IGetWorkflowStateUseCaseErrors[keyof IGetWorkflowStateUseCaseErrors];
+export declare const GetWorkflowStateUseCase: import("@webiny/di").Abstraction<IGetWorkflowStateUseCase>;
+export declare namespace GetWorkflowStateUseCase {
+    type Interface = IGetWorkflowStateUseCase;
+    type Return = Promise<Result<WorkflowState, UseCaseError>>;
+    type Error = UseCaseError;
+}
+/**
+ * GetWorkflowState repository interface
+ */
+export interface IGetWorkflowStateRepository {
+    execute(id: string): Promise<Result<IWorkflowStateRecord, RepositoryError>>;
+}
+export interface IGetWorkflowStateRepositoryErrors {
+    notFound: WorkflowStateNotFoundError;
+    persistence: WorkflowStatePersistenceError;
+}
+type RepositoryError = IGetWorkflowStateRepositoryErrors[keyof IGetWorkflowStateRepositoryErrors];
+export declare const GetWorkflowStateRepository: import("@webiny/di").Abstraction<IGetWorkflowStateRepository>;
+export declare namespace GetWorkflowStateRepository {
+    type Interface = IGetWorkflowStateRepository;
+    type Return = Promise<Result<IWorkflowStateRecord, RepositoryError>>;
+    type Error = RepositoryError;
+}
+export {};

package/features/workflowState/GetWorkflowState/abstractions.js

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"features/workflowState/GetWorkflowState/abstractions.js","sources":["../../../../src/features/workflowState/GetWorkflowState/abstractions.ts"],"sourcesContent":["import { createAbstraction } from \"@webiny/feature/api\";\nimport type { Result } from \"@webiny/feature/api\";\nimport type { IWorkflowStateRecord } from \"~/domain/workflowState/abstractions.js\";\nimport {\n    type WorkflowStateNotFoundError,\n    type WorkflowStatePersistenceError\n} from \"~/domain/workflowState/errors.js\";\nimport type { WorkflowState } from \"~/domain/workflowState/WorkflowState.js\";\n\n/**\n * GetWorkflowState use case interface\n */\nexport interface IGetWorkflowStateUseCase {\n    execute(id: string): Promise<Result<WorkflowState, UseCaseError>>;\n}\n\nexport interface IGetWorkflowStateUseCaseErrors {\n    notFound: WorkflowStateNotFoundError;\n    persistence: WorkflowStatePersistenceError;\n}\n\ntype UseCaseError = IGetWorkflowStateUseCaseErrors[keyof IGetWorkflowStateUseCaseErrors];\n\nexport const GetWorkflowStateUseCase =\n    createAbstraction<IGetWorkflowStateUseCase>(\"GetWorkflowStateUseCase\");\n\nexport namespace GetWorkflowStateUseCase {\n    export type Interface = IGetWorkflowStateUseCase;\n    export type Return = Promise<Result<WorkflowState, UseCaseError>>;\n    export type Error = UseCaseError;\n}\n\n/**\n * GetWorkflowState repository interface\n */\nexport interface IGetWorkflowStateRepository {\n    execute(id: string): Promise<Result<IWorkflowStateRecord, RepositoryError>>;\n}\n\nexport interface IGetWorkflowStateRepositoryErrors {\n    notFound: WorkflowStateNotFoundError;\n    persistence: WorkflowStatePersistenceError;\n}\n\ntype RepositoryError = IGetWorkflowStateRepositoryErrors[keyof IGetWorkflowStateRepositoryErrors];\n\nexport const GetWorkflowStateRepository = createAbstraction<IGetWorkflowStateRepository>(\n    \"GetWorkflowStateRepository\"\n);\n\nexport namespace GetWorkflowStateRepository {\n    export type Interface = IGetWorkflowStateRepository;\n    export type Return = Promise<Result<IWorkflowStateRecord, RepositoryError>>;\n    export type Error = RepositoryError;\n}\n"],"names":["GetWorkflowStateUseCase","createAbstraction","GetWorkflowStateRepository"],"mappings":";AAuBO,MAAMA,0BACTC,kBAA4C;AAsBzC,MAAMC,6BAA6BD,kBACtC"}

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

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

package/features/workflowState/GetWorkflowState/feature.js

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"features/workflowState/GetWorkflowState/feature.js","sources":["../../../../src/features/workflowState/GetWorkflowState/feature.ts"],"sourcesContent":["import { createFeature } from \"@webiny/feature/api\";\nimport { GetWorkflowStateUseCase } from \"./GetWorkflowStateUseCase.js\";\nimport { GetWorkflowStateRepository } from \"./GetWorkflowStateRepository.js\";\n\nexport const GetWorkflowStateFeature = createFeature({\n    name: \"WorkflowState/GetWorkflowState\",\n    register(container) {\n        container.register(GetWorkflowStateRepository).inSingletonScope();\n        container.register(GetWorkflowStateUseCase);\n    }\n});\n"],"names":["GetWorkflowStateFeature","createFeature","container","GetWorkflowStateRepository","GetWorkflowStateUseCase"],"mappings":";;;AAIO,MAAMA,0BAA0BC,cAAc;IACjD,MAAM;IACN,UAASC,SAAS;QACdA,UAAU,QAAQ,CAACC,4BAA4B,gBAAgB;QAC/DD,UAAU,QAAQ,CAACE;IACvB;AACJ"}

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

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

package/features/workflowState/GetWorkflowState/index.js

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

package/features/workflowState/ListOwnWorkflowStates/ListOwnWorkflowStatesUseCase.d.ts

@@ -0,0 +1,13 @@
+import { IdentityContext } from "@webiny/api-core/features/security/IdentityContext/index.js";
+import { ListWorkflowStatesUseCase } from "../ListWorkflowStates/index.js";
+import { ListOwnWorkflowStatesUseCase as UseCase } from "./abstractions.js";
+declare class ListOwnWorkflowStatesUseCaseImpl implements UseCase.Interface {
+    private identityContext;
+    private listWorkflowStates;
+    constructor(identityContext: IdentityContext.Interface, listWorkflowStates: ListWorkflowStatesUseCase.Interface);
+    execute(params?: UseCase.Params): UseCase.Return;
+}
+export declare const ListOwnWorkflowStatesUseCase: typeof ListOwnWorkflowStatesUseCaseImpl & {
+    __abstraction: import("@webiny/di").Abstraction<import("./abstractions.js").IListOwnWorkflowStatesUseCase>;
+};
+export {};

package/features/workflowState/ListOwnWorkflowStates/ListOwnWorkflowStatesUseCase.js

@@ -0,0 +1,42 @@
+import { Result } from "@webiny/feature/api";
+import { IdentityContext } from "@webiny/api-core/features/security/IdentityContext/index.js";
+import { ListWorkflowStatesUseCase } from "../ListWorkflowStates/index.js";
+import { ListOwnWorkflowStatesUseCase } from "./abstractions.js";
+class ListOwnWorkflowStatesUseCaseImpl {
+    constructor(identityContext, listWorkflowStates){
+        this.identityContext = identityContext;
+        this.listWorkflowStates = listWorkflowStates;
+    }
+    async execute(params = {}) {
+        const identity = this.identityContext.getIdentity();
+        if (identity.isAnonymous()) return Result.ok({
+            items: [],
+            meta: {
+                cursor: null,
+                hasMoreItems: false,
+                totalCount: 0
+            }
+        });
+        return this.listWorkflowStates.execute({
+            ...params,
+            where: {
+                ...params?.where,
+                values: {
+                    ...params?.where?.values,
+                    isActive: true
+                },
+                createdBy: identity.id
+            }
+        });
+    }
+}
+const ListOwnWorkflowStatesUseCase_ListOwnWorkflowStatesUseCase = ListOwnWorkflowStatesUseCase.createImplementation({
+    implementation: ListOwnWorkflowStatesUseCaseImpl,
+    dependencies: [
+        IdentityContext,
+        ListWorkflowStatesUseCase
+    ]
+});
+export { ListOwnWorkflowStatesUseCase_ListOwnWorkflowStatesUseCase as ListOwnWorkflowStatesUseCase };
+
+//# sourceMappingURL=ListOwnWorkflowStatesUseCase.js.map

package/features/workflowState/ListOwnWorkflowStates/ListOwnWorkflowStatesUseCase.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"features/workflowState/ListOwnWorkflowStates/ListOwnWorkflowStatesUseCase.js","sources":["../../../../src/features/workflowState/ListOwnWorkflowStates/ListOwnWorkflowStatesUseCase.ts"],"sourcesContent":["import { Result } from \"@webiny/feature/api\";\nimport { IdentityContext } from \"@webiny/api-core/features/security/IdentityContext/index.js\";\nimport { ListWorkflowStatesUseCase } from \"../ListWorkflowStates/index.js\";\nimport { ListOwnWorkflowStatesUseCase as UseCase } from \"./abstractions.js\";\n\nclass ListOwnWorkflowStatesUseCaseImpl implements UseCase.Interface {\n    constructor(\n        private identityContext: IdentityContext.Interface,\n        private listWorkflowStates: ListWorkflowStatesUseCase.Interface\n    ) {}\n\n    async execute(params: UseCase.Params = {}): UseCase.Return {\n        const identity = this.identityContext.getIdentity();\n        if (identity.isAnonymous()) {\n            // Return empty result if no identity\n            return Result.ok({\n                items: [],\n                meta: {\n                    cursor: null,\n                    hasMoreItems: false,\n                    totalCount: 0\n                }\n            });\n        }\n\n        return this.listWorkflowStates.execute({\n            ...params,\n            where: {\n                ...params?.where,\n                values: {\n                    ...params?.where?.values,\n                    isActive: true\n                },\n                createdBy: identity.id\n            }\n        });\n    }\n}\n\nexport const ListOwnWorkflowStatesUseCase = UseCase.createImplementation({\n    implementation: ListOwnWorkflowStatesUseCaseImpl,\n    dependencies: [IdentityContext, ListWorkflowStatesUseCase]\n});\n"],"names":["ListOwnWorkflowStatesUseCaseImpl","identityContext","listWorkflowStates","params","identity","Result","ListOwnWorkflowStatesUseCase","UseCase","IdentityContext","ListWorkflowStatesUseCase"],"mappings":";;;;AAKA,MAAMA;IACF,YACYC,eAA0C,EAC1CC,kBAAuD,CACjE;aAFUD,eAAe,GAAfA;aACAC,kBAAkB,GAAlBA;IACT;IAEH,MAAM,QAAQC,SAAyB,CAAC,CAAC,EAAkB;QACvD,MAAMC,WAAW,IAAI,CAAC,eAAe,CAAC,WAAW;QACjD,IAAIA,SAAS,WAAW,IAEpB,OAAOC,OAAO,EAAE,CAAC;YACb,OAAO,EAAE;YACT,MAAM;gBACF,QAAQ;gBACR,cAAc;gBACd,YAAY;YAChB;QACJ;QAGJ,OAAO,IAAI,CAAC,kBAAkB,CAAC,OAAO,CAAC;YACnC,GAAGF,MAAM;YACT,OAAO;gBACH,GAAGA,QAAQ,KAAK;gBAChB,QAAQ;oBACJ,GAAGA,QAAQ,OAAO,MAAM;oBACxB,UAAU;gBACd;gBACA,WAAWC,SAAS,EAAE;YAC1B;QACJ;IACJ;AACJ;AAEO,MAAME,4DAA+BC,6BAAAA,oBAA4B,CAAC;IACrE,gBAAgBP;IAChB,cAAc;QAACQ;QAAiBC;KAA0B;AAC9D"}

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

@@ -0,0 +1,22 @@
+import type { Result } from "@webiny/feature/api";
+import type { IListWorkflowStatesParams, IListWorkflowStatesResponse } from "../ListWorkflowStates/abstractions.js";
+import type { WorkflowStatePersistenceError } from "../../../domain/workflowState/errors.js";
+/**
+ * ListOwnWorkflowStates use case interface - filters by current user
+ */
+export interface IListOwnWorkflowStatesUseCase {
+    execute(params?: IListWorkflowStatesParams): Promise<Result<IListWorkflowStatesResponse, UseCaseError>>;
+}
+export interface IListOwnWorkflowStatesUseCaseErrors {
+    persistence: WorkflowStatePersistenceError;
+}
+type UseCaseError = IListOwnWorkflowStatesUseCaseErrors[keyof IListOwnWorkflowStatesUseCaseErrors];
+export declare const ListOwnWorkflowStatesUseCase: import("@webiny/di").Abstraction<IListOwnWorkflowStatesUseCase>;
+export declare namespace ListOwnWorkflowStatesUseCase {
+    type Interface = IListOwnWorkflowStatesUseCase;
+    type Params = IListWorkflowStatesParams;
+    type Response = IListWorkflowStatesResponse;
+    type Return = Promise<Result<IListWorkflowStatesResponse, UseCaseError>>;
+    type Error = UseCaseError;
+}
+export {};

package/features/workflowState/ListOwnWorkflowStates/abstractions.js

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"features/workflowState/ListOwnWorkflowStates/abstractions.js","sources":["../../../../src/features/workflowState/ListOwnWorkflowStates/abstractions.ts"],"sourcesContent":["import { createAbstraction } from \"@webiny/feature/api\";\nimport type { Result } from \"@webiny/feature/api\";\nimport type {\n    IListWorkflowStatesParams,\n    IListWorkflowStatesResponse\n} from \"../ListWorkflowStates/abstractions.js\";\nimport type { WorkflowStatePersistenceError } from \"~/domain/workflowState/errors.js\";\n\n/**\n * ListOwnWorkflowStates use case interface - filters by current user\n */\nexport interface IListOwnWorkflowStatesUseCase {\n    execute(\n        params?: IListWorkflowStatesParams\n    ): Promise<Result<IListWorkflowStatesResponse, UseCaseError>>;\n}\n\nexport interface IListOwnWorkflowStatesUseCaseErrors {\n    persistence: WorkflowStatePersistenceError;\n}\n\ntype UseCaseError = IListOwnWorkflowStatesUseCaseErrors[keyof IListOwnWorkflowStatesUseCaseErrors];\n\nexport const ListOwnWorkflowStatesUseCase = createAbstraction<IListOwnWorkflowStatesUseCase>(\n    \"ListOwnWorkflowStatesUseCase\"\n);\n\nexport namespace ListOwnWorkflowStatesUseCase {\n    export type Interface = IListOwnWorkflowStatesUseCase;\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"],"names":["ListOwnWorkflowStatesUseCase","createAbstraction"],"mappings":";AAuBO,MAAMA,+BAA+BC,kBACxC"}

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

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

package/features/workflowState/ListOwnWorkflowStates/feature.js

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

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

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

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

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

package/features/workflowState/ListOwnWorkflowStates/index.js

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

package/features/workflowState/ListRequestedWorkflowStates/ListRequestedWorkflowStatesUseCase.d.ts

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

package/features/workflowState/ListRequestedWorkflowStates/ListRequestedWorkflowStatesUseCase.js

@@ -0,0 +1,52 @@
+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 { ListWorkflowStatesUseCase } from "../ListWorkflowStates/index.js";
+import { ListRequestedWorkflowStatesUseCase } from "./abstractions.js";
+class ListRequestedWorkflowStatesUseCaseImpl {
+    constructor(identityContext, getUserTeams, listWorkflowStates){
+        this.identityContext = identityContext;
+        this.getUserTeams = getUserTeams;
+        this.listWorkflowStates = listWorkflowStates;
+    }
+    async execute(params = {}) {
+        const identity = this.identityContext.getIdentity();
+        const teamsResult = await this.getUserTeams.execute(identity.id);
+        if (teamsResult.isFail() || 0 === teamsResult.value.length || !identity?.id) return Result.ok({
+            items: [],
+            meta: {
+                cursor: null,
+                hasMoreItems: false,
+                totalCount: 0
+            }
+        });
+        const teams = teamsResult.value;
+        return await this.listWorkflowStates.execute({
+            ...params,
+            where: {
+                ...params?.where,
+                createdBy_not: identity.id,
+                values: {
+                    ...params?.where?.values,
+                    isActive: true,
+                    steps: {
+                        teams: {
+                            id_in: teams.map((team)=>team.id)
+                        }
+                    }
+                }
+            }
+        });
+    }
+}
+const ListRequestedWorkflowStatesUseCase_ListRequestedWorkflowStatesUseCase = ListRequestedWorkflowStatesUseCase.createImplementation({
+    implementation: ListRequestedWorkflowStatesUseCaseImpl,
+    dependencies: [
+        IdentityContext,
+        GetUserTeamsUseCase,
+        ListWorkflowStatesUseCase
+    ]
+});
+export { ListRequestedWorkflowStatesUseCase_ListRequestedWorkflowStatesUseCase as ListRequestedWorkflowStatesUseCase };
+
+//# sourceMappingURL=ListRequestedWorkflowStatesUseCase.js.map

package/features/workflowState/ListRequestedWorkflowStates/ListRequestedWorkflowStatesUseCase.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"features/workflowState/ListRequestedWorkflowStates/ListRequestedWorkflowStatesUseCase.js","sources":["../../../../src/features/workflowState/ListRequestedWorkflowStates/ListRequestedWorkflowStatesUseCase.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 { ListWorkflowStatesUseCase } from \"../ListWorkflowStates/index.js\";\nimport { ListRequestedWorkflowStatesUseCase as UseCase } from \"./abstractions.js\";\n\nclass ListRequestedWorkflowStatesUseCaseImpl implements UseCase.Interface {\n    constructor(\n        private identityContext: IdentityContext.Interface,\n        private getUserTeams: GetUserTeamsUseCase.Interface,\n        private listWorkflowStates: ListWorkflowStatesUseCase.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\n        if (teamsResult.isFail() || teamsResult.value.length === 0 || !identity?.id) {\n            return Result.ok({\n                items: [],\n                meta: {\n                    cursor: null,\n                    hasMoreItems: false,\n                    totalCount: 0\n                }\n            });\n        }\n\n        const teams = teamsResult.value;\n\n        return await this.listWorkflowStates.execute({\n            ...params,\n            where: {\n                ...params?.where,\n                createdBy_not: identity.id,\n                values: {\n                    ...params?.where?.values,\n                    isActive: true,\n                    steps: {\n                        teams: {\n                            id_in: teams.map(team => team.id)\n                        }\n                    }\n                }\n            }\n        });\n    }\n}\n\nexport const ListRequestedWorkflowStatesUseCase = UseCase.createImplementation({\n    implementation: ListRequestedWorkflowStatesUseCaseImpl,\n    dependencies: [IdentityContext, GetUserTeamsUseCase, ListWorkflowStatesUseCase]\n});\n"],"names":["ListRequestedWorkflowStatesUseCaseImpl","identityContext","getUserTeams","listWorkflowStates","params","identity","teamsResult","Result","teams","team","ListRequestedWorkflowStatesUseCase","UseCase","IdentityContext","GetUserTeamsUseCase","ListWorkflowStatesUseCase"],"mappings":";;;;;AAMA,MAAMA;IACF,YACYC,eAA0C,EAC1CC,YAA2C,EAC3CC,kBAAuD,CACjE;aAHUF,eAAe,GAAfA;aACAC,YAAY,GAAZA;aACAC,kBAAkB,GAAlBA;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;QAE/D,IAAIC,YAAY,MAAM,MAAMA,AAA6B,MAA7BA,YAAY,KAAK,CAAC,MAAM,IAAU,CAACD,UAAU,IACrE,OAAOE,OAAO,EAAE,CAAC;YACb,OAAO,EAAE;YACT,MAAM;gBACF,QAAQ;gBACR,cAAc;gBACd,YAAY;YAChB;QACJ;QAGJ,MAAMC,QAAQF,YAAY,KAAK;QAE/B,OAAO,MAAM,IAAI,CAAC,kBAAkB,CAAC,OAAO,CAAC;YACzC,GAAGF,MAAM;YACT,OAAO;gBACH,GAAGA,QAAQ,KAAK;gBAChB,eAAeC,SAAS,EAAE;gBAC1B,QAAQ;oBACJ,GAAGD,QAAQ,OAAO,MAAM;oBACxB,UAAU;oBACV,OAAO;wBACH,OAAO;4BACH,OAAOI,MAAM,GAAG,CAACC,CAAAA,OAAQA,KAAK,EAAE;wBACpC;oBACJ;gBACJ;YACJ;QACJ;IACJ;AACJ;AAEO,MAAMC,wEAAqCC,mCAAAA,oBAA4B,CAAC;IAC3E,gBAAgBX;IAChB,cAAc;QAACY;QAAiBC;QAAqBC;KAA0B;AACnF"}

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

@@ -0,0 +1,22 @@
+import type { Result } from "@webiny/feature/api";
+import type { IListWorkflowStatesParams, IListWorkflowStatesResponse } from "../ListWorkflowStates/abstractions.js";
+import type { WorkflowStatePersistenceError } from "../../../domain/workflowState/errors.js";
+/**
+ * ListRequestedWorkflowStates use case interface - filters by team membership
+ */
+export interface IListRequestedWorkflowStatesUseCase {
+    execute(params?: IListWorkflowStatesParams): Promise<Result<IListWorkflowStatesResponse, UseCaseError>>;
+}
+export interface IListRequestedWorkflowStatesUseCaseErrors {
+    persistence: WorkflowStatePersistenceError;
+}
+type UseCaseError = IListRequestedWorkflowStatesUseCaseErrors[keyof IListRequestedWorkflowStatesUseCaseErrors];
+export declare const ListRequestedWorkflowStatesUseCase: import("@webiny/di").Abstraction<IListRequestedWorkflowStatesUseCase>;
+export declare namespace ListRequestedWorkflowStatesUseCase {
+    type Interface = IListRequestedWorkflowStatesUseCase;
+    type Params = IListWorkflowStatesParams;
+    type Response = IListWorkflowStatesResponse;
+    type Return = Promise<Result<IListWorkflowStatesResponse, UseCaseError>>;
+    type Error = UseCaseError;
+}
+export {};

package/features/workflowState/ListRequestedWorkflowStates/abstractions.js

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"features/workflowState/ListRequestedWorkflowStates/abstractions.js","sources":["../../../../src/features/workflowState/ListRequestedWorkflowStates/abstractions.ts"],"sourcesContent":["import { createAbstraction } from \"@webiny/feature/api\";\nimport type { Result } from \"@webiny/feature/api\";\nimport type {\n    IListWorkflowStatesParams,\n    IListWorkflowStatesResponse\n} from \"../ListWorkflowStates/abstractions.js\";\nimport type { WorkflowStatePersistenceError } from \"~/domain/workflowState/errors.js\";\n\n/**\n * ListRequestedWorkflowStates use case interface - filters by team membership\n */\nexport interface IListRequestedWorkflowStatesUseCase {\n    execute(\n        params?: IListWorkflowStatesParams\n    ): Promise<Result<IListWorkflowStatesResponse, UseCaseError>>;\n}\n\nexport interface IListRequestedWorkflowStatesUseCaseErrors {\n    persistence: WorkflowStatePersistenceError;\n}\n\ntype UseCaseError =\n    IListRequestedWorkflowStatesUseCaseErrors[keyof IListRequestedWorkflowStatesUseCaseErrors];\n\nexport const ListRequestedWorkflowStatesUseCase =\n    createAbstraction<IListRequestedWorkflowStatesUseCase>(\"ListRequestedWorkflowStatesUseCase\");\n\nexport namespace ListRequestedWorkflowStatesUseCase {\n    export type Interface = IListRequestedWorkflowStatesUseCase;\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"],"names":["ListRequestedWorkflowStatesUseCase","createAbstraction"],"mappings":";AAwBO,MAAMA,qCACTC,kBAAuD"}

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

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

package/features/workflowState/ListRequestedWorkflowStates/feature.js

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

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

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

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

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

package/features/workflowState/ListRequestedWorkflowStates/index.js

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

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

@@ -0,0 +1,9 @@
+import { WorkflowStateFilter } from "./WorkflowStateFilter.js";
+import type { WorkflowState } from "../../../domain/workflowState/WorkflowState.js";
+declare class PassThroughWorkflowStateFilter implements WorkflowStateFilter.Interface {
+    filter(items: WorkflowState[]): Promise<WorkflowState[]>;
+}
+export declare const DefaultWorkflowStateFilter: typeof PassThroughWorkflowStateFilter & {
+    __abstraction: import("@webiny/di").Abstraction<import("./WorkflowStateFilter.js").IWorkflowStateFilter>;
+};
+export {};

package/features/workflowState/ListWorkflowStates/DefaultWorkflowStateFilter.js

@@ -0,0 +1,13 @@
+import { WorkflowStateFilter } from "./WorkflowStateFilter.js";
+class PassThroughWorkflowStateFilter {
+    async filter(items) {
+        return items;
+    }
+}
+const DefaultWorkflowStateFilter = WorkflowStateFilter.createImplementation({
+    implementation: PassThroughWorkflowStateFilter,
+    dependencies: []
+});
+export { DefaultWorkflowStateFilter };
+
+//# sourceMappingURL=DefaultWorkflowStateFilter.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"features/workflowState/ListWorkflowStates/DefaultWorkflowStateFilter.js","sources":["../../../../src/features/workflowState/ListWorkflowStates/DefaultWorkflowStateFilter.ts"],"sourcesContent":["import { WorkflowStateFilter } from \"./WorkflowStateFilter.js\";\nimport type { WorkflowState } from \"~/domain/workflowState/WorkflowState.js\";\n\nclass PassThroughWorkflowStateFilter implements WorkflowStateFilter.Interface {\n    async filter(items: WorkflowState[]): Promise<WorkflowState[]> {\n        return items;\n    }\n}\n\nexport const DefaultWorkflowStateFilter = WorkflowStateFilter.createImplementation({\n    implementation: PassThroughWorkflowStateFilter,\n    dependencies: []\n});\n"],"names":["PassThroughWorkflowStateFilter","items","DefaultWorkflowStateFilter","WorkflowStateFilter"],"mappings":";AAGA,MAAMA;IACF,MAAM,OAAOC,KAAsB,EAA4B;QAC3D,OAAOA;IACX;AACJ;AAEO,MAAMC,6BAA6BC,oBAAoB,oBAAoB,CAAC;IAC/E,gBAAgBH;IAChB,cAAc,EAAE;AACpB"}

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

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

package/features/workflowState/ListWorkflowStates/ListWorkflowStatesRepository.js

@@ -0,0 +1,46 @@
+import { Result } from "@webiny/feature/api";
+import { ListLatestEntriesUseCase } from "@webiny/api-headless-cms/features/contentEntry/ListEntries";
+import { WorkflowStateMapper, WorkflowStateModel } from "../../../domain/workflowState/abstractions.js";
+import { WorkflowStatePersistenceError } from "../../../domain/workflowState/errors.js";
+import { ListWorkflowStatesRepository } from "./abstractions.js";
+import { CmsWhereMapper } from "@webiny/api-headless-cms";
+class ListWorkflowStatesRepositoryImpl {
+    constructor(listEntries, model, mapper, cmsWhereMapper){
+        this.listEntries = listEntries;
+        this.model = model;
+        this.mapper = mapper;
+        this.cmsWhereMapper = cmsWhereMapper;
+    }
+    async execute(params = {}) {
+        const listResult = await this.listEntries.execute(this.model, {
+            limit: 50,
+            sort: [
+                "createdOn_DESC"
+            ],
+            ...params,
+            where: this.cmsWhereMapper.map({
+                input: params.where,
+                fields: this.model.fields
+            })
+        });
+        if (listResult.isFail()) return Result.fail(new WorkflowStatePersistenceError(listResult.error));
+        const { entries, meta } = listResult.value;
+        const records = entries.map((item)=>this.mapper.fromCmsEntry(item));
+        return Result.ok({
+            items: records,
+            meta
+        });
+    }
+}
+const ListWorkflowStatesRepository_ListWorkflowStatesRepository = ListWorkflowStatesRepository.createImplementation({
+    implementation: ListWorkflowStatesRepositoryImpl,
+    dependencies: [
+        ListLatestEntriesUseCase,
+        WorkflowStateModel,
+        WorkflowStateMapper,
+        CmsWhereMapper
+    ]
+});
+export { ListWorkflowStatesRepository_ListWorkflowStatesRepository as ListWorkflowStatesRepository };
+
+//# sourceMappingURL=ListWorkflowStatesRepository.js.map