@webiny/api-workflows 0.0.0-unstable.0156a4c312

package/features/review/ReviewTargetReadAccess/abstractions.d.ts

@@ -0,0 +1,56 @@
+import type { RoutingReadScope } from "../../../domain/routing/types.js";
+/** An admin user of the current tenant, as the engine already listed it (`AdminUser` fits). */
+export interface ReviewTargetReadUser {
+    id: string;
+    displayName: string;
+    /** The user's team ids, as stored on the admin user. */
+    teams?: string[];
+}
+export interface ReviewTargetReadUsersParams {
+    /** Namespace id, e.g. "cms.article" or "wb.page". */
+    model: string;
+    /**
+     * A target revision, or a folder without a revision (R121): model read and folder content
+     * read only; for the root folder, model read only.
+     */
+    read: RoutingReadScope;
+    /**
+     * Admin users of the current tenant, listed by the caller (`ListUsersUseCase`); the adapter
+     * does not look them up again.
+     */
+    users: ReviewTargetReadUser[];
+    /**
+     * Stop once this many readable users are found, checking `users` in order (the strategy picks
+     * the first readable candidate, R111). Every user is checked when omitted.
+     */
+    limit?: number;
+}
+export interface IReviewTargetReadAccess {
+    /** Whether this adapter answers for the namespace. */
+    canHandle(model: string): boolean;
+    /**
+     * The ids of the users who can read the target revision (or the folder's content) with the
+     * app's own permission logic (model, folder and content access, D61, D133), in the order of
+     * `users`. The target, the model and the folder's permission record are read once per call, as
+     * the current identity (A19); only each user's access is evaluated as that user, through
+     * `CandidateReadAccess` (R48, R67), in memory once the user's permissions are loaded. Fail
+     * closed: a user whose check fails is left out, and a target that cannot be read leaves
+     * everyone out.
+     */
+    filterReadableUsers(params: ReviewTargetReadUsersParams): Promise<string[]>;
+}
+/**
+ * The engine's question to a target adapter about other users (spec 6, 9.3; D133 point 4a). One
+ * implementation per namespace, registered by the app adapters; the last registered match wins and
+ * no match means no access (R50). Routing asks it for picks, rule targets and strategy candidates,
+ * reassign for the chosen user, the step-candidate list for every member and the inspector for
+ * folder-level access (R111, R112, R120, R121); the engine never asks it about the caller, whose
+ * checks are the app wrappers'. Not to be confused with the 1b
+ * `ReviewTargetAccess` flags type (`domain/review/types.ts`, R71).
+ */
+export declare const ReviewTargetReadAccess: import("@webiny/di").Abstraction<IReviewTargetReadAccess>;
+export declare namespace ReviewTargetReadAccess {
+    type Interface = IReviewTargetReadAccess;
+    type User = ReviewTargetReadUser;
+    type UsersParams = ReviewTargetReadUsersParams;
+}

package/features/review/ReviewTargetReadAccess/abstractions.js

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

package/features/review/ReviewTargetReadAccess/abstractions.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"features/review/ReviewTargetReadAccess/abstractions.js","sources":["../../../../src/features/review/ReviewTargetReadAccess/abstractions.ts"],"sourcesContent":["import { createAbstraction } from \"@webiny/feature/api\";\nimport type { RoutingReadScope } from \"~/domain/routing/types.js\";\n\n/** An admin user of the current tenant, as the engine already listed it (`AdminUser` fits). */\nexport interface ReviewTargetReadUser {\n    id: string;\n    displayName: string;\n    /** The user's team ids, as stored on the admin user. */\n    teams?: string[];\n}\n\nexport interface ReviewTargetReadUsersParams {\n    /** Namespace id, e.g. \"cms.article\" or \"wb.page\". */\n    model: string;\n    /**\n     * A target revision, or a folder without a revision (R121): model read and folder content\n     * read only; for the root folder, model read only.\n     */\n    read: RoutingReadScope;\n    /**\n     * Admin users of the current tenant, listed by the caller (`ListUsersUseCase`); the adapter\n     * does not look them up again.\n     */\n    users: ReviewTargetReadUser[];\n    /**\n     * Stop once this many readable users are found, checking `users` in order (the strategy picks\n     * the first readable candidate, R111). Every user is checked when omitted.\n     */\n    limit?: number;\n}\n\nexport interface IReviewTargetReadAccess {\n    /** Whether this adapter answers for the namespace. */\n    canHandle(model: string): boolean;\n    /**\n     * The ids of the users who can read the target revision (or the folder's content) with the\n     * app's own permission logic (model, folder and content access, D61, D133), in the order of\n     * `users`. The target, the model and the folder's permission record are read once per call, as\n     * the current identity (A19); only each user's access is evaluated as that user, through\n     * `CandidateReadAccess` (R48, R67), in memory once the user's permissions are loaded. Fail\n     * closed: a user whose check fails is left out, and a target that cannot be read leaves\n     * everyone out.\n     */\n    filterReadableUsers(params: ReviewTargetReadUsersParams): Promise<string[]>;\n}\n\n/**\n * The engine's question to a target adapter about other users (spec 6, 9.3; D133 point 4a). One\n * implementation per namespace, registered by the app adapters; the last registered match wins and\n * no match means no access (R50). Routing asks it for picks, rule targets and strategy candidates,\n * reassign for the chosen user, the step-candidate list for every member and the inspector for\n * folder-level access (R111, R112, R120, R121); the engine never asks it about the caller, whose\n * checks are the app wrappers'. Not to be confused with the 1b\n * `ReviewTargetAccess` flags type (`domain/review/types.ts`, R71).\n */\nexport const ReviewTargetReadAccess =\n    createAbstraction<IReviewTargetReadAccess>(\"ReviewTargetReadAccess\");\n\nexport namespace ReviewTargetReadAccess {\n    export type Interface = IReviewTargetReadAccess;\n    export type User = ReviewTargetReadUser;\n    export type UsersParams = ReviewTargetReadUsersParams;\n}\n"],"names":["ReviewTargetReadAccess","createAbstraction"],"mappings":";AAuDO,MAAMA,yBACTC,kBAA2C"}

package/features/review/ReviewTargetReadAccess/index.d.ts

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

package/features/review/ReviewTargetReadAccess/index.js

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

package/features/review/ReviewTargetSync/abstractions.d.ts

