@intentius/chant 0.124.45 → 0.124.48

package/dist/workspace/member-commands.js

@@ -12,7 +12,10 @@
  * - For `graph` only, members of a pinned package's kind whose kinds file
  *   says how to read them (#2874, a `graph` block): each runs `chant graph`
  *   in a reader project chant writes for it (`kind-readers.ts`). Other
- *   package kinds are `kind-not-run`, as before.
+ *   package kinds are `kind-not-run`, as before. A kind no built-in or
+ *   pinned package supplies, such as `terraform` when the pinned lexicon is
+ *   missing or at another version, is `unknown-kind` and fails the read,
+ *   with the pin's problem in the message (#4380).
  * - For `build` and `lint` only, every project an example group matches
  *   (ws-051): groups are built and linted, and have no ledger, audit or place
  *   in the graph. On a large repository this is most of the run, so
@@ -141,12 +144,24 @@ export function planMembers(verb, root, options = {}) {
             });
             continue;
         }
+        // A kind no built-in or pinned package supplies is unknown, not a kind
+        // the read leaves out (#4380): a terraform member whose pinned lexicon is
+        // missing or at another version said kind-not-run before, as if the graph
+        // never read its kind. Say why, the pin's problem included.
+        if (verb === "graph" && !kinds.get(entry.kind)) {
+            const reason = memberReason(entry, tree, kinds) ?? { code: "unknown-kind", message: `no built-in kind or pinned package supplies kind ${entry.kind}` };
+            const problems = reason.code === "unknown-kind" ? (options.kindProblems ?? []) : [];
+            unreadable.push({ name: entry.name, dir: entry.dir, kind: entry.kind, reason: problems.length ? { ...reason, message: `${reason.message}; ${problems.join("; ")}` } : reason });
+            continue;
+        }
         if (entry.kind !== "chant") {
             const why = entry.kind === "workspace"
                 ? "a nested workspace runs its own chant workspace commands"
-                : entry.kind === "design"
-                    ? "a design member is data: chant reads its files for record pins and builds nothing"
-                    : `chant workspace ${verb} runs members of kind chant, and this one is kind ${entry.kind}`;
+                : entry.kind === "repo"
+                    ? "a repo member is another repository's workspace, which runs its own chant workspace commands; chant workspace graph reads it at its pinned revision"
+                    : entry.kind === "design"
+                        ? "a design member is data: chant reads its files for record pins and builds nothing"
+                        : `chant workspace ${verb} runs members of kind chant, and this one is kind ${entry.kind}`;
             skipped.push({ name: entry.name, dir: entry.dir, kind: entry.kind, reason: { code: "kind-not-run", message: why } });
             continue;
         }
@@ -245,6 +260,9 @@ export function memberArgv(verb, unit, args) {
         // composites with their rolled-up status (#4228).
         if (args.detail !== undefined)
             argv.push("--detail", String(args.detail));
+        // Each member's chant maps its own capability view (#4378).
+        if (args.capabilityView)
+            argv.push("--capability-view");
     }
     return argv;
 }
@@ -451,14 +469,19 @@ export async function runWorkspaceMembers(ctx, verb) {
         return 0;
     }
     const results = await executePlan(plan, args);
-    const anyFailed = results.some((r) => r.exitCode !== 0) || plan.unreadable.length > 0;
+    // #2549: the disagreement lint, over every member's graph, when asked for.
+    const cross = verb === "lint" && args.crossRoot ? await runCrossRoot(found.dir, args) : undefined;
+    const anyFailed = results.some((r) => r.exitCode !== 0) || plan.unreadable.length > 0 || cross?.failed === true;
     const workspace = { name: plan.workspace.name, root: plan.workspace.root };
     if (verb === "lint" && args.format === "sarif") {
         for (const r of results)
             if (r.stderr.trim())
                 process.stderr.write(r.stderr.endsWith("\n") ? r.stderr : `${r.stderr}\n`);
         const unreadable = plan.unreadable.map((s) => ({ id: s.name, member: s.name, dir: s.dir ?? ".", exitCode: 1, stdout: "", stderr: `${s.reason.code}: ${s.reason.message}` }));
-        emitDocument(mergeSarif([...results, ...unreadable], plan.workspace.root), args.output);
+        const sarif = mergeSarif([...results, ...unreadable], plan.workspace.root);
+        if (cross)
+            (sarif.runs ?? (sarif.runs = [])).push(crossRootSarifRun(cross));
+        emitDocument(sarif, args.output);
         console.error(summaryLine(plan, results));
         return anyFailed ? 1 : 0;
     }
@@ -499,6 +522,7 @@ export async function runWorkspaceMembers(ctx, verb) {
                     ...plan.unreadable.map((s) => ({ member: s.name, dir: s.dir, exitCode: 1, diagnostics: null, reason: s.reason })),
                 ],
                 skipped: plan.skipped,
+                ...(cross ? { crossRoot: crossRootJson(cross) } : {}),
             };
         }
         emitDocument(doc, args.output);
@@ -508,5 +532,46 @@ export async function runWorkspaceMembers(ctx, verb) {
     // Text: each member's own output under a heading. A build without -o prints
     // no templates, since several members' templates can't share one stdout.
     printSections(plan, results, verb !== "build" || args.output !== undefined);
+    if (cross)
+        printCrossRoot(cross);
     return anyFailed ? 1 : 0;
 }
