slicetest 0.1.0 → 0.3.0

package/dist/drivers/mysql.js

@@ -0,0 +1,270 @@
+import mysql from "mysql2/promise";
+/**
+ * Makes rows look like the Postgres driver's, so the same scenarios pass on
+ * both: BOOLEAN (`TINYINT(1)`) columns come back as booleans, BIGINT ids as
+ * numbers when they fit, DATETIME as UTC.
+ */
+const options = {
+    supportBigNumbers: true,
+    bigNumberStrings: false,
+    timezone: "Z",
+    multipleStatements: true,
+    typeCast(field, next) {
+        if (field.type === "TINY" && field.length === 1) {
+            const v = field.string();
+            return v === null ? null : v === "1";
+        }
+        return next();
+    },
+};
+async function connect(url) {
+    const conn = await mysql.createConnection({ uri: url, ...options });
+    // Without a listener, a dropped connection would crash the worker; the next query reports it instead.
+    conn.on("error", () => { });
+    return conn;
+}
+function rowsOf(result) {
+    return Array.isArray(result) ? result : [];
+}
+export class MysqlDriver {
+    conn;
+    #keys = new Map();
+    constructor(conn) {
+        this.conn = conn;
+    }
+    static async connect(url) {
+        return new MysqlDriver(await connect(url));
+    }
+    async query(sql, params = []) {
+        const [rows] = await this.conn.query(sql, params);
+        return rowsOf(rows);
+    }
+    async queryAll(sqls) {
+        if (sqls.length === 0)
+            return [];
+        // With multipleStatements, several SELECTs come back as one array of result sets.
+        const [results] = await this.conn.query(sqls.join(";\n"));
+        return sqls.length === 1 ? [rowsOf(results)] : results.map(rowsOf);
+    }
+    async exec(script) {
+        await this.conn.query(script);
+    }
+    ident(name) {
+        return name
+            .split(".")
+            .map((part) => this.column(part))
+            .join(".");
+    }
+    column(name) {
+        return `\`${name.replace(/`/g, "``")}\``;
+    }
+    param(_n) {
+        return "?";
+    }
+    inList(column, values, params) {
+        if (values.length === 0)
+            return "FALSE";
+        params.push(...values);
+        return `${this.ident(column)} IN (${values.map(() => "?").join(", ")})`;
+    }
+    /**
+     * Base tables in the configured schemas. In MySQL a schema is a database;
+     * `public` (the default) stands for the database the URL points at.
+     */
+    async listTables(schemas, keep) {
+        const [{ current }] = (await this.query("SELECT DATABASE() AS current"));
+        const names = schemas.map((s) => (s === "public" ? current : s));
+        const rows = await this.query(`SELECT t.TABLE_SCHEMA AS \`schema\`, t.TABLE_NAME AS name,
+              (SELECT GROUP_CONCAT(k.COLUMN_NAME ORDER BY k.ORDINAL_POSITION SEPARATOR '\\n')
+                 FROM information_schema.KEY_COLUMN_USAGE k
+                WHERE k.TABLE_SCHEMA = t.TABLE_SCHEMA AND k.TABLE_NAME = t.TABLE_NAME AND k.CONSTRAINT_NAME = 'PRIMARY') AS \`key\`
+         FROM information_schema.TABLES t
+        WHERE t.TABLE_TYPE = 'BASE TABLE' AND t.TABLE_SCHEMA IN (?)
+        ORDER BY 1, 2`, [names]);
+        return rows
+            .map((r) => ({
+            name: r.schema === current ? r.name : `${r.schema}.${r.name}`,
+            quoted: `${this.ident(r.schema)}.${this.ident(r.name)}`,
+            key: r.key ? r.key.split("\n") : [],
+            bare: r.name,
+        }))
+            .filter((t) => !keep.includes(t.bare) && !keep.includes(t.name))
+            .map(({ bare: _, ...t }) => t);
+    }
+    /**
+     * TRUNCATE also restarts AUTO_INCREMENT, but it is DDL and costs a few
+     * milliseconds per table, so only tables that have rows or a used counter are
+     * truncated. Foreign key checks are off for this session only.
+     */
+    async truncate(tables) {
+        if (tables.length === 0)
+            return;
+        const [, , counters, ...filled] = await this.queryAll([
+            // Otherwise information_schema serves AUTO_INCREMENT from a cache that can be a day old.
+            "SET SESSION information_schema_stats_expiry = 0",
+            "SELECT 1",
+            `SELECT CONCAT(TABLE_SCHEMA, '.', TABLE_NAME) AS t, AUTO_INCREMENT AS n FROM information_schema.TABLES WHERE AUTO_INCREMENT > 1`,
+            ...tables.map((t) => `SELECT 1 AS x FROM ${t.quoted} LIMIT 1`),
+        ]);
+        const used = new Set(counters.map((r) => this.ident(String(r.t))));
+        const dirty = tables.filter((t, i) => filled[i].length > 0 || used.has(t.quoted));
+        if (dirty.length === 0)
+            return;
+        await this.conn.query(`SET FOREIGN_KEY_CHECKS = 0; ${dirty.map((t) => `TRUNCATE TABLE ${t.quoted}`).join("; ")}; SET FOREIGN_KEY_CHECKS = 1`);
+    }
+    /** MySQL has no RETURNING: insert, then read the row back by its primary key. */
+    async insert(table, row) {
+        const cols = Object.keys(row);
+        const sql = cols.length === 0
+            ? `INSERT INTO ${this.ident(table)} () VALUES ()`
+            : `INSERT INTO ${this.ident(table)} (${cols.map((c) => this.column(c)).join(", ")}) VALUES (${cols.map(() => "?").join(", ")})`;
+        const [res] = (await this.conn.query(sql, Object.values(row)));
+        const key = await this.#primaryKey(table);
+        const where = {};
+        for (const k of key) {
+            if (k in row)
+                where[k] = row[k];
+            else if (key.length === 1 && res.insertId)
+                where[k] = res.insertId;
+            else
+                return [row];
+        }
+        if (key.length === 0)
+            return [row];
+        const conds = Object.keys(where).map((k) => `${this.column(k)} = ?`);
+        return this.query(`SELECT * FROM ${this.ident(table)} WHERE ${conds.join(" AND ")}`, Object.values(where));
+    }
+    async #primaryKey(table) {
+        let key = this.#keys.get(table);
+        if (!key) {
+            const [schema, name] = table.includes(".") ? table.split(".", 2) : [null, table];
+            const rows = await this.query(`SELECT COLUMN_NAME AS c FROM information_schema.KEY_COLUMN_USAGE
+          WHERE TABLE_SCHEMA = COALESCE(?, DATABASE()) AND TABLE_NAME = ? AND CONSTRAINT_NAME = 'PRIMARY'
+          ORDER BY ORDINAL_POSITION`, [schema, name]);
+            key = rows.map((r) => r.c);
+            this.#keys.set(table, key);
+        }
+        return key;
+    }
+    async close() {
+        await this.conn.end();
+    }
+}
+function withDatabase(url, database) {
+    const u = new URL(url);
+    u.pathname = `/${database}`;
+    return u.toString();
+}
+function quote(name) {
+    return `\`${name.replace(/`/g, "``")}\``;
+}
+class MysqlAdmin {
+    conn;
+    url;
+    constructor(conn, url) {
+        this.conn = conn;
+        this.url = url;
+    }
+    async databases(prefix) {
+        const [rows] = await this.conn.query("SELECT SCHEMA_NAME AS name FROM information_schema.SCHEMATA");
+        return rowsOf(rows)
+            .map((r) => String(r.name))
+            .filter((n) => n.startsWith(prefix));
+    }
+    async create(name) {
+        await this.conn.query(`CREATE DATABASE ${quote(name)}`);
+    }
+    /**
+     * MySQL has no template databases: recreate each table from `SHOW CREATE
+     * TABLE` (foreign keys included) and copy its rows, then views and triggers.
+     * Stored routines and events are not copied.
+     */
+    async clone(template, name) {
+        await this.create(name);
+        const target = await connect(withDatabase(this.url, name));
+        try {
+            await target.query("SET FOREIGN_KEY_CHECKS = 0");
+            const [tables] = await this.conn.query("SELECT TABLE_NAME AS name, TABLE_TYPE AS type FROM information_schema.TABLES WHERE TABLE_SCHEMA = ? ORDER BY TABLE_NAME", [template]);
+            const list = rowsOf(tables);
+            for (const t of list.filter((t) => t.type === "BASE TABLE")) {
+                const [[create]] = (await this.conn.query(`SHOW CREATE TABLE ${quote(template)}.${quote(t.name)}`));
+                await target.query(String(create["Create Table"]));
+                const [cols] = await this.conn.query("SELECT COLUMN_NAME AS c FROM information_schema.COLUMNS WHERE TABLE_SCHEMA = ? AND TABLE_NAME = ? AND EXTRA NOT LIKE '%GENERATED%' ORDER BY ORDINAL_POSITION", [template, t.name]);
+                const names = rowsOf(cols).map((c) => quote(String(c.c))).join(", ");
+                await target.query(`INSERT INTO ${quote(t.name)} (${names}) SELECT ${names} FROM ${quote(template)}.${quote(t.name)}`);
+            }
+            // Views may depend on each other; retry the ones that fail until no progress is made.
+            let views = list.filter((t) => t.type === "VIEW");
+            while (views.length > 0) {
+                const failed = [];
+                let lastError;
+                for (const v of views) {
+                    const [[create]] = (await this.conn.query(`SHOW CREATE VIEW ${quote(template)}.${quote(v.name)}`));
+                    const sql = String(create["Create View"]).split(`${quote(template)}.`).join("");
+                    await target.query(sql).catch((e) => {
+                        failed.push(v);
+                        lastError = e;
+                    });
+                }
+                if (failed.length === views.length)
+                    throw lastError;
+                views = failed;
+            }
+            const [triggers] = await this.conn.query(`SHOW TRIGGERS FROM ${quote(template)}`);
+            for (const trg of rowsOf(triggers)) {
+                const [[create]] = (await this.conn.query(`SHOW CREATE TRIGGER ${quote(template)}.${quote(String(trg.Trigger))}`));
+                await target.query(String(create["SQL Original Statement"]));
+            }
+        }
+        catch (e) {
+            await this.drop(name).catch(() => { });
+            throw e;
+        }
+        finally {
+            await target.end().catch(() => { });
+        }
+    }
+    /** DROP DATABASE waits for open transactions, so disconnect everyone using it first. */
+    async drop(name) {
+        const [rows] = await this.conn.query("SELECT ID AS id FROM information_schema.PROCESSLIST WHERE DB = ? AND ID <> CONNECTION_ID()", [name]);
+        for (const r of rowsOf(rows))
+            await this.conn.query(`KILL ${Number(r.id)}`).catch(() => { });
+        await this.conn.query(`DROP DATABASE IF EXISTS ${quote(name)}`);
+    }
+    async withLock(key, fn) {
+        const lock = key.slice(0, 64);
+        await this.conn.query("SELECT GET_LOCK(?, -1)", [lock]);
+        try {
+            return await fn();
+        }
+        finally {
+            await this.conn.query("SELECT RELEASE_LOCK(?)", [lock]);
+        }
+    }
+    urlFor(name) {
+        return withDatabase(this.url, name);
+    }
+    async close() {
+        await this.conn.end();
+    }
+}
+export const mysqlEngine = {
+    name: "mysql",
+    defaultImage: "mysql:8.4",
+    async startContainer(image, reuse) {
+        const { MySqlContainer } = await import("@testcontainers/mysql").catch(() => {
+            throw new Error("slicetest: starting a MySQL container needs the @testcontainers/mysql package: npm i -D @testcontainers/mysql (or set db.url)");
+        });
+        const definition = new MySqlContainer(image);
+        if (reuse)
+            definition.withReuse();
+        const container = await definition.start();
+        // Root, because slicetest creates and drops databases.
+        return { url: container.getConnectionUri(true), stop: () => container.stop() };
+    },
+    async admin(url) {
+        return new MysqlAdmin(await connect(url), url);
+    },
+    driver: (url) => MysqlDriver.connect(url),
+    atlasUrl: (url) => url,
+};