@@ -0,0 +1,26 @@
+import { type Result } from "@webiny/feature/api";
+import type { ReviewData, ReviewSystemWorkflow } from "../../../domain/review/types.js";
+export interface ReviewTargetSyncParams {
+    /** The review as persisted. */
+    review: ReviewData;
+    /** The new `system.workflow` value; `null` unlocks the target (cancel, D75). */
+    systemWorkflow: ReviewSystemWorkflow | null;
+}
+export interface IReviewTargetSync {
+    /** Whether this adapter owns reviews of the model (a namespace such as `cms.*` or `wb.page`). */
+    canSync(model: string): boolean;
+    /** Fails with the adapter's error; the review stays saved (R16). */
+    sync(params: ReviewTargetSyncParams): Promise<Result<void, Error>>;
+}
+/**
+ * Writes `system.workflow` on the target after every review save (spec 4.5, D52). One
+ * implementation per namespace, registered by the app target adapters with
+ * `UpdateEntrySystemUseCase` (R63); the last registered one whose `canSync` matches wins, none
+ * matching means nothing to sync (R28).
+ */
+export declare const ReviewTargetSync: import("@webiny/di").Abstraction<IReviewTargetSync>;
+export declare namespace ReviewTargetSync {
+    type Interface = IReviewTargetSync;
+    type Params = ReviewTargetSyncParams;
+    type Return = Promise<Result<void, Error>>;
+}

package/features/review/ReviewTargetSync/abstractions.js

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

package/features/review/ReviewTargetSync/abstractions.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"features/review/ReviewTargetSync/abstractions.js","sources":["../../../../src/features/review/ReviewTargetSync/abstractions.ts"],"sourcesContent":["import { createAbstraction, type Result } from \"@webiny/feature/api\";\nimport type { ReviewData, ReviewSystemWorkflow } from \"~/domain/review/types.js\";\n\nexport interface ReviewTargetSyncParams {\n    /** The review as persisted. */\n    review: ReviewData;\n    /** The new `system.workflow` value; `null` unlocks the target (cancel, D75). */\n    systemWorkflow: ReviewSystemWorkflow | null;\n}\n\nexport interface IReviewTargetSync {\n    /** Whether this adapter owns reviews of the model (a namespace such as `cms.*` or `wb.page`). */\n    canSync(model: string): boolean;\n    /** Fails with the adapter's error; the review stays saved (R16). */\n    sync(params: ReviewTargetSyncParams): Promise<Result<void, Error>>;\n}\n\n/**\n * Writes `system.workflow` on the target after every review save (spec 4.5, D52). One\n * implementation per namespace, registered by the app target adapters with\n * `UpdateEntrySystemUseCase` (R63); the last registered one whose `canSync` matches wins, none\n * matching means nothing to sync (R28).\n */\nexport const ReviewTargetSync = createAbstraction<IReviewTargetSync>(\"ReviewTargetSync\");\n\nexport namespace ReviewTargetSync {\n    export type Interface = IReviewTargetSync;\n    export type Params = ReviewTargetSyncParams;\n    export type Return = Promise<Result<void, Error>>;\n}\n"],"names":["ReviewTargetSync","createAbstraction"],"mappings":";AAuBO,MAAMA,mBAAmBC,kBAAqC"}

package/features/review/ReviewTargetSync/index.d.ts

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

package/features/review/ReviewTargetSync/index.js

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

package/features/review/ReviewTargetUpdateGuard/ReviewTargetUpdateGuard.d.ts

@@ -0,0 +1,15 @@
+import { ReviewTargetUpdateGuard as ReviewTargetUpdateGuardAbstraction } from "./abstractions.js";
+import { WorkflowBypassService } from "../../../features/bypass/WorkflowBypassService/index.js";
+import { GetBoundWorkflowUseCase } from "../../../features/workflow/GetBoundWorkflow/index.js";
+import { GetActiveTargetReviewUseCase } from "../../../features/review/GetActiveTargetReview/index.js";
+declare class ReviewTargetUpdateGuardImpl implements ReviewTargetUpdateGuardAbstraction.Interface {
+    private bypass;
+    private getBoundWorkflow;
+    private getActiveTargetReview;
+    constructor(bypass: WorkflowBypassService.Interface, getBoundWorkflow: GetBoundWorkflowUseCase.Interface, getActiveTargetReview: GetActiveTargetReviewUseCase.Interface);
+    check(params: ReviewTargetUpdateGuardAbstraction.Params): ReviewTargetUpdateGuardAbstraction.Return;
+}
+export declare const ReviewTargetUpdateGuard: typeof ReviewTargetUpdateGuardImpl & {
+    __abstraction: import("@webiny/di").Abstraction<import("./abstractions.js").IReviewTargetUpdateGuard>;
+};
+export {};

package/features/review/ReviewTargetUpdateGuard/ReviewTargetUpdateGuard.js

@@ -0,0 +1,45 @@
+import { Result } from "@webiny/feature/api";
+import { ReviewTargetUpdateGuard } from "./abstractions.js";
+import { WorkflowBypassService } from "../../bypass/WorkflowBypassService/index.js";
+import { GetBoundWorkflowUseCase } from "../../workflow/GetBoundWorkflow/index.js";
+import { GetActiveTargetReviewUseCase } from "../GetActiveTargetReview/index.js";
+import { ReviewTargetLockedError } from "../../../domain/review/errors.js";
+class ReviewTargetUpdateGuardImpl {
+    constructor(bypass, getBoundWorkflow, getActiveTargetReview){
+        this.bypass = bypass;
+        this.getBoundWorkflow = getBoundWorkflow;
+        this.getActiveTargetReview = getActiveTargetReview;
+    }
+    async check(params) {
+        if (this.bypass.isActive()) return Result.ok();
+        const workflow = await this.getBoundWorkflow.execute({
+            model: params.model
+        });
+        if (workflow.isFail()) return Result.fail(workflow.error);
+        if (!workflow.value) return Result.ok();
+        const review = await this.getActiveTargetReview.execute({
+            model: params.model,
+            targetRevisionId: params.targetRevisionId
+        });
+        if (review.isFail()) return Result.fail(review.error);
+        if (!review.value) return Result.ok();
+        return Result.fail(new ReviewTargetLockedError({
+            reviewId: review.value.id,
+            model: params.model,
+            targetRevisionId: params.targetRevisionId,
+            reviewState: review.value.state,
+            action: "update"
+        }));
+    }
+}
+const ReviewTargetUpdateGuard_ReviewTargetUpdateGuard = ReviewTargetUpdateGuard.createImplementation({
+    implementation: ReviewTargetUpdateGuardImpl,
+    dependencies: [
+        WorkflowBypassService,
+        GetBoundWorkflowUseCase,
+        GetActiveTargetReviewUseCase
+    ]
+});
+export { ReviewTargetUpdateGuard_ReviewTargetUpdateGuard as ReviewTargetUpdateGuard };
+
+//# sourceMappingURL=ReviewTargetUpdateGuard.js.map