+async function runCrossRoot(root, args) {
+    const { workspaceGraph } = await import("./graph-cli.js");
+    const { crossRootLint } = await import("./cross-root-lint.js");
+    const { doc, failed } = await workspaceGraph({ cwd: root, ...(args.members?.length ? { members: args.members } : {}), onStderr: (t) => process.stderr.write(t) });
+    if ("error" in doc)
+        return { error: `${doc.error.code}: ${doc.error.message}`, failed: true };
+    const result = await crossRootLint(doc, args.env ? { env: args.env } : {});
+    return { result, failed: failed || result.findings.some((f) => f.severity === "error") };
+}
+function crossRootJson(cross) {
+    return cross.result ? { findings: cross.result.findings, checks: cross.result.checks, unloaded: cross.result.unloaded } : { error: cross.error };
+}
+function crossRootSarifRun(cross) {
+    const findings = cross.result?.findings ?? [];
+    return {
+        tool: { driver: { name: "chant", rules: [...new Set(findings.map((f) => f.checkId))].sort().map((id) => ({ id })) } },
+        automationDetails: { id: "cross-root/" },
+        properties: { crossRoot: true, checks: cross.result?.checks ?? [], unloaded: cross.result?.unloaded ?? [] },
+        results: findings.map((f) => ({
+            ruleId: f.checkId,
+            level: f.severity === "error" ? "error" : f.severity === "warning" ? "warning" : "note",
+            message: { text: f.message },
+            ...(f.root ? { properties: { member: f.root } } : {}),
+        })),
+        ...(cross.error ? { invocations: [{ executionSuccessful: false, toolExecutionNotifications: [{ message: { text: cross.error } }] }] } : {}),
+    };
+}
+function printCrossRoot(cross) {
+    if (!cross.result) {
+        console.log(`── cross-root  (the members' graphs could not be read: ${cross.error})`);
+        return;
+    }
+    const { findings, checks, unloaded } = cross.result;
+    console.log(`── cross-root  (${checks.join(", ")}; ${findings.length} finding${findings.length === 1 ? "" : "s"})`);
+    for (const f of findings)
+        console.log(`  ${f.severity.padEnd(7)} ${f.checkId}${f.root ? ` [${f.root}]` : ""} ${f.message}`);
+    for (const u of unloaded)
+        console.log(`  (lexicon ${u.lexicon}: its cross-root checks could not be loaded: ${u.reason})`);
+}

package/dist/workspace/migrate-links.d.ts

@@ -0,0 +1,45 @@
+/**
+ * The workspace links `chant migrate` writes (#4399).
+ *
+ * A migration reads one member (the Postgres tables) and writes into another
+ * (the ClickHouse mirrors). When both sit in a workspace, the migrated
+ * output reads the source member's outputs, and the declaration should say
+ * so: `chant workspace check` then fails when the source drops or renames an
+ * output until the mirror follows (WSP093, `./checks/links.ts`).
+ *
+ * {@link planMigrateLinks} finds the declaration above the source, the member
+ * that holds the source and the member that holds the output file, and adds
+ * a `links` entry on the second for each output the migration names. It
+ * changes only the text of that member's `links`, as the other declaration
+ * write commands do (`./json-edit.ts`). It returns a plan; the caller writes
+ * it. A migration with no workspace around it, or whose source and output
+ * are one member, has nothing to link and returns a reason when that is
+ * worth telling.
+ */
+export interface MigrateLinkPlan {
+    /** The declaration file, absolute. */
+    file: string;
+    /** The producer: the member that holds the source. */
+    producer: string;
+    /** The consumer: the member that holds the output file. */
+    consumer: string;
+    /** Outputs the consumer did not link to before. */
+    added: string[];
+    /** The declaration's new text; equal to the old when nothing was added. */
+    text: string;
+}
+export type MigrateLinkOutcome = {
+    plan: MigrateLinkPlan;
+} | {
+    skipped: string;
+} | undefined;
+/**
+ * Plan the links from the member holding `sourcePath` to the outputs a
+ * migration read, on the member holding `outputPath`.
+ */
+export declare function planMigrateLinks(opts: {
+    sourcePath: string;
+    outputPath: string | undefined;
+    outputs: readonly string[];
+}): MigrateLinkOutcome;
+//# sourceMappingURL=migrate-links.d.ts.map

package/dist/workspace/migrate-links.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"migrate-links.d.ts","sourceRoot":"","sources":["../../src/workspace/migrate-links.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;GAiBG;AAOH,MAAM,WAAW,eAAe;IAC9B,sCAAsC;IACtC,IAAI,EAAE,MAAM,CAAC;IACb,sDAAsD;IACtD,QAAQ,EAAE,MAAM,CAAC;IACjB,2DAA2D;IAC3D,QAAQ,EAAE,MAAM,CAAC;IACjB,mDAAmD;IACnD,KAAK,EAAE,MAAM,EAAE,CAAC;IAChB,2EAA2E;IAC3E,IAAI,EAAE,MAAM,CAAC;CACd;AAED,MAAM,MAAM,kBAAkB,GAAG;IAAE,IAAI,EAAE,eAAe,CAAA;CAAE,GAAG;IAAE,OAAO,EAAE,MAAM,CAAA;CAAE,GAAG,SAAS,CAAC;AA6B7F;;;GAGG;AACH,wBAAgB,gBAAgB,CAAC,IAAI,EAAE;IAAE,UAAU,EAAE,MAAM,CAAC;IAAC,UAAU,EAAE,MAAM,GAAG,SAAS,CAAC;IAAC,OAAO,EAAE,SAAS,MAAM,EAAE,CAAA;CAAE,GAAG,kBAAkB,CAqC7I"}

