@webiny/api-workflows 0.0.0-unstable.7c2def32a7 → 0.0.0-unstable.9609e4e0c9

package/features/stepRun/constants.d.ts

@@ -0,0 +1,47 @@
+/** The one private background task definition that runs an automation step (R142). */
+export declare const STEP_RUN_TASK_DEFINITION_ID = "workflowsStepRun";
+/**
+ * The task definition's ceiling (R142). The handler enforces the automation definition's own
+ * `maxIterations` below it (R145).
+ */
+export declare const STEP_RUN_MAX_ITERATIONS = 10000;
+/**
+ * How many times the handler waits for the review and the step to carry its task id before it
+ * treats the run as stale (R143): it waits while `iterations <= STEP_RUN_TASKID_WAIT_TRIES`.
+ */
+export declare const STEP_RUN_TASKID_WAIT_TRIES = 3;
+/** The continue delay, in seconds, of one wait for the task id (R143). */
+export declare const STEP_RUN_TASKID_WAIT_SECONDS = 2;
+/** Used when the automation definition has no `maxIterations` (R145). */
+export declare const DEFAULT_AUTOMATION_MAX_ITERATIONS = 50;
+/**
+ * How long, in milliseconds, a `failed` or `aborted` task may be finished before stuck detection
+ * treats the step as stuck (R152): until then the runner's `onError` / `onAbort` hooks may still
+ * fail the step with the proper reason.
+ */
+export declare const STEP_RUN_STUCK_GRACE_MS = 300000;
+/**
+ * How much of the task's remaining runtime the handler keeps back, in milliseconds, when it
+ * builds the runner's abort signal (R175): the signal fires at `remaining - margin`.
+ */
+export declare const STEP_RUN_TIMEOUT_MARGIN_MS = 30000;
+/**
+ * Below this many milliseconds left after the margin, the signal is aborted at once instead of
+ * starting a timer (R175): the step fails as timed out, restartable.
+ */
+export declare const STEP_RUN_MIN_TIMEOUT_MS = 1000;
+/**
+ * The most often a caller re-reads the stored review through `StepRunStaleCheckService` during a
+ * run, in milliseconds (R175). The service itself does not throttle: `AiStepRunner` does.
+ */
+export declare const STEP_RUN_STALE_CHECK_INTERVAL_MS = 5000;
+/** Stored by a failure hook or stuck detection for a step type with no runner (R168). */
+export declare const STEP_RUN_NEUTRAL_FAILED_REASON = "The step failed.";
+/** Stored by `onAbort` for a step type with no runner (R168). */
+export declare const STEP_RUN_NEUTRAL_ABORTED_REASON = "The step was aborted.";
+/**
+ * The error a step run task stores for an unexpected error (not a `StepRunFailure`); the raw error
+ * is only logged (R146, D188).
+ */
+export declare const STEP_RUN_UNEXPECTED_ERROR_MESSAGE = "The step run failed.";
+export declare const STEP_RUN_UNEXPECTED_ERROR_CODE = "Workflows/StepRun/Failed";

package/features/stepRun/constants.js

@@ -0,0 +1,16 @@
+const STEP_RUN_TASK_DEFINITION_ID = "workflowsStepRun";
+const STEP_RUN_MAX_ITERATIONS = 10000;
+const STEP_RUN_TASKID_WAIT_TRIES = 3;
+const STEP_RUN_TASKID_WAIT_SECONDS = 2;
+const DEFAULT_AUTOMATION_MAX_ITERATIONS = 50;
+const STEP_RUN_STUCK_GRACE_MS = 300000;
+const STEP_RUN_TIMEOUT_MARGIN_MS = 30000;
+const STEP_RUN_MIN_TIMEOUT_MS = 1000;
+const STEP_RUN_STALE_CHECK_INTERVAL_MS = 5000;
+const STEP_RUN_NEUTRAL_FAILED_REASON = "The step failed.";
+const STEP_RUN_NEUTRAL_ABORTED_REASON = "The step was aborted.";
+const STEP_RUN_UNEXPECTED_ERROR_MESSAGE = "The step run failed.";
+const STEP_RUN_UNEXPECTED_ERROR_CODE = "Workflows/StepRun/Failed";
+export { DEFAULT_AUTOMATION_MAX_ITERATIONS, STEP_RUN_MAX_ITERATIONS, STEP_RUN_MIN_TIMEOUT_MS, STEP_RUN_NEUTRAL_ABORTED_REASON, STEP_RUN_NEUTRAL_FAILED_REASON, STEP_RUN_STALE_CHECK_INTERVAL_MS, STEP_RUN_STUCK_GRACE_MS, STEP_RUN_TASKID_WAIT_SECONDS, STEP_RUN_TASKID_WAIT_TRIES, STEP_RUN_TASK_DEFINITION_ID, STEP_RUN_TIMEOUT_MARGIN_MS, STEP_RUN_UNEXPECTED_ERROR_CODE, STEP_RUN_UNEXPECTED_ERROR_MESSAGE };
+
+//# sourceMappingURL=constants.js.map