package/features/review/ReviewTargetUpdateGuard/ReviewTargetUpdateGuard.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"features/review/ReviewTargetUpdateGuard/ReviewTargetUpdateGuard.js","sources":["../../../../src/features/review/ReviewTargetUpdateGuard/ReviewTargetUpdateGuard.ts"],"sourcesContent":["import { Result } from \"@webiny/feature/api\";\nimport { ReviewTargetUpdateGuard as ReviewTargetUpdateGuardAbstraction } from \"./abstractions.js\";\nimport { WorkflowBypassService } from \"~/features/bypass/WorkflowBypassService/index.js\";\nimport { GetBoundWorkflowUseCase } from \"~/features/workflow/GetBoundWorkflow/index.js\";\nimport { GetActiveTargetReviewUseCase } from \"~/features/review/GetActiveTargetReview/index.js\";\nimport { ReviewTargetLockedError } from \"~/domain/review/errors.js\";\n\nclass ReviewTargetUpdateGuardImpl implements ReviewTargetUpdateGuardAbstraction.Interface {\n    public constructor(\n        private bypass: WorkflowBypassService.Interface,\n        private getBoundWorkflow: GetBoundWorkflowUseCase.Interface,\n        private getActiveTargetReview: GetActiveTargetReviewUseCase.Interface\n    ) {}\n\n    public async check(\n        params: ReviewTargetUpdateGuardAbstraction.Params\n    ): ReviewTargetUpdateGuardAbstraction.Return {\n        if (this.bypass.isActive()) {\n            return Result.ok();\n        }\n\n        const workflow = await this.getBoundWorkflow.execute({ model: params.model });\n        if (workflow.isFail()) {\n            return Result.fail(workflow.error);\n        }\n        if (!workflow.value) {\n            return Result.ok();\n        }\n\n        const review = await this.getActiveTargetReview.execute({\n            model: params.model,\n            targetRevisionId: params.targetRevisionId\n        });\n        if (review.isFail()) {\n            return Result.fail(review.error);\n        }\n        if (!review.value) {\n            return Result.ok();\n        }\n\n        return Result.fail(\n            new ReviewTargetLockedError({\n                reviewId: review.value.id,\n                model: params.model,\n                targetRevisionId: params.targetRevisionId,\n                reviewState: review.value.state,\n                action: \"update\"\n            })\n        );\n    }\n}\n\nexport const ReviewTargetUpdateGuard = ReviewTargetUpdateGuardAbstraction.createImplementation({\n    implementation: ReviewTargetUpdateGuardImpl,\n    dependencies: [WorkflowBypassService, GetBoundWorkflowUseCase, GetActiveTargetReviewUseCase]\n});\n"],"names":["ReviewTargetUpdateGuardImpl","bypass","getBoundWorkflow","getActiveTargetReview","params","Result","workflow","review","ReviewTargetLockedError","ReviewTargetUpdateGuard","ReviewTargetUpdateGuardAbstraction","WorkflowBypassService","GetBoundWorkflowUseCase","GetActiveTargetReviewUseCase"],"mappings":";;;;;;AAOA,MAAMA;IACF,YACYC,MAAuC,EACvCC,gBAAmD,EACnDC,qBAA6D,CACvE;aAHUF,MAAM,GAANA;aACAC,gBAAgB,GAAhBA;aACAC,qBAAqB,GAArBA;IACT;IAEH,MAAa,MACTC,MAAiD,EACR;QACzC,IAAI,IAAI,CAAC,MAAM,CAAC,QAAQ,IACpB,OAAOC,OAAO,EAAE;QAGpB,MAAMC,WAAW,MAAM,IAAI,CAAC,gBAAgB,CAAC,OAAO,CAAC;YAAE,OAAOF,OAAO,KAAK;QAAC;QAC3E,IAAIE,SAAS,MAAM,IACf,OAAOD,OAAO,IAAI,CAACC,SAAS,KAAK;QAErC,IAAI,CAACA,SAAS,KAAK,EACf,OAAOD,OAAO,EAAE;QAGpB,MAAME,SAAS,MAAM,IAAI,CAAC,qBAAqB,CAAC,OAAO,CAAC;YACpD,OAAOH,OAAO,KAAK;YACnB,kBAAkBA,OAAO,gBAAgB;QAC7C;QACA,IAAIG,OAAO,MAAM,IACb,OAAOF,OAAO,IAAI,CAACE,OAAO,KAAK;QAEnC,IAAI,CAACA,OAAO,KAAK,EACb,OAAOF,OAAO,EAAE;QAGpB,OAAOA,OAAO,IAAI,CACd,IAAIG,wBAAwB;YACxB,UAAUD,OAAO,KAAK,CAAC,EAAE;YACzB,OAAOH,OAAO,KAAK;YACnB,kBAAkBA,OAAO,gBAAgB;YACzC,aAAaG,OAAO,KAAK,CAAC,KAAK;YAC/B,QAAQ;QACZ;IAER;AACJ;AAEO,MAAME,kDAA0BC,wBAAAA,oBAAuD,CAAC;IAC3F,gBAAgBV;IAChB,cAAc;QAACW;QAAuBC;QAAyBC;KAA6B;AAChG"}

package/features/review/ReviewTargetUpdateGuard/abstractions.d.ts

@@ -0,0 +1,34 @@
+import type { Result } from "@webiny/feature/api";
+import type { ReviewTargetLockedError } from "../../../domain/review/errors.js";
+import type { GetBoundWorkflowUseCase } from "../../../features/workflow/GetBoundWorkflow/index.js";
+import type { GetActiveTargetReviewUseCase } from "../../../features/review/GetActiveTargetReview/index.js";
+export interface ReviewTargetUpdateGuardParams {
+    /** Namespace id of the target, for example `cms.article` or `wb.page`. */
+    model: string;
+    /** The revision being updated. */
+    targetRevisionId: string;
+}
+type GuardError = ReviewTargetLockedError | GetBoundWorkflowUseCase.Error | GetActiveTargetReviewUseCase.Error;
+export interface IReviewTargetUpdateGuard {
+    /**
+     * Ok when the revision may be updated. Fails with `ReviewTargetLockedError` when it has an
+     * active review on a bound namespace, or with the lookup's error when a lookup fails.
+     */
+    check(params: ReviewTargetUpdateGuardParams): Promise<Result<void, GuardError>>;
+}
+/**
+ * The save block shared by the app adapters (spec 9.2, D62, D80, D134, R54): on a namespace bound
+ * to a workflow, a revision with an active review cannot be updated, including an approved or
+ * rejected one. Unbound namespaces never look up reviews, and failed lookups block the update.
+ * The automation run is exempt (D36, D62, R150): while `WorkflowBypassService.isActive()` the
+ * check passes before the binding lookup. Internal (D132): no permission checks; the adapters'
+ * update handlers call it and throw its error.
+ */
+export declare const ReviewTargetUpdateGuard: import("@webiny/di").Abstraction<IReviewTargetUpdateGuard>;
+export declare namespace ReviewTargetUpdateGuard {
+    type Interface = IReviewTargetUpdateGuard;
+    type Params = ReviewTargetUpdateGuardParams;
+    type Error = GuardError;
+    type Return = Promise<Result<void, GuardError>>;
+}
+export {};