package/dist/workspace/migrate-links.js

@@ -0,0 +1,100 @@
+/**
+ * The workspace links `chant migrate` writes (#4399).
+ *
+ * A migration reads one member (the Postgres tables) and writes into another
+ * (the ClickHouse mirrors). When both sit in a workspace, the migrated
+ * output reads the source member's outputs, and the declaration should say
+ * so: `chant workspace check` then fails when the source drops or renames an
+ * output until the mirror follows (WSP093, `./checks/links.ts`).
+ *
+ * {@link planMigrateLinks} finds the declaration above the source, the member
+ * that holds the source and the member that holds the output file, and adds
+ * a `links` entry on the second for each output the migration names. It
+ * changes only the text of that member's `links`, as the other declaration
+ * write commands do (`./json-edit.ts`). It returns a plan; the caller writes
+ * it. A migration with no workspace around it, or whose source and output
+ * are one member, has nothing to link and returns a reason when that is
+ * worth telling.
+ */
+import { existsSync, readFileSync } from "node:fs";
+import { dirname, isAbsolute, join, relative, resolve, sep } from "node:path";
+import { DECLARATION_FILES, parseDeclaration } from "./declaration.js";
+import { appendElement, setProperty } from "./json-edit.js";
+/** The workspace declaration at or above `start`. */
+function findDeclaration(start) {
+    let dir = resolve(start);
+    for (;;) {
+        for (const name of DECLARATION_FILES) {
+            const candidate = join(dir, name);
+            if (existsSync(candidate))
+                return candidate;
+        }
+        const parent = dirname(dir);
+        if (parent === dir)
+            return undefined;
+        dir = parent;
+    }
+}
+/** The deepest member whose directory holds `path`. */
+function memberHolding(declaration, root, path) {
+    let best;
+    for (const m of declaration.members) {
+        const memberRoot = resolve(root, m.dir);
+        const rel = relative(memberRoot, path);
+        if (rel === ".." || rel.startsWith(`..${sep}`) || isAbsolute(rel))
+            continue;
+        // The longer root is the deeper member.
+        if (!best || memberRoot.length > best.depth)
+            best = { member: m, depth: memberRoot.length };
+    }
+    return best?.member;
+}
+/**
+ * Plan the links from the member holding `sourcePath` to the outputs a
+ * migration read, on the member holding `outputPath`.
+ */
+export function planMigrateLinks(opts) {
+    const source = resolve(opts.sourcePath);
+    const file = findDeclaration(source);
+    if (!file)
+        return undefined;
+    if (opts.outputPath === undefined)
+        return { skipped: "pass --output inside the ClickHouse member to link its columns to the Postgres member" };
+    const root = dirname(file);
+    const text = readFileSync(file, "utf8");
+    let declaration;
+    try {
+        declaration = parseDeclaration(text, file);
+    }
+    catch (err) {
+        return { skipped: `the workspace declaration ${file} does not read, so no link was written: ${err instanceof Error ? err.message : String(err)}` };
+    }
+    const producer = memberHolding(declaration, root, source);
+    const consumer = memberHolding(declaration, root, resolve(opts.outputPath));
+    if (!producer)
+        return { skipped: `${opts.sourcePath} is in no member of ${file}, so no link was written` };
+    if (!consumer)
+        return { skipped: `${opts.outputPath} is in no member of ${file}, so no link was written` };
+    if (producer.name === consumer.name)
+        return { skipped: `the source and the output are both in member ${producer.name}; a member does not link to itself` };
+    const have = new Set(consumer.links.filter((l) => l.member === producer.name && l.kind === null).map((l) => l.output));
+    const added = [...new Set(opts.outputs)].filter((o) => !have.has(o));
+    if (added.length === 0)
+        return { plan: { file, producer: producer.name, consumer: consumer.name, added, text } };
+    const jsonc = file.endsWith(".jsonc");
+    const links = added.map((output) => ({ member: producer.name, output }));
+    let next = text;
+    if (consumer.links.length === 0) {
+        next = setProperty(next, jsonc, consumer.pointer, "links", links);
+    }
+    else {
+        for (const l of links)
+            next = appendElement(next, jsonc, `${consumer.pointer}/links`, l);
+    }
+    // The edit is never written unless it reads back with the links it meant to add.
+    const back = parseDeclaration(next, file).members.find((m) => m.name === consumer.name);
+    if (!back || back.links.length !== consumer.links.length + added.length) {
+        return { skipped: `the edit to ${file} did not read back as the links it meant to add, so nothing was written` };
+    }
+    return { plan: { file, producer: producer.name, consumer: consumer.name, added, text: next } };
+}

package/dist/workspace/migration-dirs.d.ts