package/dist/drivers/postgres.d.ts

@@ -0,0 +1,19 @@
+import type { Driver, Engine, Row, Table } from "./driver.js";
+export declare class PostgresDriver implements Driver {
+    private readonly client;
+    private constructor();
+    static connect(url: string): Promise<PostgresDriver>;
+    query<T extends Row = Row>(sql: string, params?: unknown[]): Promise<T[]>;
+    queryAll(sqls: string[]): Promise<Row[][]>;
+    exec(script: string): Promise<void>;
+    ident(name: string): string;
+    column(name: string): string;
+    param(n: number): string;
+    inList(column: string, values: unknown[], params: unknown[]): string;
+    /** Ordinary and partitioned tables, skipping partitions and tables owned by extensions (e.g. PostGIS's `spatial_ref_sys`). */
+    listTables(schemas: string[], keep: string[]): Promise<Table[]>;
+    truncate(tables: Table[]): Promise<void>;
+    insert(table: string, row: Row): Promise<Row[]>;
+    close(): Promise<void>;
+}
+export declare const postgres: Engine;

package/dist/drivers/postgres.js

@@ -0,0 +1,164 @@
+import pg from "pg";
+const INT8 = 20;
+/** int8 columns (bigserial ids, count(*)) come back as numbers when they fit, instead of strings. */
+const types = {
+    getTypeParser(oid, format) {
+        if (oid === INT8 && format !== "binary") {
+            return (v) => {
+                const n = Number(v);
+                return Number.isSafeInteger(n) ? n : v;
+            };
+        }
+        return pg.types.getTypeParser(oid, format);
+    },
+};
+export class PostgresDriver {
+    client;
+    constructor(client) {
+        this.client = client;
+    }
+    static async connect(url) {
+        const client = new pg.Client({ connectionString: url, types });
+        // Without a listener, a dropped connection would crash the worker; the next query reports it instead.
+        client.on("error", () => { });
+        await client.connect();
+        return new PostgresDriver(client);
+    }
+    async query(sql, params = []) {
+        return (await this.client.query(sql, params)).rows;
+    }
+    async queryAll(sqls) {
+        if (sqls.length === 0)
+            return [];
+        // The simple query protocol runs several statements in one round trip.
+        const res = (await this.client.query(sqls.join(";\n")));
+        return (Array.isArray(res) ? res : [res]).map((r) => r.rows);
+    }
+    async exec(script) {
+        await this.client.query(script);
+    }
+    ident(name) {
+        return name
+            .split(".")
+            .map((part) => this.column(part))
+            .join(".");
+    }
+    column(name) {
+        return `"${name.replace(/"/g, '""')}"`;
+    }
+    param(n) {
+        return `$${n}`;
+    }
+    inList(column, values, params) {
+        params.push(values);
+        return `${this.ident(column)} = ANY($${params.length})`;
+    }
+    /** Ordinary and partitioned tables, skipping partitions and tables owned by extensions (e.g. PostGIS's `spatial_ref_sys`). */
+    async listTables(schemas, keep) {
+        const rows = await this.query(`SELECT n.nspname AS schema, c.relname AS name,
+              (SELECT array_agg(a.attname::text ORDER BY k.ord)
+                 FROM pg_index i
+                 CROSS JOIN LATERAL unnest(i.indkey) WITH ORDINALITY AS k(attnum, ord)
+                 JOIN pg_attribute a ON a.attrelid = c.oid AND a.attnum = k.attnum
+                WHERE i.indrelid = c.oid AND i.indisprimary) AS key
+         FROM pg_class c
+         JOIN pg_namespace n ON n.oid = c.relnamespace
+        WHERE c.relkind IN ('r', 'p')
+          AND NOT c.relispartition
+          AND n.nspname = ANY($1)
+          AND NOT (c.relname = ANY($2) OR n.nspname || '.' || c.relname = ANY($2))
+          AND NOT EXISTS (
+            SELECT 1 FROM pg_depend d
+             WHERE d.classid = 'pg_class'::regclass AND d.objid = c.oid AND d.deptype = 'e')
+        ORDER BY 1, 2`, [schemas, keep]);
+        return rows.map((r) => ({
+            name: r.schema === "public" ? r.name : `${r.schema}.${r.name}`,
+            quoted: `${this.ident(r.schema)}.${this.ident(r.name)}`,
+            key: r.key ?? [],
+        }));
+    }
+    async truncate(tables) {
+        if (tables.length > 0)
+            await this.client.query(`TRUNCATE ${tables.map((t) => t.quoted).join(", ")} RESTART IDENTITY CASCADE`);
+    }
+    async insert(table, row) {
+        const cols = Object.keys(row);
+        const sql = cols.length === 0
+            ? `INSERT INTO ${this.ident(table)} DEFAULT VALUES RETURNING *`
+            : `INSERT INTO ${this.ident(table)} (${cols.map((c) => this.ident(c)).join(", ")}) VALUES (${cols.map((_, i) => `$${i + 1}`).join(", ")}) RETURNING *`;
+        return this.query(sql, Object.values(row));
+    }
+    async close() {
+        await this.client.end();
+    }
+}
+function withDatabase(url, database) {
+    const u = new URL(url);
+    u.pathname = `/${database}`;
+    return u.toString();
+}
+function quote(name) {
+    return `"${name.replace(/"/g, '""')}"`;
+}
+class PostgresAdmin {
+    client;
+    url;
+    constructor(client, url) {
+        this.client = client;
+        this.url = url;
+    }
+    async databases(prefix) {
+        const { rows } = await this.client.query("SELECT datname FROM pg_database WHERE starts_with(datname, $1)", [prefix]);
+        return rows.map((r) => r.datname);
+    }
+    async create(name) {
+        await this.client.query(`CREATE DATABASE ${quote(name)}`);
+    }
+    async clone(template, name) {
+        await this.client.query(`CREATE DATABASE ${quote(name)} TEMPLATE ${quote(template)}`);
+    }
+    async drop(name) {
+        await this.client.query(`DROP DATABASE IF EXISTS ${quote(name)} WITH (FORCE)`);
+    }
+    async withLock(key, fn) {
+        await this.client.query("SELECT pg_advisory_lock(hashtext($1))", [key]);
+        try {
+            return await fn();
+        }
+        finally {
+            await this.client.query("SELECT pg_advisory_unlock(hashtext($1))", [key]);
+        }
+    }
+    urlFor(name) {
+        return withDatabase(this.url, name);
+    }
+    async close() {
+        await this.client.end();
+    }
+}
+export const postgres = {
+    name: "postgres",
+    defaultImage: "postgres:17-alpine",
+    async startContainer(image, reuse) {
+        const { PostgreSqlContainer } = await import("@testcontainers/postgresql");
+        const definition = new PostgreSqlContainer(image);
+        // A reused container is left running and found again by its configuration on the next run.
+        if (reuse)
+            definition.withReuse();
+        const container = await definition.start();
+        return { url: container.getConnectionUri(), stop: () => container.stop() };
+    },
+    async admin(url) {
+        const client = new pg.Client({ connectionString: url });
+        client.on("error", () => { });
+        await client.connect();
+        return new PostgresAdmin(client, url);
+    },
+    driver: (url) => PostgresDriver.connect(url),
+    atlasUrl(url) {
+        const u = new URL(url);
+        if (!u.searchParams.has("sslmode"))
+            u.searchParams.set("sslmode", "disable");
+        return u.toString();
+    },
+};