package/features/stepRun/constants.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"features/stepRun/constants.js","sources":["../../../src/features/stepRun/constants.ts"],"sourcesContent":["/** The one private background task definition that runs an automation step (R142). */\nexport const STEP_RUN_TASK_DEFINITION_ID = \"workflowsStepRun\";\n\n/**\n * The task definition's ceiling (R142). The handler enforces the automation definition's own\n * `maxIterations` below it (R145).\n */\nexport const STEP_RUN_MAX_ITERATIONS = 10000;\n\n/**\n * How many times the handler waits for the review and the step to carry its task id before it\n * treats the run as stale (R143): it waits while `iterations <= STEP_RUN_TASKID_WAIT_TRIES`.\n */\nexport const STEP_RUN_TASKID_WAIT_TRIES = 3;\n\n/** The continue delay, in seconds, of one wait for the task id (R143). */\nexport const STEP_RUN_TASKID_WAIT_SECONDS = 2;\n\n/** Used when the automation definition has no `maxIterations` (R145). */\nexport const DEFAULT_AUTOMATION_MAX_ITERATIONS = 50;\n\n/**\n * How long, in milliseconds, a `failed` or `aborted` task may be finished before stuck detection\n * treats the step as stuck (R152): until then the runner's `onError` / `onAbort` hooks may still\n * fail the step with the proper reason.\n */\nexport const STEP_RUN_STUCK_GRACE_MS = 300000;\n\n/**\n * How much of the task's remaining runtime the handler keeps back, in milliseconds, when it\n * builds the runner's abort signal (R175): the signal fires at `remaining - margin`.\n */\nexport const STEP_RUN_TIMEOUT_MARGIN_MS = 30000;\n\n/**\n * Below this many milliseconds left after the margin, the signal is aborted at once instead of\n * starting a timer (R175): the step fails as timed out, restartable.\n */\nexport const STEP_RUN_MIN_TIMEOUT_MS = 1000;\n\n/**\n * The most often a caller re-reads the stored review through `StepRunStaleCheckService` during a\n * run, in milliseconds (R175). The service itself does not throttle: `AiStepRunner` does.\n */\nexport const STEP_RUN_STALE_CHECK_INTERVAL_MS = 5000;\n\n/** Stored by a failure hook or stuck detection for a step type with no runner (R168). */\nexport const STEP_RUN_NEUTRAL_FAILED_REASON = \"The step failed.\";\n\n/** Stored by `onAbort` for a step type with no runner (R168). */\nexport const STEP_RUN_NEUTRAL_ABORTED_REASON = \"The step was aborted.\";\n\n/**\n * The error a step run task stores for an unexpected error (not a `StepRunFailure`); the raw error\n * is only logged (R146, D188).\n */\nexport const STEP_RUN_UNEXPECTED_ERROR_MESSAGE = \"The step run failed.\";\nexport const STEP_RUN_UNEXPECTED_ERROR_CODE = \"Workflows/StepRun/Failed\";\n"],"names":["STEP_RUN_TASK_DEFINITION_ID","STEP_RUN_MAX_ITERATIONS","STEP_RUN_TASKID_WAIT_TRIES","STEP_RUN_TASKID_WAIT_SECONDS","DEFAULT_AUTOMATION_MAX_ITERATIONS","STEP_RUN_STUCK_GRACE_MS","STEP_RUN_TIMEOUT_MARGIN_MS","STEP_RUN_MIN_TIMEOUT_MS","STEP_RUN_STALE_CHECK_INTERVAL_MS","STEP_RUN_NEUTRAL_FAILED_REASON","STEP_RUN_NEUTRAL_ABORTED_REASON","STEP_RUN_UNEXPECTED_ERROR_MESSAGE","STEP_RUN_UNEXPECTED_ERROR_CODE"],"mappings":"AACO,MAAMA,8BAA8B;AAMpC,MAAMC,0BAA0B;AAMhC,MAAMC,6BAA6B;AAGnC,MAAMC,+BAA+B;AAGrC,MAAMC,oCAAoC;AAO1C,MAAMC,0BAA0B;AAMhC,MAAMC,6BAA6B;AAMnC,MAAMC,0BAA0B;AAMhC,MAAMC,mCAAmC;AAGzC,MAAMC,iCAAiC;AAGvC,MAAMC,kCAAkC;AAMxC,MAAMC,oCAAoC;AAC1C,MAAMC,iCAAiC"}

package/features/stepRun/types.d.ts

@@ -0,0 +1,8 @@
+/**
+ * The only input of the step run task (R142). The handler reads nothing else from it (R148):
+ * the definition, settings and models come from the review snapshot.
+ */
+export interface StepRunTaskInput {
+    reviewId: string;
+    stepId: string;
+}

package/features/stepTypes/AutomationStepType/AutomationStepType.d.ts

@@ -0,0 +1,40 @@
+import { Result } from "@webiny/feature/api";
+import { StepRunReachService } from "../../../features/stepRun/StepRunReachService/index.js";
+import { WorkflowValidationError } from "../../../domain/workflow/errors.js";
+import { AutomationDefinitionRegistryService } from "../../../features/automation/AutomationDefinitionRegistryService/abstractions.js";
+import { StepType } from "../../../features/stepTypes/StepType/abstractions.js";
+/**
+ * The built-in automation step (spec 7.2, R133): runs a developer-written `AutomationDefinition`
+ * chosen by `config.automationId`. Save-time validation checks the definition exists, covers the
+ * workflow's models and accepts the settings (D35, D37, R137). `reach` checks the same things
+ * again and hands the trigger to `StepRunReachService` (R149, R168).
+ */
+declare class AutomationStepTypeImpl implements StepType.Interface {
+    private definitions;
+    private stepRunReach;
+    readonly type = "automation";
+    readonly title = "Automation";
+    readonly configSchema: import("zod").ZodObject<{
+        automationId: import("zod").ZodString;
+        settings: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodUnknown>;
+    }, import("zod/v4/core").$strip>;
+    constructor(definitions: AutomationDefinitionRegistryService.Interface, stepRunReach: StepRunReachService.Interface);
+    describeAvailability(): Promise<StepType.Availability>;
+    validate({ step, workflow }: StepType.ValidateParams): Result<never, WorkflowValidationError> | Result<{
+        id: string;
+        title: string;
+        color: string;
+        description?: string;
+        type: string;
+        notifications: import("../../../domain/workflow/types").WorkflowStepNotification[];
+        config: {
+            automationId: string;
+            settings: Record<string, unknown>;
+        };
+    }, never>;
+    reach({ review, step, actor, now }: StepType.ReachParams): Promise<Result<void, import("../../stepRun/StepRunReachService/abstractions").StepRunReachError>>;
+}
+export declare const AutomationStepType: typeof AutomationStepTypeImpl & {
+    __abstraction: import("@webiny/di").Abstraction<import("~/features/stepTypes/StepType/abstractions.js").IStepType>;
+};
+export {};

package/features/stepTypes/AutomationStepType/AutomationStepType.js