@@ -0,0 +1,74 @@
+/**
+ * The readers for goose, golang-migrate and clickhouse-migrations
+ * directories (#4400). Each lists the migrations in the order the tool
+ * applies them. None runs the tool or a server: the schema the migrations
+ * produce comes from a replay.
+ *
+ * File layouts, checked against the tools' own docs and source:
+ *
+ * - goose (pressly/goose 9a201bb): `<version>_<name>.sql` directly in the
+ *   directory, the version a positive integer before the first `_`
+ *   (`NumericComponent`, migration.go); ordered by that number, so a
+ *   sequential `00001` and a timestamp `20240101120000` sort together.
+ *   A file holds `-- +goose Up` and, optionally, a later `-- +goose Down`
+ *   (internal/sqlparser/parser.go); `-- +goose NO TRANSACTION` runs it
+ *   outside a transaction. `.go` migrations are listed in the version order
+ *   but are code, so each is a gap.
+ * - golang-migrate (golang-migrate/migrate 504568a): `<version>_<name>.up.<ext>`
+ *   and `.down.<ext>` directly in the directory, matched by
+ *   `^([0-9]+)_(.*)\.(down|up)\.(.*)$` (source/parse.go); ordered by the
+ *   version, a 64-bit unsigned integer. The up files are the migrations; a
+ *   version with a down file and no up file, or two files for one version
+ *   and direction, is a gap.
+ * - clickhouse-migrations, the Python tool (zifter/clickhouse-migrations) and
+ *   the Node tool (npm clickhouse-migrations): `<version>_<name>.sql` directly
+ *   in the migrations directory, the version an integer before the first `_`,
+ *   applied in ascending numeric order. The Python tool also reads an
+ *   optional `<version>_<name>.down.sql` rollback beside it. The dialect is
+ *   always ClickHouse.
+ *
+ * What the migrations produce comes from a replay (`chant sql replay`), which
+ * records the tables and columns in {@link REPLAY_FILE} beside the
+ * migrations. Each reader returns them as the member's outputs when the
+ * recorded digest still matches the files, and a gap that says to replay
+ * again when it does not (see {@link withReplay}).
+ *
+ * The member's `migrationsDir` field names the directory under the member's
+ * own, and `dialect` names the dialect for goose and golang-migrate, whose
+ * tools take it from a driver or URL the directory does not hold.
+ */
+import type { KindLinkRead, KindReadMigration, KindReaderInput } from "./kind-link-readers.js";
+import { type WorkspaceTree } from "./tree.js";
+/** The dialects a migration directory's `dialect` field names. */
+export declare const MIGRATION_DIALECTS: readonly ["postgres", "clickhouse"];
+export declare function fieldString(fields: KindReaderInput["fields"], name: string, fallback: string): string;
+/** The directory a reader lists: the member's `migrationsDir` under its own directory. */
+export declare function migrationsDirOf(input: KindReaderInput): string;
+/** The goose annotation on `line` (`up`, `down`, `no transaction`, ...), or undefined when it holds none. Mirrors the parser's rule: a comment that contains `+goose`. */
+export declare function gooseAnnotation(line: string): string | undefined;
+/** The file a replay writes in the member's directory: the tables and columns the migrations produced, and the digest of the files it ran (#4400). */
+export declare const REPLAY_FILE = "chant.replay.json";
+/** What {@link REPLAY_FILE} holds. */
+export interface ReplaySnapshot {
+    schema: 1;
+    dialect: string;
+    /** {@link migrationDigest} of the files the replay ran. */
+    digest: string;
+    /** Names as `<schema>.<table>` and `<schema>.<table>.<column>` (Postgres), or `<database>...` (ClickHouse), the contract of #3931. */
+    outputs: string[];
+}
+/** A digest of the migration files in order, so a snapshot can tell the files changed. `extra` are files beside them that change what runs, such as Flyway's configuration. */
+export declare function migrationDigest(read: (file: string) => string, files: readonly string[]): string;
+/** The files a replay of `migrations` depends on, in order. */
+export declare function replayFiles(tree: WorkspaceTree, migrations: readonly KindReadMigration[], extra?: readonly string[]): string[];
+/**
+ * Add the recorded replay to a reader's result: the snapshot's names as
+ * outputs when its digest matches the files, else a gap flagged `outputs`
+ * (a link into the member is then unresolved, not missing). A snapshot
+ * that does not parse is a gap too.
+ */
+export declare function withReplay(result: KindLinkRead, tree: WorkspaceTree, dir: string, extra?: readonly string[]): KindLinkRead;
+export declare const readGooseDir: (input: KindReaderInput) => KindLinkRead;
+export declare const readGolangMigrateDir: (input: KindReaderInput) => KindLinkRead;
+export declare const readClickHouseMigrationsDir: (input: KindReaderInput) => KindLinkRead;
+//# sourceMappingURL=migration-dirs.d.ts.map

