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

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

@@ -0,0 +1 @@
+{"version":3,"names":["Result","ListLatestEntriesUseCase","WorkflowStateModel","WorkflowStateMapper","WorkflowStateNotFoundError","WorkflowStatePersistenceError","MultipleWorkflowsFoundError","GetTargetWorkflowStateRepository","Repository","GetTargetWorkflowStateRepositoryImpl","constructor","listEntries","model","mapper","execute","input","listResult","where","values","app","targetRevisionId","isActive","limit","isFail","fail","error","entries","meta","value","length","totalCount","items","record","fromCmsEntry","ok","createImplementation","implementation","dependencies"],"sources":["GetTargetWorkflowStateRepository.ts"],"sourcesContent":["import { Result } from \"@webiny/feature/api\";\nimport { ListLatestEntriesUseCase } from \"@webiny/api-headless-cms/features/contentEntry/ListEntries\";\nimport { WorkflowStateModel, WorkflowStateMapper } from \"~/domain/workflowState/abstractions.js\";\nimport type { IWorkflowStateRecord } from \"~/domain/workflowState/abstractions.js\";\nimport {\n    WorkflowStateNotFoundError,\n    WorkflowStatePersistenceError,\n    MultipleWorkflowsFoundError\n} from \"~/domain/workflowState/errors.js\";\nimport { GetTargetWorkflowStateRepository as Repository } from \"./abstractions.js\";\n\nclass GetTargetWorkflowStateRepositoryImpl implements Repository.Interface {\n    constructor(\n        private listEntries: ListLatestEntriesUseCase.Interface,\n        private model: WorkflowStateModel.Interface,\n        private mapper: WorkflowStateMapper.Interface\n    ) {}\n\n    async execute(input: Repository.Params): Repository.Return {\n        const listResult = await this.listEntries.execute<Omit<IWorkflowStateRecord, \"id\">>(\n            this.model,\n            {\n                where: {\n                    values: {\n                        app: input.app,\n                        targetRevisionId: input.targetRevisionId,\n                        isActive: true\n                    }\n                },\n                limit: 1\n            }\n        );\n\n        if (listResult.isFail()) {\n            return Result.fail(new WorkflowStatePersistenceError(listResult.error));\n        }\n\n        const { entries, meta } = listResult.value;\n\n        if (entries.length === 0) {\n            return Result.fail(\n                new WorkflowStateNotFoundError({\n                    app: input.app,\n                    targetRevisionId: input.targetRevisionId\n                })\n            );\n        }\n\n        if (meta.totalCount > 1) {\n            return Result.fail(\n                new MultipleWorkflowsFoundError({\n                    app: input.app,\n                    targetRevisionId: input.targetRevisionId,\n                    items: entries\n                })\n            );\n        }\n\n        const record = this.mapper.fromCmsEntry(entries[0]);\n        return Result.ok(record);\n    }\n}\n\nexport const GetTargetWorkflowStateRepository = Repository.createImplementation({\n    implementation: GetTargetWorkflowStateRepositoryImpl,\n    dependencies: [ListLatestEntriesUseCase, WorkflowStateModel, WorkflowStateMapper]\n});\n"],"mappings":"AAAA,SAASA,MAAM,QAAQ,qBAAqB;AAC5C,SAASC,wBAAwB,QAAQ,4DAA4D;AACrG,SAASC,kBAAkB,EAAEC,mBAAmB;AAEhD,SACIC,0BAA0B,EAC1BC,6BAA6B,EAC7BC,2BAA2B;AAE/B,SAASC,gCAAgC,IAAIC,UAAU;AAEvD,MAAMC,oCAAoC,CAAiC;EACvEC,WAAWA,CACCC,WAA+C,EAC/CC,KAAmC,EACnCC,MAAqC,EAC/C;IAAA,KAHUF,WAA+C,GAA/CA,WAA+C;IAAA,KAC/CC,KAAmC,GAAnCA,KAAmC;IAAA,KACnCC,MAAqC,GAArCA,MAAqC;EAC9C;EAEH,MAAMC,OAAOA,CAACC,KAAwB,EAAqB;IACvD,MAAMC,UAAU,GAAG,MAAM,IAAI,CAACL,WAAW,CAACG,OAAO,CAC7C,IAAI,CAACF,KAAK,EACV;MACIK,KAAK,EAAE;QACHC,MAAM,EAAE;UACJC,GAAG,EAAEJ,KAAK,CAACI,GAAG;UACdC,gBAAgB,EAAEL,KAAK,CAACK,gBAAgB;UACxCC,QAAQ,EAAE;QACd;MACJ,CAAC;MACDC,KAAK,EAAE;IACX,CACJ,CAAC;IAED,IAAIN,UAAU,CAACO,MAAM,CAAC,CAAC,EAAE;MACrB,OAAOvB,MAAM,CAACwB,IAAI,CAAC,IAAInB,6BAA6B,CAACW,UAAU,CAACS,KAAK,CAAC,CAAC;IAC3E;IAEA,MAAM;MAAEC,OAAO;MAAEC;IAAK,CAAC,GAAGX,UAAU,CAACY,KAAK;IAE1C,IAAIF,OAAO,CAACG,MAAM,KAAK,CAAC,EAAE;MACtB,OAAO7B,MAAM,CAACwB,IAAI,CACd,IAAIpB,0BAA0B,CAAC;QAC3Be,GAAG,EAAEJ,KAAK,CAACI,GAAG;QACdC,gBAAgB,EAAEL,KAAK,CAACK;MAC5B,CAAC,CACL,CAAC;IACL;IAEA,IAAIO,IAAI,CAACG,UAAU,GAAG,CAAC,EAAE;MACrB,OAAO9B,MAAM,CAACwB,IAAI,CACd,IAAIlB,2BAA2B,CAAC;QAC5Ba,GAAG,EAAEJ,KAAK,CAACI,GAAG;QACdC,gBAAgB,EAAEL,KAAK,CAACK,gBAAgB;QACxCW,KAAK,EAAEL;MACX,CAAC,CACL,CAAC;IACL;IAEA,MAAMM,MAAM,GAAG,IAAI,CAACnB,MAAM,CAACoB,YAAY,CAACP,OAAO,CAAC,CAAC,CAAC,CAAC;IACnD,OAAO1B,MAAM,CAACkC,EAAE,CAACF,MAAM,CAAC;EAC5B;AACJ;AAEA,OAAO,MAAMzB,gCAAgC,GAAGC,UAAU,CAAC2B,oBAAoB,CAAC;EAC5EC,cAAc,EAAE3B,oCAAoC;EACpD4B,YAAY,EAAE,CAACpC,wBAAwB,EAAEC,kBAAkB,EAAEC,mBAAmB;AACpF,CAAC,CAAC","ignoreList":[]}

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

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