@@ -0,0 +1,89 @@
+import { Result } from "@webiny/feature/api";
+import { getAutomationActor } from "../../../domain/automation/getAutomationActor.js";
+import { StepRunReachService } from "../../stepRun/StepRunReachService/index.js";
+import { WorkflowValidationError } from "../../../domain/workflow/errors.js";
+import { AUTOMATION_STEP_TYPE } from "../../../domain/workflow/stepTypes.js";
+import { automationStepConfigSchema } from "../../../domain/automation/automationStepConfigSchema.js";
+import { matchesAutomationScope } from "../../../domain/automation/matchesAutomationScope.js";
+import { parseAutomationSettings } from "../../../domain/automation/parseAutomationSettings.js";
+import { parseAutomationSettingsIssue } from "../../../domain/automation/parseAutomationSettingsIssue.js";
+import { AutomationDefinitionRegistryService } from "../../automation/AutomationDefinitionRegistryService/abstractions.js";
+import { StepType } from "../StepType/abstractions.js";
+const fail = (message, stepId, field)=>Result.fail(new WorkflowValidationError(message, {
+        stepId,
+        field
+    }));
+class AutomationStepTypeImpl {
+    constructor(definitions, stepRunReach){
+        this.definitions = definitions;
+        this.stepRunReach = stepRunReach;
+        this.type = AUTOMATION_STEP_TYPE;
+        this.title = "Automation";
+        this.configSchema = automationStepConfigSchema;
+    }
+    async describeAvailability() {
+        if (0 === this.definitions.list().length) return {
+            available: false,
+            unavailableReason: "No automation is defined."
+        };
+        return {
+            available: true,
+            unavailableReason: null
+        };
+    }
+    validate({ step, workflow }) {
+        const shell = automationStepConfigSchema.safeParse(step.config);
+        if (!shell.success) return fail(`Step "${step.title}" needs an automation.`, step.id, "config.automationId");
+        const { automationId, settings } = shell.data;
+        const definition = this.definitions.get(automationId);
+        if (!definition) return fail(`Step "${step.title}" uses the automation "${automationId}", which is not defined.`, step.id, "config.automationId");
+        if (!matchesAutomationScope(definition.models, workflow.models)) return fail(`Automation "${automationId}" is not available for this workflow's models.`, step.id, "config.automationId");
+        const parsed = parseAutomationSettingsIssue(definition.settingsSchema, settings);
+        if (parsed.isFail()) {
+            const { path, message } = parsed.error;
+            const detail = path ? `${path}: ${message}` : message;
+            const field = path ? `config.settings.${path}` : "config.settings";
+            return fail(`Step "${step.title}" settings are not valid: ${detail}.`, step.id, field);
+        }
+        return Result.ok({
+            ...step,
+            config: {
+                automationId,
+                settings
+            }
+        });
+    }
+    async reach({ review, step, actor, now }) {
+        const data = review.toData();
+        let failure = null;
+        const config = automationStepConfigSchema.safeParse(step.config);
+        if (config.success) {
+            const automationId = config.data.automationId;
+            const definition = this.definitions.get(automationId);
+            if (definition) if (matchesAutomationScope(definition.models, data.workflow.models)) {
+                const settings = parseAutomationSettings(definition.settingsSchema, config.data.settings);
+                if (settings.isFail()) failure = `The automation settings are not valid: ${settings.error}.`;
+            } else failure = `The automation "${automationId}" is not available for this workflow's models.`;
+            else failure = `The automation "${automationId}" is not available.`;
+        } else failure = "The automation step configuration is not valid.";
+        return this.stepRunReach.reach({
+            review,
+            step,
+            actor,
+            owner: getAutomationActor(data.createdBy),
+            now,
+            failure,
+            startFailure: "The automation could not be started."
+        });
+    }
+}
+const AutomationStepType = StepType.createImplementation({
+    implementation: AutomationStepTypeImpl,
+    dependencies: [
+        AutomationDefinitionRegistryService,
+        StepRunReachService
+    ]
+});
+export { AutomationStepType };
+
+//# sourceMappingURL=AutomationStepType.js.map

package/features/stepTypes/AutomationStepType/AutomationStepType.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"features/stepTypes/AutomationStepType/AutomationStepType.js","sources":["../../../../src/features/stepTypes/AutomationStepType/AutomationStepType.ts"],"sourcesContent":["import { Result } from \"@webiny/feature/api\";\nimport { getAutomationActor } from \"~/domain/automation/getAutomationActor.js\";\nimport { StepRunReachService } from \"~/features/stepRun/StepRunReachService/index.js\";\nimport { WorkflowValidationError } from \"~/domain/workflow/errors.js\";\nimport { AUTOMATION_STEP_TYPE } from \"~/domain/workflow/stepTypes.js\";\nimport { automationStepConfigSchema } from \"~/domain/automation/automationStepConfigSchema.js\";\nimport { matchesAutomationScope } from \"~/domain/automation/matchesAutomationScope.js\";\nimport { parseAutomationSettings } from \"~/domain/automation/parseAutomationSettings.js\";\nimport { parseAutomationSettingsIssue } from \"~/domain/automation/parseAutomationSettingsIssue.js\";\nimport { AutomationDefinitionRegistryService } from \"~/features/automation/AutomationDefinitionRegistryService/abstractions.js\";\nimport { StepType } from \"~/features/stepTypes/StepType/abstractions.js\";\n\nconst fail = (message: string, stepId: string, field: string) => {\n    return Result.fail(new WorkflowValidationError(message, { stepId, field }));\n};\n\n/**\n * The built-in automation step (spec 7.2, R133): runs a developer-written `AutomationDefinition`\n * chosen by `config.automationId`. Save-time validation checks the definition exists, covers the\n * workflow's models and accepts the settings (D35, D37, R137). `reach` checks the same things\n * again and hands the trigger to `StepRunReachService` (R149, R168).\n */\nclass AutomationStepTypeImpl implements StepType.Interface {\n    public readonly type = AUTOMATION_STEP_TYPE;\n    public readonly title = \"Automation\";\n    public readonly configSchema = automationStepConfigSchema;\n\n    public constructor(\n        private definitions: AutomationDefinitionRegistryService.Interface,\n        private stepRunReach: StepRunReachService.Interface\n    ) {}\n\n    public async describeAvailability(): Promise<StepType.Availability> {\n        if (this.definitions.list().length === 0) {\n            return { available: false, unavailableReason: \"No automation is defined.\" };\n        }\n        return { available: true, unavailableReason: null };\n    }\n\n    public validate({ step, workflow }: StepType.ValidateParams) {\n        const shell = automationStepConfigSchema.safeParse(step.config);\n        if (!shell.success) {\n            return fail(\n                `Step \"${step.title}\" needs an automation.`,\n                step.id,\n                \"config.automationId\"\n            );\n        }\n        const { automationId, settings } = shell.data;\n\n        const definition = this.definitions.get(automationId);\n        if (!definition) {\n            return fail(\n                `Step \"${step.title}\" uses the automation \"${automationId}\", which is not defined.`,\n                step.id,\n                \"config.automationId\"\n            );\n        }\n        if (!matchesAutomationScope(definition.models, workflow.models)) {\n            return fail(\n                `Automation \"${automationId}\" is not available for this workflow's models.`,\n                step.id,\n                \"config.automationId\"\n            );\n        }\n\n        const parsed = parseAutomationSettingsIssue(definition.settingsSchema, settings);\n        if (parsed.isFail()) {\n            const { path, message } = parsed.error;\n            const detail = path ? `${path}: ${message}` : message;\n            const field = path ? `config.settings.${path}` : \"config.settings\";\n            return fail(`Step \"${step.title}\" settings are not valid: ${detail}.`, step.id, field);\n        }\n\n        // Stored as the author entered them (R137): the parse above only validates. Every use\n        // (reach, run) parses the stored settings again, so a transform schema keeps working.\n        return Result.ok({ ...step, config: { automationId, settings } });\n    }\n\n    public async reach({ review, step, actor, now }: StepType.ReachParams) {\n        const data = review.toData();\n\n        // Everything that can stop the step from running is checked here, in this order, and ends\n        // in a fixed reason (R146). The same checks run again before every run (R148).\n        let failure: string | null = null;\n        const config = automationStepConfigSchema.safeParse(step.config);\n        if (!config.success) {\n            // A config that no longer parses has its own reason (P3), not the missing-definition one.\n            failure = \"The automation step configuration is not valid.\";\n        } else {\n            const automationId = config.data.automationId;\n            const definition = this.definitions.get(automationId);\n            if (!definition) {\n                failure = `The automation \"${automationId}\" is not available.`;\n            } else if (!matchesAutomationScope(definition.models, data.workflow.models)) {\n                failure = `The automation \"${automationId}\" is not available for this workflow's models.`;\n            } else {\n                const settings = parseAutomationSettings(\n                    definition.settingsSchema,\n                    config.data.settings\n                );\n                if (settings.isFail()) {\n                    failure = `The automation settings are not valid: ${settings.error}.`;\n                }\n            }\n        }\n\n        // Trigger as the requester, reach, abort and fail are the shared reach path (R168).\n        return this.stepRunReach.reach({\n            review,\n            step,\n            actor,\n            owner: getAutomationActor(data.createdBy),\n            now,\n            failure,\n            startFailure: \"The automation could not be started.\"\n        });\n    }\n}\n\nexport const AutomationStepType = StepType.createImplementation({\n    implementation: AutomationStepTypeImpl,\n    dependencies: [AutomationDefinitionRegistryService, StepRunReachService]\n});\n"],"names":["fail","message","stepId","field","Result","WorkflowValidationError","AutomationStepTypeImpl","definitions","stepRunReach","AUTOMATION_STEP_TYPE","automationStepConfigSchema","step","workflow","shell","automationId","settings","definition","matchesAutomationScope","parsed","parseAutomationSettingsIssue","path","detail","review","actor","now","data","failure","config","parseAutomationSettings","getAutomationActor","AutomationStepType","StepType","AutomationDefinitionRegistryService","StepRunReachService"],"mappings":"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"}