package/dist/workspace/migration-dirs.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"migration-dirs.d.ts","sourceRoot":"","sources":["../../src/workspace/migration-dirs.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAsCG;AAGH,OAAO,KAAK,EAAE,YAAY,EAAe,iBAAiB,EAAE,eAAe,EAAE,MAAM,qBAAqB,CAAC;AAEzG,OAAO,EAAY,KAAK,aAAa,EAAE,MAAM,QAAQ,CAAC;AAEtD,kEAAkE;AAClE,eAAO,MAAM,kBAAkB,YAAI,UAAU,EAAE,YAAY,CAAU,CAAC;AAEtE,wBAAgB,WAAW,CAAC,MAAM,EAAE,eAAe,CAAC,QAAQ,CAAC,EAAE,IAAI,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,GAAG,MAAM,CAGrG;AAED,0FAA0F;AAC1F,wBAAgB,eAAe,CAAC,KAAK,EAAE,eAAe,GAAG,MAAM,CAG9D;AAWD,0KAA0K;AAC1K,wBAAgB,eAAe,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,GAAG,SAAS,CAIhE;AA4HD,sJAAsJ;AACtJ,eAAO,MAAM,WAAW,sBAAsB,CAAC;AAE/C,sCAAsC;AACtC,MAAM,WAAW,cAAc;IAC7B,MAAM,EAAE,CAAC,CAAC;IACV,OAAO,EAAE,MAAM,CAAC;IAChB,2DAA2D;IAC3D,MAAM,EAAE,MAAM,CAAC;IACf,sIAAsI;IACtI,OAAO,EAAE,MAAM,EAAE,CAAC;CACnB;AAED,+KAA+K;AAC/K,wBAAgB,eAAe,CAAC,IAAI,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,MAAM,EAAE,KAAK,EAAE,SAAS,MAAM,EAAE,GAAG,MAAM,CAShG;AAED,+DAA+D;AAC/D,wBAAgB,WAAW,CAAC,IAAI,EAAE,aAAa,EAAE,UAAU,EAAE,SAAS,iBAAiB,EAAE,EAAE,KAAK,GAAE,SAAS,MAAM,EAAO,GAAG,MAAM,EAAE,CAElI;AAED;;;;;GAKG;AACH,wBAAgB,UAAU,CAAC,MAAM,EAAE,YAAY,EAAE,IAAI,EAAE,aAAa,EAAE,GAAG,EAAE,MAAM,EAAE,KAAK,GAAE,SAAS,MAAM,EAAO,GAAG,YAAY,CA6B9H;AAED,eAAO,MAAM,YAAY,UAAW,eAAe,KAAG,YAAsE,CAAC;AAC7H,eAAO,MAAM,oBAAoB,UAAW,eAAe,KAAG,YAA8E,CAAC;AAC7I,eAAO,MAAM,2BAA2B,UAAW,eAAe,KAAG,YAAqF,CAAC"}

package/dist/workspace/migration-dirs.js

