@webiny/api-workflows 0.0.0-unstable.81ae05e56b → 0.0.0-unstable.9609e4e0c9

package/features/settings/shared/WorkflowSettingsModelProvider.d.ts

@@ -0,0 +1,13 @@
+import type { CmsModel } from "@webiny/api-headless-cms/types/index.js";
+import { GetModelUseCase } from "@webiny/api-headless-cms/features/contentModel/GetModel/index.js";
+import { WorkflowSettingsModelProvider as Abstraction } from "../../../domain/settings/abstractions/WorkflowSettingsModelProvider.js";
+/** Same contract as `WorkflowModelProvider`: no memoization, no `withoutAuthorization`. */
+declare class WorkflowSettingsModelProviderImpl implements Abstraction.Interface {
+    private getModel;
+    constructor(getModel: GetModelUseCase.Interface);
+    get(): Promise<CmsModel>;
+}
+export declare const WorkflowSettingsModelProvider: typeof WorkflowSettingsModelProviderImpl & {
+    __abstraction: import("@webiny/di").Abstraction<import("~/domain/settings/abstractions/WorkflowSettingsModelProvider.js").IWorkflowSettingsModelProvider>;
+};
+export {};

package/features/settings/shared/WorkflowSettingsModelProvider.js

@@ -0,0 +1,22 @@
+import { GetModelUseCase } from "@webiny/api-headless-cms/features/contentModel/GetModel/index.js";
+import { WorkflowSettingsModelProvider } from "../../../domain/settings/abstractions/WorkflowSettingsModelProvider.js";
+import { WORKFLOW_SETTINGS_MODEL_ID } from "../../../constants.js";
+class WorkflowSettingsModelProviderImpl {
+    constructor(getModel){
+        this.getModel = getModel;
+    }
+    async get() {
+        const result = await this.getModel.execute(WORKFLOW_SETTINGS_MODEL_ID);
+        if (result.isFail()) throw result.error;
+        return result.value;
+    }
+}
+const WorkflowSettingsModelProvider_WorkflowSettingsModelProvider = WorkflowSettingsModelProvider.createImplementation({
+    implementation: WorkflowSettingsModelProviderImpl,
+    dependencies: [
+        GetModelUseCase
+    ]
+});
+export { WorkflowSettingsModelProvider_WorkflowSettingsModelProvider as WorkflowSettingsModelProvider };
+
+//# sourceMappingURL=WorkflowSettingsModelProvider.js.map

package/features/settings/shared/WorkflowSettingsModelProvider.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"features/settings/shared/WorkflowSettingsModelProvider.js","sources":["../../../../src/features/settings/shared/WorkflowSettingsModelProvider.ts"],"sourcesContent":["import type { CmsModel } from \"@webiny/api-headless-cms/types/index.js\";\nimport { GetModelUseCase } from \"@webiny/api-headless-cms/features/contentModel/GetModel/index.js\";\nimport { WorkflowSettingsModelProvider as Abstraction } from \"~/domain/settings/abstractions/WorkflowSettingsModelProvider.js\";\nimport { WORKFLOW_SETTINGS_MODEL_ID } from \"~/constants.js\";\n\n/** Same contract as `WorkflowModelProvider`: no memoization, no `withoutAuthorization`. */\nclass WorkflowSettingsModelProviderImpl implements Abstraction.Interface {\n    constructor(private getModel: GetModelUseCase.Interface) {}\n\n    async get(): Promise<CmsModel> {\n        const result = await this.getModel.execute(WORKFLOW_SETTINGS_MODEL_ID);\n        if (result.isFail()) {\n            throw result.error;\n        }\n        return result.value;\n    }\n}\n\nexport const WorkflowSettingsModelProvider = Abstraction.createImplementation({\n    implementation: WorkflowSettingsModelProviderImpl,\n    dependencies: [GetModelUseCase]\n});\n"],"names":["WorkflowSettingsModelProviderImpl","getModel","result","WORKFLOW_SETTINGS_MODEL_ID","WorkflowSettingsModelProvider","Abstraction","GetModelUseCase"],"mappings":";;;AAMA,MAAMA;IACF,YAAoBC,QAAmC,CAAE;aAArCA,QAAQ,GAARA;IAAsC;IAE1D,MAAM,MAAyB;QAC3B,MAAMC,SAAS,MAAM,IAAI,CAAC,QAAQ,CAAC,OAAO,CAACC;QAC3C,IAAID,OAAO,MAAM,IACb,MAAMA,OAAO,KAAK;QAEtB,OAAOA,OAAO,KAAK;IACvB;AACJ;AAEO,MAAME,8DAAgCC,8BAAAA,oBAAgC,CAAC;IAC1E,gBAAgBL;IAChB,cAAc;QAACM;KAAgB;AACnC"}

package/features/settings/shared/WorkflowSettingsRepository.d.ts

@@ -0,0 +1,21 @@
+import { Result } from "@webiny/feature/api";
+import { CreateEntryUseCase } from "@webiny/api-headless-cms/features/contentEntry/CreateEntry/index.js";
+import { UpdateEntryUseCase } from "@webiny/api-headless-cms/features/contentEntry/UpdateEntry/index.js";
+import { GetEntryByIdUseCase } from "@webiny/api-headless-cms/features/contentEntry/GetEntryById/index.js";
+import { WorkflowSettingsModelProvider } from "../../../domain/settings/abstractions/WorkflowSettingsModelProvider.js";
+import { WorkflowSettingsRepository as Abstraction } from "../../../domain/settings/abstractions/WorkflowSettingsRepository.js";
+import { WorkflowSettingsPersistenceError } from "../../../domain/settings/errors.js";
+import type { WorkflowSettings } from "../../../domain/settings/types.js";
+declare class WorkflowSettingsRepositoryImpl implements Abstraction.Interface {
+    private modelProvider;
+    private getEntryById;
+    private createEntry;
+    private updateEntry;
+    constructor(modelProvider: WorkflowSettingsModelProvider.Interface, getEntryById: GetEntryByIdUseCase.Interface, createEntry: CreateEntryUseCase.Interface, updateEntry: UpdateEntryUseCase.Interface);
+    get(): Promise<Result<WorkflowSettings, WorkflowSettingsPersistenceError>>;
+    save(settings: WorkflowSettings): Promise<Result<WorkflowSettings, WorkflowSettingsPersistenceError>>;
+}
+export declare const WorkflowSettingsRepository: typeof WorkflowSettingsRepositoryImpl & {
+    __abstraction: import("@webiny/di").Abstraction<import("~/domain/settings/abstractions/WorkflowSettingsRepository.js").IWorkflowSettingsRepository>;
+};
+export {};

package/features/settings/shared/WorkflowSettingsRepository.js

