@itmetsam/samurai-framework 0.3.0 → 0.5.0

package/dist/flows/run/handlers/index.js

@@ -1,13 +1,11 @@
-import { UNSUPPORTED_KINDS } from "../../core/index.js";
+import { STEP_HANDLERS } from "../../steps/catalog.js";
 import { condition } from "./condition.js";
 import { end } from "./end.js";
 import { group } from "./group.js";
 import { parallel } from "./parallel.js";
-import { setVariable } from "./set-variable.js";
 import { start } from "./start.js";
 import { test } from "./test.js";
-import { wait } from "./wait.js";
-/** The kinds a run can execute, by kind */
+/** The kinds a run can execute, by kind: the closed ones and every built-in step */
 export const HANDLERS = {
     start,
     end,
@@ -15,8 +13,5 @@ export const HANDLERS = {
     group,
     condition,
     parallel,
-    wait,
-    "set-variable": setVariable,
+    ...STEP_HANDLERS,
 };
-/** Kinds that exist in `flows/core` and have no handler yet (core's one list) */
-export const UNSUPPORTED = UNSUPPORTED_KINDS;

package/dist/flows/run/handlers/support.d.ts

@@ -1,4 +1,4 @@
-import { type ExpressionContext, type FlowFile, type FlowNodeModel } from "../../core/index.js";
+import { type AnyNodeDefinition, type ExpressionContext, type FlowFile, type FlowNodeModel } from "../../core/index.js";
 import type { RunEvent } from "../../../runner/reporter.js";
 import type { NodeResult, NodeTest } from "../events.js";
 /** What a handler can use of the run */
@@ -14,6 +14,9 @@ export interface HandlerRun {
     runTests: (tests: NodeTest[], onEvent: (e: RunEvent) => void) => Promise<"passed" | "failed" | "cancelled">;
     sleep: (ms: number, signal: AbortSignal) => Promise<void>;
     onTestEvent: (nodeId: string, e: RunEvent) => void;
+    /** Definitions of kinds core doesn't have (steps), for expression scopes */
+    nodes: readonly AnyNodeDefinition[];
+    log: (nodeId: string, level: "info" | "warn" | "error", text: string) => void;
 }
 /** What a handler decides; the walker adds timing */
 export type Outcome = Omit<NodeResult, "durationMs"> | "cancelled";

package/dist/flows/run/handlers/support.js

@@ -19,4 +19,4 @@ export async function runNodeTests(node, run, list) {
         : { status: "failed", error: "A test failed." };
 }
 /** The checker's problem with an expression, as the builder would show it: a bypassed check fails the node the same way */
-export const problemAt = (node, run, text) => checkExpression(parseExpression(text), scopeAt(run.flow, node.id, run.environment))?.message;
+export const problemAt = (node, run, text) => checkExpression(parseExpression(text), scopeAt(run.flow, node.id, run.environment, run.nodes))?.message;

package/dist/flows/run/index.d.ts

@@ -1,8 +1,9 @@
 /** Running flows: handlers, the walker, a project's flow files. Node only; see `flows/core` for the pure half. */
 export * from "./events.js";
-export { HANDLERS, UNSUPPORTED } from "./handlers/index.js";
+export { HANDLERS } from "./handlers/index.js";
 export type { Handler, HandlerRun, Outcome } from "./handlers/index.js";
 export { runFlow, type RunFlowOptions } from "./run.js";
 export { FLOW_SUFFIX, flowsDir, listFlows, readFlow, readFlowPath, readFlows, } from "./files.js";
 export * from "./report.js";
+export { projectSteps, type StepSet } from "../steps/set.js";
 export { FlowCheckError, checkFlowInProject, chooseEnvironment, runFlowInProject, type RunFlowInProjectOptions, } from "./project.js";

package/dist/flows/run/index.js

@@ -1,7 +1,8 @@
 /** Running flows: handlers, the walker, a project's flow files. Node only; see `flows/core` for the pure half. */
 export * from "./events.js";
-export { HANDLERS, UNSUPPORTED } from "./handlers/index.js";
+export { HANDLERS } from "./handlers/index.js";
 export { runFlow } from "./run.js";
 export { FLOW_SUFFIX, flowsDir, listFlows, readFlow, readFlowPath, readFlows, } from "./files.js";
 export * from "./report.js";
+export { projectSteps } from "../steps/set.js";
 export { FlowCheckError, checkFlowInProject, chooseEnvironment, runFlowInProject, } from "./project.js";

package/dist/flows/run/project.js

@@ -1,11 +1,12 @@
 import path from "node:path";
-import { loadConfig, setActiveProject } from "../../config/config.js";
+import { projectConfig } from "../../config/config.js";
 import { checkFlow, withKeys, } from "../core/index.js";
-import { DEFAULT_SRC_DIR, resolveGroups, testId, toPosix, } from "../../runner/groups.js";
+import { DEFAULT_SRC_DIR, realPath, resolveGroups, testId, toPosix, } from "../../runner/groups.js";
 import { withProject } from "../../runner/project.js";
 import { runTests } from "../../runner/run.js";
 import TestRunner from "../../runner/test-runner.js";
 import { readFlow } from "./files.js";
+import { projectSteps } from "../steps/set.js";
 import { HANDLERS } from "./handlers/index.js";
 import { runFlow } from "./run.js";
 /** The flow has errors; nothing was run */
@@ -16,18 +17,6 @@ export class FlowCheckError extends Error {
         this.name = "FlowCheckError";
     }
 }