@@ -0,0 +1,254 @@
+/**
+ * The readers for goose, golang-migrate and clickhouse-migrations
+ * directories (#4400). Each lists the migrations in the order the tool
+ * applies them. None runs the tool or a server: the schema the migrations
+ * produce comes from a replay.
+ *
+ * File layouts, checked against the tools' own docs and source:
+ *
+ * - goose (pressly/goose 9a201bb): `<version>_<name>.sql` directly in the
+ *   directory, the version a positive integer before the first `_`
+ *   (`NumericComponent`, migration.go); ordered by that number, so a
+ *   sequential `00001` and a timestamp `20240101120000` sort together.
+ *   A file holds `-- +goose Up` and, optionally, a later `-- +goose Down`
+ *   (internal/sqlparser/parser.go); `-- +goose NO TRANSACTION` runs it
+ *   outside a transaction. `.go` migrations are listed in the version order
+ *   but are code, so each is a gap.
+ * - golang-migrate (golang-migrate/migrate 504568a): `<version>_<name>.up.<ext>`
+ *   and `.down.<ext>` directly in the directory, matched by
+ *   `^([0-9]+)_(.*)\.(down|up)\.(.*)$` (source/parse.go); ordered by the
+ *   version, a 64-bit unsigned integer. The up files are the migrations; a
+ *   version with a down file and no up file, or two files for one version
+ *   and direction, is a gap.
+ * - clickhouse-migrations, the Python tool (zifter/clickhouse-migrations) and
+ *   the Node tool (npm clickhouse-migrations): `<version>_<name>.sql` directly
+ *   in the migrations directory, the version an integer before the first `_`,
+ *   applied in ascending numeric order. The Python tool also reads an
+ *   optional `<version>_<name>.down.sql` rollback beside it. The dialect is
+ *   always ClickHouse.
+ *
+ * What the migrations produce comes from a replay (`chant sql replay`), which
+ * records the tables and columns in {@link REPLAY_FILE} beside the
+ * migrations. Each reader returns them as the member's outputs when the
+ * recorded digest still matches the files, and a gap that says to replay
+ * again when it does not (see {@link withReplay}).
+ *
+ * The member's `migrationsDir` field names the directory under the member's
+ * own, and `dialect` names the dialect for goose and golang-migrate, whose
+ * tools take it from a driver or URL the directory does not hold.
+ */
+import { createHash } from "node:crypto";
+import { joinPath } from "./tree.js";
+/** The dialects a migration directory's `dialect` field names. */
+export const MIGRATION_DIALECTS = ["postgres", "clickhouse"];
+export function fieldString(fields, name, fallback) {
+    const v = fields?.[name];
+    return typeof v === "string" && v !== "" ? v : fallback;
+}
+/** The directory a reader lists: the member's `migrationsDir` under its own directory. */
+export function migrationsDirOf(input) {
+    const sub = fieldString(input.fields, "migrationsDir", ".");
+    return joinPath(input.dir, sub.replace(/^\.\/?/, ""));
+}
+function filesIn(tree, dir) {
+    return (tree.list(dir) ?? []).filter((e) => e.type === "file").map((e) => e.name).sort();
+}
+const lineOf = (text, pred) => {
+    const i = text.split(/\r?\n/).findIndex(pred);
+    return i < 0 ? 0 : i + 1;
+};
+/** The goose annotation on `line` (`up`, `down`, `no transaction`, ...), or undefined when it holds none. Mirrors the parser's rule: a comment that contains `+goose`. */
+export function gooseAnnotation(line) {
+    const t = line.trim();
+    if (!t.startsWith("--") || !t.includes("+goose"))
+        return undefined;
+    return t.replace("+goose", "").replace(/^--\s*/, "").trim().toLowerCase();
+}
+function listGooseDir(input) {
+    const { tree } = input;
+    const dir = migrationsDirOf(input);
+    const dialect = fieldString(input.fields, "dialect", "postgres");
+    const gaps = [];
+    const result = { reader: "goose-dir", links: [], gaps, migrations: [] };
+    const found = [];
+    for (const name of filesIn(tree, dir)) {
+        const ext = name.endsWith(".sql") ? ".sql" : name.endsWith(".go") && !name.endsWith("_test.go") ? ".go" : null;
+        if (!ext)
+            continue;
+        const file = joinPath(dir, name);
+        const before = name.split("_")[0] ?? "";
+        const n = /^[0-9]+$/.test(before) && name.includes("_") ? Number(before) : NaN;
+        if (!Number.isSafeInteger(n) || n < 1) {
+            gaps.push({ file, line: 1, message: `${name} has no version goose can read: the name starts with a positive integer, then _, so goose would stop here` });
+            continue;
+        }
+        if (ext === ".go") {
+            gaps.push({ file, line: 1, message: `${name} is a Go migration; its code is not SQL, so it is not listed` });
+            found.push({ n, migration: null, file });
+            continue;
+        }
+        const text = tree.read(file);
+        const up = lineOf(text, (l) => gooseAnnotation(l) === "up");
+        if (up === 0) {
+            gaps.push({ file, line: 1, message: `${name} has no -- +goose Up annotation, so goose refuses it` });
+            continue;
+        }
+        const down = lineOf(text, (l) => gooseAnnotation(l) === "down");
+        if (down !== 0 && down < up)
+            gaps.push({ file, line: down, message: `${name}: -- +goose Down comes before -- +goose Up, which goose refuses` });
+        found.push({
+            n,
+            file,
+            migration: {
+                position: 0,
+                version: String(n),
+                name: name.slice(before.length + 1, -ext.length),
+                type: "versioned",
+                file,
+                line: up,
+                down: down !== 0,
+                dialect,
+                transaction: !text.split(/\r?\n/).some((l) => gooseAnnotation(l) === "no transaction"),
+            },
+        });
+    }
+    found.sort((a, b) => a.n - b.n || (a.file < b.file ? -1 : 1));
+    const seen = new Map();
+    for (const f of found) {
+        const prior = seen.get(f.n);
+        if (prior)
+            gaps.push({ file: f.file, line: 1, message: `version ${String(f.n)} is also ${prior}; goose refuses a duplicate version` });
+        else
+            seen.set(f.n, f.file);
+    }
+    for (const f of found)
+        if (f.migration)
+            result.migrations.push(f.migration);
+    result.migrations.forEach((m, i) => (m.position = i + 1));
+    return result;
+}
+const MIGRATE_NAME = /^([0-9]+)_(.*)\.(down|up)\.(.*)$/;
+function listGolangMigrateDir(input) {
+    const { tree } = input;
+    const dir = migrationsDirOf(input);
+    const dialect = fieldString(input.fields, "dialect", "postgres");
+    const gaps = [];
+    const result = { reader: "golang-migrate-dir", links: [], gaps, migrations: [] };
+    const ups = new Map();
+    const downs = new Map();
+    for (const name of filesIn(tree, dir)) {
+        const m = MIGRATE_NAME.exec(name);
+        if (!m)
+            continue;
+        const version = BigInt(m[1]);
+        const file = joinPath(dir, name);
+        if (version > 18446744073709551615n) {
+            gaps.push({ file, line: 1, message: `${name}: the version does not fit a 64-bit unsigned integer, which golang-migrate requires` });
+            continue;
+        }
+        const table = m[3] === "up" ? ups : downs;
+        if (table.has(version)) {
+            gaps.push({ file, line: 1, message: `${name}: another ${m[3]} file already has version ${m[1]}; golang-migrate refuses a duplicate` });
+            continue;
+        }
+        if (m[3] === "up")
+            ups.set(version, { name: m[2], file, version: m[1] });
+        else
+            downs.set(version, file);
+    }
+    for (const [v, file] of downs)
+        if (!ups.has(v))
+            gaps.push({ file, line: 1, message: `version ${String(v)} has a down file and no up file` });
+    [...ups.entries()]
+        .sort((a, b) => (a[0] < b[0] ? -1 : a[0] > b[0] ? 1 : 0))
+        .forEach(([v, u], i) => result.migrations.push({ position: i + 1, version: u.version, name: u.name, type: "versioned", file: u.file, line: 1, down: downs.get(v) ?? false, dialect }));
+    return result;
+}
+const CLICKHOUSE_NAME = /^([0-9]+)_(.+)\.sql$/;
+function listClickHouseMigrationsDir(input) {
+    const { tree } = input;
+    const dir = migrationsDirOf(input);
+    const gaps = [];
+    const result = { reader: "clickhouse-migrations-dir", links: [], gaps, migrations: [] };
+    const names = filesIn(tree, dir).filter((n) => n.endsWith(".sql"));
+    const rollbacks = new Map(names.filter((n) => n.endsWith(".down.sql")).map((n) => [n.slice(0, -".down.sql".length), joinPath(dir, n)]));
+    const ups = [];
+    for (const name of names) {
+        if (name.endsWith(".down.sql"))
+            continue;
+        const m = CLICKHOUSE_NAME.exec(name);
+        if (!m) {
+            gaps.push({ file: joinPath(dir, name), line: 1, message: `${name} has no version before its first _, so clickhouse-migrations reports a bad file name` });
+            continue;
+        }
+        ups.push({ n: BigInt(m[1]), version: m[1], name: m[2], file: joinPath(dir, name) });
+    }
+    ups.sort((a, b) => (a.n < b.n ? -1 : a.n > b.n ? 1 : a.file < b.file ? -1 : 1));
+    const seen = new Map();
+    for (const u of ups) {
+        const prior = seen.get(u.n);
+        if (prior)
+            gaps.push({ file: u.file, line: 1, message: `version ${u.version} is also ${prior}; leading zeros are not significant, so clickhouse-migrations reports a duplicate version` });
+        else
+            seen.set(u.n, u.file);
+    }
+    ups.forEach((u, i) => result.migrations.push({ position: i + 1, version: u.version, name: u.name, type: "versioned", file: u.file, line: 1, down: rollbacks.get(u.file.split("/").pop().slice(0, -".sql".length)) ?? false, dialect: "clickhouse" }));
+    return result;
+}
+/** The file a replay writes in the member's directory: the tables and columns the migrations produced, and the digest of the files it ran (#4400). */
+export const REPLAY_FILE = "chant.replay.json";
+/** A digest of the migration files in order, so a snapshot can tell the files changed. `extra` are files beside them that change what runs, such as Flyway's configuration. */
+export function migrationDigest(read, files) {
+    const h = createHash("sha256");
+    for (const f of files) {
+        h.update(f);
+        h.update("\0");
+        h.update(read(f));
+        h.update("\0");
+    }
+    return `sha256:${h.digest("hex")}`;
+}
+/** The files a replay of `migrations` depends on, in order. */
+export function replayFiles(tree, migrations, extra = []) {
+    return [...extra.filter((f) => tree.stat(f) === "file"), ...migrations.map((m) => m.file)];
+}
+/**
+ * Add the recorded replay to a reader's result: the snapshot's names as
+ * outputs when its digest matches the files, else a gap flagged `outputs`
+ * (a link into the member is then unresolved, not missing). A snapshot
+ * that does not parse is a gap too.
+ */
+export function withReplay(result, tree, dir, extra = []) {
+    const file = joinPath(dir, REPLAY_FILE);
+    const migrations = result.migrations ?? [];
+    const gap = (message, line = 1) => result.gaps.push({ file: tree.stat(file) === "file" ? file : dir || ".", line, message, outputs: true });
+    if (tree.stat(file) !== "file") {
+        gap(`no ${REPLAY_FILE}: replay the migrations to record the tables and columns they produce (chant sql replay ${dir || "."})`);
+        return result;
+    }
+    let text;
+    let snap;
+    try {
+        text = tree.read(file);
+        snap = JSON.parse(text);
+    }
+    catch (err) {
+        gap(`${REPLAY_FILE} could not be read (${err.message}), so the tables the migrations produce are unknown`);
+        return result;
+    }
+    if (snap.schema !== 1 || typeof snap.digest !== "string" || !Array.isArray(snap.outputs) || snap.outputs.some((o) => typeof o !== "string")) {
+        gap(`${REPLAY_FILE} is not a replay snapshot (schema 1 with a digest and outputs), so the tables the migrations produce are unknown`);
+        return result;
+    }
+    const digest = migrationDigest((f) => tree.read(f), replayFiles(tree, migrations, extra));
+    if (digest !== snap.digest) {
+        gap(`the migrations changed since ${REPLAY_FILE} was recorded, so the tables they produce are unknown; replay again (chant sql replay ${dir || "."})`);
+        return result;
+    }
+    const lines = text.split("\n");
+    result.outputs = snap.outputs.map((name) => ({ name, file, line: Math.max(1, lines.findIndex((l) => l.includes(JSON.stringify(name))) + 1) }));
+    return result;
+}
+export const readGooseDir = (input) => withReplay(listGooseDir(input), input.tree, input.dir);
+export const readGolangMigrateDir = (input) => withReplay(listGolangMigrateDir(input), input.tree, input.dir);
+export const readClickHouseMigrationsDir = (input) => withReplay(listClickHouseMigrationsDir(input), input.tree, input.dir);