package/features/review/ReviewTargetUpdateGuard/abstractions.js

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

package/features/review/ReviewTargetUpdateGuard/abstractions.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"features/review/ReviewTargetUpdateGuard/abstractions.js","sources":["../../../../src/features/review/ReviewTargetUpdateGuard/abstractions.ts"],"sourcesContent":["import { createAbstraction } from \"@webiny/feature/api\";\nimport type { Result } from \"@webiny/feature/api\";\nimport type { ReviewTargetLockedError } from \"~/domain/review/errors.js\";\nimport type { GetBoundWorkflowUseCase } from \"~/features/workflow/GetBoundWorkflow/index.js\";\nimport type { GetActiveTargetReviewUseCase } from \"~/features/review/GetActiveTargetReview/index.js\";\n\nexport interface ReviewTargetUpdateGuardParams {\n    /** Namespace id of the target, for example `cms.article` or `wb.page`. */\n    model: string;\n    /** The revision being updated. */\n    targetRevisionId: string;\n}\n\ntype GuardError =\n    | ReviewTargetLockedError\n    | GetBoundWorkflowUseCase.Error\n    | GetActiveTargetReviewUseCase.Error;\n\nexport interface IReviewTargetUpdateGuard {\n    /**\n     * Ok when the revision may be updated. Fails with `ReviewTargetLockedError` when it has an\n     * active review on a bound namespace, or with the lookup's error when a lookup fails.\n     */\n    check(params: ReviewTargetUpdateGuardParams): Promise<Result<void, GuardError>>;\n}\n\n/**\n * The save block shared by the app adapters (spec 9.2, D62, D80, D134, R54): on a namespace bound\n * to a workflow, a revision with an active review cannot be updated, including an approved or\n * rejected one. Unbound namespaces never look up reviews, and failed lookups block the update.\n * The automation run is exempt (D36, D62, R150): while `WorkflowBypassService.isActive()` the\n * check passes before the binding lookup. Internal (D132): no permission checks; the adapters'\n * update handlers call it and throw its error.\n */\nexport const ReviewTargetUpdateGuard =\n    createAbstraction<IReviewTargetUpdateGuard>(\"ReviewTargetUpdateGuard\");\n\nexport namespace ReviewTargetUpdateGuard {\n    export type Interface = IReviewTargetUpdateGuard;\n    export type Params = ReviewTargetUpdateGuardParams;\n    export type Error = GuardError;\n    export type Return = Promise<Result<void, GuardError>>;\n}\n"],"names":["ReviewTargetUpdateGuard","createAbstraction"],"mappings":";AAkCO,MAAMA,0BACTC,kBAA4C"}

package/features/review/ReviewTargetUpdateGuard/index.d.ts

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

package/features/review/ReviewTargetUpdateGuard/index.js

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

package/features/review/StartReviewStep/StartReviewStepUseCase.d.ts

@@ -0,0 +1,13 @@
+import { ReviewRepository } from "../../../domain/review/abstractions/ReviewRepository.js";
+import { ReviewSaver } from "../ReviewSaver/abstractions.js";
+import { StartReviewStepUseCase as StartReviewStepUseCaseAbstraction } from "./abstractions.js";
+declare class StartReviewStepUseCaseImpl implements StartReviewStepUseCaseAbstraction.Interface {
+    private repository;
+    private saver;
+    constructor(repository: ReviewRepository.Interface, saver: ReviewSaver.Interface);
+    execute(input: StartReviewStepUseCaseAbstraction.Input): StartReviewStepUseCaseAbstraction.Return;
+}
+export declare const StartReviewStepUseCase: typeof StartReviewStepUseCaseImpl & {
+    __abstraction: import("@webiny/di").Abstraction<import("./abstractions.js").IStartReviewStepUseCase>;
+};
+export {};

package/features/review/StartReviewStep/StartReviewStepUseCase.js

@@ -0,0 +1,34 @@
+import { Result } from "@webiny/feature/api";
+import { Review } from "../../../domain/review/Review.js";
+import { ReviewRepository } from "../../../domain/review/abstractions/ReviewRepository.js";
+import { ReviewSaver } from "../ReviewSaver/abstractions.js";
+import { StartReviewStepUseCase } from "./abstractions.js";
+class StartReviewStepUseCaseImpl {
+    constructor(repository, saver){
+        this.repository = repository;
+        this.saver = saver;
+    }
+    async execute(input) {
+        const loaded = await this.repository.get(input.reviewId);
+        if (loaded.isFail()) return Result.fail(loaded.error);
+        const review = Review.fromData(loaded.value);
+        const started = review.start({
+            stepId: input.stepId,
+            actor: input.actor,
+            actorTeamIds: input.actorTeamIds,
+            now: new Date().toISOString()
+        });
+        if (started.isFail()) return Result.fail(started.error);
+        return this.saver.save(review);
+    }
+}
+const StartReviewStepUseCase_StartReviewStepUseCase = StartReviewStepUseCase.createImplementation({
+    implementation: StartReviewStepUseCaseImpl,
+    dependencies: [
+        ReviewRepository,
+        ReviewSaver
+    ]
+});
+export { StartReviewStepUseCase_StartReviewStepUseCase as StartReviewStepUseCase };
+
+//# sourceMappingURL=StartReviewStepUseCase.js.map