@@ -0,0 +1,65 @@
+import { Result } from "@webiny/feature/api";
+import { createIdentifier } from "@webiny/utils";
+import { CreateEntryUseCase } from "@webiny/api-headless-cms/features/contentEntry/CreateEntry/index.js";
+import { UpdateEntryUseCase } from "@webiny/api-headless-cms/features/contentEntry/UpdateEntry/index.js";
+import { GetEntryByIdUseCase } from "@webiny/api-headless-cms/features/contentEntry/GetEntryById/index.js";
+import { WorkflowSettingsModelProvider } from "../../../domain/settings/abstractions/WorkflowSettingsModelProvider.js";
+import { WorkflowSettingsRepository } from "../../../domain/settings/abstractions/WorkflowSettingsRepository.js";
+import { WorkflowSettingsPersistenceError } from "../../../domain/settings/errors.js";
+import { WORKFLOW_SETTINGS_ENTRY_ID } from "../../../constants.js";
+import { WorkflowSettingsEntryMapper } from "./WorkflowSettingsEntryMapper.js";
+const ENTRY_NOT_FOUND = "Cms/Entry/NotFound";
+const SETTINGS_REVISION_ID = createIdentifier({
+    id: WORKFLOW_SETTINGS_ENTRY_ID,
+    version: 1
+});
+class WorkflowSettingsRepositoryImpl {
+    constructor(modelProvider, getEntryById, createEntry, updateEntry){
+        this.modelProvider = modelProvider;
+        this.getEntryById = getEntryById;
+        this.createEntry = createEntry;
+        this.updateEntry = updateEntry;
+    }
+    async get() {
+        const model = await this.modelProvider.get();
+        const result = await this.getEntryById.execute(model, SETTINGS_REVISION_ID);
+        if (result.isFail()) {
+            if (result.error.code === ENTRY_NOT_FOUND) return Result.ok({
+                exclusions: []
+            });
+            return Result.fail(new WorkflowSettingsPersistenceError(result.error));
+        }
+        return Result.ok(WorkflowSettingsEntryMapper.fromEntry(result.value));
+    }
+    async save(settings) {
+        const model = await this.modelProvider.get();
+        const values = WorkflowSettingsEntryMapper.toValues(settings);
+        const existing = await this.getEntryById.execute(model, SETTINGS_REVISION_ID);
+        if (existing.isFail() && existing.error.code !== ENTRY_NOT_FOUND) return Result.fail(new WorkflowSettingsPersistenceError(existing.error));
+        if (existing.isOk()) {
+            const updated = await this.updateEntry.execute(model, SETTINGS_REVISION_ID, {
+                values
+            });
+            if (updated.isFail()) return Result.fail(new WorkflowSettingsPersistenceError(updated.error));
+            return Result.ok(WorkflowSettingsEntryMapper.fromEntry(updated.value));
+        }
+        const created = await this.createEntry.execute(model, {
+            id: WORKFLOW_SETTINGS_ENTRY_ID,
+            values
+        });
+        if (created.isFail()) return Result.fail(new WorkflowSettingsPersistenceError(created.error));
+        return Result.ok(WorkflowSettingsEntryMapper.fromEntry(created.value));
+    }
+}
+const WorkflowSettingsRepository_WorkflowSettingsRepository = WorkflowSettingsRepository.createImplementation({
+    implementation: WorkflowSettingsRepositoryImpl,
+    dependencies: [
+        WorkflowSettingsModelProvider,
+        GetEntryByIdUseCase,
+        CreateEntryUseCase,
+        UpdateEntryUseCase
+    ]
+});
+export { WorkflowSettingsRepository_WorkflowSettingsRepository as WorkflowSettingsRepository };
+
+//# sourceMappingURL=WorkflowSettingsRepository.js.map