package/features/workflowState/GetTargetWorkflowState/GetTargetWorkflowStateUseCase.js

@@ -0,0 +1,38 @@
+import { Result } from "@webiny/feature/api";
+import { parseIdentifier } from "@webiny/utils/parseIdentifier.js";
+import { IdentityContext } from "@webiny/api-core/features/IdentityContext";
+import { GetUserTeamsUseCase } from "../../internal/GetUserTeams/index.js";
+import { GetTargetWorkflowStateRepository, GetTargetWorkflowStateUseCase as UseCase } from "./abstractions.js";
+import { WorkflowState } from "../../../domain/workflowState/WorkflowState.js";
+import { WorkflowStateValidationError } from "../../../domain/workflowState/errors.js";
+class GetTargetWorkflowStateUseCaseImpl {
+  constructor(identityContext, getUserTeams, repository) {
+    this.identityContext = identityContext;
+    this.getUserTeams = getUserTeams;
+    this.repository = repository;
+  }
+  async execute(input) {
+    const {
+      version
+    } = parseIdentifier(input.targetRevisionId);
+    if (!version) {
+      return Result.fail(new WorkflowStateValidationError("Cannot get a workflow state without version of a target record."));
+    }
+    const recordResult = await this.repository.execute(input);
+    if (recordResult.isFail()) {
+      return Result.fail(recordResult.error);
+    }
+    const record = recordResult.value;
+    const identity = this.identityContext.getIdentity();
+    const teamsResult = await this.getUserTeams.execute(identity.id);
+    const teams = teamsResult.value;
+    const workflowState = new WorkflowState(record, teams, identity);
+    return Result.ok(workflowState);
+  }
+}
+export const GetTargetWorkflowStateUseCase = UseCase.createImplementation({
+  implementation: GetTargetWorkflowStateUseCaseImpl,
+  dependencies: [IdentityContext, GetUserTeamsUseCase, GetTargetWorkflowStateRepository]
+});
+
+//# sourceMappingURL=GetTargetWorkflowStateUseCase.js.map

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