package/dist/gen.d.ts

@@ -0,0 +1,24 @@
+/** Where the last run's OpenAPI coverage is kept for `slicetest gen --uncovered`. */
+export declare function coverageCacheFile(root: string): string;
+export interface GenOptions {
+    /** The app's spec, relative to `root`. */
+    spec: string;
+    /** Directory for the scenario files, relative to `root`. Default `scenarios`. */
+    out?: string;
+    /** Only responses the last run didn't produce. */
+    uncovered?: boolean;
+    force?: boolean;
+}
+/**
+ * Scenario skeletons for the documented responses of an OpenAPI spec, one
+ * `<resource>.gen.scenario.yaml` per first path segment. A 2xx response gets a
+ * runnable scenario, with a request built from the spec and, when the path
+ * needs an id, a step that creates the resource first through the collection's
+ * POST. Other responses become skipped scenarios: a to-do list of the states
+ * the tests still have to arrange.
+ */
+export declare function gen(root: string, opts: GenOptions): Promise<{
+    written: string[];
+    skipped: string[];
+    count: number;
+}>;

package/dist/gen.js

@@ -0,0 +1,116 @@
+import { existsSync } from "node:fs";
+import { mkdir, readFile, writeFile } from "node:fs/promises";
+import path from "node:path";
+import { stringify } from "yaml";
+import { OpenApiSpec } from "./openapi.js";
+/** Where the last run's OpenAPI coverage is kept for `slicetest gen --uncovered`. */
+export function coverageCacheFile(root) {
+    return path.join(root, "node_modules", ".cache", "slicetest", "openapi-coverage.json");
+}
+/**
+ * Scenario skeletons for the documented responses of an OpenAPI spec, one
+ * `<resource>.gen.scenario.yaml` per first path segment. A 2xx response gets a
+ * runnable scenario, with a request built from the spec and, when the path
+ * needs an id, a step that creates the resource first through the collection's
+ * POST. Other responses become skipped scenarios: a to-do list of the states
+ * the tests still have to arrange.
+ */
+export async function gen(root, opts) {
+    const spec = await OpenApiSpec.load(path.resolve(root, opts.spec), opts.spec);
+    const ops = spec.operations();
+    let covered = new Set();
+    if (opts.uncovered) {
+        const cache = coverageCacheFile(root);
+        if (!existsSync(cache))
+            throw new Error("slicetest: no coverage from a previous run yet. Run the scenarios once (with `openapi` set), then `slicetest gen --uncovered`.");
+        covered = new Set(JSON.parse(await readFile(cache, "utf8")));
+    }
+    const files = new Map();
+    let count = 0;
+    for (const op of ops) {
+        for (const key of op.responses) {
+            if (covered.has(`${op.method} ${op.template} ${key}`))
+                continue;
+            const resource = op.template.split("/").find((s) => s && !s.startsWith("{")) ?? "root";
+            const list = files.get(resource) ?? [];
+            list.push(scenarioFor(op, key, ops));
+            files.set(resource, list);
+            count++;
+        }
+    }
+    const dir = path.resolve(root, opts.out ?? "scenarios");
+    const written = [];
+    const skipped = [];
+    for (const [resource, scenarios] of files) {
+        const file = path.join(dir, `${resource}.gen.scenario.yaml`);
+        const rel = path.relative(root, file);
+        if (existsSync(file) && !opts.force) {
+            skipped.push(rel);
+            continue;
+        }
+        const header = [
+            "# yaml-language-server: $schema=https://unpkg.com/slicetest/schema/scenario.schema.json",
+            `# Generated by \`slicetest gen\` from ${opts.spec}${opts.uncovered ? " (responses the last run didn't cover)" : ""}.`,
+            "# Requests are built from the spec's examples and schemas: adjust them to your data, then drop the `skip`s one by one.",
+            "",
+        ].join("\n");
+        await mkdir(dir, { recursive: true });
+        await writeFile(file, header + stringify({ scenarios }, { lineWidth: 0, aliasDuplicateObjects: false }));
+        written.push(rel);
+    }
+    return { written, skipped, count };
+}
+function scenarioFor(op, key, all) {
+    const steps = [];
+    let pathText = op.template;
+    const success = /^2/.test(key);
+    let unresolved = false;
+    for (const [name, sample] of Object.entries(op.pathParams)) {
+        const creator = success ? creatorFor(op, name, all) : undefined;
+        if (creator) {
+            steps.push(requestStep(creator.op, creator.op.template, { status: Number(creator.status) }, { [name]: `json.${creator.field}` }));
+            pathText = pathText.replace(`{${name}}`, `{{${name}}}`);
+        }
+        else {
+            pathText = pathText.replace(`{${name}}`, encodeURIComponent(String(sample ?? 1)));
+            unresolved = true;
+        }
+    }
+    const status = /^\d{3}$/.test(key) ? Number(key) : undefined;
+    // Two error responses need no arranging: a made-up id is not found, and an empty body is invalid.
+    const notFound = status === 404 && Object.keys(op.pathParams).length > 0;
+    const invalid = (status === 400 || status === 422) && isFilledObject(op.json);
+    steps.push(requestStep(invalid ? { ...op, json: {} } : op, pathText, { status }));
+    const name = `${op.method} ${op.template} → ${key}${op.summary ? ` (${op.summary})` : ""}`;
+    const runnable = success ? !unresolved : notFound || invalid;
+    return runnable ? { name, steps } : { name: `${name} — TODO: arrange the state that produces this`, skip: true, steps };
+}
+/**
+ * The POST on the collection above `template` whose success response carries
+ * the value for `param`: `{id}` in `/polls/{id}/votes` comes from `POST /polls`'s `id`.
+ */
+function creatorFor(op, param, all) {
+    const i = op.template.indexOf(`{${param}}`);
+    const collection = op.template.slice(0, i).replace(/\/$/, "");
+    const post = all.find((o) => o.method === "POST" && o.template === collection);
+    if (!post)
+        return undefined;
+    const field = [param, "id"].find((f) => post.createdFields.includes(f));
+    const status = post.responses.filter((k) => /^2\d\d$/.test(k)).sort()[0];
+    return field && status ? { op: post, field, status } : undefined;
+}
+function requestStep(op, pathText, expect, capture) {
+    const step = { request: `${op.method} ${pathText}` };
+    if (Object.keys(op.query).length)
+        step.query = Object.fromEntries(Object.entries(op.query).map(([k, v]) => [k, String(v)]));
+    if (op.json !== undefined)
+        step.json = op.json;
+    if (expect.status)
+        step.expect = { status: expect.status };
+    if (capture)
+        step.capture = capture;
+    return step;
+}
+function isFilledObject(v) {
+    return !!v && typeof v === "object" && !Array.isArray(v) && Object.keys(v).length > 0;
+}

package/dist/global-setup.d.ts

@@ -1,7 +1,13 @@
 import type { TestProject } from "vitest/node";
+import type { ResolvedOptions } from "./config.js";
 import "./provided.js";
-/** Runs once per vitest run: start Postgres, migrate a template database, hand its location to the workers. */
+/** Runs once per vitest run: start the database server, migrate a template database, hand its location to the workers. */
 export default function setup(project: TestProject): Promise<() => Promise<void>>;
+/**
+ * A hash of everything that determines the migrated schema, or undefined when
+ * that can't be known (a migration command without `inputs`).
+ */
+export declare function migrationKey(opts: Pick<ResolvedOptions, "db" | "root">): Promise<string | undefined>;
 /**
  * Atlas wants `file://<path>` with forward slashes. Absolute paths (including
  * Windows drive paths) are made relative to the root, which is the cwd Atlas runs in.