package/features/settings/shared/WorkflowSettingsRepository.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"features/settings/shared/WorkflowSettingsRepository.js","sources":["../../../../src/features/settings/shared/WorkflowSettingsRepository.ts"],"sourcesContent":["import { Result } from \"@webiny/feature/api\";\nimport { createIdentifier } from \"@webiny/utils\";\nimport { CreateEntryUseCase } from \"@webiny/api-headless-cms/features/contentEntry/CreateEntry/index.js\";\nimport { UpdateEntryUseCase } from \"@webiny/api-headless-cms/features/contentEntry/UpdateEntry/index.js\";\nimport { GetEntryByIdUseCase } from \"@webiny/api-headless-cms/features/contentEntry/GetEntryById/index.js\";\nimport { WorkflowSettingsModelProvider } from \"~/domain/settings/abstractions/WorkflowSettingsModelProvider.js\";\nimport { WorkflowSettingsRepository as Abstraction } from \"~/domain/settings/abstractions/WorkflowSettingsRepository.js\";\nimport { WorkflowSettingsPersistenceError } from \"~/domain/settings/errors.js\";\nimport type { WorkflowSettings } from \"~/domain/settings/types.js\";\nimport { WORKFLOW_SETTINGS_ENTRY_ID } from \"~/constants.js\";\nimport {\n    WorkflowSettingsEntryMapper,\n    type WorkflowSettingsEntryValues\n} from \"./WorkflowSettingsEntryMapper.js\";\n\nconst ENTRY_NOT_FOUND = \"Cms/Entry/NotFound\";\nconst SETTINGS_REVISION_ID = createIdentifier({ id: WORKFLOW_SETTINGS_ENTRY_ID, version: 1 });\n\nclass WorkflowSettingsRepositoryImpl implements Abstraction.Interface {\n    constructor(\n        private modelProvider: WorkflowSettingsModelProvider.Interface,\n        private getEntryById: GetEntryByIdUseCase.Interface,\n        private createEntry: CreateEntryUseCase.Interface,\n        private updateEntry: UpdateEntryUseCase.Interface\n    ) {}\n\n    async get(): Promise<Result<WorkflowSettings, WorkflowSettingsPersistenceError>> {\n        const model = await this.modelProvider.get();\n        const result = await this.getEntryById.execute<WorkflowSettingsEntryValues>(\n            model,\n            SETTINGS_REVISION_ID\n        );\n        if (result.isFail()) {\n            if (result.error.code === ENTRY_NOT_FOUND) {\n                return Result.ok({ exclusions: [] });\n            }\n            return Result.fail(new WorkflowSettingsPersistenceError(result.error));\n        }\n        return Result.ok(WorkflowSettingsEntryMapper.fromEntry(result.value));\n    }\n\n    async save(\n        settings: WorkflowSettings\n    ): Promise<Result<WorkflowSettings, WorkflowSettingsPersistenceError>> {\n        const model = await this.modelProvider.get();\n        const values = WorkflowSettingsEntryMapper.toValues(settings);\n\n        const existing = await this.getEntryById.execute<WorkflowSettingsEntryValues>(\n            model,\n            SETTINGS_REVISION_ID\n        );\n        if (existing.isFail() && existing.error.code !== ENTRY_NOT_FOUND) {\n            return Result.fail(new WorkflowSettingsPersistenceError(existing.error));\n        }\n\n        if (existing.isOk()) {\n            const updated = await this.updateEntry.execute<WorkflowSettingsEntryValues>(\n                model,\n                SETTINGS_REVISION_ID,\n                { values }\n            );\n            if (updated.isFail()) {\n                return Result.fail(new WorkflowSettingsPersistenceError(updated.error));\n            }\n            return Result.ok(WorkflowSettingsEntryMapper.fromEntry(updated.value));\n        }\n\n        // Two concurrent first saves of a tenant can both reach this point; the second create fails\n        // with Persistence (duplicate id) instead of winning (D106). Accepted: settings are edited\n        // rarely, by editors, and a retry succeeds as an update.\n        const created = await this.createEntry.execute<WorkflowSettingsEntryValues>(model, {\n            id: WORKFLOW_SETTINGS_ENTRY_ID,\n            values\n        });\n        if (created.isFail()) {\n            return Result.fail(new WorkflowSettingsPersistenceError(created.error));\n        }\n        return Result.ok(WorkflowSettingsEntryMapper.fromEntry(created.value));\n    }\n}\n\nexport const WorkflowSettingsRepository = Abstraction.createImplementation({\n    implementation: WorkflowSettingsRepositoryImpl,\n    dependencies: [\n        WorkflowSettingsModelProvider,\n        GetEntryByIdUseCase,\n        CreateEntryUseCase,\n        UpdateEntryUseCase\n    ]\n});\n"],"names":["ENTRY_NOT_FOUND","SETTINGS_REVISION_ID","createIdentifier","WORKFLOW_SETTINGS_ENTRY_ID","WorkflowSettingsRepositoryImpl","modelProvider","getEntryById","createEntry","updateEntry","model","result","Result","WorkflowSettingsPersistenceError","WorkflowSettingsEntryMapper","settings","values","existing","updated","created","WorkflowSettingsRepository","Abstraction","WorkflowSettingsModelProvider","GetEntryByIdUseCase","CreateEntryUseCase","UpdateEntryUseCase"],"mappings":";;;;;;;;;;AAeA,MAAMA,kBAAkB;AACxB,MAAMC,uBAAuBC,iBAAiB;IAAE,IAAIC;IAA4B,SAAS;AAAE;AAE3F,MAAMC;IACF,YACYC,aAAsD,EACtDC,YAA2C,EAC3CC,WAAyC,EACzCC,WAAyC,CACnD;aAJUH,aAAa,GAAbA;aACAC,YAAY,GAAZA;aACAC,WAAW,GAAXA;aACAC,WAAW,GAAXA;IACT;IAEH,MAAM,MAA2E;QAC7E,MAAMC,QAAQ,MAAM,IAAI,CAAC,aAAa,CAAC,GAAG;QAC1C,MAAMC,SAAS,MAAM,IAAI,CAAC,YAAY,CAAC,OAAO,CAC1CD,OACAR;QAEJ,IAAIS,OAAO,MAAM,IAAI;YACjB,IAAIA,OAAO,KAAK,CAAC,IAAI,KAAKV,iBACtB,OAAOW,OAAO,EAAE,CAAC;gBAAE,YAAY,EAAE;YAAC;YAEtC,OAAOA,OAAO,IAAI,CAAC,IAAIC,iCAAiCF,OAAO,KAAK;QACxE;QACA,OAAOC,OAAO,EAAE,CAACE,4BAA4B,SAAS,CAACH,OAAO,KAAK;IACvE;IAEA,MAAM,KACFI,QAA0B,EACyC;QACnE,MAAML,QAAQ,MAAM,IAAI,CAAC,aAAa,CAAC,GAAG;QAC1C,MAAMM,SAASF,4BAA4B,QAAQ,CAACC;QAEpD,MAAME,WAAW,MAAM,IAAI,CAAC,YAAY,CAAC,OAAO,CAC5CP,OACAR;QAEJ,IAAIe,SAAS,MAAM,MAAMA,SAAS,KAAK,CAAC,IAAI,KAAKhB,iBAC7C,OAAOW,OAAO,IAAI,CAAC,IAAIC,iCAAiCI,SAAS,KAAK;QAG1E,IAAIA,SAAS,IAAI,IAAI;YACjB,MAAMC,UAAU,MAAM,IAAI,CAAC,WAAW,CAAC,OAAO,CAC1CR,OACAR,sBACA;gBAAEc;YAAO;YAEb,IAAIE,QAAQ,MAAM,IACd,OAAON,OAAO,IAAI,CAAC,IAAIC,iCAAiCK,QAAQ,KAAK;YAEzE,OAAON,OAAO,EAAE,CAACE,4BAA4B,SAAS,CAACI,QAAQ,KAAK;QACxE;QAKA,MAAMC,UAAU,MAAM,IAAI,CAAC,WAAW,CAAC,OAAO,CAA8BT,OAAO;YAC/E,IAAIN;YACJY;QACJ;QACA,IAAIG,QAAQ,MAAM,IACd,OAAOP,OAAO,IAAI,CAAC,IAAIC,iCAAiCM,QAAQ,KAAK;QAEzE,OAAOP,OAAO,EAAE,CAACE,4BAA4B,SAAS,CAACK,QAAQ,KAAK;IACxE;AACJ;AAEO,MAAMC,wDAA6BC,2BAAAA,oBAAgC,CAAC;IACvE,gBAAgBhB;IAChB,cAAc;QACViB;QACAC;QACAC;QACAC;KACH;AACL"}

package/features/settings/shared/feature.d.ts

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

package/features/settings/shared/feature.js

@@ -0,0 +1,13 @@
+import { createFeature } from "@webiny/feature/api";
+import { WorkflowSettingsModelProvider } from "./WorkflowSettingsModelProvider.js";
+import { WorkflowSettingsRepository } from "./WorkflowSettingsRepository.js";
+const WorkflowSettingsSharedFeature = createFeature({
+    name: "Workflows/WorkflowSettingsShared",
+    register (container) {
+        container.register(WorkflowSettingsModelProvider);
+        container.register(WorkflowSettingsRepository).inSingletonScope();
+    }
+});
+export { WorkflowSettingsSharedFeature };
+
+//# sourceMappingURL=feature.js.map

package/features/settings/shared/feature.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"features/settings/shared/feature.js","sources":["../../../../src/features/settings/shared/feature.ts"],"sourcesContent":["import { createFeature } from \"@webiny/feature/api\";\nimport { WorkflowSettingsModelProvider } from \"./WorkflowSettingsModelProvider.js\";\nimport { WorkflowSettingsRepository } from \"./WorkflowSettingsRepository.js\";\n\nexport const WorkflowSettingsSharedFeature = createFeature({\n    name: \"Workflows/WorkflowSettingsShared\",\n    register(container) {\n        container.register(WorkflowSettingsModelProvider);\n        container.register(WorkflowSettingsRepository).inSingletonScope();\n    }\n});\n"],"names":["WorkflowSettingsSharedFeature","createFeature","container","WorkflowSettingsModelProvider","WorkflowSettingsRepository"],"mappings":";;;AAIO,MAAMA,gCAAgCC,cAAc;IACvD,MAAM;IACN,UAASC,SAAS;QACdA,UAAU,QAAQ,CAACC;QACnBD,UAAU,QAAQ,CAACE,4BAA4B,gBAAgB;IACnE;AACJ"}

package/features/shared/ActorEntryMapper.d.ts

@@ -0,0 +1,13 @@
+import type { Actor } from "../../domain/review/types.js";
+/** How an `Actor` is stored in an object field of a private model. */
+export interface ActorEntryValues {
+    type: string;
+    id: string;
+    displayName: string;
+    identityType: string | null;
+}
+/** Maps actors to and from object fields; used by the review and assignment-log mappers. */
+export declare class ActorEntryMapper {
+    static toEntry(actor: Actor): ActorEntryValues;
+    static fromEntry(value: ActorEntryValues | null | undefined): Actor | null;
+}

package/features/shared/ActorEntryMapper.js