package/features/stepTypes/ReviewStepType/ReviewStepType.d.ts

@@ -0,0 +1,86 @@
+import { Result } from "@webiny/feature/api";
+import { FeatureFlags } from "@webiny/api-core/features/featureFlags/abstractions.js";
+import { WorkflowValidationError } from "../../../domain/workflow/errors.js";
+import { StepAssignmentResolver } from "../../../features/review/StepAssignmentResolver/abstractions.js";
+import { StepType } from "../../../features/stepTypes/StepType/abstractions.js";
+/**
+ * The built-in review step (spec 4.1, R131): a person reviews, the step is routed to a team
+ * (spec 6). Reaching a step resolves its assignment (`StepAssignmentResolver`) and applies it.
+ * It needs teams: with the teams switch off it reports itself unavailable (R290).
+ */
+declare class ReviewStepTypeImpl implements StepType.Interface {
+    private resolver;
+    private featureFlags;
+    readonly type = "review";
+    readonly title = "Review";
+    readonly configSchema: import("zod").ZodObject<{
+        teams: import("zod").ZodArray<import("zod").ZodString>;
+        assignment: import("zod").ZodObject<{
+            strategy: import("zod").ZodEnum<{
+                leastLoaded: "leastLoaded";
+                none: "none";
+                roundRobin: "roundRobin";
+            }>;
+            allowManualPick: import("zod").ZodBoolean;
+            rules: import("zod").ZodArray<import("zod").ZodObject<{
+                id: import("zod").ZodString;
+                conditions: import("zod").ZodObject<{
+                    requesterUserId: import("zod").ZodOptional<import("zod").ZodString>;
+                    requesterTeamId: import("zod").ZodOptional<import("zod").ZodString>;
+                    folder: import("zod").ZodOptional<import("zod").ZodObject<{
+                        id: import("zod").ZodString;
+                        type: import("zod").ZodString;
+                        includeDescendants: import("zod").ZodBoolean;
+                    }, import("zod/v4/core").$strip>>;
+                    modelId: import("zod").ZodOptional<import("zod").ZodString>;
+                }, import("zod/v4/core").$strip>;
+                target: import("zod").ZodObject<{
+                    type: import("zod").ZodEnum<{
+                        team: "team";
+                        user: "user";
+                    }>;
+                    id: import("zod").ZodString;
+                }, import("zod/v4/core").$strip>;
+            }, import("zod/v4/core").$strip>>;
+        }, import("zod/v4/core").$strip>;
+    }, import("zod/v4/core").$strip>;
+    constructor(resolver: StepAssignmentResolver.Interface, featureFlags: FeatureFlags.Interface);
+    describeAvailability(): Promise<StepType.Availability>;
+    validate({ step }: StepType.ValidateParams): Result<never, WorkflowValidationError> | Result<{
+        id: string;
+        title: string;
+        color: string;
+        description?: string;
+        type: string;
+        notifications: import("../../../domain/workflow/types").WorkflowStepNotification[];
+        config: {
+            teams: string[];
+            assignment: {
+                strategy: "leastLoaded" | "none" | "roundRobin";
+                allowManualPick: boolean;
+                rules: {
+                    id: string;
+                    conditions: {
+                        requesterUserId?: string | undefined;
+                        requesterTeamId?: string | undefined;
+                        folder?: {
+                            id: string;
+                            type: string;
+                            includeDescendants: boolean;
+                        } | undefined;
+                        modelId?: string | undefined;
+                    };
+                    target: {
+                        type: "team" | "user";
+                        id: string;
+                    };
+                }[];
+            };
+        };
+    }, never>;
+    reach({ review, step, actor, now }: StepType.ReachParams): Promise<Result<void, import("../../../domain/review/errors").ReviewInvalidStateError>>;
+}
+export declare const ReviewStepType: typeof ReviewStepTypeImpl & {
+    __abstraction: import("@webiny/di").Abstraction<import("~/features/stepTypes/StepType/abstractions.js").IStepType>;
+};
+export {};

package/features/stepTypes/ReviewStepType/ReviewStepType.js