package/features/review/StartReviewStep/StartReviewStepUseCase.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"features/review/StartReviewStep/StartReviewStepUseCase.js","sources":["../../../../src/features/review/StartReviewStep/StartReviewStepUseCase.ts"],"sourcesContent":["import { Result } from \"@webiny/feature/api\";\nimport { Review } from \"~/domain/review/Review.js\";\nimport { ReviewRepository } from \"~/domain/review/abstractions/ReviewRepository.js\";\nimport { ReviewSaver } from \"../ReviewSaver/abstractions.js\";\nimport { StartReviewStepUseCase as StartReviewStepUseCaseAbstraction } from \"./abstractions.js\";\n\nclass StartReviewStepUseCaseImpl implements StartReviewStepUseCaseAbstraction.Interface {\n    constructor(\n        private repository: ReviewRepository.Interface,\n        private saver: ReviewSaver.Interface\n    ) {}\n\n    async execute(\n        input: StartReviewStepUseCaseAbstraction.Input\n    ): StartReviewStepUseCaseAbstraction.Return {\n        const loaded = await this.repository.get(input.reviewId);\n        if (loaded.isFail()) {\n            return Result.fail(loaded.error);\n        }\n        const review = Review.fromData(loaded.value);\n\n        const started = review.start({\n            stepId: input.stepId,\n            actor: input.actor,\n            actorTeamIds: input.actorTeamIds,\n            now: new Date().toISOString()\n        });\n        if (started.isFail()) {\n            return Result.fail(started.error);\n        }\n\n        return this.saver.save(review);\n    }\n}\n\nexport const StartReviewStepUseCase = StartReviewStepUseCaseAbstraction.createImplementation({\n    implementation: StartReviewStepUseCaseImpl,\n    dependencies: [ReviewRepository, ReviewSaver]\n});\n"],"names":["StartReviewStepUseCaseImpl","repository","saver","input","loaded","Result","review","Review","started","Date","StartReviewStepUseCase","StartReviewStepUseCaseAbstraction","ReviewRepository","ReviewSaver"],"mappings":";;;;;AAMA,MAAMA;IACF,YACYC,UAAsC,EACtCC,KAA4B,CACtC;aAFUD,UAAU,GAAVA;aACAC,KAAK,GAALA;IACT;IAEH,MAAM,QACFC,KAA8C,EACN;QACxC,MAAMC,SAAS,MAAM,IAAI,CAAC,UAAU,CAAC,GAAG,CAACD,MAAM,QAAQ;QACvD,IAAIC,OAAO,MAAM,IACb,OAAOC,OAAO,IAAI,CAACD,OAAO,KAAK;QAEnC,MAAME,SAASC,OAAO,QAAQ,CAACH,OAAO,KAAK;QAE3C,MAAMI,UAAUF,OAAO,KAAK,CAAC;YACzB,QAAQH,MAAM,MAAM;YACpB,OAAOA,MAAM,KAAK;YAClB,cAAcA,MAAM,YAAY;YAChC,KAAK,IAAIM,OAAO,WAAW;QAC/B;QACA,IAAID,QAAQ,MAAM,IACd,OAAOH,OAAO,IAAI,CAACG,QAAQ,KAAK;QAGpC,OAAO,IAAI,CAAC,KAAK,CAAC,IAAI,CAACF;IAC3B;AACJ;AAEO,MAAMI,gDAAyBC,uBAAAA,oBAAsD,CAAC;IACzF,gBAAgBX;IAChB,cAAc;QAACY;QAAkBC;KAAY;AACjD"}

package/features/review/StartReviewStep/abstractions.d.ts

@@ -0,0 +1,27 @@
+import { type Result } from "@webiny/feature/api";
+import type { ReviewData } from "../../../domain/review/types.js";
+import type { ReviewActorNotUserError, ReviewInvalidStateError, ReviewNotCandidateError, ReviewNotFoundError, ReviewPersistenceError, ReviewRequesterCannotReviewError, ReviewStepNotCurrentError, ReviewTargetSyncError } from "../../../domain/review/errors.js";
+import type { ReviewActorInput } from "../shared/types.js";
+export interface IStartReviewStepUseCaseErrors {
+    notFound: ReviewNotFoundError;
+    invalidState: ReviewInvalidStateError;
+    stepNotCurrent: ReviewStepNotCurrentError;
+    actorNotUser: ReviewActorNotUserError;
+    requesterCannotReview: ReviewRequesterCannotReviewError;
+    notCandidate: ReviewNotCandidateError;
+    persistence: ReviewPersistenceError;
+    targetSync: ReviewTargetSyncError;
+}
+type UseCaseError = IStartReviewStepUseCaseErrors[keyof IStartReviewStepUseCaseErrors];
+export interface IStartReviewStepUseCase {
+    execute(input: ReviewActorInput): Promise<Result<ReviewData, UseCaseError>>;
+}
+/** A candidate takes an awaiting step from the pool (spec 5.1 "start"). */
+export declare const StartReviewStepUseCase: import("@webiny/di").Abstraction<IStartReviewStepUseCase>;
+export declare namespace StartReviewStepUseCase {
+    type Interface = IStartReviewStepUseCase;
+    type Input = ReviewActorInput;
+    type Error = UseCaseError;
+    type Return = Promise<Result<ReviewData, UseCaseError>>;
+}
+export {};

package/features/review/StartReviewStep/abstractions.js

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

package/features/review/StartReviewStep/abstractions.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"features/review/StartReviewStep/abstractions.js","sources":["../../../../src/features/review/StartReviewStep/abstractions.ts"],"sourcesContent":["import { createAbstraction, type Result } from \"@webiny/feature/api\";\nimport type { ReviewData } from \"~/domain/review/types.js\";\nimport type {\n    ReviewActorNotUserError,\n    ReviewInvalidStateError,\n    ReviewNotCandidateError,\n    ReviewNotFoundError,\n    ReviewPersistenceError,\n    ReviewRequesterCannotReviewError,\n    ReviewStepNotCurrentError,\n    ReviewTargetSyncError\n} from \"~/domain/review/errors.js\";\nimport type { ReviewActorInput } from \"../shared/types.js\";\n\nexport interface IStartReviewStepUseCaseErrors {\n    notFound: ReviewNotFoundError;\n    invalidState: ReviewInvalidStateError;\n    stepNotCurrent: ReviewStepNotCurrentError;\n    actorNotUser: ReviewActorNotUserError;\n    requesterCannotReview: ReviewRequesterCannotReviewError;\n    notCandidate: ReviewNotCandidateError;\n    persistence: ReviewPersistenceError;\n    targetSync: ReviewTargetSyncError;\n}\n\ntype UseCaseError = IStartReviewStepUseCaseErrors[keyof IStartReviewStepUseCaseErrors];\n\nexport interface IStartReviewStepUseCase {\n    execute(input: ReviewActorInput): Promise<Result<ReviewData, UseCaseError>>;\n}\n\n/** A candidate takes an awaiting step from the pool (spec 5.1 \"start\"). */\nexport const StartReviewStepUseCase =\n    createAbstraction<IStartReviewStepUseCase>(\"StartReviewStepUseCase\");\n\nexport namespace StartReviewStepUseCase {\n    export type Interface = IStartReviewStepUseCase;\n    export type Input = ReviewActorInput;\n    export type Error = UseCaseError;\n    export type Return = Promise<Result<ReviewData, UseCaseError>>;\n}\n"],"names":["StartReviewStepUseCase","createAbstraction"],"mappings":";AAgCO,MAAMA,yBACTC,kBAA2C"}