@@ -0,0 +1,24 @@
+class ActorEntryMapper {
+    static toEntry(actor) {
+        return {
+            type: actor.type,
+            id: actor.id,
+            displayName: actor.displayName,
+            identityType: actor.identityType ?? null
+        };
+    }
+    static fromEntry(value) {
+        if (!value?.id) return null;
+        return {
+            type: value.type,
+            id: value.id,
+            displayName: value.displayName ?? "",
+            ...value.identityType ? {
+                identityType: value.identityType
+            } : {}
+        };
+    }
+}
+export { ActorEntryMapper };
+
+//# sourceMappingURL=ActorEntryMapper.js.map

package/features/shared/ActorEntryMapper.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"features/shared/ActorEntryMapper.js","sources":["../../../src/features/shared/ActorEntryMapper.ts"],"sourcesContent":["import type { Actor, ActorType } from \"~/domain/review/types.js\";\n\n/** How an `Actor` is stored in an object field of a private model. */\nexport interface ActorEntryValues {\n    type: string;\n    id: string;\n    displayName: string;\n    identityType: string | null;\n}\n\n/** Maps actors to and from object fields; used by the review and assignment-log mappers. */\nexport class ActorEntryMapper {\n    public static toEntry(actor: Actor): ActorEntryValues {\n        return {\n            type: actor.type,\n            id: actor.id,\n            displayName: actor.displayName,\n            identityType: actor.identityType ?? null\n        };\n    }\n\n    public static fromEntry(value: ActorEntryValues | null | undefined): Actor | null {\n        if (!value?.id) {\n            return null;\n        }\n        return {\n            type: value.type as ActorType,\n            id: value.id,\n            displayName: value.displayName ?? \"\",\n            ...(value.identityType ? { identityType: value.identityType } : {})\n        };\n    }\n}\n"],"names":["ActorEntryMapper","actor","value"],"mappings":"AAWO,MAAMA;IACT,OAAc,QAAQC,KAAY,EAAoB;QAClD,OAAO;YACH,MAAMA,MAAM,IAAI;YAChB,IAAIA,MAAM,EAAE;YACZ,aAAaA,MAAM,WAAW;YAC9B,cAAcA,MAAM,YAAY,IAAI;QACxC;IACJ;IAEA,OAAc,UAAUC,KAA0C,EAAgB;QAC9E,IAAI,CAACA,OAAO,IACR,OAAO;QAEX,OAAO;YACH,MAAMA,MAAM,IAAI;YAChB,IAAIA,MAAM,EAAE;YACZ,aAAaA,MAAM,WAAW,IAAI;YAClC,GAAIA,MAAM,YAAY,GAAG;gBAAE,cAAcA,MAAM,YAAY;YAAC,IAAI,CAAC,CAAC;QACtE;IACJ;AACJ"}

package/features/shared/toIsoString.d.ts

@@ -0,0 +1,2 @@
+/** CMS returns `datetime` values as `Date` when read from storage and as strings on write. */
+export declare const toIsoString: (value: unknown) => string | null;

package/features/shared/toIsoString.js

@@ -0,0 +1,8 @@
+const toIsoString = (value)=>{
+    if (value instanceof Date) return value.toISOString();
+    if ("string" == typeof value && value.length > 0) return value;
+    return null;
+};
+export { toIsoString };
+
+//# sourceMappingURL=toIsoString.js.map

package/features/shared/toIsoString.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"features/shared/toIsoString.js","sources":["../../../src/features/shared/toIsoString.ts"],"sourcesContent":["/** CMS returns `datetime` values as `Date` when read from storage and as strings on write. */\nexport const toIsoString = (value: unknown): string | null => {\n    if (value instanceof Date) {\n        return value.toISOString();\n    }\n    if (typeof value === \"string\" && value.length > 0) {\n        return value;\n    }\n    return null;\n};\n"],"names":["toIsoString","value","Date"],"mappings":"AACO,MAAMA,cAAc,CAACC;IACxB,IAAIA,iBAAiBC,MACjB,OAAOD,MAAM,WAAW;IAE5B,IAAI,AAAiB,YAAjB,OAAOA,SAAsBA,MAAM,MAAM,GAAG,GAC5C,OAAOA;IAEX,OAAO;AACX"}

package/features/stepRun/AutomationStepRunner/AutomationStepRunner.d.ts

@@ -0,0 +1,27 @@
+import { Logger } from "@webiny/api-core/features/logger/index.js";
+import type { Actor, ReviewStep } from "../../../domain/review/types.js";
+import { AutomationDefinitionRegistryService } from "../../../features/automation/AutomationDefinitionRegistryService/index.js";
+import { WorkflowBypassService } from "../../../features/bypass/WorkflowBypassService/index.js";
+import { StepRunner } from "../../../features/stepRun/StepRunner/abstractions.js";
+/**
+ * Runs an automation step (spec 7.4, R142): the logic the phase 5 handler held, moved here
+ * unchanged (R168). Looks up and validates everything from the review snapshot (A53, R148),
+ * then runs the developer's definition inside the bypass and only there (D36, R150). It ignores
+ * `signal` (R175) and is never `singleRun`: an automation may continue (R135).
+ */
+declare class AutomationStepRunnerImpl implements StepRunner.Interface {
+    private definitions;
+    private bypass;
+    private logger;
+    readonly type = "automation";
+    readonly singleRun = false;
+    readonly failureReasons: StepRunner.FailureReasons;
+    constructor(definitions: AutomationDefinitionRegistryService.Interface, bypass: WorkflowBypassService.Interface, logger: Logger.Interface);
+    maxIterationsReason(step: ReviewStep): string;
+    getActor(requester: Actor): Actor;
+    run({ review, step, task, iteration, state }: StepRunner.Params): Promise<StepRunner.Outcome>;
+}
+export declare const AutomationStepRunner: typeof AutomationStepRunnerImpl & {
+    __abstraction: import("@webiny/di").Abstraction<import("~/features/stepRun/StepRunner/abstractions.js").IStepRunner>;
+};
+export {};

package/features/stepRun/AutomationStepRunner/AutomationStepRunner.js