@@ -0,0 +1,78 @@
+import { Result } from "@webiny/feature/api";
+import { FeatureFlags } from "@webiny/api-core/features/featureFlags/abstractions.js";
+import { TEAMS_FEATURE_FLAG } from "../../../constants.js";
+import { WorkflowValidationError } from "../../../domain/workflow/errors.js";
+import { findReviewStepConfigProblem } from "../../../domain/workflow/findReviewStepConfigProblem.js";
+import { findRuleWithoutTarget } from "../../../domain/workflow/findRuleWithoutTarget.js";
+import { getConfigIssueField } from "../../../domain/workflow/getConfigIssueField.js";
+import { RULES_FIELD, RULE_TARGET_FIELD, RULE_TARGET_TEAM_OUTSIDE_TEAMS_MESSAGE, getRuleIdDuplicateMessage, getRuleTargetMissingMessage } from "../../../domain/workflow/ruleErrorMessages.js";
+import { reviewStepConfigSchema } from "../../../domain/workflow/reviewStepConfigSchema.js";
+import { REVIEW_STEP_TYPE } from "../../../domain/workflow/stepTypes.js";
+import { StepAssignmentResolver } from "../../review/StepAssignmentResolver/abstractions.js";
+import { StepType } from "../StepType/abstractions.js";
+const fail = (message, stepId, field, ruleId = null)=>Result.fail(new WorkflowValidationError(message, {
+        stepId,
+        field,
+        ruleId
+    }));
+const TEAMS_NOT_ENABLED_REASON = "Teams are not enabled.";
+class ReviewStepTypeImpl {
+    constructor(resolver, featureFlags){
+        this.resolver = resolver;
+        this.featureFlags = featureFlags;
+        this.type = REVIEW_STEP_TYPE;
+        this.title = "Review";
+        this.configSchema = reviewStepConfigSchema;
+    }
+    async describeAvailability() {
+        const teamsEnabled = this.featureFlags.get().isEnabled(TEAMS_FEATURE_FLAG);
+        if (!teamsEnabled) return {
+            available: false,
+            unavailableReason: TEAMS_NOT_ENABLED_REASON
+        };
+        return {
+            available: true,
+            unavailableReason: null
+        };
+    }
+    validate({ step }) {
+        const withoutTarget = findRuleWithoutTarget(step.config);
+        if (withoutTarget) return fail(getRuleTargetMissingMessage(step.title), step.id, RULE_TARGET_FIELD, withoutTarget.ruleId);
+        const parsed = reviewStepConfigSchema.safeParse(step.config);
+        if (!parsed.success) {
+            const [issue] = parsed.error.issues;
+            const field = getConfigIssueField(issue?.path ?? []);
+            return fail(`Step "${step.title}" has an invalid configuration: ${issue?.message ?? "unknown error"}`, step.id, field);
+        }
+        const problem = findReviewStepConfigProblem(parsed.data);
+        if (problem?.type === "noTeams") return fail(`Step "${step.title}" needs at least one team.`, step.id, "config.teams");
+        if (problem?.type === "duplicateRuleId") return fail(getRuleIdDuplicateMessage(step.title, problem.ruleId), step.id, RULES_FIELD);
+        if (problem?.type === "teamTargetOutsideTeams") return fail(RULE_TARGET_TEAM_OUTSIDE_TEAMS_MESSAGE, step.id, RULE_TARGET_FIELD, problem.ruleId);
+        return Result.ok({
+            ...step,
+            config: parsed.data
+        });
+    }
+    async reach({ review, step, actor, now }) {
+        const resolution = await this.resolver.resolve({
+            review: review.toData(),
+            step,
+            now: new Date(now)
+        });
+        return review.reach({
+            resolution,
+            actor,
+            now
+        });
+    }
+}
+const ReviewStepType = StepType.createImplementation({
+    implementation: ReviewStepTypeImpl,
+    dependencies: [
+        StepAssignmentResolver,
+        FeatureFlags
+    ]
+});
+export { ReviewStepType };
+
+//# sourceMappingURL=ReviewStepType.js.map