@@ -0,0 +1 @@
+{"version":3,"names":["Result","parseIdentifier","IdentityContext","GetUserTeamsUseCase","GetTargetWorkflowStateRepository","GetTargetWorkflowStateUseCase","UseCase","WorkflowState","WorkflowStateValidationError","GetTargetWorkflowStateUseCaseImpl","constructor","identityContext","getUserTeams","repository","execute","input","version","targetRevisionId","fail","recordResult","isFail","error","record","value","identity","getIdentity","teamsResult","id","teams","workflowState","ok","createImplementation","implementation","dependencies"],"sources":["GetTargetWorkflowStateUseCase.ts"],"sourcesContent":["import { Result } from \"@webiny/feature/api\";\nimport { parseIdentifier } from \"@webiny/utils/parseIdentifier.js\";\nimport { IdentityContext } from \"@webiny/api-core/features/IdentityContext\";\nimport { GetUserTeamsUseCase } from \"~/features/internal/GetUserTeams/index.js\";\nimport {\n    GetTargetWorkflowStateRepository,\n    GetTargetWorkflowStateUseCase as UseCase\n} from \"./abstractions.js\";\nimport { WorkflowState } from \"~/domain/workflowState/WorkflowState.js\";\nimport { WorkflowStateValidationError } from \"~/domain/workflowState/errors.js\";\n\nclass GetTargetWorkflowStateUseCaseImpl implements UseCase.Interface {\n    constructor(\n        private identityContext: IdentityContext.Interface,\n        private getUserTeams: GetUserTeamsUseCase.Interface,\n        private repository: GetTargetWorkflowStateRepository.Interface\n    ) {}\n\n    async execute(input: UseCase.Params): UseCase.Return {\n        const { version } = parseIdentifier(input.targetRevisionId);\n        if (!version) {\n            return Result.fail(\n                new WorkflowStateValidationError(\n                    \"Cannot get a workflow state without version of a target record.\"\n                )\n            );\n        }\n\n        const recordResult = await this.repository.execute(input);\n\n        if (recordResult.isFail()) {\n            return Result.fail(recordResult.error);\n        }\n\n        const record = recordResult.value;\n\n        const identity = this.identityContext.getIdentity();\n\n        const teamsResult = await this.getUserTeams.execute(identity.id);\n        const teams = teamsResult.value;\n\n        const workflowState = new WorkflowState(record, teams, identity);\n\n        return Result.ok(workflowState);\n    }\n}\n\nexport const GetTargetWorkflowStateUseCase = UseCase.createImplementation({\n    implementation: GetTargetWorkflowStateUseCaseImpl,\n    dependencies: [IdentityContext, GetUserTeamsUseCase, GetTargetWorkflowStateRepository]\n});\n"],"mappings":"AAAA,SAASA,MAAM,QAAQ,qBAAqB;AAC5C,SAASC,eAAe,QAAQ,kCAAkC;AAClE,SAASC,eAAe,QAAQ,2CAA2C;AAC3E,SAASC,mBAAmB;AAC5B,SACIC,gCAAgC,EAChCC,6BAA6B,IAAIC,OAAO;AAE5C,SAASC,aAAa;AACtB,SAASC,4BAA4B;AAErC,MAAMC,iCAAiC,CAA8B;EACjEC,WAAWA,CACCC,eAA0C,EAC1CC,YAA2C,EAC3CC,UAAsD,EAChE;IAAA,KAHUF,eAA0C,GAA1CA,eAA0C;IAAA,KAC1CC,YAA2C,GAA3CA,YAA2C;IAAA,KAC3CC,UAAsD,GAAtDA,UAAsD;EAC/D;EAEH,MAAMC,OAAOA,CAACC,KAAqB,EAAkB;IACjD,MAAM;MAAEC;IAAQ,CAAC,GAAGf,eAAe,CAACc,KAAK,CAACE,gBAAgB,CAAC;IAC3D,IAAI,CAACD,OAAO,EAAE;MACV,OAAOhB,MAAM,CAACkB,IAAI,CACd,IAAIV,4BAA4B,CAC5B,iEACJ,CACJ,CAAC;IACL;IAEA,MAAMW,YAAY,GAAG,MAAM,IAAI,CAACN,UAAU,CAACC,OAAO,CAACC,KAAK,CAAC;IAEzD,IAAII,YAAY,CAACC,MAAM,CAAC,CAAC,EAAE;MACvB,OAAOpB,MAAM,CAACkB,IAAI,CAACC,YAAY,CAACE,KAAK,CAAC;IAC1C;IAEA,MAAMC,MAAM,GAAGH,YAAY,CAACI,KAAK;IAEjC,MAAMC,QAAQ,GAAG,IAAI,CAACb,eAAe,CAACc,WAAW,CAAC,CAAC;IAEnD,MAAMC,WAAW,GAAG,MAAM,IAAI,CAACd,YAAY,CAACE,OAAO,CAACU,QAAQ,CAACG,EAAE,CAAC;IAChE,MAAMC,KAAK,GAAGF,WAAW,CAACH,KAAK;IAE/B,MAAMM,aAAa,GAAG,IAAItB,aAAa,CAACe,MAAM,EAAEM,KAAK,EAAEJ,QAAQ,CAAC;IAEhE,OAAOxB,MAAM,CAAC8B,EAAE,CAACD,aAAa,CAAC;EACnC;AACJ;AAEA,OAAO,MAAMxB,6BAA6B,GAAGC,OAAO,CAACyB,oBAAoB,CAAC;EACtEC,cAAc,EAAEvB,iCAAiC;EACjDwB,YAAY,EAAE,CAAC/B,eAAe,EAAEC,mBAAmB,EAAEC,gCAAgC;AACzF,CAAC,CAAC","ignoreList":[]}

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

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