package/features/review/StartReviewStep/events.d.ts

@@ -0,0 +1,16 @@
+import { DomainEvent } from "@webiny/api-core/features/eventPublisher/index.js";
+import type { IEventHandler } from "@webiny/api-core/features/eventPublisher/index.js";
+import type { ReviewStepStartedFact } from "../../../domain/review/facts.js";
+import type { ReviewEventPayload } from "../shared/events.js";
+/**
+ * ReviewStepStartedEvent - published after the review is saved.
+ */
+export declare class ReviewStepStartedEvent extends DomainEvent<ReviewEventPayload<ReviewStepStartedFact>> {
+    eventType: "Workflows/Review/StepStarted";
+    getHandlerAbstraction(): import("@webiny/di").Abstraction<IEventHandler<ReviewStepStartedEvent>>;
+}
+export declare const ReviewStepStartedEventHandler: import("@webiny/di").Abstraction<IEventHandler<ReviewStepStartedEvent>>;
+export declare namespace ReviewStepStartedEventHandler {
+    type Interface = IEventHandler<ReviewStepStartedEvent>;
+    type Event = ReviewStepStartedEvent;
+}

package/features/review/StartReviewStep/events.js

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

package/features/review/StartReviewStep/events.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"features/review/StartReviewStep/events.js","sources":["../../../../src/features/review/StartReviewStep/events.ts"],"sourcesContent":["import { createAbstraction } from \"@webiny/feature/api\";\nimport { DomainEvent } from \"@webiny/api-core/features/eventPublisher/index.js\";\nimport type { IEventHandler } from \"@webiny/api-core/features/eventPublisher/index.js\";\nimport type { ReviewStepStartedFact } from \"~/domain/review/facts.js\";\nimport type { ReviewEventPayload } from \"../shared/events.js\";\n\n/**\n * ReviewStepStartedEvent - published after the review is saved.\n */\nexport class ReviewStepStartedEvent extends DomainEvent<ReviewEventPayload<ReviewStepStartedFact>> {\n    eventType = \"Workflows/Review/StepStarted\" as const;\n\n    getHandlerAbstraction() {\n        return ReviewStepStartedEventHandler;\n    }\n}\n\nexport const ReviewStepStartedEventHandler = createAbstraction<\n    IEventHandler<ReviewStepStartedEvent>\n>(\"ReviewStepStartedEventHandler\");\n\nexport namespace ReviewStepStartedEventHandler {\n    export type Interface = IEventHandler<ReviewStepStartedEvent>;\n    export type Event = ReviewStepStartedEvent;\n}\n"],"names":["ReviewStepStartedEvent","DomainEvent","ReviewStepStartedEventHandler","createAbstraction"],"mappings":";;AASO,MAAMA,+BAA+BC;IAGxC,wBAAwB;QACpB,OAAOC;IACX;;QALG,qBACH,SAAS,GAAG;;AAKhB;AAEO,MAAMA,gCAAgCC,kBAE3C"}

package/features/review/StartReviewStep/feature.d.ts

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

package/features/review/StartReviewStep/feature.js

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

package/features/review/StartReviewStep/feature.js.map

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

package/features/review/StartReviewStep/index.d.ts

@@ -0,0 +1,3 @@
+export { StartReviewStepUseCase } from "./abstractions.js";
+export type { ReviewActorInput } from "../shared/types.js";
+export { ReviewStepStartedEventHandler } from "./events.js";

package/features/review/StartReviewStep/index.js

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

package/features/review/StepAssignmentResolver/RoutingStepAssignmentResolver.d.ts

@@ -0,0 +1,20 @@
+import { Logger } from "@webiny/api-core/features/logger/index.js";
+import { RoutingEvaluatorService } from "../../../features/routing/RoutingEvaluatorService/abstractions.js";
+import { StepAssignmentResolver } from "./abstractions.js";
+/**
+ * Step reach routing (spec 6, R110): pick, rules, strategy, pool, through
+ * `RoutingEvaluatorService`. Never blocks the review (R116): a failed lookup gives the pool with a
+ * fixed reason, keeping what the evaluator had decided (the narrowed teams, a team-target rule,
+ * the skips gathered); a throwing read check gives the pool of the step's teams without skips.
+ * The error is logged.
+ */
+declare class RoutingStepAssignmentResolverImpl implements StepAssignmentResolver.Interface {
+    private evaluator;
+    private logger;
+    constructor(evaluator: RoutingEvaluatorService.Interface, logger: Logger.Interface);
+    resolve(params: StepAssignmentResolver.Params): Promise<StepAssignmentResolver.Resolution>;
+}
+export declare const RoutingStepAssignmentResolver: typeof RoutingStepAssignmentResolverImpl & {
+    __abstraction: import("@webiny/di").Abstraction<import("./abstractions.js").IStepAssignmentResolver>;
+};
+export {};

package/features/review/StepAssignmentResolver/RoutingStepAssignmentResolver.js

@@ -0,0 +1,86 @@
+import { Logger } from "@webiny/api-core/features/logger/index.js";
+import { parseReviewStepConfig } from "../../../domain/workflow/reviewStepConfigSchema.js";
+import { createRoutingFailedResolution } from "../../../domain/routing/createRoutingFailedResolution.js";
+import { toStepAssignmentResolution } from "../../../domain/routing/toStepAssignmentResolution.js";
+import { ROUTING_FAILED_REASON } from "../../../domain/routing/reasons.js";
+import { RoutingEvaluatorService } from "../../routing/RoutingEvaluatorService/abstractions.js";
+import { StepAssignmentResolver } from "./abstractions.js";
+import { hasErrorSource } from "../../../domain/hasErrorSource.js";
+class RoutingStepAssignmentResolverImpl {
+    constructor(evaluator, logger){
+        this.evaluator = evaluator;
+        this.logger = logger;
+    }
+    async resolve(params) {
+        const config = parseReviewStepConfig(params.step.config);
+        if (!config) return {
+            owner: null,
+            candidateTeamIds: [],
+            assignment: {
+                source: "pool"
+            },
+            records: [
+                {
+                    kind: "outcome",
+                    userId: null,
+                    source: "pool",
+                    ruleId: null,
+                    by: null,
+                    reason: null
+                }
+            ]
+        };
+        try {
+            const evaluated = await this.evaluator.evaluate({
+                config,
+                model: params.review.model,
+                workflowId: params.review.workflowId,
+                reviewId: params.review.id,
+                stepId: params.step.id,
+                requesterId: params.review.createdBy.id,
+                pickedUserId: params.step.pickedUserId,
+                folder: params.review.targetContext.folder,
+                read: {
+                    type: "target",
+                    targetId: params.review.targetId,
+                    targetRevisionId: params.review.targetRevisionId
+                },
+                now: params.now
+            });
+            if (evaluated.isFail()) {
+                this.logger.error({
+                    err: hasErrorSource(evaluated.error) ? evaluated.error.source : evaluated.error,
+                    reviewId: params.review.id,
+                    stepId: params.step.id
+                }, ROUTING_FAILED_REASON);
+                return createRoutingFailedResolution(evaluated.error.decided ?? {
+                    candidateTeamIds: config.teams,
+                    ruleId: null,
+                    skips: []
+                });
+            }
+            return toStepAssignmentResolution(evaluated.value);
+        } catch (error) {
+            this.logger.error({
+                err: error,
+                reviewId: params.review.id,
+                stepId: params.step.id
+            }, ROUTING_FAILED_REASON);
+            return createRoutingFailedResolution({
+                candidateTeamIds: config.teams,
+                ruleId: null,
+                skips: []
+            });
+        }
+    }
+}
+const RoutingStepAssignmentResolver = StepAssignmentResolver.createImplementation({
+    implementation: RoutingStepAssignmentResolverImpl,
+    dependencies: [
+        RoutingEvaluatorService,
+        Logger
+    ]
+});
+export { RoutingStepAssignmentResolver };
+
+//# sourceMappingURL=RoutingStepAssignmentResolver.js.map