package/features/stepTypes/ReviewStepType/ReviewStepType.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"features/stepTypes/ReviewStepType/ReviewStepType.js","sources":["../../../../src/features/stepTypes/ReviewStepType/ReviewStepType.ts"],"sourcesContent":["import { Result } from \"@webiny/feature/api\";\nimport { FeatureFlags } from \"@webiny/api-core/features/featureFlags/abstractions.js\";\nimport { TEAMS_FEATURE_FLAG } from \"~/constants.js\";\nimport { WorkflowValidationError } from \"~/domain/workflow/errors.js\";\nimport { findReviewStepConfigProblem } from \"~/domain/workflow/findReviewStepConfigProblem.js\";\nimport { findRuleWithoutTarget } from \"~/domain/workflow/findRuleWithoutTarget.js\";\nimport { getConfigIssueField } from \"~/domain/workflow/getConfigIssueField.js\";\nimport { getRuleTargetMissingMessage } from \"~/domain/workflow/ruleErrorMessages.js\";\nimport { getRuleIdDuplicateMessage } from \"~/domain/workflow/ruleErrorMessages.js\";\nimport { RULE_TARGET_FIELD } from \"~/domain/workflow/ruleErrorMessages.js\";\nimport { RULES_FIELD } from \"~/domain/workflow/ruleErrorMessages.js\";\nimport { RULE_TARGET_TEAM_OUTSIDE_TEAMS_MESSAGE } from \"~/domain/workflow/ruleErrorMessages.js\";\nimport { reviewStepConfigSchema } from \"~/domain/workflow/reviewStepConfigSchema.js\";\nimport { REVIEW_STEP_TYPE } from \"~/domain/workflow/stepTypes.js\";\nimport { StepAssignmentResolver } from \"~/features/review/StepAssignmentResolver/abstractions.js\";\nimport { StepType } from \"~/features/stepTypes/StepType/abstractions.js\";\n\nconst fail = (message: string, stepId: string, field: string, ruleId: string | null = null) => {\n    return Result.fail(new WorkflowValidationError(message, { stepId, field, ruleId }));\n};\n\n/** Why the type cannot be added while teams are off (R290, Q59.5). */\nconst TEAMS_NOT_ENABLED_REASON = \"Teams are not enabled.\";\n\n/**\n * The built-in review step (spec 4.1, R131): a person reviews, the step is routed to a team\n * (spec 6). Reaching a step resolves its assignment (`StepAssignmentResolver`) and applies it.\n * It needs teams: with the teams switch off it reports itself unavailable (R290).\n */\nclass ReviewStepTypeImpl implements StepType.Interface {\n    public readonly type = REVIEW_STEP_TYPE;\n    public readonly title = \"Review\";\n    public readonly configSchema = reviewStepConfigSchema;\n\n    public constructor(\n        private resolver: StepAssignmentResolver.Interface,\n        private featureFlags: FeatureFlags.Interface\n    ) {}\n\n    public async describeAvailability(): Promise<StepType.Availability> {\n        // R287: read again on every call, never cached at registration. A throw reaches the step\n        // type list, which turns it into its fixed persistence error.\n        const teamsEnabled = this.featureFlags.get().isEnabled(TEAMS_FEATURE_FLAG);\n        if (!teamsEnabled) {\n            return { available: false, unavailableReason: TEAMS_NOT_ENABLED_REASON };\n        }\n        return { available: true, unavailableReason: null };\n    }\n\n    public validate({ step }: StepType.ValidateParams) {\n        // A rule without a target is named by its id, before the schema reports it by index.\n        const withoutTarget = findRuleWithoutTarget(step.config);\n        if (withoutTarget) {\n            return fail(\n                getRuleTargetMissingMessage(step.title),\n                step.id,\n                RULE_TARGET_FIELD,\n                withoutTarget.ruleId\n            );\n        }\n\n        const parsed = reviewStepConfigSchema.safeParse(step.config);\n        if (!parsed.success) {\n            const [issue] = parsed.error.issues;\n            const field = getConfigIssueField(issue?.path ?? []);\n            return fail(\n                `Step \"${step.title}\" has an invalid configuration: ${issue?.message ?? \"unknown error\"}`,\n                step.id,\n                field\n            );\n        }\n\n        // At least one team, unique rule ids, and team targets among the step's teams (spec 4.1, 6). User targets\n        // need a user lookup, so `StoreWorkflowUseCase` checks them after this validation (R122).\n        const problem = findReviewStepConfigProblem(parsed.data);\n        if (problem?.type === \"noTeams\") {\n            return fail(`Step \"${step.title}\" needs at least one team.`, step.id, \"config.teams\");\n        }\n        if (problem?.type === \"duplicateRuleId\") {\n            return fail(\n                getRuleIdDuplicateMessage(step.title, problem.ruleId),\n                step.id,\n                RULES_FIELD\n            );\n        }\n        if (problem?.type === \"teamTargetOutsideTeams\") {\n            return fail(\n                RULE_TARGET_TEAM_OUTSIDE_TEAMS_MESSAGE,\n                step.id,\n                RULE_TARGET_FIELD,\n                problem.ruleId\n            );\n        }\n\n        return Result.ok({ ...step, config: parsed.data });\n    }\n\n    public async reach({ review, step, actor, now }: StepType.ReachParams) {\n        const resolution = await this.resolver.resolve({\n            review: review.toData(),\n            step,\n            now: new Date(now)\n        });\n        return review.reach({ resolution, actor, now });\n    }\n}\n\nexport const ReviewStepType = StepType.createImplementation({\n    implementation: ReviewStepTypeImpl,\n    dependencies: [StepAssignmentResolver, FeatureFlags]\n});\n"],"names":["fail","message","stepId","field","ruleId","Result","WorkflowValidationError","TEAMS_NOT_ENABLED_REASON","ReviewStepTypeImpl","resolver","featureFlags","REVIEW_STEP_TYPE","reviewStepConfigSchema","teamsEnabled","TEAMS_FEATURE_FLAG","step","withoutTarget","findRuleWithoutTarget","getRuleTargetMissingMessage","RULE_TARGET_FIELD","parsed","issue","getConfigIssueField","problem","findReviewStepConfigProblem","getRuleIdDuplicateMessage","RULES_FIELD","RULE_TARGET_TEAM_OUTSIDE_TEAMS_MESSAGE","review","actor","now","resolution","Date","ReviewStepType","StepType","StepAssignmentResolver","FeatureFlags"],"mappings":";;;;;;;;;;;;AAiBA,MAAMA,OAAO,CAACC,SAAiBC,QAAgBC,OAAeC,SAAwB,IAAI,GAC/EC,OAAO,IAAI,CAAC,IAAIC,wBAAwBL,SAAS;QAAEC;QAAQC;QAAOC;IAAO;AAIpF,MAAMG,2BAA2B;AAOjC,MAAMC;IAKF,YACYC,QAA0C,EAC1CC,YAAoC,CAC9C;aAFUD,QAAQ,GAARA;aACAC,YAAY,GAAZA;aANI,IAAI,GAAGC;aACP,KAAK,GAAG;aACR,YAAY,GAAGC;IAK5B;IAEH,MAAa,uBAAuD;QAGhE,MAAMC,eAAe,IAAI,CAAC,YAAY,CAAC,GAAG,GAAG,SAAS,CAACC;QACvD,IAAI,CAACD,cACD,OAAO;YAAE,WAAW;YAAO,mBAAmBN;QAAyB;QAE3E,OAAO;YAAE,WAAW;YAAM,mBAAmB;QAAK;IACtD;IAEO,SAAS,EAAEQ,IAAI,EAA2B,EAAE;QAE/C,MAAMC,gBAAgBC,sBAAsBF,KAAK,MAAM;QACvD,IAAIC,eACA,OAAOhB,KACHkB,4BAA4BH,KAAK,KAAK,GACtCA,KAAK,EAAE,EACPI,mBACAH,cAAc,MAAM;QAI5B,MAAMI,SAASR,uBAAuB,SAAS,CAACG,KAAK,MAAM;QAC3D,IAAI,CAACK,OAAO,OAAO,EAAE;YACjB,MAAM,CAACC,MAAM,GAAGD,OAAO,KAAK,CAAC,MAAM;YACnC,MAAMjB,QAAQmB,oBAAoBD,OAAO,QAAQ,EAAE;YACnD,OAAOrB,KACH,CAAC,MAAM,EAAEe,KAAK,KAAK,CAAC,gCAAgC,EAAEM,OAAO,WAAW,iBAAiB,EACzFN,KAAK,EAAE,EACPZ;QAER;QAIA,MAAMoB,UAAUC,4BAA4BJ,OAAO,IAAI;QACvD,IAAIG,SAAS,SAAS,WAClB,OAAOvB,KAAK,CAAC,MAAM,EAAEe,KAAK,KAAK,CAAC,0BAA0B,CAAC,EAAEA,KAAK,EAAE,EAAE;QAE1E,IAAIQ,SAAS,SAAS,mBAClB,OAAOvB,KACHyB,0BAA0BV,KAAK,KAAK,EAAEQ,QAAQ,MAAM,GACpDR,KAAK,EAAE,EACPW;QAGR,IAAIH,SAAS,SAAS,0BAClB,OAAOvB,KACH2B,wCACAZ,KAAK,EAAE,EACPI,mBACAI,QAAQ,MAAM;QAItB,OAAOlB,OAAO,EAAE,CAAC;YAAE,GAAGU,IAAI;YAAE,QAAQK,OAAO,IAAI;QAAC;IACpD;IAEA,MAAa,MAAM,EAAEQ,MAAM,EAAEb,IAAI,EAAEc,KAAK,EAAEC,GAAG,EAAwB,EAAE;QACnE,MAAMC,aAAa,MAAM,IAAI,CAAC,QAAQ,CAAC,OAAO,CAAC;YAC3C,QAAQH,OAAO,MAAM;YACrBb;YACA,KAAK,IAAIiB,KAAKF;QAClB;QACA,OAAOF,OAAO,KAAK,CAAC;YAAEG;YAAYF;YAAOC;QAAI;IACjD;AACJ;AAEO,MAAMG,iBAAiBC,SAAS,oBAAoB,CAAC;IACxD,gBAAgB1B;IAChB,cAAc;QAAC2B;QAAwBC;KAAa;AACxD"}

package/features/stepTypes/StepType/abstractions.d.ts