@@ -0,0 +1,96 @@
+import { Logger } from "@webiny/api-core/features/logger/index.js";
+import { automationStepConfigSchema } from "../../../domain/automation/automationStepConfigSchema.js";
+import { getAutomationActor } from "../../../domain/automation/getAutomationActor.js";
+import { matchesAutomationScope } from "../../../domain/automation/matchesAutomationScope.js";
+import { parseAutomationSettings } from "../../../domain/automation/parseAutomationSettings.js";
+import { REJECT_COMMENT_MIN_LENGTH } from "../../../domain/review/Review.js";
+import { AUTOMATION_STEP_TYPE } from "../../../domain/workflow/stepTypes.js";
+import { AutomationDefinitionRegistryService } from "../../automation/AutomationDefinitionRegistryService/index.js";
+import { WorkflowBypassService } from "../../bypass/WorkflowBypassService/index.js";
+import { DEFAULT_AUTOMATION_MAX_ITERATIONS } from "../constants.js";
+import { StepRunFailure } from "../StepRunFailure.js";
+import { StepRunner } from "../StepRunner/abstractions.js";
+class AutomationStepRunnerImpl {
+    constructor(definitions, bypass, logger){
+        this.definitions = definitions;
+        this.bypass = bypass;
+        this.logger = logger;
+        this.type = AUTOMATION_STEP_TYPE;
+        this.singleRun = false;
+        this.failureReasons = {
+            error: "The automation failed.",
+            aborted: "The automation was aborted.",
+            stuck: "The automation task ended without a result."
+        };
+    }
+    maxIterationsReason(step) {
+        const config = automationStepConfigSchema.safeParse(step.config);
+        const own = config.success ? this.definitions.get(config.data.automationId) : null;
+        const maxIterations = own?.maxIterations ?? DEFAULT_AUTOMATION_MAX_ITERATIONS;
+        return `The automation did not finish in ${maxIterations} iterations.`;
+    }
+    getActor(requester) {
+        return getAutomationActor(requester);
+    }
+    async run({ review, step, task, iteration, state }) {
+        const config = automationStepConfigSchema.safeParse(step.config);
+        if (!config.success) throw new StepRunFailure("The automation step configuration is not valid.");
+        const automationId = config.data.automationId;
+        const definition = this.definitions.get(automationId);
+        if (!definition) throw new StepRunFailure(`The automation "${automationId}" is not available.`);
+        if (!matchesAutomationScope(definition.models, review.workflow.models)) throw new StepRunFailure(`The automation "${automationId}" is not available for this workflow's models.`);
+        const maxIterations = definition.maxIterations ?? DEFAULT_AUTOMATION_MAX_ITERATIONS;
+        if (iteration > maxIterations) throw new StepRunFailure(`The automation did not finish in ${maxIterations} iterations.`);
+        const settings = parseAutomationSettings(definition.settingsSchema, config.data.settings);
+        if (settings.isFail()) throw new StepRunFailure(`The automation settings are not valid: ${settings.error}.`);
+        let outcome;
+        try {
+            outcome = await this.bypass.run(()=>definition.run({
+                    settings: settings.value,
+                    review,
+                    step,
+                    iteration,
+                    state
+                }));
+        } catch (error) {
+            this.logger.error({
+                err: error,
+                taskId: task.id,
+                reviewId: review.id,
+                stepId: step.id
+            }, "The automation threw.");
+            throw new StepRunFailure("The automation failed.");
+        }
+        switch(outcome.type){
+            case "approved":
+                return {
+                    type: "approved",
+                    comment: outcome.comment
+                };
+            case "rejected":
+                {
+                    const comment = (outcome.comment ?? "").trim();
+                    if (comment.length < REJECT_COMMENT_MIN_LENGTH) throw new StepRunFailure("The automation rejected without a comment.");
+                    return {
+                        type: "rejected",
+                        comment
+                    };
+                }
+            case "continue":
+                return outcome;
+            default:
+                throw new StepRunFailure("The automation failed: It returned an unknown outcome.");
+        }
+    }
+}
+const AutomationStepRunner = StepRunner.createImplementation({
+    implementation: AutomationStepRunnerImpl,
+    dependencies: [
+        AutomationDefinitionRegistryService,
+        WorkflowBypassService,
+        Logger
+    ]
+});
+export { AutomationStepRunner };
+
+//# sourceMappingURL=AutomationStepRunner.js.map