package/features/workflowState/GetTargetWorkflowState/abstractions.js

@@ -0,0 +1,15 @@
+import { createAbstraction } from "@webiny/feature/api";
+
+/**
+ * GetTargetWorkflowState use case interface
+ */
+
+export const GetTargetWorkflowStateUseCase = createAbstraction("GetTargetWorkflowStateUseCase");
+
+/**
+ * GetTargetWorkflowState repository interface
+ */
+
+export const GetTargetWorkflowStateRepository = createAbstraction("GetTargetWorkflowStateRepository");
+
+//# sourceMappingURL=abstractions.js.map

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

@@ -0,0 +1 @@
+{"version":3,"names":["createAbstraction","GetTargetWorkflowStateUseCase","GetTargetWorkflowStateRepository"],"sources":["abstractions.ts"],"sourcesContent":["import { createAbstraction } from \"@webiny/feature/api\";\nimport type { Result } from \"@webiny/feature/api\";\nimport type { IWorkflowStateRecord } from \"~/domain/workflowState/abstractions.js\";\nimport {\n    type WorkflowStateNotFoundError,\n    type WorkflowStatePersistenceError,\n    type MultipleWorkflowsFoundError,\n    WorkflowStateValidationError\n} from \"~/domain/workflowState/errors.js\";\nimport type { WorkflowState } from \"~/domain/workflowState/WorkflowState.js\";\n\nexport interface IGetTargetWorkflowStateParams {\n    app: string;\n    targetRevisionId: string;\n}\n\n/**\n * GetTargetWorkflowState use case interface\n */\nexport interface IGetTargetWorkflowStateUseCase {\n    execute(input: IGetTargetWorkflowStateParams): Promise<Result<WorkflowState, UseCaseError>>;\n}\n\nexport interface IGetTargetWorkflowStateUseCaseErrors {\n    notFound: WorkflowStateNotFoundError;\n    persistence: WorkflowStatePersistenceError;\n    multipleFound: MultipleWorkflowsFoundError;\n    validation: WorkflowStateValidationError;\n}\n\ntype UseCaseError =\n    IGetTargetWorkflowStateUseCaseErrors[keyof IGetTargetWorkflowStateUseCaseErrors];\n\nexport const GetTargetWorkflowStateUseCase = createAbstraction<IGetTargetWorkflowStateUseCase>(\n    \"GetTargetWorkflowStateUseCase\"\n);\n\nexport namespace GetTargetWorkflowStateUseCase {\n    export type Interface = IGetTargetWorkflowStateUseCase;\n    export type Params = IGetTargetWorkflowStateParams;\n    export type Return = Promise<Result<WorkflowState, UseCaseError>>;\n    export type Error = UseCaseError;\n}\n\n/**\n * GetTargetWorkflowState repository interface\n */\nexport interface IGetTargetWorkflowStateRepository {\n    execute(\n        input: IGetTargetWorkflowStateParams\n    ): Promise<Result<IWorkflowStateRecord, RepositoryError>>;\n}\n\nexport interface IGetTargetWorkflowStateRepositoryErrors {\n    notFound: WorkflowStateNotFoundError;\n    persistence: WorkflowStatePersistenceError;\n    multipleFound: MultipleWorkflowsFoundError;\n}\n\ntype RepositoryError =\n    IGetTargetWorkflowStateRepositoryErrors[keyof IGetTargetWorkflowStateRepositoryErrors];\n\nexport const GetTargetWorkflowStateRepository =\n    createAbstraction<IGetTargetWorkflowStateRepository>(\"GetTargetWorkflowStateRepository\");\n\nexport namespace GetTargetWorkflowStateRepository {\n    export type Interface = IGetTargetWorkflowStateRepository;\n    export type Params = IGetTargetWorkflowStateParams;\n    export type Return = Promise<Result<IWorkflowStateRecord, RepositoryError>>;\n    export type Error = RepositoryError;\n}\n"],"mappings":"AAAA,SAASA,iBAAiB,QAAQ,qBAAqB;;AAgBvD;AACA;AACA;;AAeA,OAAO,MAAMC,6BAA6B,GAAGD,iBAAiB,CAC1D,+BACJ,CAAC;;AASD;AACA;AACA;;AAgBA,OAAO,MAAME,gCAAgC,GACzCF,iBAAiB,CAAoC,kCAAkC,CAAC","ignoreList":[]}

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

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