@@ -0,0 +1,67 @@
+import { type Result } from "@webiny/feature/api";
+import type { ZodType } from "zod";
+import type { Review } from "../../../domain/review/Review.js";
+import type { Actor, ReviewStep } from "../../../domain/review/types.js";
+import type { ReviewInvalidStateError, ReviewStepNotCurrentError } from "../../../domain/review/errors.js";
+import type { WorkflowValidationError } from "../../../domain/workflow/errors.js";
+import type { WorkflowStep, WorkflowValues } from "../../../domain/workflow/types.js";
+export interface StepTypeAvailability {
+    available: boolean;
+    /** Why the type cannot be added now; `null` when available. */
+    unavailableReason: string | null;
+}
+export interface StepTypeValidateParams {
+    /** The step as the editor saved it; its `id` and `title` are already checked. */
+    step: WorkflowStep;
+    /** The workflow being saved (its models are already checked). */
+    workflow: WorkflowValues;
+}
+export interface StepTypeReachParams {
+    review: Review;
+    /** The pending step being reached. */
+    step: ReviewStep;
+    /** Who caused the step to be reached. */
+    actor: Actor;
+    now: string;
+}
+export interface IStepType {
+    /** Stored on `WorkflowStep.type`, e.g. "review". */
+    readonly type: string;
+    readonly title: string;
+    /** Validates the step's `config`; `null` when the type has no editable config. */
+    readonly configSchema: ZodType | null;
+    describeAvailability(): Promise<StepTypeAvailability>;
+    /**
+     * Save-time validation of one step. Pure of I/O: a type that needs a registry gets it
+     * injected. Returns the step with its normalised `config`.
+     */
+    validate(params: StepTypeValidateParams): Result<WorkflowStep, WorkflowValidationError>;
+    /**
+     * Optional save-time check that needs I/O (R165), e.g. "the chosen model has a configured
+     * connection". Runs after `validate` of every step and after the save's conflict,
+     * not-found and same-model checks, and only for a step that is new or whose normalised
+     * `config` differs from the stored workflow's, so a workflow whose external resource was
+     * removed later can still be saved without touching that step. `params.step` is the step
+     * `validate` returned. A throw is a `WorkflowPersistenceError`.
+     */
+    checkConfig?(params: StepTypeValidateParams): Promise<Result<void, WorkflowValidationError>>;
+    /**
+     * Puts the pending step of the review into its next state (spec 5.2). Returns the review's
+     * transition errors as they are (R159); never swallows one.
+     */
+    reach(params: StepTypeReachParams): Promise<Result<void, ReviewInvalidStateError | ReviewStepNotCurrentError>>;
+}
+/**
+ * A kind of workflow step (spec 4.1, 7.1, R131). Multi-registered: the engine registers `review`
+ * and `automation`; ai-powerups registers `ai` (R177). `StepTypeRegistryService` returns the last
+ * registration per `type`. The save-time validation, `listStepTypes` and the step reach go
+ * through it.
+ */
+export declare const StepType: import("@webiny/di").Abstraction<IStepType>;
+export declare namespace StepType {
+    type Interface = IStepType;
+    type Availability = StepTypeAvailability;
+    type ValidateParams = StepTypeValidateParams;
+    type CheckConfig = NonNullable<IStepType["checkConfig"]>;
+    type ReachParams = StepTypeReachParams;
+}

package/features/stepTypes/StepType/abstractions.js

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

package/features/stepTypes/StepType/abstractions.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"features/stepTypes/StepType/abstractions.js","sources":["../../../../src/features/stepTypes/StepType/abstractions.ts"],"sourcesContent":["import { createAbstraction, type Result } from \"@webiny/feature/api\";\nimport type { ZodType } from \"zod\";\nimport type { Review } from \"~/domain/review/Review.js\";\nimport type { Actor, ReviewStep } from \"~/domain/review/types.js\";\nimport type { ReviewInvalidStateError, ReviewStepNotCurrentError } from \"~/domain/review/errors.js\";\nimport type { WorkflowValidationError } from \"~/domain/workflow/errors.js\";\nimport type { WorkflowStep, WorkflowValues } from \"~/domain/workflow/types.js\";\n\nexport interface StepTypeAvailability {\n    available: boolean;\n    /** Why the type cannot be added now; `null` when available. */\n    unavailableReason: string | null;\n}\n\nexport interface StepTypeValidateParams {\n    /** The step as the editor saved it; its `id` and `title` are already checked. */\n    step: WorkflowStep;\n    /** The workflow being saved (its models are already checked). */\n    workflow: WorkflowValues;\n}\n\nexport interface StepTypeReachParams {\n    review: Review;\n    /** The pending step being reached. */\n    step: ReviewStep;\n    /** Who caused the step to be reached. */\n    actor: Actor;\n    now: string;\n}\n\nexport interface IStepType {\n    /** Stored on `WorkflowStep.type`, e.g. \"review\". */\n    readonly type: string;\n    readonly title: string;\n    /** Validates the step's `config`; `null` when the type has no editable config. */\n    readonly configSchema: ZodType | null;\n    describeAvailability(): Promise<StepTypeAvailability>;\n    /**\n     * Save-time validation of one step. Pure of I/O: a type that needs a registry gets it\n     * injected. Returns the step with its normalised `config`.\n     */\n    validate(params: StepTypeValidateParams): Result<WorkflowStep, WorkflowValidationError>;\n    /**\n     * Optional save-time check that needs I/O (R165), e.g. \"the chosen model has a configured\n     * connection\". Runs after `validate` of every step and after the save's conflict,\n     * not-found and same-model checks, and only for a step that is new or whose normalised\n     * `config` differs from the stored workflow's, so a workflow whose external resource was\n     * removed later can still be saved without touching that step. `params.step` is the step\n     * `validate` returned. A throw is a `WorkflowPersistenceError`.\n     */\n    checkConfig?(params: StepTypeValidateParams): Promise<Result<void, WorkflowValidationError>>;\n    /**\n     * Puts the pending step of the review into its next state (spec 5.2). Returns the review's\n     * transition errors as they are (R159); never swallows one.\n     */\n    reach(\n        params: StepTypeReachParams\n    ): Promise<Result<void, ReviewInvalidStateError | ReviewStepNotCurrentError>>;\n}\n\n/**\n * A kind of workflow step (spec 4.1, 7.1, R131). Multi-registered: the engine registers `review`\n * and `automation`; ai-powerups registers `ai` (R177). `StepTypeRegistryService` returns the last\n * registration per `type`. The save-time validation, `listStepTypes` and the step reach go\n * through it.\n */\nexport const StepType = createAbstraction<IStepType>(\"StepType\");\n\nexport namespace StepType {\n    export type Interface = IStepType;\n    export type Availability = StepTypeAvailability;\n    export type ValidateParams = StepTypeValidateParams;\n    export type CheckConfig = NonNullable<IStepType[\"checkConfig\"]>;\n    export type ReachParams = StepTypeReachParams;\n}\n"],"names":["StepType","createAbstraction"],"mappings":";AAkEO,MAAMA,WAAWC,kBAA6B"}

package/features/stepTypes/StepType/index.d.ts

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

package/features/stepTypes/StepType/index.js

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

package/features/stepTypes/StepTypeRegistryService/StepTypeRegistryService.d.ts