package/features/stepRun/AutomationStepRunner/AutomationStepRunner.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"features/stepRun/AutomationStepRunner/AutomationStepRunner.js","sources":["../../../../src/features/stepRun/AutomationStepRunner/AutomationStepRunner.ts"],"sourcesContent":["import { Logger } from \"@webiny/api-core/features/logger/index.js\";\nimport { automationStepConfigSchema } from \"~/domain/automation/automationStepConfigSchema.js\";\nimport { getAutomationActor } from \"~/domain/automation/getAutomationActor.js\";\nimport { matchesAutomationScope } from \"~/domain/automation/matchesAutomationScope.js\";\nimport { parseAutomationSettings } from \"~/domain/automation/parseAutomationSettings.js\";\nimport { REJECT_COMMENT_MIN_LENGTH } from \"~/domain/review/Review.js\";\nimport type { Actor, ReviewStep } from \"~/domain/review/types.js\";\nimport { AUTOMATION_STEP_TYPE } from \"~/domain/workflow/stepTypes.js\";\nimport type { AutomationDefinition } from \"~/features/automation/AutomationDefinition/index.js\";\nimport { AutomationDefinitionRegistryService } from \"~/features/automation/AutomationDefinitionRegistryService/index.js\";\nimport { WorkflowBypassService } from \"~/features/bypass/WorkflowBypassService/index.js\";\nimport { DEFAULT_AUTOMATION_MAX_ITERATIONS } from \"~/features/stepRun/constants.js\";\nimport { StepRunFailure } from \"~/features/stepRun/StepRunFailure.js\";\nimport { StepRunner } from \"~/features/stepRun/StepRunner/abstractions.js\";\n\n/**\n * Runs an automation step (spec 7.4, R142): the logic the phase 5 handler held, moved here\n * unchanged (R168). Looks up and validates everything from the review snapshot (A53, R148),\n * then runs the developer's definition inside the bypass and only there (D36, R150). It ignores\n * `signal` (R175) and is never `singleRun`: an automation may continue (R135).\n */\nclass AutomationStepRunnerImpl implements StepRunner.Interface {\n    public readonly type = AUTOMATION_STEP_TYPE;\n    public readonly singleRun = false;\n    public readonly failureReasons: StepRunner.FailureReasons = {\n        error: \"The automation failed.\",\n        aborted: \"The automation was aborted.\",\n        stuck: \"The automation task ended without a result.\"\n    };\n\n    public constructor(\n        private definitions: AutomationDefinitionRegistryService.Interface,\n        private bypass: WorkflowBypassService.Interface,\n        private logger: Logger.Interface\n    ) {}\n\n    public maxIterationsReason(step: ReviewStep): string {\n        // The reason names the automation's own limit from the review snapshot, never the\n        // 10000 ceiling of the task definition (R145, P4).\n        const config = automationStepConfigSchema.safeParse(step.config);\n        const own = config.success ? this.definitions.get(config.data.automationId) : null;\n        const maxIterations = own?.maxIterations ?? DEFAULT_AUTOMATION_MAX_ITERATIONS;\n        return `The automation did not finish in ${maxIterations} iterations.`;\n    }\n\n    public getActor(requester: Actor): Actor {\n        return getAutomationActor(requester);\n    }\n\n    public async run({\n        review,\n        step,\n        task,\n        iteration,\n        state\n    }: StepRunner.Params): Promise<StepRunner.Outcome> {\n        const config = automationStepConfigSchema.safeParse(step.config);\n        if (!config.success) {\n            throw new StepRunFailure(\"The automation step configuration is not valid.\");\n        }\n        const automationId = config.data.automationId;\n        const definition = this.definitions.get(automationId);\n        if (!definition) {\n            throw new StepRunFailure(`The automation \"${automationId}\" is not available.`);\n        }\n        // Checked again on every run, like on reach (R148): a definition narrowed by a deploy no\n        // longer runs for the workflow's models.\n        if (!matchesAutomationScope(definition.models, review.workflow.models)) {\n            throw new StepRunFailure(\n                `The automation \"${automationId}\" is not available for this workflow's models.`\n            );\n        }\n        const maxIterations = definition.maxIterations ?? DEFAULT_AUTOMATION_MAX_ITERATIONS;\n        if (iteration > maxIterations) {\n            throw new StepRunFailure(\n                `The automation did not finish in ${maxIterations} iterations.`\n            );\n        }\n        const settings = parseAutomationSettings(definition.settingsSchema, config.data.settings);\n        if (settings.isFail()) {\n            throw new StepRunFailure(`The automation settings are not valid: ${settings.error}.`);\n        }\n\n        // Run inside the bypass, and only there (D36, R150).\n        let outcome: AutomationDefinition.Outcome;\n        try {\n            outcome = await this.bypass.run(() =>\n                definition.run({\n                    settings: settings.value,\n                    review,\n                    step,\n                    iteration,\n                    state\n                })\n            );\n        } catch (error) {\n            // The raw message can carry internals: logged, never stored (R146).\n            this.logger.error(\n                { err: error, taskId: task.id, reviewId: review.id, stepId: step.id },\n                \"The automation threw.\"\n            );\n            throw new StepRunFailure(\"The automation failed.\");\n        }\n\n        switch (outcome.type) {\n            case \"approved\":\n                return { type: \"approved\", comment: outcome.comment };\n            case \"rejected\": {\n                const comment = (outcome.comment ?? \"\").trim();\n                if (comment.length < REJECT_COMMENT_MIN_LENGTH) {\n                    throw new StepRunFailure(\"The automation rejected without a comment.\");\n                }\n                return { type: \"rejected\", comment };\n            }\n            case \"continue\":\n                return outcome;\n            default:\n                throw new StepRunFailure(\"The automation failed: It returned an unknown outcome.\");\n        }\n    }\n}\n\nexport const AutomationStepRunner = StepRunner.createImplementation({\n    implementation: AutomationStepRunnerImpl,\n    dependencies: [AutomationDefinitionRegistryService, WorkflowBypassService, Logger]\n});\n"],"names":["AutomationStepRunnerImpl","definitions","bypass","logger","AUTOMATION_STEP_TYPE","step","config","automationStepConfigSchema","own","maxIterations","DEFAULT_AUTOMATION_MAX_ITERATIONS","requester","getAutomationActor","review","task","iteration","state","StepRunFailure","automationId","definition","matchesAutomationScope","settings","parseAutomationSettings","outcome","error","comment","REJECT_COMMENT_MIN_LENGTH","AutomationStepRunner","StepRunner","AutomationDefinitionRegistryService","WorkflowBypassService","Logger"],"mappings":";;;;;;;;;;;;AAqBA,MAAMA;IASF,YACYC,WAA0D,EAC1DC,MAAuC,EACvCC,MAAwB,CAClC;aAHUF,WAAW,GAAXA;aACAC,MAAM,GAANA;aACAC,MAAM,GAANA;aAXI,IAAI,GAAGC;aACP,SAAS,GAAG;aACZ,cAAc,GAA8B;YACxD,OAAO;YACP,SAAS;YACT,OAAO;QACX;IAMG;IAEI,oBAAoBC,IAAgB,EAAU;QAGjD,MAAMC,SAASC,2BAA2B,SAAS,CAACF,KAAK,MAAM;QAC/D,MAAMG,MAAMF,OAAO,OAAO,GAAG,IAAI,CAAC,WAAW,CAAC,GAAG,CAACA,OAAO,IAAI,CAAC,YAAY,IAAI;QAC9E,MAAMG,gBAAgBD,KAAK,iBAAiBE;QAC5C,OAAO,CAAC,iCAAiC,EAAED,cAAc,YAAY,CAAC;IAC1E;IAEO,SAASE,SAAgB,EAAS;QACrC,OAAOC,mBAAmBD;IAC9B;IAEA,MAAa,IAAI,EACbE,MAAM,EACNR,IAAI,EACJS,IAAI,EACJC,SAAS,EACTC,KAAK,EACW,EAA+B;QAC/C,MAAMV,SAASC,2BAA2B,SAAS,CAACF,KAAK,MAAM;QAC/D,IAAI,CAACC,OAAO,OAAO,EACf,MAAM,IAAIW,eAAe;QAE7B,MAAMC,eAAeZ,OAAO,IAAI,CAAC,YAAY;QAC7C,MAAMa,aAAa,IAAI,CAAC,WAAW,CAAC,GAAG,CAACD;QACxC,IAAI,CAACC,YACD,MAAM,IAAIF,eAAe,CAAC,gBAAgB,EAAEC,aAAa,mBAAmB,CAAC;QAIjF,IAAI,CAACE,uBAAuBD,WAAW,MAAM,EAAEN,OAAO,QAAQ,CAAC,MAAM,GACjE,MAAM,IAAII,eACN,CAAC,gBAAgB,EAAEC,aAAa,8CAA8C,CAAC;QAGvF,MAAMT,gBAAgBU,WAAW,aAAa,IAAIT;QAClD,IAAIK,YAAYN,eACZ,MAAM,IAAIQ,eACN,CAAC,iCAAiC,EAAER,cAAc,YAAY,CAAC;QAGvE,MAAMY,WAAWC,wBAAwBH,WAAW,cAAc,EAAEb,OAAO,IAAI,CAAC,QAAQ;QACxF,IAAIe,SAAS,MAAM,IACf,MAAM,IAAIJ,eAAe,CAAC,uCAAuC,EAAEI,SAAS,KAAK,CAAC,CAAC,CAAC;QAIxF,IAAIE;QACJ,IAAI;YACAA,UAAU,MAAM,IAAI,CAAC,MAAM,CAAC,GAAG,CAAC,IAC5BJ,WAAW,GAAG,CAAC;oBACX,UAAUE,SAAS,KAAK;oBACxBR;oBACAR;oBACAU;oBACAC;gBACJ;QAER,EAAE,OAAOQ,OAAO;YAEZ,IAAI,CAAC,MAAM,CAAC,KAAK,CACb;gBAAE,KAAKA;gBAAO,QAAQV,KAAK,EAAE;gBAAE,UAAUD,OAAO,EAAE;gBAAE,QAAQR,KAAK,EAAE;YAAC,GACpE;YAEJ,MAAM,IAAIY,eAAe;QAC7B;QAEA,OAAQM,QAAQ,IAAI;YAChB,KAAK;gBACD,OAAO;oBAAE,MAAM;oBAAY,SAASA,QAAQ,OAAO;gBAAC;YACxD,KAAK;gBAAY;oBACb,MAAME,UAAWF,AAAAA,CAAAA,QAAQ,OAAO,IAAI,EAAC,EAAG,IAAI;oBAC5C,IAAIE,QAAQ,MAAM,GAAGC,2BACjB,MAAM,IAAIT,eAAe;oBAE7B,OAAO;wBAAE,MAAM;wBAAYQ;oBAAQ;gBACvC;YACA,KAAK;gBACD,OAAOF;YACX;gBACI,MAAM,IAAIN,eAAe;QACjC;IACJ;AACJ;AAEO,MAAMU,uBAAuBC,WAAW,oBAAoB,CAAC;IAChE,gBAAgB5B;IAChB,cAAc;QAAC6B;QAAqCC;QAAuBC;KAAO;AACtF"}

package/features/stepRun/AutomationStepRunner/feature.d.ts

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