package/dist/workspace/nested-graph.d.ts

@@ -45,6 +45,8 @@ export declare function readNestedDocument(stdout: string, exitCode: number, std
 export declare function readNested(abs: string, args: Partial<ParsedArgs>, at: string | null | undefined, schemaId: string, contract: number, toolchain?: Toolchain | undefined): Promise<NestedRead & {
     stderr: string;
 }>;
+/** Whether a chant refused `--capability-view` as a flag it doesn't know (#4378): one from before it. */
+export declare function refusedCapabilityView(stderr: string): boolean;
 /**
  * Fold a nested workspace's graph into the outer one, under the outer member
  * `outer`, and fill that member's entry. The outer graph's other sections are

package/dist/workspace/nested-graph.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"nested-graph.d.ts","sourceRoot":"","sources":["../../src/workspace/nested-graph.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;GAoBG;AAGH,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,iBAAiB,CAAC;AAClD,OAAO,EAA8B,KAAK,cAAc,EAAqB,KAAK,cAAc,EAAE,MAAM,iBAAiB,CAAC;AAE1H,YAAY,EAAE,eAAe,EAAE,MAAM,iBAAiB,CAAC;AACvD,OAAO,EAAmB,KAAK,SAAS,EAAE,MAAM,mBAAmB,CAAC;AAEpE,8CAA8C;AAC9C,MAAM,MAAM,UAAU,GAClB;IAAE,EAAE,EAAE,IAAI,CAAC;IAAC,KAAK,EAAE,MAAM,GAAG,IAAI,CAAC;IAAC,GAAG,EAAE,cAAc,GAAG;QAAE,QAAQ,EAAE,MAAM,CAAC;QAAC,KAAK,CAAC,EAAE,MAAM,CAAA;KAAE,CAAA;CAAE,GAC9F;IAAE,EAAE,EAAE,KAAK,CAAC;IAAC,KAAK,EAAE,MAAM,GAAG,IAAI,CAAC;IAAC,IAAI,EAAE,gBAAgB,GAAG,mBAAmB,GAAG,wBAAwB,CAAC;IAAC,OAAO,EAAE,MAAM,CAAA;CAAE,CAAC;AAElI,0FAA0F;AAC1F,wBAAgB,UAAU,CAAC,GAAG,EAAE,MAAM,EAAE,IAAI,EAAE,OAAO,CAAC,UAAU,CAAC,EAAE,EAAE,EAAE,MAAM,GAAG,IAAI,GAAG,SAAS,GAAG,MAAM,EAAE,CAa1G;AAeD,+EAA+E;AAC/E,wBAAgB,kBAAkB,CAAC,MAAM,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,GAAG,UAAU,CAwBnI;AAED,uEAAuE;AACvE,wBAAsB,UAAU,CAC9B,GAAG,EAAE,MAAM,EACX,IAAI,EAAE,OAAO,CAAC,UAAU,CAAC,EACzB,EAAE,EAAE,MAAM,GAAG,IAAI,GAAG,SAAS,EAC7B,QAAQ,EAAE,MAAM,EAChB,QAAQ,EAAE,MAAM,EAChB,SAAS,GAAE,SAAS,GAAG,SAAqB,GAC3C,OAAO,CAAC,UAAU,GAAG;IAAE,MAAM,EAAE,MAAM,CAAA;CAAE,CAAC,CAG1C;AAYD;;;;GAIG;AACH,wBAAgB,UAAU,CAAC,KAAK,EAAE,cAAc,EAAE,MAAM,EAAE,cAAc,EAAE,KAAK,EAAE,cAAc,GAAG;IAAE,QAAQ,EAAE,MAAM,CAAA;CAAE,GAAG,IAAI,CAwD5H"}
+{"version":3,"file":"nested-graph.d.ts","sourceRoot":"","sources":["../../src/workspace/nested-graph.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;GAoBG;AAGH,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,iBAAiB,CAAC;AAElD,OAAO,EAA8B,KAAK,cAAc,EAAqB,KAAK,cAAc,EAAE,MAAM,iBAAiB,CAAC;AAE1H,YAAY,EAAE,eAAe,EAAE,MAAM,iBAAiB,CAAC;AACvD,OAAO,EAAmB,KAAK,SAAS,EAAE,MAAM,mBAAmB,CAAC;AAEpE,8CAA8C;AAC9C,MAAM,MAAM,UAAU,GAClB;IAAE,EAAE,EAAE,IAAI,CAAC;IAAC,KAAK,EAAE,MAAM,GAAG,IAAI,CAAC;IAAC,GAAG,EAAE,cAAc,GAAG;QAAE,QAAQ,EAAE,MAAM,CAAC;QAAC,KAAK,CAAC,EAAE,MAAM,CAAA;KAAE,CAAA;CAAE,GAC9F;IAAE,EAAE,EAAE,KAAK,CAAC;IAAC,KAAK,EAAE,MAAM,GAAG,IAAI,CAAC;IAAC,IAAI,EAAE,gBAAgB,GAAG,mBAAmB,GAAG,wBAAwB,CAAC;IAAC,OAAO,EAAE,MAAM,CAAA;CAAE,CAAC;AAElI,0FAA0F;AAC1F,wBAAgB,UAAU,CAAC,GAAG,EAAE,MAAM,EAAE,IAAI,EAAE,OAAO,CAAC,UAAU,CAAC,EAAE,EAAE,EAAE,MAAM,GAAG,IAAI,GAAG,SAAS,GAAG,MAAM,EAAE,CAc1G;AAeD,+EAA+E;AAC/E,wBAAgB,kBAAkB,CAAC,MAAM,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,GAAG,UAAU,CAwBnI;AAED,uEAAuE;AACvE,wBAAsB,UAAU,CAC9B,GAAG,EAAE,MAAM,EACX,IAAI,EAAE,OAAO,CAAC,UAAU,CAAC,EACzB,EAAE,EAAE,MAAM,GAAG,IAAI,GAAG,SAAS,EAC7B,QAAQ,EAAE,MAAM,EAChB,QAAQ,EAAE,MAAM,EAChB,SAAS,GAAE,SAAS,GAAG,SAAqB,GAC3C,OAAO,CAAC,UAAU,GAAG;IAAE,MAAM,EAAE,MAAM,CAAA;CAAE,CAAC,CAS1C;AAED,yGAAyG;AACzG,wBAAgB,qBAAqB,CAAC,MAAM,EAAE,MAAM,GAAG,OAAO,CAE7D;AAYD;;;;GAIG;AACH,wBAAgB,UAAU,CAAC,KAAK,EAAE,cAAc,EAAE,MAAM,EAAE,cAAc,EAAE,KAAK,EAAE,cAAc,GAAG;IAAE,QAAQ,EAAE,MAAM,CAAA;CAAE,GAAG,IAAI,CA0E5H"}