@@ -0,0 +1,12 @@
+import { StepType } from "../../../features/stepTypes/StepType/abstractions.js";
+import { StepTypeRegistryService as Abstraction } from "./abstractions.js";
+declare class StepTypeRegistryServiceImpl implements Abstraction.Interface {
+    private readonly stepTypes;
+    constructor(stepTypes: StepType.Interface[]);
+    get(type: string): StepType.Interface | null;
+    list(): StepType.Interface[];
+}
+export declare const StepTypeRegistryService: typeof StepTypeRegistryServiceImpl & {
+    __abstraction: import("@webiny/di").Abstraction<import("./abstractions.js").IStepTypeRegistryService>;
+};
+export {};

package/features/stepTypes/StepTypeRegistryService/StepTypeRegistryService.js

@@ -0,0 +1,30 @@
+import { StepType } from "../StepType/abstractions.js";
+import { StepTypeRegistryService } from "./abstractions.js";
+class StepTypeRegistryServiceImpl {
+    constructor(stepTypes){
+        this.stepTypes = new Map();
+        for (const stepType of stepTypes)this.stepTypes.set(stepType.type, stepType);
+    }
+    get(type) {
+        return this.stepTypes.get(type) ?? null;
+    }
+    list() {
+        return [
+            ...this.stepTypes.values()
+        ];
+    }
+}
+const StepTypeRegistryService_StepTypeRegistryService = StepTypeRegistryService.createImplementation({
+    implementation: StepTypeRegistryServiceImpl,
+    dependencies: [
+        [
+            StepType,
+            {
+                multiple: true
+            }
+        ]
+    ]
+});
+export { StepTypeRegistryService_StepTypeRegistryService as StepTypeRegistryService };
+
+//# sourceMappingURL=StepTypeRegistryService.js.map

package/features/stepTypes/StepTypeRegistryService/StepTypeRegistryService.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"features/stepTypes/StepTypeRegistryService/StepTypeRegistryService.js","sources":["../../../../src/features/stepTypes/StepTypeRegistryService/StepTypeRegistryService.ts"],"sourcesContent":["import { StepType } from \"~/features/stepTypes/StepType/abstractions.js\";\nimport { StepTypeRegistryService as Abstraction } from \"./abstractions.js\";\n\nclass StepTypeRegistryServiceImpl implements Abstraction.Interface {\n    private readonly stepTypes = new Map<string, StepType.Interface>();\n\n    public constructor(stepTypes: StepType.Interface[]) {\n        for (const stepType of stepTypes) {\n            this.stepTypes.set(stepType.type, stepType);\n        }\n    }\n\n    public get(type: string): StepType.Interface | null {\n        return this.stepTypes.get(type) ?? null;\n    }\n\n    public list(): StepType.Interface[] {\n        return [...this.stepTypes.values()];\n    }\n}\n\nexport const StepTypeRegistryService = Abstraction.createImplementation({\n    implementation: StepTypeRegistryServiceImpl,\n    dependencies: [[StepType, { multiple: true }]]\n});\n"],"names":["StepTypeRegistryServiceImpl","stepTypes","Map","stepType","type","StepTypeRegistryService","Abstraction","StepType"],"mappings":";;AAGA,MAAMA;IAGF,YAAmBC,SAA+B,CAAE;aAFnC,SAAS,GAAG,IAAIC;QAG7B,KAAK,MAAMC,YAAYF,UACnB,IAAI,CAAC,SAAS,CAAC,GAAG,CAACE,SAAS,IAAI,EAAEA;IAE1C;IAEO,IAAIC,IAAY,EAA6B;QAChD,OAAO,IAAI,CAAC,SAAS,CAAC,GAAG,CAACA,SAAS;IACvC;IAEO,OAA6B;QAChC,OAAO;eAAI,IAAI,CAAC,SAAS,CAAC,MAAM;SAAG;IACvC;AACJ;AAEO,MAAMC,kDAA0BC,wBAAAA,oBAAgC,CAAC;IACpE,gBAAgBN;IAChB,cAAc;QAAC;YAACO;YAAU;gBAAE,UAAU;YAAK;SAAE;KAAC;AAClD"}

package/features/stepTypes/StepTypeRegistryService/abstractions.d.ts

@@ -0,0 +1,12 @@
+import type { StepType } from "../../../features/stepTypes/StepType/abstractions.js";
+export interface IStepTypeRegistryService {
+    /** The step type for `type`; `null` when none is registered. */
+    get(type: string): StepType.Interface | null;
+    /** Registration order; the last registration per `type` wins and keeps the first one's place. */
+    list(): StepType.Interface[];
+}
+/** The registered step types (R131). */
+export declare const StepTypeRegistryService: import("@webiny/di").Abstraction<IStepTypeRegistryService>;
+export declare namespace StepTypeRegistryService {
+    type Interface = IStepTypeRegistryService;
+}

package/features/stepTypes/StepTypeRegistryService/abstractions.js

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

package/features/stepTypes/StepTypeRegistryService/abstractions.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"features/stepTypes/StepTypeRegistryService/abstractions.js","sources":["../../../../src/features/stepTypes/StepTypeRegistryService/abstractions.ts"],"sourcesContent":["import { createAbstraction } from \"@webiny/feature/api\";\nimport type { StepType } from \"~/features/stepTypes/StepType/abstractions.js\";\n\nexport interface IStepTypeRegistryService {\n    /** The step type for `type`; `null` when none is registered. */\n    get(type: string): StepType.Interface | null;\n    /** Registration order; the last registration per `type` wins and keeps the first one's place. */\n    list(): StepType.Interface[];\n}\n\n/** The registered step types (R131). */\nexport const StepTypeRegistryService =\n    createAbstraction<IStepTypeRegistryService>(\"StepTypeRegistryService\");\n\nexport namespace StepTypeRegistryService {\n    export type Interface = IStepTypeRegistryService;\n}\n"],"names":["StepTypeRegistryService","createAbstraction"],"mappings":";AAWO,MAAMA,0BACTC,kBAA4C"}

package/features/stepTypes/StepTypeRegistryService/index.d.ts

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

package/features/stepTypes/StepTypeRegistryService/index.js

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

package/features/stepTypes/feature.d.ts

@@ -0,0 +1,5 @@
+/** The step type registry and the built-in step types (R131). */
+export declare const StepTypesFeature: {
+    name: string;
+    register(container: import("@webiny/di").Container): void;
+};

package/features/stepTypes/feature.js

@@ -0,0 +1,15 @@
+import { createFeature } from "@webiny/feature/api";
+import { StepTypeRegistryService } from "./StepTypeRegistryService/StepTypeRegistryService.js";
+import { ReviewStepType } from "./ReviewStepType/ReviewStepType.js";
+import { AutomationStepType } from "./AutomationStepType/AutomationStepType.js";
+const StepTypesFeature = createFeature({
+    name: "Workflows/StepTypes",
+    register (container) {
+        container.register(StepTypeRegistryService);
+        container.register(ReviewStepType);
+        container.register(AutomationStepType);
+    }
+});
+export { StepTypesFeature };
+
+//# sourceMappingURL=feature.js.map