package/features/stepRun/AutomationStepRunner/feature.js

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

package/features/stepRun/AutomationStepRunner/feature.js.map

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

package/features/stepRun/GetReviewStepRun/GetReviewStepRunUseCase.d.ts

@@ -0,0 +1,13 @@
+import { GetTaskUseCase } from "@webiny/background-tasks/api/features/GetTask/index.js";
+import { ReviewRepository } from "../../../domain/review/abstractions/ReviewRepository.js";
+import { GetReviewStepRunUseCase as UseCase } from "./abstractions.js";
+declare class GetReviewStepRunUseCaseImpl implements UseCase.Interface {
+    private repository;
+    private getTask;
+    constructor(repository: ReviewRepository.Interface, getTask: GetTaskUseCase.Interface);
+    execute(input: UseCase.Input): UseCase.Return;
+}
+export declare const GetReviewStepRunUseCase: typeof GetReviewStepRunUseCaseImpl & {
+    __abstraction: import("@webiny/di").Abstraction<import("./abstractions.js").IGetReviewStepRunUseCase>;
+};
+export {};

package/features/stepRun/GetReviewStepRun/GetReviewStepRunUseCase.js

@@ -0,0 +1,46 @@
+import { Result } from "@webiny/feature/api";
+import { GetTaskUseCase } from "@webiny/background-tasks/api/features/GetTask/index.js";
+import { TaskNotFoundError } from "@webiny/background-tasks/api/domain/errors.js";
+import { ReviewRepository } from "../../../domain/review/abstractions/ReviewRepository.js";
+import { ReviewPersistenceError, ReviewStepRunNotFoundError } from "../../../domain/review/errors.js";
+import { GetReviewStepRunUseCase } from "./abstractions.js";
+import { toReviewStepRunInfo } from "./toReviewStepRunInfo.js";
+class GetReviewStepRunUseCaseImpl {
+    constructor(repository, getTask){
+        this.repository = repository;
+        this.getTask = getTask;
+    }
+    async execute(input) {
+        const loaded = await this.repository.get(input.reviewId);
+        if (loaded.isFail()) return Result.fail(loaded.error);
+        const step = loaded.value.steps.find((item)=>item.id === input.stepId);
+        const isCurrent = step?.taskId === input.taskId;
+        const isEarlier = step?.runs.some((run)=>run.taskId === input.taskId);
+        if (!step || !(isCurrent || isEarlier)) return Result.fail(new ReviewStepRunNotFoundError({
+            reviewId: input.reviewId,
+            stepId: input.stepId,
+            taskId: input.taskId
+        }));
+        const task = await this.getTask.execute(input.taskId);
+        if (task.isFail()) {
+            if (task.error instanceof TaskNotFoundError) return Result.ok(null);
+            return Result.fail(new ReviewPersistenceError(task.error));
+        }
+        const info = toReviewStepRunInfo({
+            step,
+            taskId: input.taskId,
+            task: task.value
+        });
+        return Result.ok(info);
+    }
+}
+const GetReviewStepRunUseCase_GetReviewStepRunUseCase = GetReviewStepRunUseCase.createImplementation({
+    implementation: GetReviewStepRunUseCaseImpl,
+    dependencies: [
+        ReviewRepository,
+        GetTaskUseCase
+    ]
+});
+export { GetReviewStepRunUseCase_GetReviewStepRunUseCase as GetReviewStepRunUseCase };
+
+//# sourceMappingURL=GetReviewStepRunUseCase.js.map

package/features/stepRun/GetReviewStepRun/GetReviewStepRunUseCase.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"features/stepRun/GetReviewStepRun/GetReviewStepRunUseCase.js","sources":["../../../../src/features/stepRun/GetReviewStepRun/GetReviewStepRunUseCase.ts"],"sourcesContent":["import { Result } from \"@webiny/feature/api\";\nimport { GetTaskUseCase } from \"@webiny/background-tasks/api/features/GetTask/index.js\";\nimport { TaskNotFoundError } from \"@webiny/background-tasks/api/domain/errors.js\";\nimport { ReviewRepository } from \"~/domain/review/abstractions/ReviewRepository.js\";\nimport { ReviewPersistenceError, ReviewStepRunNotFoundError } from \"~/domain/review/errors.js\";\nimport { GetReviewStepRunUseCase as UseCase } from \"./abstractions.js\";\nimport { toReviewStepRunInfo } from \"./toReviewStepRunInfo.js\";\n\nclass GetReviewStepRunUseCaseImpl implements UseCase.Interface {\n    constructor(\n        private repository: ReviewRepository.Interface,\n        private getTask: GetTaskUseCase.Interface\n    ) {}\n\n    async execute(input: UseCase.Input): UseCase.Return {\n        const loaded = await this.repository.get(input.reviewId);\n        if (loaded.isFail()) {\n            return Result.fail(loaded.error);\n        }\n\n        // Only the step's own task ids are read: its current task or one of its earlier runs.\n        // Any other id, another step's or another review's, is refused before the task is read.\n        const step = loaded.value.steps.find(item => item.id === input.stepId);\n        const isCurrent = step?.taskId === input.taskId;\n        const isEarlier = step?.runs.some(run => run.taskId === input.taskId);\n        if (!step || !(isCurrent || isEarlier)) {\n            return Result.fail(\n                new ReviewStepRunNotFoundError({\n                    reviewId: input.reviewId,\n                    stepId: input.stepId,\n                    taskId: input.taskId\n                })\n            );\n        }\n\n        const task = await this.getTask.execute(input.taskId);\n        if (task.isFail()) {\n            if (task.error instanceof TaskNotFoundError) {\n                return Result.ok(null);\n            }\n            return Result.fail(new ReviewPersistenceError(task.error));\n        }\n\n        const info = toReviewStepRunInfo({ step, taskId: input.taskId, task: task.value });\n        return Result.ok(info);\n    }\n}\n\nexport const GetReviewStepRunUseCase = UseCase.createImplementation({\n    implementation: GetReviewStepRunUseCaseImpl,\n    dependencies: [ReviewRepository, GetTaskUseCase]\n});\n"],"names":["GetReviewStepRunUseCaseImpl","repository","getTask","input","loaded","Result","step","item","isCurrent","isEarlier","run","ReviewStepRunNotFoundError","task","TaskNotFoundError","ReviewPersistenceError","info","toReviewStepRunInfo","GetReviewStepRunUseCase","UseCase","ReviewRepository","GetTaskUseCase"],"mappings":";;;;;;;AAQA,MAAMA;IACF,YACYC,UAAsC,EACtCC,OAAiC,CAC3C;aAFUD,UAAU,GAAVA;aACAC,OAAO,GAAPA;IACT;IAEH,MAAM,QAAQC,KAAoB,EAAkB;QAChD,MAAMC,SAAS,MAAM,IAAI,CAAC,UAAU,CAAC,GAAG,CAACD,MAAM,QAAQ;QACvD,IAAIC,OAAO,MAAM,IACb,OAAOC,OAAO,IAAI,CAACD,OAAO,KAAK;QAKnC,MAAME,OAAOF,OAAO,KAAK,CAAC,KAAK,CAAC,IAAI,CAACG,CAAAA,OAAQA,KAAK,EAAE,KAAKJ,MAAM,MAAM;QACrE,MAAMK,YAAYF,MAAM,WAAWH,MAAM,MAAM;QAC/C,MAAMM,YAAYH,MAAM,KAAK,KAAKI,CAAAA,MAAOA,IAAI,MAAM,KAAKP,MAAM,MAAM;QACpE,IAAI,CAACG,QAAQ,CAAEE,CAAAA,aAAaC,SAAQ,GAChC,OAAOJ,OAAO,IAAI,CACd,IAAIM,2BAA2B;YAC3B,UAAUR,MAAM,QAAQ;YACxB,QAAQA,MAAM,MAAM;YACpB,QAAQA,MAAM,MAAM;QACxB;QAIR,MAAMS,OAAO,MAAM,IAAI,CAAC,OAAO,CAAC,OAAO,CAACT,MAAM,MAAM;QACpD,IAAIS,KAAK,MAAM,IAAI;YACf,IAAIA,KAAK,KAAK,YAAYC,mBACtB,OAAOR,OAAO,EAAE,CAAC;YAErB,OAAOA,OAAO,IAAI,CAAC,IAAIS,uBAAuBF,KAAK,KAAK;QAC5D;QAEA,MAAMG,OAAOC,oBAAoB;YAAEV;YAAM,QAAQH,MAAM,MAAM;YAAE,MAAMS,KAAK,KAAK;QAAC;QAChF,OAAOP,OAAO,EAAE,CAACU;IACrB;AACJ;AAEO,MAAME,kDAA0BC,wBAAAA,oBAA4B,CAAC;IAChE,gBAAgBlB;IAChB,cAAc;QAACmB;QAAkBC;KAAe;AACpD"}

