slicetest 0.5.0 → 0.6.0

package/dist/config.js

@@ -1,3 +1,5 @@
+/** The config files `npx slicetest` (and `slicetest()` without options) look for, in order. */
+export const CONFIG_NAMES = ["slicetest.config.yaml", "slicetest.config.yml", "slicetest.config.json"];
 export function resolveOptions(opts, root) {
     validate(opts);
     return {
@@ -6,16 +8,20 @@ export function resolveOptions(opts, root) {
         services: Object.fromEntries(Object.entries(opts.services ?? {}).map(([name, s]) => [name, { ...s, ready: s.ready && resolveReady(s.ready) }])),
         containers: opts.containers ?? {},
         mail: opts.mail ?? false,
+        offline: opts.offline ?? false,
+        workers: opts.workers,
         auth: opts.auth === true ? {} : (opts.auth ?? false),
-        db: resolveDb(opts.db ?? {}),
+        db: opts.db === false ? { ...resolveDb({}), none: true } : resolveDb(opts.db ?? {}),
         stubs: (opts.stubs ?? []).map(stubName),
         openapi: {
             app: typeof opts.openapi === "object" ? opts.openapi.spec : opts.openapi,
+            fromApp: typeof opts.openapi === "object" ? opts.openapi.fromApp : undefined,
             minCoverage: typeof opts.openapi === "object" ? opts.openapi.minCoverage : undefined,
             stubs: Object.fromEntries((opts.stubs ?? []).flatMap((s) => (typeof s === "object" && s.openapi ? [[s.name, s.openapi]] : []))),
             autoReply: (opts.stubs ?? []).flatMap((s) => (typeof s === "object" && s.autoReply ? [s.name] : [])),
         },
         recordings: resolveRecordings(opts.stubs ?? []),
+        intercept: Object.fromEntries((opts.stubs ?? []).flatMap((s) => (typeof s === "object" ? (s.hosts ?? []).map((h) => [h.toLowerCase(), s.name]) : []))),
         http: opts.http,
     };
 }
@@ -66,12 +72,20 @@ function validate(opts) {
             fail(`${where}.ready.path must start with "/", got "${ready.path}"`);
     };
     checkReady(opts.app.ready, "app");
+    if (opts.app.scope !== undefined && opts.app.scope !== "file" && opts.app.scope !== "worker")
+        fail(`app.scope must be "file" or "worker", got ${JSON.stringify(opts.app.scope)}`);
+    const checkBuild = (build, where) => {
+        if (build !== undefined && (typeof build !== "string" || !build.trim()))
+            fail(`${where}.build must be a command, e.g. "npm run build"`);
+    };
+    checkBuild(opts.app.build, "app");
     for (const [name, s] of Object.entries(opts.services ?? {})) {
         if (!/^[\w-]+$/.test(name))
             fail(`service name "${name}" may only contain letters, digits, "_" and "-"`);
         if (!s || typeof s.command !== "string" || !s.command.trim())
             fail(`services.${name}.command is required`);
         checkReady(s.ready, `services.${name}`);
+        checkBuild(s.build, `services.${name}`);
     }
     for (const [name, c] of Object.entries(opts.containers ?? {})) {
         if (!/^[\w-]+$/.test(name))
@@ -86,6 +100,10 @@ function validate(opts) {
                 fail(`containers.${name}.${key} must be a list of strings, e.g. ["redis-cli", "FLUSHALL"]`);
         }
     }
+    if (opts.workers !== undefined && !(Number.isInteger(opts.workers) && opts.workers >= 1))
+        fail(`workers must be a positive whole number, got ${JSON.stringify(opts.workers)}`);
+    if (opts.offline !== undefined && typeof opts.offline !== "boolean")
+        fail(`offline must be true or false, got ${JSON.stringify(opts.offline)}`);
     if (opts.mail !== undefined && typeof opts.mail !== "boolean")
         fail(`mail must be true or false, got ${JSON.stringify(opts.mail)}`);
     if (opts.auth !== undefined && typeof opts.auth !== "boolean") {
@@ -99,16 +117,21 @@ function validate(opts) {
         if (opts.auth.claims !== undefined && (!opts.auth.claims || typeof opts.auth.claims !== "object" || Array.isArray(opts.auth.claims)))
             fail("auth.claims must be a mapping of claim names to values");
     }
-    const engine = opts.db?.engine;
+    const dbOpts = opts.db === false ? undefined : opts.db;
+    const engine = dbOpts?.engine;
     if (engine !== undefined && engine !== "postgres" && engine !== "mysql" && engine !== "sqlite")
         fail(`db.engine must be "postgres", "mysql" or "sqlite", got ${JSON.stringify(engine)}`);
-    if (opts.db?.queries !== undefined && typeof opts.db.queries !== "boolean")
-        fail(`db.queries must be true or false, got ${JSON.stringify(opts.db.queries)}`);
-    if (engine === "sqlite" && opts.db?.queries)
+    if (dbOpts?.queries !== undefined && typeof dbOpts.queries !== "boolean")
+        fail(`db.queries must be true or false, got ${JSON.stringify(dbOpts.queries)}`);
+    if (dbOpts?.neon !== undefined && typeof dbOpts.neon !== "boolean")
+        fail(`db.neon must be true or false, got ${JSON.stringify(dbOpts.neon)}`);
+    if (dbOpts?.neon && (engine === "mysql" || engine === "sqlite"))
+        fail("db.neon is Neon's protocol for Postgres; it doesn't apply to " + engine);
+    if (engine === "sqlite" && dbOpts?.queries)
         fail("db.queries needs a database server (postgres or mysql): an SQLite app opens the file directly, so there is no connection to read");
-    if (engine === "sqlite" && opts.db?.url)
+    if (engine === "sqlite" && dbOpts?.url)
         fail("db.url doesn't apply to sqlite: slicetest creates the database files itself and passes them to the app as {{db.url}} / {{db.path}}");
-    const migrate = opts.db?.migrate;
+    const migrate = dbOpts?.migrate;
     if (migrate) {
         const keys = Object.keys(migrate).filter((k) => ["atlas", "sql", "command"].includes(k));
         if (keys.length !== 1)
@@ -117,8 +140,15 @@ function validate(opts) {
     const oas = opts.openapi;
     if (oas !== undefined) {
         const spec = typeof oas === "object" && oas ? oas.spec : oas;
-        if (typeof spec !== "string" || !spec)
-            fail('openapi must be the path of an OpenAPI file, or { spec, minCoverage }');
+        const fromApp = typeof oas === "object" && oas ? oas.fromApp : undefined;
+        if (fromApp !== undefined) {
+            if (spec !== undefined)
+                fail("openapi takes either spec (a file) or fromApp (a path the app serves its spec at), not both");
+            if (typeof fromApp !== "string" || !fromApp.startsWith("/"))
+                fail(`openapi.fromApp must be a path on the app such as "/v3/api-docs", got ${JSON.stringify(fromApp)}`);
+        }
+        else if (typeof spec !== "string" || !spec)
+            fail('openapi must be the path of an OpenAPI file, or { spec, minCoverage }, or { fromApp: "/v3/api-docs" }');
         const min = typeof oas === "object" ? oas.minCoverage : undefined;
         if (min !== undefined && !(typeof min === "number" && min >= 0 && min <= 100))
             fail("openapi.minCoverage must be a percentage between 0 and 100");
@@ -132,6 +162,28 @@ function validate(opts) {
             fail(`stub "${s.name}": upstream must be an http(s) URL, got ${JSON.stringify(s.upstream)}`);
         if (typeof s === "object" && s.recordings !== undefined && !s.upstream)
             fail(`stub "${s.name}": recordings needs an upstream to record from`);
+        if (typeof s === "object" && s.hosts !== undefined) {
+            if (!Array.isArray(s.hosts) || s.hosts.length === 0)
+                fail(`stub "${s.name}": hosts must be a list of host names, e.g. ["api.github.com"]`);
+            for (const h of s.hosts) {
+                if (typeof h !== "string" || !/^(\*\.)?[a-z0-9]([a-z0-9-]*[a-z0-9])?(\.[a-z0-9]([a-z0-9-]*[a-z0-9])?)+$|^[a-z0-9-]+$/i.test(h)) {
+                    fail(`stub "${s.name}": hosts takes host names (or *.domain for every subdomain), no scheme, port or path; got ${JSON.stringify(h)}`);
+                }
+                if (["localhost", "127.0.0.1"].includes(h.toLowerCase()))
+                    fail(`stub "${s.name}": ${h} can't be intercepted; point the app at {{stub.${s.name}}} instead`);
+            }
+        }
+    }
+    const seen = new Map();
+    for (const s of opts.stubs ?? []) {
+        if (typeof s !== "object")
+            continue;
+        for (const h of s.hosts ?? []) {
+            const other = seen.get(h.toLowerCase());
+            if (other)
+                fail(`host ${h} is intercepted by both stub "${other}" and stub "${s.name}"`);
+            seen.set(h.toLowerCase(), s.name);
+        }
     }
     const stubs = (opts.stubs ?? []).map(stubName);
     for (const name of stubs) {

package/dist/containers.d.ts

@@ -19,4 +19,6 @@ export declare class Dependency {
     /** Start of a scenario: run the `reset` command, if any. */
     reset(): Promise<void>;
     stop(): Promise<void>;
+    /** Synchronous removal for a worker exiting without tearing down (Ryuk is often off with Podman). */
+    removeNow(): void;
 }

package/dist/containers.js

@@ -1,3 +1,4 @@
+import { execFileSync } from "node:child_process";
 import { configureContainerRuntime } from "./container-runtime.js";
 /**
  * A container the app depends on (Redis, a search engine, an S3 emulator),
@@ -23,7 +24,9 @@ export class Dependency {
         if (opts.ready)
             definition = definition.withWaitStrategy(Wait.forLogMessage(opts.ready.log));
         try {
-            return new Dependency(name, await definition.start(), opts);
+            const dependency = new Dependency(name, await definition.start(), opts);
+            running.add(dependency);
+            return dependency;
         }
         catch (e) {
             throw new Error(`slicetest: container "${name}" (${opts.image}) didn't start: ${e.message}`);
@@ -54,6 +57,22 @@ export class Dependency {
             await this.exec(this.opts.reset);
     }
     async stop() {
+        running.delete(this);
         await this.container.stop();
     }
+    /** Synchronous removal for a worker exiting without tearing down (Ryuk is often off with Podman). */
+    removeNow() {
+        for (const cli of ["docker", "podman"]) {
+            try {
+                execFileSync(cli, ["rm", "-f", this.container.getId()], { stdio: "ignore", timeout: 10_000, windowsHide: true });
+                return;
+            }
+            catch { }
+        }
+    }
 }
+const running = new Set();
+process.once("exit", () => {
+    for (const d of running)
+        d.removeNow();
+});

package/dist/db.d.ts

@@ -95,3 +95,5 @@ export declare class Db {
 }
 /** Short summary of `changes()` for failure output. */
 export declare function formatChanges(changes: Changes, maxRows?: number): string;
+/** The `db` of an app without a database (`db: false`): resetting is a no-op, anything else explains. */
+export declare function noDatabase(): Db;

package/dist/db.js

@@ -282,3 +282,21 @@ export function formatChanges(changes, maxRows = 3) {
 function truncate(s, max = 200) {
     return s.length > max ? `${s.slice(0, max)}…` : s;
 }
+/** The `db` of an app without a database (`db: false`): resetting is a no-op, anything else explains. */
+export function noDatabase() {
+    const off = () => {
+        throw new Error("slicetest: the app has no database (db: false), so db.* isn't available. Configure `db` to use it.");
+    };
+    return new Proxy({}, {
+        get(_, prop) {
+            if (prop === "reset" || prop === "close")
+                return async () => { };
+            if (prop === "changesSinceStart")
+                return async () => ({});
+            if (prop === "then")
+                return undefined;
+            // The real methods are async, so this rejects like they would.
+            return async () => off();
+        },
+    });
+}

package/dist/doctor.js

@@ -67,7 +67,12 @@ export async function doctor(configPath, probes = machine, env = process.env) {
     }
     // Database: a server that's there already, or a container runtime to start one in.
     const url = opts.db.engine === "sqlite" ? undefined : (opts.db.url ?? env.SLICETEST_DATABASE_URL);
-    if (opts.db.engine === "sqlite") {
+    if (opts.db.none) {
+        add("ok", "no database (db: false)");
+        if (Object.keys(opts.containers).length)
+            await checkContainerRuntime(add, probes, `runs ${Object.values(opts.containers).map((c) => c.image).join(", ")}`);
+    }
+    else if (opts.db.engine === "sqlite") {
         const [maj = 0, min = 0] = process.versions.node.split(".").map(Number);
         if (maj > 22 || (maj === 22 && min >= 5))
             add("ok", "sqlite (node:sqlite, no server needed)");
@@ -97,7 +102,10 @@ export async function doctor(configPath, probes = machine, env = process.env) {
         }
     }
     const m = opts.db.migrate;
-    if (!m)
+    if (opts.db.none) {
+        // Nothing to migrate.
+    }
+    else if (!m)
         add("warn", "db.migrate not set", "scenarios run against an empty database unless the app creates its own tables");
     else if ("atlas" in m) {
         await checkPath(add, "migrations", m.atlas.dir.replace(/^file:\/\//, ""), root, rel);
@@ -118,12 +126,16 @@ export async function doctor(configPath, probes = machine, env = process.env) {
     for (const [label, p] of [["app", opts.app], ...Object.entries(opts.services).map(([n, s]) => [`service ${n}`, s])]) {
         if (p.cwd)
             await checkPath(add, `${label} cwd`, p.cwd, root, rel);
-        const program = firstWord(p.command);
-        if (program && !/^[.\\/]|\{\{|\$/.test(program)) {
+        const seen = new Set();
+        for (const command of [p.build, p.command]) {
+            const program = command && firstWord(command);
+            if (!program || /^[.\\/]|\{\{|\$/.test(program) || seen.has(program))
+                continue;
+            seen.add(program);
             if (await onPath(program, env))
                 add("ok", `${label}: ${program} found`);
             else
-                add("warn", `${label}: ${program} not found on PATH`, `\`${p.command}\` may fail to start. Fine if a shell alias or a relative script provides it`);
+                add("warn", `${label}: ${program} not found on PATH`, `\`${command}\` may fail to start. Fine if a shell alias or a relative script provides it`);
         }
     }
     const specs = [...(opts.openapi.app ? [["app OpenAPI", opts.openapi.app]] : []), ...Object.entries(opts.openapi.stubs).map(([n, f]) => [`stub ${n} OpenAPI`, f])];

package/dist/form.d.ts

@@ -0,0 +1,45 @@
+/**
+ * Submitting an HTML form the way a browser with JavaScript off does: every
+ * successful control of the form, plus the button that was pressed. This is
+ * what makes hidden fields work without the test knowing about them: CSRF
+ * tokens (Django, Rails, Laravel) and Next.js / Remix server actions, whose
+ * forms carry the action id and bound arguments in hidden inputs.
+ */
+export interface SubmitOptions {
+    /**
+     * The submit button to press, by its text, `value`, `name` or `id`. Pressing it
+     * also picks its form. Default: the form's only submit button, or none.
+     */
+    button?: string;
+    /** The form, by `id`, `name` or position (0-based), when the page has several and no `button` picks one. */
+    form?: string | number;
+    /** Values typed into the form, by field name. A name the form doesn't have is an error (a typo, usually). */
+    fields?: Record<string, string | number | boolean | (string | number)[]>;
+}
+export interface FormRequest {
+    method: "GET" | "POST";
+    /** Path (and query) relative to the page. */
+    action: string;
+    body?: URLSearchParams | FormData;
+}
+interface Control {
+    tag: "input" | "button" | "select" | "textarea";
+    attrs: Record<string, string>;
+    /** Text content: a button's label, a textarea's value. */
+    text: string;
+    /** For select: its options. */
+    options: {
+        value: string;
+        selected: boolean;
+    }[];
+}
+interface ParsedForm {
+    attrs: Record<string, string>;
+    controls: Control[];
+}
+export declare function decodeEntities(s: string): string;
+/** The forms of a page with their controls, in document order. Controls with a `form="id"` attribute join that form. */
+export declare function parseForms(html: string): ParsedForm[];
+/** Works out the request a browser would send for this page's form. */
+export declare function formRequest(html: string, opts?: SubmitOptions): FormRequest;
+export {};

package/dist/form.js

@@ -0,0 +1,226 @@
+/**
+ * Submitting an HTML form the way a browser with JavaScript off does: every
+ * successful control of the form, plus the button that was pressed. This is
+ * what makes hidden fields work without the test knowing about them: CSRF
+ * tokens (Django, Rails, Laravel) and Next.js / Remix server actions, whose
+ * forms carry the action id and bound arguments in hidden inputs.
+ */
+const TAG = /<!--[\s\S]*?-->|<(\/?)([a-zA-Z][\w-]*)((?:\s+[^\s=>/]+(?:\s*=\s*(?:"[^"]*"|'[^']*'|[^\s>]+))?)*)\s*\/?>/g;
+const ATTR = /([^\s=>/]+)(?:\s*=\s*(?:"([^"]*)"|'([^']*)'|([^\s>]+)))?/g;
+const RAW_TEXT = new Set(["script", "style", "template"]);
+const ENTITIES = { amp: "&", lt: "<", gt: ">", quot: '"', apos: "'", nbsp: " ", "#39": "'" };
+export function decodeEntities(s) {
+    return s.replace(/&(#x[0-9a-f]+|#\d+|[a-z]+\d*);/gi, (m, e) => {
+        if (e[0] === "#") {
+            const code = e[1] === "x" || e[1] === "X" ? Number.parseInt(e.slice(2), 16) : Number.parseInt(e.slice(1), 10);
+            return Number.isFinite(code) ? String.fromCodePoint(code) : m;
+        }
+        return ENTITIES[e.toLowerCase()] ?? m;
+    });
+}
+function parseAttrs(s) {
+    const attrs = {};
+    for (const m of s.matchAll(ATTR)) {
+        const name = m[1].toLowerCase();
+        if (!(name in attrs))
+            attrs[name] = decodeEntities(m[2] ?? m[3] ?? m[4] ?? "");
+    }
+    return attrs;
+}
+const textOf = (html) => decodeEntities(html.replace(/<[^>]*>/g, "")).replace(/\s+/g, " ").trim();
+/** The forms of a page with their controls, in document order. Controls with a `form="id"` attribute join that form. */
+export function parseForms(html) {
+    const forms = [];
+    const byId = new Map();
+    const orphans = [];
+    let current;
+    let open;
+    let select;
+    let option;
+    const add = (control) => {
+        const formId = control.attrs.form;
+        if (formId !== undefined)
+            orphans.push({ formId, control });
+        else
+            current?.controls.push(control);
+    };
+    const closeOption = (end) => {
+        if (!option || !select)
+            return;
+        const value = option.attrs.value ?? textOf(html.slice(option.start, end));
+        select.options.push({ value, selected: "selected" in option.attrs });
+        option = undefined;
+    };
+    TAG.lastIndex = 0;
+    for (let m = TAG.exec(html); m; m = TAG.exec(html)) {
+        if (!m[2])
+            continue; // comment
+        const closing = m[1] === "/";
+        const tag = m[2].toLowerCase();
+        if (!closing && RAW_TEXT.has(tag)) {
+            const end = html.toLowerCase().indexOf(`</${tag}`, TAG.lastIndex);
+            TAG.lastIndex = end < 0 ? html.length : end;
+            continue;
+        }
+        if (tag === "form") {
+            if (closing)
+                current = undefined;
+            else if (!current) {
+                current = { attrs: parseAttrs(m[3] ?? ""), controls: [] };
+                forms.push(current);
+                if (current.attrs.id)
+                    byId.set(current.attrs.id, current);
+            }
+            continue;
+        }
+        if (tag === "button" || tag === "textarea") {
+            if (closing) {
+                if (open?.control.tag === tag) {
+                    open.control.text = tag === "textarea" ? decodeEntities(html.slice(open.start, m.index)).replace(/^\r?\n/, "") : textOf(html.slice(open.start, m.index));
+                    open = undefined;
+                }
+            }
+            else {
+                const control = { tag, attrs: parseAttrs(m[3] ?? ""), text: "", options: [] };
+                add(control);
+                open = { control, start: TAG.lastIndex };
+                if (tag === "textarea") {
+                    // Its content is text, not markup.
+                    const end = html.toLowerCase().indexOf("</textarea", TAG.lastIndex);
+                    TAG.lastIndex = end < 0 ? html.length : end;
+                }
+            }
+            continue;
+        }
+        if (tag === "select") {
+            if (closing) {
+                closeOption(m.index);
+                select = undefined;
+            }
+            else {
+                select = { tag, attrs: parseAttrs(m[3] ?? ""), text: "", options: [] };
+                add(select);
+            }
+            continue;
+        }
+        if (tag === "option" || tag === "optgroup") {
+            closeOption(m.index);
+            if (tag === "option" && !closing && select)
+                option = { attrs: parseAttrs(m[3] ?? ""), start: TAG.lastIndex };
+            continue;
+        }
+        if (tag === "input" && !closing)
+            add({ tag, attrs: parseAttrs(m[3] ?? ""), text: "", options: [] });
+    }
+    for (const { formId, control } of orphans)
+        byId.get(formId)?.controls.push(control);
+    return forms;
+}
+const isSubmit = (c) => (c.tag === "button" && (c.attrs.type ?? "submit").toLowerCase() === "submit") || (c.tag === "input" && ["submit", "image"].includes((c.attrs.type ?? "").toLowerCase()));
+const label = (c) => (c.tag === "button" ? c.text : (c.attrs.value ?? (c.attrs.type?.toLowerCase() === "image" ? (c.attrs.alt ?? "") : "Submit")));
+function describe(form, i) {
+    const name = form.attrs.id ? `#${form.attrs.id}` : form.attrs.name ? `name=${form.attrs.name}` : `form ${i}`;
+    const buttons = form.controls.filter(isSubmit).map((b) => JSON.stringify(label(b)));
+    return `${name} (${(form.attrs.method ?? "get").toUpperCase()} ${form.attrs.action || "<this page>"}; buttons: ${buttons.join(", ") || "none"})`;
+}
+/** Works out the request a browser would send for this page's form. */
+export function formRequest(html, opts = {}) {
+    const forms = parseForms(html);
+    const list = () => (forms.length ? forms.map((f, i) => `  ${describe(f, i)}`).join("\n") : "  (none)");
+    if (forms.length === 0)
+        throw new Error("slicetest: submit: the page has no <form>");
+    let form;
+    if (opts.form !== undefined) {
+        form = typeof opts.form === "number" ? forms[opts.form] : forms.find((f) => f.attrs.id === opts.form || f.attrs.name === opts.form);
+        if (!form)
+            throw new Error(`slicetest: submit: no form ${JSON.stringify(opts.form)} on the page. Forms:\n${list()}`);
+    }
+    let button;
+    if (opts.button !== undefined) {
+        const want = opts.button.trim();
+        const matches = (b) => [label(b).trim(), b.attrs.value, b.attrs.name, b.attrs.id].includes(want);
+        const candidates = (form ? [form] : forms).flatMap((f) => f.controls.filter((c) => isSubmit(c) && matches(c)).map((c) => ({ f, c })));
+        if (candidates.length === 0)
+            throw new Error(`slicetest: submit: no submit button ${JSON.stringify(want)}${form ? " in that form" : ""}. Forms:\n${list()}`);
+        if (candidates.length > 1 && new Set(candidates.map((x) => x.f)).size > 1) {
+            throw new Error(`slicetest: submit: ${candidates.length} forms have a button ${JSON.stringify(want)}; pick one with \`form\`. Forms:\n${list()}`);
+        }
+        form = candidates[0].f;
+        button = candidates[0].c;
+    }
+    if (!form) {
+        if (forms.length > 1)
+            throw new Error(`slicetest: submit: the page has ${forms.length} forms; pick one with \`button\` or \`form\`. Forms:\n${list()}`);
+        form = forms[0];
+    }
+    if (!button) {
+        const submits = form.controls.filter(isSubmit);
+        if (submits.length === 1)
+            button = submits[0];
+    }
+    if (button && "disabled" in button.attrs)
+        throw new Error(`slicetest: submit: the button ${JSON.stringify(label(button))} is disabled`);
+    const names = new Set(form.controls.filter((c) => c.attrs.name !== undefined && !isSubmit(c) && c.tag !== "button").map((c) => c.attrs.name));
+    const typed = new Map();
+    for (const [name, value] of Object.entries(opts.fields ?? {})) {
+        if (!names.has(name)) {
+            const shown = [...names].filter((n) => !n.startsWith("$ACTION_"));
+            throw new Error(`slicetest: submit: the form has no field "${name}". Fields: ${shown.join(", ") || "(none)"}`);
+        }
+        typed.set(name, typeof value === "boolean" ? value : (Array.isArray(value) ? value : [value]).map(String));
+    }
+    // The successful controls, in document order (HTML's "constructing the entry list").
+    // A typed value replaces what the page had: text for a field, the checked state for
+    // checkboxes and radios (true / false, or the values to check), the options of a select.
+    const entries = [];
+    const done = new Set();
+    for (const c of form.controls) {
+        const name = c.attrs.name;
+        if (name === undefined || "disabled" in c.attrs)
+            continue;
+        if (c.tag === "button" || isSubmit(c)) {
+            if (c === button)
+                entries.push([name, c.attrs.value ?? ""]);
+            continue;
+        }
+        const type = c.tag === "input" ? (c.attrs.type ?? "text").toLowerCase() : c.tag;
+        if (type === "reset" || type === "button" || type === "file")
+            continue;
+        const want = typed.get(name);
+        if (type === "checkbox" || type === "radio") {
+            const value = c.attrs.value ?? "on";
+            const checked = want === undefined ? "checked" in c.attrs : typeof want === "boolean" ? want : want.includes(value);
+            if (checked)
+                entries.push([name, value]);
+        }
+        else if (want !== undefined) {
+            // Every value goes out at the first control of that name.
+            if (!done.has(name))
+                for (const v of want === true ? ["on"] : want === false ? [] : want)
+                    entries.push([name, v]);
+            done.add(name);
+        }
+        else if (c.tag === "textarea")
+            entries.push([name, c.text]);
+        else if (c.tag === "select") {
+            const selected = c.options.filter((o) => o.selected);
+            const chosen = selected.length ? selected : "multiple" in c.attrs || c.options.length === 0 ? [] : [c.options[0]];
+            for (const o of chosen)
+                entries.push([name, o.value]);
+        }
+        else
+            entries.push([name, c.attrs.value ?? ""]);
+    }
+    const pick = (attr) => (button && button.attrs[`form${attr}`] !== undefined ? button.attrs[`form${attr}`] : form.attrs[attr]);
+    const method = (pick("method") ?? "get").toUpperCase() === "POST" ? "POST" : "GET";
+    const action = pick("action") ?? "";
+    if (method === "GET")
+        return { method, action: `${action.replace(/[?#].*$/, "")}?${new URLSearchParams(entries)}` };
+    const multipart = (pick("enctype") ?? "").toLowerCase() === "multipart/form-data";
+    if (!multipart)
+        return { method, action, body: new URLSearchParams(entries) };
+    const body = new FormData();
+    for (const [k, v] of entries)
+        body.append(k, v);
+    return { method, action, body };
+}

package/dist/global-setup.d.ts

@@ -13,3 +13,4 @@ export declare function migrationKey(opts: Pick<ResolvedOptions, "db" | "root">)
  * Windows drive paths) are made relative to the root, which is the cwd Atlas runs in.
  */
 export declare function atlasDirUrl(dir: string, root: string): string;
+export declare function buildAll(opts: Pick<ResolvedOptions, "app" | "services" | "root">): Promise<void>;