package/features/workflowState/GetTargetWorkflowState/feature.js

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

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

@@ -0,0 +1 @@
+{"version":3,"names":["createFeature","GetTargetWorkflowStateUseCase","GetTargetWorkflowStateRepository","GetTargetWorkflowStateFeature","name","register","container","inSingletonScope"],"sources":["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"],"mappings":"AAAA,SAASA,aAAa,QAAQ,qBAAqB;AACnD,SAASC,6BAA6B;AACtC,SAASC,gCAAgC;AAEzC,OAAO,MAAMC,6BAA6B,GAAGH,aAAa,CAAC;EACvDI,IAAI,EAAE,sCAAsC;EAC5CC,QAAQA,CAACC,SAAS,EAAE;IAChBA,SAAS,CAACD,QAAQ,CAACH,gCAAgC,CAAC,CAACK,gBAAgB,CAAC,CAAC;IACvED,SAAS,CAACD,QAAQ,CAACJ,6BAA6B,CAAC;EACrD;AACJ,CAAC,CAAC","ignoreList":[]}

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,3 @@
+export { GetTargetWorkflowStateUseCase, GetTargetWorkflowStateRepository } from "./abstractions.js";
+
+//# sourceMappingURL=index.js.map

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

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

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,32 @@
+import { Result } from "@webiny/feature/api";
+import { GetEntryByIdUseCase } from "@webiny/api-headless-cms/features/contentEntry/GetEntryById/index.js";
+import { WorkflowStateModel, WorkflowStateMapper } from "../../../domain/workflowState/abstractions.js";
+import { WorkflowStateNotFoundError, WorkflowStatePersistenceError } from "../../../domain/workflowState/errors.js";
+import { GetWorkflowStateRepository as Repository } 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 (entryResult.error.code === "Cms/Entry/NotFound") {
+        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);
+  }
+}
+export const GetWorkflowStateRepository = Repository.createImplementation({
+  implementation: GetWorkflowStateRepositoryImpl,
+  dependencies: [GetEntryByIdUseCase, WorkflowStateModel, WorkflowStateMapper]
+});
+
+//# sourceMappingURL=GetWorkflowStateRepository.js.map

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

@@ -0,0 +1 @@
+{"version":3,"names":["Result","GetEntryByIdUseCase","WorkflowStateModel","WorkflowStateMapper","WorkflowStateNotFoundError","WorkflowStatePersistenceError","GetWorkflowStateRepository","Repository","GetWorkflowStateRepositoryImpl","constructor","getEntryById","model","mapper","execute","id","entryResult","isFail","error","code","fail","entry","value","record","fromCmsEntry","ok","createImplementation","implementation","dependencies"],"sources":["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"],"mappings":"AAAA,SAASA,MAAM,QAAQ,qBAAqB;AAC5C,SAASC,mBAAmB,QAAQ,sEAAsE;AAC1G,SAASC,kBAAkB,EAAEC,mBAAmB;AAEhD,SACIC,0BAA0B,EAC1BC,6BAA6B;AAEjC,SAASC,0BAA0B,IAAIC,UAAU;AAEjD,MAAMC,8BAA8B,CAAiC;EACjEC,WAAWA,CACCC,YAA2C,EAC3CC,KAAmC,EACnCC,MAAqC,EAC/C;IAAA,KAHUF,YAA2C,GAA3CA,YAA2C;IAAA,KAC3CC,KAAmC,GAAnCA,KAAmC;IAAA,KACnCC,MAAqC,GAArCA,MAAqC;EAC9C;EAEH,MAAMC,OAAOA,CAACC,EAAU,EAAqB;IACzC,MAAMC,WAAW,GAAG,MAAM,IAAI,CAACL,YAAY,CAACG,OAAO,CAC/C,IAAI,CAACF,KAAK,EACVG,EACJ,CAAC;IAED,IAAIC,WAAW,CAACC,MAAM,CAAC,CAAC,EAAE;MACtB,IAAID,WAAW,CAACE,KAAK,CAACC,IAAI,KAAK,oBAAoB,EAAE;QACjD,OAAOlB,MAAM,CAACmB,IAAI,CAAC,IAAIf,0BAA0B,CAAC;UAAEU;QAAG,CAAC,CAAC,CAAC;MAC9D;MAEA,OAAOd,MAAM,CAACmB,IAAI,CAAC,IAAId,6BAA6B,CAACU,WAAW,CAACE,KAAK,CAAC,CAAC;IAC5E;IAEA,MAAMG,KAAK,GAAGL,WAAW,CAACM,KAAK;IAE/B,MAAMC,MAAM,GAAG,IAAI,CAACV,MAAM,CAACW,YAAY,CAACH,KAAK,CAAC;IAC9C,OAAOpB,MAAM,CAACwB,EAAE,CAACF,MAAM,CAAC;EAC5B;AACJ;AAEA,OAAO,MAAMhB,0BAA0B,GAAGC,UAAU,CAACkB,oBAAoB,CAAC;EACtEC,cAAc,EAAElB,8BAA8B;EAC9CmB,YAAY,EAAE,CAAC1B,mBAAmB,EAAEC,kBAAkB,EAAEC,mBAAmB;AAC/E,CAAC,CAAC","ignoreList":[]}

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