package/features/review/StepAssignmentResolver/RoutingStepAssignmentResolver.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"features/review/StepAssignmentResolver/RoutingStepAssignmentResolver.js","sources":["../../../../src/features/review/StepAssignmentResolver/RoutingStepAssignmentResolver.ts"],"sourcesContent":["import { Logger } from \"@webiny/api-core/features/logger/index.js\";\nimport { parseReviewStepConfig } from \"~/domain/workflow/reviewStepConfigSchema.js\";\nimport { createRoutingFailedResolution } from \"~/domain/routing/createRoutingFailedResolution.js\";\nimport { toStepAssignmentResolution } from \"~/domain/routing/toStepAssignmentResolution.js\";\nimport { ROUTING_FAILED_REASON } from \"~/domain/routing/reasons.js\";\nimport { RoutingEvaluatorService } from \"~/features/routing/RoutingEvaluatorService/abstractions.js\";\nimport { StepAssignmentResolver } from \"./abstractions.js\";\nimport { hasErrorSource } from \"~/domain/hasErrorSource.js\";\n\n/**\n * Step reach routing (spec 6, R110): pick, rules, strategy, pool, through\n * `RoutingEvaluatorService`. Never blocks the review (R116): a failed lookup gives the pool with a\n * fixed reason, keeping what the evaluator had decided (the narrowed teams, a team-target rule,\n * the skips gathered); a throwing read check gives the pool of the step's teams without skips.\n * The error is logged.\n */\nclass RoutingStepAssignmentResolverImpl implements StepAssignmentResolver.Interface {\n    public constructor(\n        private evaluator: RoutingEvaluatorService.Interface,\n        private logger: Logger.Interface\n    ) {}\n\n    public async resolve(\n        params: StepAssignmentResolver.Params\n    ): Promise<StepAssignmentResolver.Resolution> {\n        // Save-time validation guarantees a parsable config. An unparsable one (edited storage)\n        // leaves an empty pool; the review step type does not fail such a step (R116).\n        const config = parseReviewStepConfig(params.step.config);\n        if (!config) {\n            return {\n                owner: null,\n                candidateTeamIds: [],\n                assignment: { source: \"pool\" },\n                records: [\n                    {\n                        kind: \"outcome\",\n                        userId: null,\n                        source: \"pool\",\n                        ruleId: null,\n                        by: null,\n                        reason: null\n                    }\n                ]\n            };\n        }\n\n        try {\n            const evaluated = await this.evaluator.evaluate({\n                config,\n                model: params.review.model,\n                workflowId: params.review.workflowId,\n                // Least loaded does not count the review being routed (its previous step).\n                reviewId: params.review.id,\n                stepId: params.step.id,\n                requesterId: params.review.createdBy.id,\n                pickedUserId: params.step.pickedUserId,\n                // The target's current folder: moves are refused while a review is in progress\n                // (D84, R55). Its ancestors are read now, through the folder port (R130).\n                folder: params.review.targetContext.folder,\n                read: {\n                    type: \"target\",\n                    targetId: params.review.targetId,\n                    targetRevisionId: params.review.targetRevisionId\n                },\n                now: params.now\n            });\n            if (evaluated.isFail()) {\n                this.logger.error(\n                    {\n                        err: hasErrorSource(evaluated.error)\n                            ? evaluated.error.source\n                            : evaluated.error,\n                        reviewId: params.review.id,\n                        stepId: params.step.id\n                    },\n                    ROUTING_FAILED_REASON\n                );\n                return createRoutingFailedResolution(\n                    evaluated.error.decided ?? {\n                        candidateTeamIds: config.teams,\n                        ruleId: null,\n                        skips: []\n                    }\n                );\n            }\n            return toStepAssignmentResolution(evaluated.value);\n        } catch (error) {\n            this.logger.error(\n                { err: error, reviewId: params.review.id, stepId: params.step.id },\n                ROUTING_FAILED_REASON\n            );\n            return createRoutingFailedResolution({\n                candidateTeamIds: config.teams,\n                ruleId: null,\n                skips: []\n            });\n        }\n    }\n}\n\nexport const RoutingStepAssignmentResolver = StepAssignmentResolver.createImplementation({\n    implementation: RoutingStepAssignmentResolverImpl,\n    dependencies: [RoutingEvaluatorService, Logger]\n});\n"],"names":["RoutingStepAssignmentResolverImpl","evaluator","logger","params","config","parseReviewStepConfig","evaluated","hasErrorSource","ROUTING_FAILED_REASON","createRoutingFailedResolution","toStepAssignmentResolution","error","RoutingStepAssignmentResolver","StepAssignmentResolver","RoutingEvaluatorService","Logger"],"mappings":";;;;;;;;AAgBA,MAAMA;IACF,YACYC,SAA4C,EAC5CC,MAAwB,CAClC;aAFUD,SAAS,GAATA;aACAC,MAAM,GAANA;IACT;IAEH,MAAa,QACTC,MAAqC,EACK;QAG1C,MAAMC,SAASC,sBAAsBF,OAAO,IAAI,CAAC,MAAM;QACvD,IAAI,CAACC,QACD,OAAO;YACH,OAAO;YACP,kBAAkB,EAAE;YACpB,YAAY;gBAAE,QAAQ;YAAO;YAC7B,SAAS;gBACL;oBACI,MAAM;oBACN,QAAQ;oBACR,QAAQ;oBACR,QAAQ;oBACR,IAAI;oBACJ,QAAQ;gBACZ;aACH;QACL;QAGJ,IAAI;YACA,MAAME,YAAY,MAAM,IAAI,CAAC,SAAS,CAAC,QAAQ,CAAC;gBAC5CF;gBACA,OAAOD,OAAO,MAAM,CAAC,KAAK;gBAC1B,YAAYA,OAAO,MAAM,CAAC,UAAU;gBAEpC,UAAUA,OAAO,MAAM,CAAC,EAAE;gBAC1B,QAAQA,OAAO,IAAI,CAAC,EAAE;gBACtB,aAAaA,OAAO,MAAM,CAAC,SAAS,CAAC,EAAE;gBACvC,cAAcA,OAAO,IAAI,CAAC,YAAY;gBAGtC,QAAQA,OAAO,MAAM,CAAC,aAAa,CAAC,MAAM;gBAC1C,MAAM;oBACF,MAAM;oBACN,UAAUA,OAAO,MAAM,CAAC,QAAQ;oBAChC,kBAAkBA,OAAO,MAAM,CAAC,gBAAgB;gBACpD;gBACA,KAAKA,OAAO,GAAG;YACnB;YACA,IAAIG,UAAU,MAAM,IAAI;gBACpB,IAAI,CAAC,MAAM,CAAC,KAAK,CACb;oBACI,KAAKC,eAAeD,UAAU,KAAK,IAC7BA,UAAU,KAAK,CAAC,MAAM,GACtBA,UAAU,KAAK;oBACrB,UAAUH,OAAO,MAAM,CAAC,EAAE;oBAC1B,QAAQA,OAAO,IAAI,CAAC,EAAE;gBAC1B,GACAK;gBAEJ,OAAOC,8BACHH,UAAU,KAAK,CAAC,OAAO,IAAI;oBACvB,kBAAkBF,OAAO,KAAK;oBAC9B,QAAQ;oBACR,OAAO,EAAE;gBACb;YAER;YACA,OAAOM,2BAA2BJ,UAAU,KAAK;QACrD,EAAE,OAAOK,OAAO;YACZ,IAAI,CAAC,MAAM,CAAC,KAAK,CACb;gBAAE,KAAKA;gBAAO,UAAUR,OAAO,MAAM,CAAC,EAAE;gBAAE,QAAQA,OAAO,IAAI,CAAC,EAAE;YAAC,GACjEK;YAEJ,OAAOC,8BAA8B;gBACjC,kBAAkBL,OAAO,KAAK;gBAC9B,QAAQ;gBACR,OAAO,EAAE;YACb;QACJ;IACJ;AACJ;AAEO,MAAMQ,gCAAgCC,uBAAuB,oBAAoB,CAAC;IACrF,gBAAgBb;IAChB,cAAc;QAACc;QAAyBC;KAAO;AACnD"}