package/features/stepRun/GetReviewStepRun/abstractions.d.ts

@@ -0,0 +1,32 @@
+import { type Result } from "@webiny/feature/api";
+import type { ReviewStepRunInfo } from "../../../domain/review/ReviewStepRunInfo.js";
+import type { ReviewNotFoundError, ReviewPersistenceError, ReviewStepRunNotFoundError } from "../../../domain/review/errors.js";
+export interface GetReviewStepRunInput {
+    reviewId: string;
+    stepId: string;
+    /** The step's current task id or the task id of one of its earlier runs. */
+    taskId: string;
+}
+export interface IGetReviewStepRunUseCaseErrors {
+    notFound: ReviewNotFoundError;
+    persistence: ReviewPersistenceError;
+    stepRunNotFound: ReviewStepRunNotFoundError;
+}
+type UseCaseError = IGetReviewStepRunUseCaseErrors[keyof IGetReviewStepRunUseCaseErrors];
+export interface IGetReviewStepRunUseCase {
+    execute(input: GetReviewStepRunInput): Promise<Result<ReviewStepRunInfo | null, UseCaseError>>;
+}
+/**
+ * The background task of one attempt of an AI or automation step, as workflows shows it (R257,
+ * D161). Internal (D132): no permission check; the app wrapper checks read access to the target
+ * and `editor` or `reassign` (`canViewStepRunByPermission`). Only task ids of the step are read,
+ * `null` means the task record is gone, and only the fields of `ReviewStepRunInfo` leave.
+ */
+export declare const GetReviewStepRunUseCase: import("@webiny/di").Abstraction<IGetReviewStepRunUseCase>;
+export declare namespace GetReviewStepRunUseCase {
+    type Interface = IGetReviewStepRunUseCase;
+    type Input = GetReviewStepRunInput;
+    type Error = UseCaseError;
+    type Return = Promise<Result<ReviewStepRunInfo | null, UseCaseError>>;
+}
+export {};

package/features/stepRun/GetReviewStepRun/abstractions.js

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

package/features/stepRun/GetReviewStepRun/abstractions.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"features/stepRun/GetReviewStepRun/abstractions.js","sources":["../../../../src/features/stepRun/GetReviewStepRun/abstractions.ts"],"sourcesContent":["import { createAbstraction, type Result } from \"@webiny/feature/api\";\nimport type { ReviewStepRunInfo } from \"~/domain/review/ReviewStepRunInfo.js\";\nimport type {\n    ReviewNotFoundError,\n    ReviewPersistenceError,\n    ReviewStepRunNotFoundError\n} from \"~/domain/review/errors.js\";\n\nexport interface GetReviewStepRunInput {\n    reviewId: string;\n    stepId: string;\n    /** The step's current task id or the task id of one of its earlier runs. */\n    taskId: string;\n}\n\nexport interface IGetReviewStepRunUseCaseErrors {\n    notFound: ReviewNotFoundError;\n    persistence: ReviewPersistenceError;\n    stepRunNotFound: ReviewStepRunNotFoundError;\n}\n\ntype UseCaseError = IGetReviewStepRunUseCaseErrors[keyof IGetReviewStepRunUseCaseErrors];\n\nexport interface IGetReviewStepRunUseCase {\n    execute(input: GetReviewStepRunInput): Promise<Result<ReviewStepRunInfo | null, UseCaseError>>;\n}\n\n/**\n * The background task of one attempt of an AI or automation step, as workflows shows it (R257,\n * D161). Internal (D132): no permission check; the app wrapper checks read access to the target\n * and `editor` or `reassign` (`canViewStepRunByPermission`). Only task ids of the step are read,\n * `null` means the task record is gone, and only the fields of `ReviewStepRunInfo` leave.\n */\nexport const GetReviewStepRunUseCase =\n    createAbstraction<IGetReviewStepRunUseCase>(\"GetReviewStepRunUseCase\");\n\nexport namespace GetReviewStepRunUseCase {\n    export type Interface = IGetReviewStepRunUseCase;\n    export type Input = GetReviewStepRunInput;\n    export type Error = UseCaseError;\n    export type Return = Promise<Result<ReviewStepRunInfo | null, UseCaseError>>;\n}\n"],"names":["GetReviewStepRunUseCase","createAbstraction"],"mappings":";AAiCO,MAAMA,0BACTC,kBAA4C"}

package/features/stepRun/GetReviewStepRun/feature.d.ts

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

package/features/stepRun/GetReviewStepRun/feature.js

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

package/features/stepRun/GetReviewStepRun/feature.js.map

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

package/features/stepRun/GetReviewStepRun/index.d.ts

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

package/features/stepRun/GetReviewStepRun/index.js

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

package/features/stepRun/GetReviewStepRun/toReviewStepRunInfo.d.ts

@@ -0,0 +1,15 @@
+import { type TaskService } from "@webiny/api-core/features/task/TaskService/index.js";
+import type { ReviewStepRunInfo } from "../../../domain/review/ReviewStepRunInfo.js";
+import type { ReviewStep } from "../../../domain/review/types.js";
+export interface ToReviewStepRunInfoParams {
+    step: ReviewStep;
+    /** The step's current task id or the task id of one of its earlier runs. */
+    taskId: string;
+    task: TaskService.Task;
+}
+/**
+ * Builds the step run info of one attempt (R257) from the review's step and the task. `outcome`
+ * and `reason` come from the review, never from the task (R146); times prefer the review's record
+ * and fall back to the task's. Nothing else of the task is read.
+ */
+export declare const toReviewStepRunInfo: (params: ToReviewStepRunInfoParams) => ReviewStepRunInfo;