@@ -0,0 +1,14 @@
+import { IdentityContext } from "@webiny/api-core/features/IdentityContext";
+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,30 @@
+import { Result } from "@webiny/feature/api";
+import { IdentityContext } from "@webiny/api-core/features/IdentityContext";
+import { GetUserTeamsUseCase } from "../../internal/GetUserTeams/index.js";
+import { GetWorkflowStateRepository, GetWorkflowStateUseCase as UseCase } 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);
+  }
+}
+export const GetWorkflowStateUseCase = UseCase.createImplementation({
+  implementation: GetWorkflowStateUseCaseImpl,
+  dependencies: [IdentityContext, GetUserTeamsUseCase, GetWorkflowStateRepository]
+});
+
+//# sourceMappingURL=GetWorkflowStateUseCase.js.map

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

@@ -0,0 +1 @@
+{"version":3,"names":["Result","IdentityContext","GetUserTeamsUseCase","GetWorkflowStateRepository","GetWorkflowStateUseCase","UseCase","WorkflowState","GetWorkflowStateUseCaseImpl","constructor","identityContext","getUserTeams","repository","execute","id","recordResult","isFail","fail","error","record","value","identity","getIdentity","teamsResult","teams","workflowState","ok","createImplementation","implementation","dependencies"],"sources":["GetWorkflowStateUseCase.ts"],"sourcesContent":["import { Result } from \"@webiny/feature/api\";\nimport { IdentityContext } from \"@webiny/api-core/features/IdentityContext\";\nimport { GetUserTeamsUseCase } from \"~/features/internal/GetUserTeams/index.js\";\nimport { 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"],"mappings":"AAAA,SAASA,MAAM,QAAQ,qBAAqB;AAC5C,SAASC,eAAe,QAAQ,2CAA2C;AAC3E,SAASC,mBAAmB;AAC5B,SAASC,0BAA0B,EAAEC,uBAAuB,IAAIC,OAAO;AACvE,SAASC,aAAa;AAEtB,MAAMC,2BAA2B,CAA8B;EAC3DC,WAAWA,CACCC,eAA0C,EAC1CC,YAA2C,EAC3CC,UAAgD,EAC1D;IAAA,KAHUF,eAA0C,GAA1CA,eAA0C;IAAA,KAC1CC,YAA2C,GAA3CA,YAA2C;IAAA,KAC3CC,UAAgD,GAAhDA,UAAgD;EACzD;EAEH,MAAMC,OAAOA,CAACC,EAAU,EAAkB;IACtC,MAAMC,YAAY,GAAG,MAAM,IAAI,CAACH,UAAU,CAACC,OAAO,CAACC,EAAE,CAAC;IAEtD,IAAIC,YAAY,CAACC,MAAM,CAAC,CAAC,EAAE;MACvB,OAAOf,MAAM,CAACgB,IAAI,CAACF,YAAY,CAACG,KAAK,CAAC;IAC1C;IAEA,MAAMC,MAAM,GAAGJ,YAAY,CAACK,KAAK;IAEjC,MAAMC,QAAQ,GAAG,IAAI,CAACX,eAAe,CAACY,WAAW,CAAC,CAAC;IAEnD,MAAMC,WAAW,GAAG,MAAM,IAAI,CAACZ,YAAY,CAACE,OAAO,CAACQ,QAAQ,CAACP,EAAE,CAAC;IAChE,MAAMU,KAAK,GAAGD,WAAW,CAACH,KAAK;IAE/B,MAAMK,aAAa,GAAG,IAAIlB,aAAa,CAACY,MAAM,EAAEK,KAAK,EAAEH,QAAQ,CAAC;IAEhE,OAAOpB,MAAM,CAACyB,EAAE,CAACD,aAAa,CAAC;EACnC;AACJ;AAEA,OAAO,MAAMpB,uBAAuB,GAAGC,OAAO,CAACqB,oBAAoB,CAAC;EAChEC,cAAc,EAAEpB,2BAA2B;EAC3CqB,YAAY,EAAE,CAAC3B,eAAe,EAAEC,mBAAmB,EAAEC,0BAA0B;AACnF,CAAC,CAAC","ignoreList":[]}

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

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