package/features/review/StepAssignmentResolver/abstractions.d.ts

@@ -0,0 +1,30 @@
+import type { ReviewData, ReviewStep, StepAssignmentResolution } from "../../../domain/review/types.js";
+/**
+ * Resolvers must read the step being reached from `params.step`. The review-level current-step
+ * fields on `params.review` (`currentStepId`, `currentStepState`, `currentOwnerId`,
+ * `currentCandidateTeamIds`) still describe the previous step while a step is being reached.
+ */
+export interface StepAssignmentResolverParams {
+    review: ReviewData;
+    /** The review step being reached; carries `pickedUserId` and the step config. */
+    step: ReviewStep;
+    /**
+     * The reach time (R118): exclusion expiry and the records' `assignedOn` use it. Routing never
+     * calls `new Date()`.
+     */
+    now: Date;
+}
+export interface IStepAssignmentResolver {
+    resolve(params: StepAssignmentResolverParams): Promise<StepAssignmentResolution>;
+}
+/**
+ * Decides who holds a review step when it is reached (spec 5.2, 6). The registered
+ * implementation is `RoutingStepAssignmentResolver`: pick, rules, strategy, pool; any failure
+ * falls through to the pool (R110, R116). A later registration wins on resolve.
+ */
+export declare const StepAssignmentResolver: import("@webiny/di").Abstraction<IStepAssignmentResolver>;
+export declare namespace StepAssignmentResolver {
+    type Interface = IStepAssignmentResolver;
+    type Params = StepAssignmentResolverParams;
+    type Resolution = StepAssignmentResolution;
+}

package/features/review/StepAssignmentResolver/abstractions.js

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

package/features/review/StepAssignmentResolver/abstractions.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"features/review/StepAssignmentResolver/abstractions.js","sources":["../../../../src/features/review/StepAssignmentResolver/abstractions.ts"],"sourcesContent":["import { createAbstraction } from \"@webiny/feature/api\";\nimport type { ReviewData, ReviewStep, StepAssignmentResolution } from \"~/domain/review/types.js\";\n\n/**\n * Resolvers must read the step being reached from `params.step`. The review-level current-step\n * fields on `params.review` (`currentStepId`, `currentStepState`, `currentOwnerId`,\n * `currentCandidateTeamIds`) still describe the previous step while a step is being reached.\n */\nexport interface StepAssignmentResolverParams {\n    review: ReviewData;\n    /** The review step being reached; carries `pickedUserId` and the step config. */\n    step: ReviewStep;\n    /**\n     * The reach time (R118): exclusion expiry and the records' `assignedOn` use it. Routing never\n     * calls `new Date()`.\n     */\n    now: Date;\n}\n\nexport interface IStepAssignmentResolver {\n    resolve(params: StepAssignmentResolverParams): Promise<StepAssignmentResolution>;\n}\n\n/**\n * Decides who holds a review step when it is reached (spec 5.2, 6). The registered\n * implementation is `RoutingStepAssignmentResolver`: pick, rules, strategy, pool; any failure\n * falls through to the pool (R110, R116). A later registration wins on resolve.\n */\nexport const StepAssignmentResolver =\n    createAbstraction<IStepAssignmentResolver>(\"StepAssignmentResolver\");\n\nexport namespace StepAssignmentResolver {\n    export type Interface = IStepAssignmentResolver;\n    export type Params = StepAssignmentResolverParams;\n    export type Resolution = StepAssignmentResolution;\n}\n"],"names":["StepAssignmentResolver","createAbstraction"],"mappings":";AA4BO,MAAMA,yBACTC,kBAA2C"}

package/features/review/StepAssignmentResolver/index.d.ts

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

package/features/review/StepAssignmentResolver/index.js

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