-/** Reads the project's config without keeping the project active (`withProject` is one at a time) */
-async function configOf(options) {
-    if (options.config)
-        return options.config;
-    setActiveProject({ dir: path.resolve(options.projectDir ?? process.cwd()) });
-    try {
-        return await loadConfig();
-    }
-    finally {
-        setActiveProject(undefined);
-    }
-}
 /** The environment: the option, else the flow's `envDefault` (when the project has it), else the config's default, else the first, else "default" */
 export function chooseEnvironment(config, flow, option) {
     const names = Object.keys(config.environments ?? {});
@@ -45,7 +34,8 @@ async function prepare(options) {
     const flow = withKeys(options.flow ?? (await readFlow(projectDir, options.flowId)));
     const unsupported = options.unsupported ?? "fail";
     // Config, environment, tests and groups (one project session, then it ends)
-    const config = await configOf({ ...options, projectDir });
+    const config = await projectConfig({ ...options, projectDir });
+    const steps = await projectSteps({ config });
     const name = chooseEnvironment(config, flow, options.environment);
     const environment = {
         name,
@@ -55,7 +45,9 @@ async function prepare(options) {
                 : {}),
         },
     };
-    const srcDir = path.resolve(projectDir, config.srcDir ?? DEFAULT_SRC_DIR);
+    // Real paths, like the registered test files
+    const realDir = realPath(projectDir);
+    const srcDir = realPath(path.resolve(realDir, config.srcDir ?? DEFAULT_SRC_DIR));
     const { tests, groups } = await withProject({
         projectDir,
         config,
@@ -69,21 +61,26 @@ async function prepare(options) {
             name: t.name,
             relative: toPosix(path.relative(srcDir, t.file)),
         }));
-        const groups = resolveGroups(config, tests.map((t) => ({ file: t.relative, name: t.name })), projectDir, srcDir);
+        const groups = resolveGroups(config, tests.map((t) => ({ file: t.relative, name: t.name })), realDir, srcDir);
         return { tests, groups };
     });
     const problems = checkFlow(flow, {
         tests: tests.map((t) => t.id),
         groups: groups.map((g) => g.name),
         environment,
-        handled: new Set(Object.keys(HANDLERS)),
+        handled: new Set([
+            ...Object.keys(HANDLERS),
+            ...Object.keys(steps.handlers),
+        ]),
         unsupported,
+        nodes: steps.nodes,
     });
     return {
         projectDir,
         flow,
         unsupported,
         config,
+        steps,
         name,
         environment,
         tests,
@@ -105,7 +102,7 @@ export async function checkFlowInProject(options) {
  * its tests through `runTests`, one after the other. One at a time per process.
  */
 export async function runFlowInProject(options) {
-    const { projectDir, flow, unsupported, config, name, environment, tests, groups, problems, } = await prepare(options);
+    const { projectDir, flow, unsupported, config, steps, name, environment, tests, groups, problems, } = await prepare(options);
     const errors = problems.filter((p) => p.level === "error");
     if (errors.length)
         throw new FlowCheckError(errors);
@@ -134,6 +131,8 @@ export async function runFlowInProject(options) {
         ...(options.onEvent && { onEvent: options.onEvent }),
         ...(options.sleep && { sleep: options.sleep }),
         unsupported,
+        handlers: { ...HANDLERS, ...steps.handlers },
+        nodes: steps.nodes,
         runTests: async ({ tests, onEvent, signal }) => {
             const summary = await run({
                 projectDir,

package/dist/flows/run/run.d.ts

@@ -30,7 +30,7 @@ export interface RunFlowOptions {
     unsupported?: "fail" | "skip";
     /** The handlers by kind. @default HANDLERS */
     handlers?: Readonly<Record<string, Handler>>;
-    /** Definitions of kinds beyond the ones `flows/core` registers (a handler needs one to be walked) */
+    /** Definitions of kinds core doesn't have. @default the built-in steps */
     nodes?: readonly AnyNodeDefinition[];
 }
 /**

package/dist/flows/run/run.js

@@ -1,4 +1,6 @@
 import { inFillOrder, meetOf, nodeDef, } from "../core/index.js";
+import logger from "../../logger/index.js";
+import { STEP_NODES } from "../steps/catalog.js";
 import { HANDLERS } from "./handlers/index.js";
 const defaultSleep = (ms, signal) => new Promise((resolve, reject) => {
     if (signal.aborted)
@@ -26,7 +28,8 @@ export async function runFlow(options) {
     const { flow, onEvent = () => { } } = options;
     const signal = options.signal ?? new AbortController().signal;
     const handlers = options.handlers ?? HANDLERS;
-    const defOf = (kind) => options.nodes?.find((d) => d.kind === kind) ??
+    const nodes = options.nodes ?? STEP_NODES;
+    const defOf = (kind) => nodes.find((d) => d.kind === kind) ??
         (() => {
             try {
                 return nodeDef(kind);
@@ -66,6 +69,8 @@ export async function runFlow(options) {
         sleep: options.sleep ?? defaultSleep,
         runTests: (tests, onTestEvent) => options.runTests({ tests, onEvent: onTestEvent, signal }),
         onTestEvent: (nodeId, event) => onEvent({ type: "test", nodeId, event }),
+        nodes,
+        log: (nodeId, level, text) => logger[level](`[${nodeId}] ${text}`),
     };
     let stopped;
     const visited = new Set();
@@ -73,6 +78,7 @@ export async function runFlow(options) {
         results[node.id] = result;
         if (node.key)
             context.nodes[node.key] = {
+                ...result.outputs,
                 status: result.status,
                 durationMs: result.durationMs,
                 error: result.error,

package/dist/flows/steps/api.d.ts

@@ -0,0 +1,23 @@
+/** Any response passes and outputs its status; a network error or a bad URL fails the node */
+export declare const api: import("./define.js").StepDefinition<import("./define.js").RunConfigOf<readonly [{
+    readonly path: "config.method";
+    readonly type: "select";
+    readonly label: "Method";
+    readonly options: {
+        label: string;
+        value: string;
+    }[];
+    readonly default: "GET";
+}, {
+    readonly path: "config.url";
+    readonly type: "expression";
+    readonly label: "URL";
+    readonly placeholder: "env.baseUrl + \"/health\"";
+    readonly default: "";
+}, {
+    readonly path: "config.body";
+    readonly type: "code";
+    readonly label: "Body";
+    readonly placeholder: "{ \"name\": \"test\" }";
+    readonly default: "";
+}]>>;

package/dist/flows/steps/api.js

@@ -0,0 +1,63 @@
+import { defineStep } from "./define.js";
+const METHODS = ["GET", "POST", "PUT", "PATCH", "DELETE"].map((m) => ({
+    label: m,
+    value: m,
+}));
+const isJson = (text) => {
+    try {
+        JSON.parse(text);
+        return true;
+    }
+    catch {
+        return false;
+    }
+};
+/** Any response passes and outputs its status; a network error or a bad URL fails the node */
+export const api = defineStep({
+    kind: "api",
+    label: "HTTP request",
+    icon: "globe",
+    section: "integrations",
+    fields: [
+        {
+            path: "config.method",
+            type: "select",
+            label: "Method",
+            options: METHODS,
+            default: "GET",
+        },
+        {
+            path: "config.url",
+            type: "expression",
+            label: "URL",
+            placeholder: 'env.baseUrl + "/health"',
+            default: "",
+        },
+        {
+            path: "config.body",
+            type: "code",
+            label: "Body",
+            placeholder: '{ "name": "test" }',
+            default: "",
+        },
+    ],
+    summary: "{config.method} {config.url}",
+    outputs: [
+        { name: "statusCode", label: "Status code" },
+        { name: "body", label: "Response body" },
+    ],
+    async run({ config, signal }) {
+        const body = config.method !== "GET" && config.body ? config.body : undefined;
+        const res = await fetch(String(config.url), {
+            method: config.method,
+            signal,
+            ...(body !== undefined && {
+                body,
+                headers: {
+                    "content-type": isJson(body) ? "application/json" : "text/plain",
+                },
+            }),
+        });
+        return { outputs: { statusCode: res.status, body: await res.text() } };
+    },
+});

package/dist/flows/steps/catalog.d.ts

@@ -0,0 +1,22 @@
+import type { AnyNodeDefinition, FlowFile, FlowProblem, StepInfo } from "../core/index.js";
+import type { Handler } from "../run/handlers/support.js";
+import { type StepDefinition } from "./define.js";
+import type { SamuraiTestConfig } from "../../types/config.js";
+/** The built-in steps, in library order */
+export declare const STEPS: readonly StepDefinition<any>[];
+export declare const STEP_NODES: readonly AnyNodeDefinition[];
+export declare const STEP_HANDLERS: Readonly<Record<string, Handler>>;
+/** The steps as data, for the app */
+export declare const stepCatalog: (steps?: readonly StepDefinition<any>[]) => StepInfo[];
+/** The project's steps as data: the built-ins, then its config's. `projectDir` defaults to the working directory. */
+export declare function listSteps(options?: {
+    projectDir?: string;
+    config?: SamuraiTestConfig;
+}): Promise<StepInfo[]>;
+/** Only the steps' own `validate` problems (the project's steps included): the app checks everything else itself */
+export declare function validateSteps(flow: FlowFile, options: {
+    tests?: string[];
+    groups?: string[];
+    projectDir?: string;
+    config?: SamuraiTestConfig;
+}): Promise<FlowProblem[]>;

package/dist/flows/steps/catalog.js

@@ -0,0 +1,36 @@
+import { infoOf } from "./define.js";
+import { BUILTIN_SET, BUILTIN_STEPS, projectSteps } from "./set.js";
+/** The built-in steps, in library order */
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+export const STEPS = BUILTIN_STEPS;
+export const STEP_NODES = BUILTIN_SET.nodes;
+export const STEP_HANDLERS = BUILTIN_SET.handlers;
+/** The steps as data, for the app */
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+export const stepCatalog = (steps = STEPS) => steps.map(infoOf);
+/** The project's steps as data: the built-ins, then its config's. `projectDir` defaults to the working directory. */
+export async function listSteps(options = {}) {
+    return [...(await projectSteps(options)).catalog];
+}
+/** Only the steps' own `validate` problems (the project's steps included): the app checks everything else itself */
+export async function validateSteps(flow, options) {
+    const set = await projectSteps(options);
+    const tests = options.tests ? new Set(options.tests) : undefined;
+    const groups = options.groups ? new Set(options.groups) : undefined;
+    return flow.nodes.flatMap((n) => {
+        const step = set.steps.find((s) => s.kind === n.kind);
+        if (!step?.validate)
+            return [];
+        const def = set.nodes.find((d) => d.kind === n.kind);
+        return step.validate({
+            ...n,
+            config: {
+                ...Object.fromEntries(step.fields.map((f) => [
+                    f.path.slice(7),
+                    "default" in f ? f.default : undefined,
+                ])),
+                ...n.config,
+            },
+        }, { label: def.label, tests, groups });
+    });
+}

package/dist/flows/steps/define.d.ts

@@ -0,0 +1,51 @@
+import { type AnyNodeDefinition, type NodeCoreDefinition, type StepField, type StepInfo } from "../core/index.js";
+type RunValueOf<F> = F extends {
+    type: "expression";
+} ? unknown : F extends {
+    type: "number";
+} ? number : F extends {
+    type: "switch";
+} ? boolean : string;
+/** `config` as `run` sees it: expression fields arrive evaluated */
+export type RunConfigOf<F extends readonly StepField[]> = {
+    [K in F[number] as K["path"] extends `config.${infer P}` ? P : never]: RunValueOf<K>;
+};
+export interface StepRunInput<C> {
+    config: C;
+    env: Readonly<Record<string, unknown>>;
+    vars: Readonly<Record<string, unknown>>;
+    node: {
+        id: string;
+        key?: string;
+        title?: string;
+    };
+    /** Aborted when the run is stopped */
+    signal: AbortSignal;
+    /** Waits, unless the run is stopped first */
+    sleep: (ms: number) => Promise<void>;
+    log: (level: "info" | "warn" | "error", text: string) => void;
+}
+export interface StepResult {
+    /** Declared in `outputs`; readable later as `nodes.<key>.<name>` */
+    outputs?: Record<string, unknown>;
+    /** Only the name the `writesVar` field holds */
+    vars?: Record<string, unknown>;
+    note?: string;
+}
+export interface StepDefinition<C = Record<string, unknown>> extends StepInfo {
+    /** Problems with this node alone; runs in the engine (checks and before a run) */
+    validate?: NodeCoreDefinition<string, any>["validate"];
+    /** What the step does in a run: return to pass, throw to fail */
+    run: (input: StepRunInput<C>) => Promise<StepResult | void>;
+}
+/** The checks every step passes: in `defineStep`, and again when a project lists it. Throws for a step that can't work. */
+export declare function checkStep(def: StepDefinition<any>, where?: string): void;
+/** Declares a flow step: one way in, one way out. Throws for a definition that can't work. */
+export declare function defineStep<const F extends readonly StepField[]>(def: Omit<StepDefinition<RunConfigOf<F>>, "fields"> & {
+    fields: F;
+}): StepDefinition<RunConfigOf<F>>;
+/** The step as data, without its functions: what the catalog holds */
+export declare function infoOf(step: StepDefinition<never>): StepInfo;
+/** The definition the walker and checkFlow use for a step */
+export declare const stepNode: (step: StepDefinition<any>) => AnyNodeDefinition;
+export {};

package/dist/flows/steps/define.js

@@ -0,0 +1,51 @@
+import { CLOSED_KINDS, RESERVED_OUTPUTS, STEP_KIND, stepNodeOf, } from "../core/index.js";
+/** The checks every step passes: in `defineStep`, and again when a project lists it. Throws for a step that can't work. */
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+export function checkStep(def, where = "") {
+    const name = `Step "${def.kind}"${where}`;
+    if (CLOSED_KINDS.includes(def.kind))
+        throw new Error(`${name}: "${def.kind}" is a closed kind; steps can't replace it.`);
+    if (!STEP_KIND.test(def.kind))
+        throw new Error(`${name}: "${def.kind}" isn't a valid step kind. Use lowercase letters, digits and -.`);
+    if (!Array.isArray(def.fields))
+        throw new Error(`${name}: fields must be a list.`);
+    for (const f of def.fields) {
+        if (!f.path.startsWith("config."))
+            throw new Error(`${name}: field "${f.path}" must be a config. path.`);
+        if (f.pattern !== undefined)
+            try {
+                new RegExp(f.pattern);
+            }
+            catch {
+                throw new Error(`${name}: field "${f.path}" has a pattern that isn't a valid regular expression.`);
+            }
+    }
+    const outputs = (def.outputs ?? []).map((o) => o.name);
+    for (const o of outputs) {
+        if (RESERVED_OUTPUTS.includes(o))
+            throw new Error(`${name}: output "${o}" is reserved.`);
+        if (outputs.indexOf(o) !== outputs.lastIndexOf(o))
+            throw new Error(`${name}: output "${o}" is declared twice.`);
+    }
+    if (def.writesVar !== undefined &&
+        !def.fields.some((f) => f.path === def.writesVar))
+        throw new Error(`${name}: writesVar "${def.writesVar}" isn't one of its fields.`);
+    if (typeof def.run !== "function")
+        throw new Error(`${name}: run must be a function.`);
+}
+/** Declares a flow step: one way in, one way out. Throws for a definition that can't work. */
+export function defineStep(def) {
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    checkStep(def);
+    return def;
+}
+/** The step as data, without its functions: what the catalog holds */
+export function infoOf(step) {
+    const { run: _run, validate: _validate, ...info } = step;
+    void _run;
+    void _validate;
+    return JSON.parse(JSON.stringify(info));
+}
+/** The definition the walker and checkFlow use for a step */
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+export const stepNode = (step) => stepNodeOf(infoOf(step), step.validate);

package/dist/flows/steps/handler.d.ts

@@ -0,0 +1,4 @@
+import { type Handler } from "../run/handlers/support.js";
+import { type StepDefinition } from "./define.js";
+/** The one handler every step runs through */
+export declare function stepHandler(step: StepDefinition<any>): Handler;

package/dist/flows/steps/handler.js

@@ -0,0 +1,82 @@
+import { evaluateText, getPath, withDefaults } from "../core/index.js";
+import { fail, problemAt } from "../run/handlers/support.js";
+import { stepNode } from "./define.js";
+const keysOf = (o) => Object.keys(o ?? {});
+/** The one handler every step runs through */
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+export function stepHandler(step) {
+    const def = stepNode(step);
+    return async (node, run) => {
+        const typed = withDefaults(def, node);
+        const config = { ...typed.config };
+        for (const f of step.fields) {
+            if (f.type !== "expression")
+                continue;
+            const text = String(getPath(typed, f.path) ?? "");
+            const problem = problemAt(node, run, text);
+            if (problem)
+                return { status: "failed", error: problem };
+            try {
+                config[f.path.slice("config.".length)] = evaluateText(text, run.context);
+            }
+            catch (e) {
+                return fail(e);
+            }
+        }
+        // A step that ignores the signal must not hold the run: Stop wins the race
+        const stopped = new Promise((resolve) => {
+            if (run.signal.aborted)
+                resolve("stopped");
+            run.signal.addEventListener("abort", () => resolve("stopped"), {
+                once: true,
+            });
+        });
+        let result;
+        try {
+            result = await Promise.race([
+                step.run({
+                    config,
+                    env: { ...run.context.env },
+                    vars: { ...run.context.vars },
+                    node: {
+                        id: node.id,
+                        ...(node.key && { key: node.key }),
+                        ...(node.title && { title: node.title }),
+                    },
+                    signal: run.signal,
+                    sleep: (ms) => run.sleep(ms, run.signal),
+                    log: (level, text) => run.log(node.id, level, text),
+                }),
+                stopped,
+            ]);
+        }
+        catch (e) {
+            if (run.signal.aborted)
+                return "cancelled";
+            return fail(e);
+        }
+        if (result === "stopped" || run.signal.aborted)
+            return "cancelled";
+        const declared = new Set((step.outputs ?? []).map((o) => o.name));
+        const extra = keysOf(result?.outputs).filter((k) => !declared.has(k));
+        if (extra.length)
+            return {
+                status: "failed",
+                error: `${step.label} returned outputs it doesn't declare: ${extra.join(", ")}.`,
+            };
+        const allowed = step.writesVar ? getPath(typed, step.writesVar) : undefined;
+        const wrongVars = keysOf(result?.vars).filter((k) => k !== allowed);
+        if (wrongVars.length)
+            return {
+                status: "failed",
+                error: `${step.label} wrote variables it doesn't declare: ${wrongVars.join(", ")}.`,
+            };
+        Object.assign(run.context.vars, result?.vars);
+        return {
+            status: "passed",
+            ...(keysOf(result?.outputs).length > 0 && { outputs: result.outputs }),
+            ...(keysOf(result?.vars).length > 0 && { wrote: result.vars }),
+            ...(result?.note && { note: result.note }),
+        };
+    };
+}

package/dist/flows/steps/index.d.ts

@@ -0,0 +1,6 @@
+/** Flow steps: define your own, and the built-in ones. Node only. */
+export { checkStep, defineStep, stepNode, type RunConfigOf, type StepDefinition, type StepResult, type StepRunInput, } from "./define.js";
+export { stepHandler } from "./handler.js";
+export { BUILTIN_SET, BUILTIN_STEPS, projectSteps, stepSet, type StepSet, } from "./set.js";
+export { STEPS, STEP_HANDLERS, STEP_NODES, listSteps, stepCatalog, validateSteps, } from "./catalog.js";
+export type { StepField, StepInfo, StepOutput, StepSection, } from "../core/index.js";

package/dist/flows/steps/index.js

@@ -0,0 +1,5 @@
+/** Flow steps: define your own, and the built-in ones. Node only. */
+export { checkStep, defineStep, stepNode, } from "./define.js";
+export { stepHandler } from "./handler.js";
+export { BUILTIN_SET, BUILTIN_STEPS, projectSteps, stepSet, } from "./set.js";
+export { STEPS, STEP_HANDLERS, STEP_NODES, listSteps, stepCatalog, validateSteps, } from "./catalog.js";

package/dist/flows/{core/nodes → steps}/set-variable.d.ts

@@ -1,9 +1,12 @@
-export declare const setVariable: import("./define.js").NodeCoreDefinition<"set-variable", import("./define.js").ConfigOf<readonly [{
+export declare const setVariable: import("./define.js").StepDefinition<import("./define.js").RunConfigOf<readonly [{
     readonly path: "config.name";
     readonly type: "text";
     readonly label: "Name";
     readonly placeholder: "orderId";
     readonly default: "";
+    readonly required: true;
+    readonly pattern: "^[a-z][a-z0-9_]*$";
+    readonly patternMessage: "use lowercase letters, digits and _ for the name.";
 }, {
     readonly path: "config.value";
     readonly type: "expression";

package/dist/flows/steps/set-variable.js

@@ -0,0 +1,31 @@
+import { defineStep } from "./define.js";
+export const setVariable = defineStep({
+    kind: "set-variable",
+    label: "Set variable",
+    icon: "braces",
+    section: "control",
+    fields: [
+        {
+            path: "config.name",
+            type: "text",
+            label: "Name",
+            placeholder: "orderId",
+            default: "",
+            required: true,
+            pattern: "^[a-z][a-z0-9_]*$",
+            patternMessage: "use lowercase letters, digits and _ for the name.",
+        },
+        {
+            path: "config.value",
+            type: "expression",
+            label: "Value",
+            placeholder: '"order-" + run.environment',
+            default: "",
+        },
+    ],
+    summary: "vars.{config.name} = {config.value}",
+    writesVar: "config.name",
+    async run({ config }) {
+        return { vars: { [config.name]: config.value } };
+    },
+});

package/dist/flows/steps/set.d.ts

@@ -0,0 +1,26 @@
+import type { SamuraiTestConfig } from "../../types/config.js";
+import type { AnyNodeDefinition, StepInfo } from "../core/index.js";
+import type { Handler } from "../run/handlers/support.js";
+import { type StepDefinition } from "./define.js";
+type AnyStep = StepDefinition<any>;
+/** The built-in steps, in library order */
+export declare const BUILTIN_STEPS: readonly AnyStep[];
+/** Everything a project's steps give the walker, the check and the app */
+export interface StepSet {
+    /** The built-ins, then the project's in config order */
+    steps: readonly AnyStep[];
+    nodes: readonly AnyNodeDefinition[];
+    handlers: Readonly<Record<string, Handler>>;
+    /** The steps as data, for the app */
+    catalog: StepInfo[];
+}
+/** The built-in steps plus a project's (its config's `steps`). Throws for a list that can't work. */
+export declare function stepSet(projectSteps?: unknown): StepSet;
+/** The built-in steps alone */
+export declare const BUILTIN_SET: StepSet;
+/** The project's steps: its config's `steps` after the built-ins. `projectDir` defaults to the working directory. */
+export declare function projectSteps(options?: {
+    projectDir?: string;
+    config?: SamuraiTestConfig;
+}): Promise<StepSet>;
+export {};