@@ -0,0 +1 @@
+{"version":3,"names":["createAbstraction","GetWorkflowStateUseCase","GetWorkflowStateRepository"],"sources":["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"],"mappings":"AAAA,SAASA,iBAAiB,QAAQ,qBAAqB;;AASvD;AACA;AACA;;AAYA,OAAO,MAAMC,uBAAuB,GAChCD,iBAAiB,CAA2B,yBAAyB,CAAC;;AAQ1E;AACA;AACA;;AAYA,OAAO,MAAME,0BAA0B,GAAGF,iBAAiB,CACvD,4BACJ,CAAC","ignoreList":[]}

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

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

package/features/workflowState/GetWorkflowState/feature.js

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

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

@@ -0,0 +1 @@
+{"version":3,"names":["createFeature","GetWorkflowStateUseCase","GetWorkflowStateRepository","GetWorkflowStateFeature","name","register","container","inSingletonScope"],"sources":["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"],"mappings":"AAAA,SAASA,aAAa,QAAQ,qBAAqB;AACnD,SAASC,uBAAuB;AAChC,SAASC,0BAA0B;AAEnC,OAAO,MAAMC,uBAAuB,GAAGH,aAAa,CAAC;EACjDI,IAAI,EAAE,gCAAgC;EACtCC,QAAQA,CAACC,SAAS,EAAE;IAChBA,SAAS,CAACD,QAAQ,CAACH,0BAA0B,CAAC,CAACK,gBAAgB,CAAC,CAAC;IACjED,SAAS,CAACD,QAAQ,CAACJ,uBAAuB,CAAC;EAC/C;AACJ,CAAC,CAAC","ignoreList":[]}

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,3 @@
+export { GetWorkflowStateUseCase, GetWorkflowStateRepository } from "./abstractions.js";
+
+//# sourceMappingURL=index.js.map

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

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

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

@@ -0,0 +1,13 @@
+import { IdentityContext } from "@webiny/api-core/features/IdentityContext";
+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,41 @@
+import { Result } from "@webiny/feature/api";
+import { IdentityContext } from "@webiny/api-core/features/IdentityContext";
+import { ListWorkflowStatesUseCase } from "../ListWorkflowStates/index.js";
+import { ListOwnWorkflowStatesUseCase as UseCase } 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 empty result if no identity
+      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
+      }
+    });
+  }
+}
+export const ListOwnWorkflowStatesUseCase = UseCase.createImplementation({
+  implementation: ListOwnWorkflowStatesUseCaseImpl,
+  dependencies: [IdentityContext, ListWorkflowStatesUseCase]
+});
+
+//# sourceMappingURL=ListOwnWorkflowStatesUseCase.js.map

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

@@ -0,0 +1 @@
+{"version":3,"names":["Result","IdentityContext","ListWorkflowStatesUseCase","ListOwnWorkflowStatesUseCase","UseCase","ListOwnWorkflowStatesUseCaseImpl","constructor","identityContext","listWorkflowStates","execute","params","identity","getIdentity","isAnonymous","ok","items","meta","cursor","hasMoreItems","totalCount","where","values","isActive","createdBy","id","createImplementation","implementation","dependencies"],"sources":["ListOwnWorkflowStatesUseCase.ts"],"sourcesContent":["import { Result } from \"@webiny/feature/api\";\nimport { IdentityContext } from \"@webiny/api-core/features/IdentityContext\";\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"],"mappings":"AAAA,SAASA,MAAM,QAAQ,qBAAqB;AAC5C,SAASC,eAAe,QAAQ,2CAA2C;AAC3E,SAASC,yBAAyB;AAClC,SAASC,4BAA4B,IAAIC,OAAO;AAEhD,MAAMC,gCAAgC,CAA8B;EAChEC,WAAWA,CACCC,eAA0C,EAC1CC,kBAAuD,EACjE;IAAA,KAFUD,eAA0C,GAA1CA,eAA0C;IAAA,KAC1CC,kBAAuD,GAAvDA,kBAAuD;EAChE;EAEH,MAAMC,OAAOA,CAACC,MAAsB,GAAG,CAAC,CAAC,EAAkB;IACvD,MAAMC,QAAQ,GAAG,IAAI,CAACJ,eAAe,CAACK,WAAW,CAAC,CAAC;IACnD,IAAID,QAAQ,CAACE,WAAW,CAAC,CAAC,EAAE;MACxB;MACA,OAAOb,MAAM,CAACc,EAAE,CAAC;QACbC,KAAK,EAAE,EAAE;QACTC,IAAI,EAAE;UACFC,MAAM,EAAE,IAAI;UACZC,YAAY,EAAE,KAAK;UACnBC,UAAU,EAAE;QAChB;MACJ,CAAC,CAAC;IACN;IAEA,OAAO,IAAI,CAACX,kBAAkB,CAACC,OAAO,CAAC;MACnC,GAAGC,MAAM;MACTU,KAAK,EAAE;QACH,GAAGV,MAAM,EAAEU,KAAK;QAChBC,MAAM,EAAE;UACJ,GAAGX,MAAM,EAAEU,KAAK,EAAEC,MAAM;UACxBC,QAAQ,EAAE;QACd,CAAC;QACDC,SAAS,EAAEZ,QAAQ,CAACa;MACxB;IACJ,CAAC,CAAC;EACN;AACJ;AAEA,OAAO,MAAMrB,4BAA4B,GAAGC,OAAO,CAACqB,oBAAoB,CAAC;EACrEC,cAAc,EAAErB,gCAAgC;EAChDsB,YAAY,EAAE,CAAC1B,eAAe,EAAEC,yBAAyB;AAC7D,CAAC,CAAC","ignoreList":[]}

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,9 @@
+import { createAbstraction } from "@webiny/feature/api";
+
+/**
+ * ListOwnWorkflowStates use case interface - filters by current user
+ */
+
+export const ListOwnWorkflowStatesUseCase = createAbstraction("ListOwnWorkflowStatesUseCase");
+
+//# sourceMappingURL=abstractions.js.map

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

@@ -0,0 +1 @@
+{"version":3,"names":["createAbstraction","ListOwnWorkflowStatesUseCase"],"sources":["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"],"mappings":"AAAA,SAASA,iBAAiB,QAAQ,qBAAqB;;AAQvD;AACA;AACA;;AAaA,OAAO,MAAMC,4BAA4B,GAAGD,iBAAiB,CACzD,8BACJ,CAAC","ignoreList":[]}

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

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

package/features/workflowState/ListOwnWorkflowStates/feature.js

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

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

@@ -0,0 +1 @@
+{"version":3,"names":["createFeature","ListOwnWorkflowStatesUseCase","ListOwnWorkflowStatesFeature","name","register","container"],"sources":["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"],"mappings":"AAAA,SAASA,aAAa,QAAQ,qBAAqB;AACnD,SAASC,4BAA4B;AAErC,OAAO,MAAMC,4BAA4B,GAAGF,aAAa,CAAC;EACtDG,IAAI,EAAE,qCAAqC;EAC3CC,QAAQA,CAACC,SAAS,EAAE;IAChBA,SAAS,CAACD,QAAQ,CAACH,4BAA4B,CAAC;EACpD;AACJ,CAAC,CAAC","ignoreList":[]}

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

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

package/features/workflowState/ListOwnWorkflowStates/index.js

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

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

@@ -0,0 +1 @@
+{"version":3,"names":["ListOwnWorkflowStatesUseCase"],"sources":["index.ts"],"sourcesContent":["export { ListOwnWorkflowStatesUseCase } from \"./abstractions.js\";\n"],"mappings":"AAAA,SAASA,4BAA4B","ignoreList":[]}

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

@@ -0,0 +1,15 @@
+import { IdentityContext } from "@webiny/api-core/features/IdentityContext";
+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,49 @@
+import { Result } from "@webiny/feature/api";
+import { IdentityContext } from "@webiny/api-core/features/IdentityContext";
+import { GetUserTeamsUseCase } from "../../internal/GetUserTeams/index.js";
+import { ListWorkflowStatesUseCase } from "../ListWorkflowStates/index.js";
+import { ListRequestedWorkflowStatesUseCase as UseCase } 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() || teamsResult.value.length === 0 || !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)
+            }
+          }
+        }
+      }
+    });
+  }
+}
+export const ListRequestedWorkflowStatesUseCase = UseCase.createImplementation({
+  implementation: ListRequestedWorkflowStatesUseCaseImpl,
+  dependencies: [IdentityContext, GetUserTeamsUseCase, ListWorkflowStatesUseCase]
+});
+
+//# sourceMappingURL=ListRequestedWorkflowStatesUseCase.js.map