@intentius/chant 0.124.46 → 0.124.49

package/dist/workspace/cross-root-lint.js

@@ -0,0 +1,111 @@
+/**
+ * The disagreement lint (#2549, #2524 D6): `chant workspace lint --cross-root`.
+ *
+ * A member link is written down once, on the consumer. The members' graphs
+ * can surface the same relation on their own: a consumer's parameter that
+ * joins another member's output by name, or any relation a lexicon puts in
+ * its IR. The lint reports where the two disagree.
+ *
+ * It uses #1939's cross-build-root mode. Each composed member is one build
+ * root, read under the member's own toolchain as `chant workspace graph`
+ * reads it (`crossRootInputs` in `./workspace-run.ts`), and the composed
+ * graph's link table goes to every check as `ctx.links`. The checks are:
+ *
+ * - LNK001, core's own: the consumer declares a link to one member's output
+ *   while its graph joins a parameter of the same name to another member's.
+ * - every cross-root check a lexicon ships through `crossRootChecks()`, for
+ *   the lexicons the members' graphs name. A lexicon applies its own rule
+ *   once it surfaces the relation in its IR. One that can't be loaded here
+ *   is reported and skipped.
+ *
+ * Nothing runs unless `--cross-root` asks, so a plain `workspace lint`, and
+ * level 0, pay nothing for it.
+ */
+import { joinKey } from "../join-key.js";
+import { runCrossRootChecks } from "../lint/post-synth.js";
+import { crossRootInputs } from "./workspace-run.js";
+export const LNK001_ID = "LNK001";
+/** The links of the composed graph, as a cross-root check reads them. Ambiguous rows and record links are left out. */
+export function crossRootLinks(links) {
+    const out = [];
+    for (const row of links) {
+        const r = row;
+        if (typeof r.consumer !== "string" || typeof r.producer !== "string" || typeof r.output !== "string" || typeof r.origin !== "string")
+            continue;
+        out.push({
+            consumer: r.consumer,
+            producer: r.producer,
+            output: r.output,
+            origin: r.origin,
+            ...(typeof r.input === "string" || r.input === null ? { input: r.input } : {}),
+            ...(typeof r.status === "string" ? { status: r.status } : {}),
+        });
+    }
+    return out;
+}
+/**
+ * LNK001: a declared link and a join the graph surfaces name different
+ * producers for the same handle. The consumer must be one of the run's roots,
+ * so its graph was read.
+ */
+export const lnk001 = {
+    id: LNK001_ID,
+    description: "A declared member link and the join the members' graphs surface name different producers for the same output",
+    scope: "cross-root",
+    check(ctx) {
+        const links = ctx.links ?? [];
+        const findings = [];
+        const declared = links.filter((l) => l.origin === "declared" && l.status !== "invalid");
+        for (const inferred of links) {
+            if (!inferred.origin.startsWith("inferred:") || inferred.status !== "resolved")
+                continue;
+            if (!ctx.root(inferred.consumer))
+                continue;
+            const keys = new Set([joinKey(inferred.output), ...(inferred.input ? [joinKey(inferred.input)] : [])]);
+            for (const d of declared) {
+                if (d.consumer !== inferred.consumer || d.producer === inferred.producer)
+                    continue;
+                if (!keys.has(joinKey(d.output)))
+                    continue;
+                findings.push({
+                    checkId: LNK001_ID,
+                    severity: "warning",
+                    message: `${d.consumer} declares a link to ${d.producer}'s output ${d.output}, but its graph joins ` +
+                        `${inferred.input ? `parameter ${inferred.input}` : "a parameter"} to ${inferred.producer}'s output ${inferred.output}. ` +
+                        `Point the link at the member the graph reads from, or rename the parameter so it joins the declared output.`,
+                    root: d.consumer,
+                    entity: inferred.input ?? undefined,
+                });
+            }
+        }
+        return findings;
+    },
+};
+async function pluginChecks(lexicon) {
+    const { loadPlugin } = await import("../cli/plugins.js");
+    const plugin = await loadPlugin(lexicon);
+    return plugin.crossRootChecks?.() ?? [];
+}
+/**
+ * Run the disagreement lint over a composed graph: one root per composed
+ * member, LNK001, and the cross-root checks of every lexicon the roots name.
+ */
+export async function crossRootLint(graph, opts = {}) {
+    const roots = crossRootInputs(graph, opts.env);
+    const lexicons = [...new Set(roots.flatMap((r) => [...r.buildResult.entities.values()].map((e) => e.lexicon)))]
+        .filter((l) => typeof l === "string" && l !== "chant")
+        .sort();
+    const checks = [lnk001];
+    const unloaded = [];
+    for (const lexicon of lexicons) {
+        try {
+            checks.push(...(await (opts.load ?? pluginChecks)(lexicon)));
+        }
+        catch (err) {
+            unloaded.push({ lexicon, reason: err instanceof Error ? err.message.split("\n")[0] : String(err) });
+        }
+    }
+    const findings = runCrossRootChecks(checks, roots, { ...(opts.env ? { env: opts.env } : {}), links: crossRootLinks(graph.links) });
+    const ran = checks.filter((c) => c.scope === "cross-root").map((c) => c.id);
+    return { findings, checks: ran, unloaded };
+}

package/dist/workspace/dbt-models-reader.d.ts

@@ -0,0 +1,44 @@
+/**
+ * A dbt project's models as outputs (#3935), read beside its sources by the
+ * `dbt-project` reader.
+ *
+ * A model exposes `<schema>.<model>` and, for each column its YAML lists,
+ * `<schema>.<model>.<column>`, named by the contract of #3931: names as
+ * declared, Postgres case folding, never rendered per target. As with
+ * sources, nothing runs: dbt, Jinja and `profiles.yml` stay unread.
+ *
+ * - A model is a `.sql` file under the project's `model-paths`. Its name is
+ *   the file's name, or its `alias`. Python models, seeds and snapshots are
+ *   not read.
+ * - `enabled`, `schema` and `alias` come from the first of: the model's own
+ *   `{{ config(...) }}`, the `config:` of its entry in a model YAML, then the
+ *   `+` keys of `dbt_project.yml` that match the model's path (the project's
+ *   name, each directory under the model path, the model's name), the
+ *   deepest first.
+ * - The schema is the member's `modelSchema` field when it is set, and
+ *   dbt's config is then not read for it. Otherwise it is the schema dbt
+ *   config names, but dbt's default `generate_schema_name` joins the target's
+ *   schema to a custom one (`<target_schema>_<custom>`), and a model with no
+ *   custom schema lands in the target's schema, so the name depends on the
+ *   target. The model is then a gap that says to set `modelSchema`. The
+ *   exception is a project whose `generate_schema_name` macro is the usual
+ *   override (the custom schema as it stands, the target's schema when there
+ *   is none): a model with a custom schema is named by it. Any other
+ *   override is not evaluated, and every model is a gap.
+ * - A templated schema, alias or `enabled`, or one that is not a plain
+ *   string, is a gap; chant never renders it.
+ */
+import type { KindLinkRead, KindReaderInput } from "./kind-link-readers.js";
+import { type Dialect, type Quoting } from "./dbt-project-common.js";
+export interface DbtModelsContext {
+    input: KindReaderInput;
+    project: Record<string, unknown>;
+    projectFile: string;
+    /** The tree-relative model paths, already checked. */
+    paths: string[];
+    quoting: Quoting;
+    dialect: Dialect;
+    result: KindLinkRead;
+}
+export declare function readDbtModels(ctx: DbtModelsContext): void;
+//# sourceMappingURL=dbt-models-reader.d.ts.map

package/dist/workspace/dbt-models-reader.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"dbt-models-reader.d.ts","sourceRoot":"","sources":["../../src/workspace/dbt-models-reader.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6BG;AAIH,OAAO,KAAK,EAAkB,YAAY,EAAE,eAAe,EAAE,MAAM,qBAAqB,CAAC;AACzF,OAAO,EAQL,KAAK,OAAO,EACZ,KAAK,OAAO,EACb,MAAM,sBAAsB,CAAC;AAG9B,MAAM,WAAW,gBAAgB;IAC/B,KAAK,EAAE,eAAe,CAAC;IACvB,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;IACjC,WAAW,EAAE,MAAM,CAAC;IACpB,sDAAsD;IACtD,KAAK,EAAE,MAAM,EAAE,CAAC;IAChB,OAAO,EAAE,OAAO,CAAC;IACjB,OAAO,EAAE,OAAO,CAAC;IACjB,MAAM,EAAE,YAAY,CAAC;CACtB;AAcD,wBAAgB,aAAa,CAAC,GAAG,EAAE,gBAAgB,GAAG,IAAI,CAmHzD"}

package/dist/workspace/dbt-models-reader.js

@@ -0,0 +1,356 @@
+/**
+ * A dbt project's models as outputs (#3935), read beside its sources by the
+ * `dbt-project` reader.
+ *
+ * A model exposes `<schema>.<model>` and, for each column its YAML lists,
+ * `<schema>.<model>.<column>`, named by the contract of #3931: names as
+ * declared, Postgres case folding, never rendered per target. As with
+ * sources, nothing runs: dbt, Jinja and `profiles.yml` stay unread.
+ *
+ * - A model is a `.sql` file under the project's `model-paths`. Its name is
+ *   the file's name, or its `alias`. Python models, seeds and snapshots are
+ *   not read.
+ * - `enabled`, `schema` and `alias` come from the first of: the model's own
+ *   `{{ config(...) }}`, the `config:` of its entry in a model YAML, then the
+ *   `+` keys of `dbt_project.yml` that match the model's path (the project's
+ *   name, each directory under the model path, the model's name), the
+ *   deepest first.
+ * - The schema is the member's `modelSchema` field when it is set, and
+ *   dbt's config is then not read for it. Otherwise it is the schema dbt
+ *   config names, but dbt's default `generate_schema_name` joins the target's
+ *   schema to a custom one (`<target_schema>_<custom>`), and a model with no
+ *   custom schema lands in the target's schema, so the name depends on the
+ *   target. The model is then a gap that says to set `modelSchema`. The
+ *   exception is a project whose `generate_schema_name` macro is the usual
+ *   override (the custom schema as it stands, the target's schema when there
+ *   is none): a model with a custom schema is named by it. Any other
+ *   override is not evaluated, and every model is a gap.
+ * - A templated schema, alias or `enabled`, or one that is not a plain
+ *   string, is a gap; chant never renders it.
+ */
+import { posix } from "node:path";
+import { parseYAMLDocument } from "../yaml.js";
+import { isObject, isTemplated, keyLine, lines, nameLine, scalar, yamlFiles, } from "./dbt-project-common.js";
+import { joinPath, skippedDir } from "./tree.js";
+const KEYS = ["schema", "alias", "enabled"];
+export function readDbtModels(ctx) {
+    const { input, project, projectFile, paths, quoting, dialect, result } = ctx;
+    const { tree, dir, fields } = input;
+    const gaps = result.gaps;
+    const outputs = (result.outputs ?? (result.outputs = []));
+    const modelSchema = typeof fields?.modelSchema === "string" && fields.modelSchema !== "" ? fields.modelSchema : null;
+    const name = (v, quoted) => (dialect === "postgres" && !quoted ? v.toLowerCase() : v);
+    const projectName = scalar(project.name);
+    const macro = modelSchema === null ? schemaMacro(tree, dir, project) : { kind: "default" };
+    // Model YAML: config and columns, by model name.
+    const yamlModels = new Map();
+    for (const p of paths) {
+        for (const file of yamlFiles(tree, p)) {
+            let text;
+            let doc;
+            try {
+                text = tree.read(file);
+                doc = parseYAMLDocument(text);
+            }
+            catch (err) {
+                // The sources pass reports an unreadable file, as a gap that leaves outputs out.
+                void err;
+                continue;
+            }
+            if (!isObject(doc) || !Array.isArray(doc.models))
+                continue;
+            const fileLines = lines(text);
+            let cursor = keyLine(fileLines, "models");
+            for (const entry of doc.models) {
+                if (!isObject(entry))
+                    continue;
+                const modelName = scalar(entry.name);
+                cursor = nameLine(fileLines, modelName, cursor);
+                if (modelName === undefined)
+                    continue;
+                const cols = [];
+                let columnCursor = cursor;
+                for (const column of Array.isArray(entry.columns) ? entry.columns : []) {
+                    if (!isObject(column))
+                        continue;
+                    const columnName = scalar(column.name);
+                    columnCursor = nameLine(fileLines, columnName, columnCursor);
+                    if (columnName === undefined || isTemplated(columnName)) {
+                        gaps.push({ file, line: columnCursor, message: `model ${modelName}: column ${JSON.stringify(column.name)} is a Jinja template or not a name, which chant does not render; it was not read`, outputs: true });
+                        continue;
+                    }
+                    cols.push({ name: columnName, quote: column.quote === true, line: columnCursor, file });
+                }
+                const config = isObject(entry.config) ? { ...entry.config } : {};
+                yamlModels.set(modelName, { config, columns: cols, file });
+            }
+        }
+    }
+    const seen = new Set();
+    for (const p of paths) {
+        for (const file of sqlFiles(tree, p)) {
+            const modelName = posix.basename(file).replace(/\.sql$/, "");
+            if (seen.has(modelName))
+                continue;
+            seen.add(modelName);
+            const text = tree.read(file);
+            const inline = readInlineConfig(text);
+            const yaml = yamlModels.get(modelName);
+            const rel = posix.relative(p || ".", posix.dirname(file));
+            const segments = [...(rel === "" || rel === "." ? [] : rel.split("/")), modelName];
+            const fromProject = projectName ? projectConfig(project.models, projectName, segments) : {};
+            const config = {
+                schema: pick(inline.schema, setting(yaml?.config.schema, `config of ${modelName} in ${yaml?.file}`), setting(fromProject.schema, `+schema in ${projectFile}`)),
+                alias: pick(inline.alias, setting(yaml?.config.alias, `config of ${modelName} in ${yaml?.file}`), setting(fromProject.alias, `+alias in ${projectFile}`)),
+                enabled: pick(inline.enabled, setting(yaml?.config.enabled, `config of ${modelName} in ${yaml?.file}`), setting(fromProject.enabled, `+enabled in ${projectFile}`)),
+            };
+            const line = inline.line;
+            const gap = (message) => gaps.push({ file, line, message: `model ${modelName}: ${message}`, outputs: true });
+            const enabled = config.enabled;
+            if (enabled.status === "dynamic") {
+                gap(`enabled is ${enabled.text} (${enabled.at}), which chant does not render; the model was not read`);
+                continue;
+            }
+            if (enabled.status === "value" && enabled.value === false)
+                continue;
+            if (enabled.status === "value" && enabled.value !== true) {
+                gap(`enabled is ${JSON.stringify(enabled.value)} (${enabled.at}), not true or false; the model was not read`);
+                continue;
+            }
+            // The model's name: its alias, or the file's.
+            let relation = modelName;
+            if (config.alias.status === "dynamic") {
+                gap(`alias ${config.alias.text} (${config.alias.at}) is a Jinja template or not a name, which chant does not render; the model was not read`);
+                continue;
+            }
+            if (config.alias.status === "value") {
+                const alias = scalar(config.alias.value);
+                if (alias === undefined || alias === "" || isTemplated(alias)) {
+                    gap(`alias ${JSON.stringify(config.alias.value)} (${config.alias.at}) is a Jinja template or not a name, which chant does not render; the model was not read`);
+                    continue;
+                }
+                relation = alias;
+            }
+            // The schema it lands in.
+            let schema;
+            if (modelSchema !== null) {
+                schema = modelSchema;
+            }
+            else {
+                const resolved = modelSchemaFromConfig(config.schema, macro);
+                if (typeof resolved !== "string") {
+                    gap(`${resolved.message}; set modelSchema on the dbt member to name the schema its models land in`);
+                    continue;
+                }
+                schema = resolved;
+            }
+            const model = `${name(schema, quoting.schema)}.${name(relation, quoting.identifier)}`;
+            outputs.push({ name: model, file, line });
+            for (const column of yaml?.columns ?? [])
+                outputs.push({ name: `${model}.${name(column.name, column.quote)}`, file: column.file, line: column.line });
+        }
+    }
+}
+/** The schema config names, or why that does not give a name. */
+function modelSchemaFromConfig(schema, macro) {
+    if (schema.status === "dynamic")
+        return { message: `schema ${schema.text} (${schema.at}) is a Jinja template, which chant does not render for a target` };
+    if (macro.kind === "other")
+        return { message: `the project overrides generate_schema_name (${macro.file}:${macro.line}), which chant does not evaluate, so it cannot tell which schema the model lands in` };
+    if (schema.status === "unset")
+        return { message: "it sets no schema, so it lands in the target's schema, which profiles.yml names and chant does not read" };
+    const custom = scalar(schema.value);
+    if (custom === undefined || custom === "" || isTemplated(custom))
+        return { message: `schema ${JSON.stringify(schema.value)} (${schema.at}) is a Jinja template or not a name, which chant does not render` };
+    if (macro.kind === "custom-as-is")
+        return custom;
+    return { message: `schema ${JSON.stringify(custom)} (${schema.at}) is joined to the target's schema by dbt's default generate_schema_name (<target_schema>_${custom}), so the name depends on the target` };
+}
+/**
+ * Whether the project overrides `generate_schema_name`, in a `.sql` file under
+ * `macro-paths` (`macros` by default). The usual override returns the custom
+ * schema as it stands: with the tags removed, its body is the target's schema
+ * and `{{ custom_schema_name | trim }}`, one per branch of an `is none` test.
+ * Any other body is not evaluated.
+ */
+function schemaMacro(tree, dir, project) {
+    const raw = project["macro-paths"] ?? ["macros"];
+    if (!Array.isArray(raw))
+        return { kind: "default" };
+    let found = { kind: "default" };
+    for (const p of raw) {
+        if (typeof p !== "string" || isTemplated(p) || posix.isAbsolute(p))
+            continue;
+        const at = posix.normalize(joinPath(dir, p));
+        if (at === ".." || at.startsWith("../"))
+            continue;
+        for (const file of sqlFiles(tree, at === "." ? "" : at)) {
+            let text;
+            try {
+                text = tree.read(file);
+            }
+            catch {
+                continue;
+            }
+            const start = /\{%-?\s*macro\s+generate_schema_name\s*\(/.exec(text);
+            if (!start)
+                continue;
+            const line = text.slice(0, start.index).split("\n").length;
+            const end = /\{%-?\s*endmacro\s*-?%\}/.exec(text.slice(start.index));
+            const body = text.slice(start.index + start[0].length, end ? start.index + end.index : undefined);
+            const afterSignature = body.slice(body.indexOf("%}") + 2);
+            const flat = afterSignature.replace(/\{%[\s\S]*?%\}/g, "").replace(/\s+/g, "");
+            const asIs = /^\{\{(?:target\.schema|default_schema)\}\}\{\{custom_schema_name\|trim\}\}$/.test(flat) && /custom_schema_name(?:is|==)none/.test(afterSignature.replace(/\s+/g, ""));
+            found = asIs ? { kind: "custom-as-is" } : { kind: "other", file, line };
+        }
+    }
+    return found;
+}
+/** `.sql` files under tree-relative directory `dir`, skipping dot directories and node_modules; sorted. */
+function sqlFiles(tree, dir) {
+    if (dir !== "" && tree.stat(dir) !== "dir")
+        return [];
+    const out = [];
+    const walk = (at) => {
+        for (const e of tree.list(at) ?? []) {
+            const path = joinPath(at, e.name);
+            if (e.type === "dir") {
+                if (!skippedDir(e.name))
+                    walk(path);
+            }
+            else if (/\.sql$/.test(e.name)) {
+                out.push(path);
+            }
+        }
+    };
+    walk(dir);
+    return out.sort();
+}
+/** The first setting that is set: the model's own, then its YAML's, then the project's. */
+function pick(...settings) {
+    return settings.find((s) => s.status !== "unset") ?? { status: "unset" };
+}
+function setting(value, at) {
+    if (value === undefined || value === null)
+        return { status: "unset" };
+    if (typeof value === "string" && isTemplated(value))
+        return { status: "dynamic", at, text: JSON.stringify(value) };
+    return { status: "value", value, at };
+}
+const PROJECT_KEYS = new Set(KEYS);
+/** The configs `dbt_project.yml` sets for a model: the project's block, then each directory down to the model's name; deeper wins. */
+function projectConfig(models, projectName, segments) {
+    const out = {};
+    if (!isObject(models))
+        return out;
+    let node = models[projectName];
+    const take = (n) => {
+        for (const [k, v] of Object.entries(n)) {
+            if (k.startsWith("+") && PROJECT_KEYS.has(k.slice(1)))
+                out[k.slice(1)] = v;
+            else if (PROJECT_KEYS.has(k) && !isObject(v))
+                out[k] = v;
+        }
+    };
+    if (!isObject(node))
+        return out;
+    take(node);
+    for (const seg of segments) {
+        node = node[seg];
+        if (!isObject(node))
+            break;
+        take(node);
+    }
+    return out;
+}
+/** What a model's own `{{ config(...) }}` calls set, and the line of the first one (1 when none). */
+function readInlineConfig(text) {
+    const out = { schema: { status: "unset" }, alias: { status: "unset" }, enabled: { status: "unset" }, line: 1 };
+    // Comments are blanked, not removed, so lines stay where they were.
+    const blank = (m) => m.replace(/[^\n]/g, " ");
+    const code = text.replace(/\{#[\s\S]*?#\}/g, blank).replace(/--[^\n]*/g, blank);
+    const open = /\{\{-?\s*config\s*\(/g;
+    let first = true;
+    for (let m = open.exec(code); m; m = open.exec(code)) {
+        const args = balanced(code, open.lastIndex);
+        if (args === undefined)
+            continue;
+        if (first) {
+            out.line = code.slice(0, m.index).split("\n").length;
+            first = false;
+        }
+        for (const arg of splitTop(args)) {
+            const kv = /^\s*([A-Za-z_]\w*)\s*=\s*([\s\S]*?)\s*$/.exec(arg);
+            if (!kv || !PROJECT_KEYS.has(kv[1]))
+                continue;
+            const at = "the model's config()";
+            const raw = kv[2];
+            const str = /^(['"])((?:(?!\1)[^\\]|\\.)*)\1$/.exec(raw);
+            let s;
+            if (str)
+                s = isTemplated(str[2]) ? { status: "dynamic", at, text: raw } : { status: "value", value: str[2], at };
+            else if (/^true$/i.test(raw))
+                s = { status: "value", value: true, at };
+            else if (/^false$/i.test(raw))
+                s = { status: "value", value: false, at };
+            else if (/^(none|null)$/i.test(raw))
+                s = { status: "unset" };
+            else
+                s = { status: "dynamic", at, text: raw };
+            out[kv[1]] = s;
+        }
+    }
+    return out;
+}
+/** The text from `from` up to the parenthesis that closes the one before it, or undefined. */
+function balanced(text, from) {
+    let depth = 1;
+    let quote = null;
+    for (let i = from; i < text.length; i++) {
+        const c = text[i];
+        if (quote) {
+            if (c === "\\")
+                i++;
+            else if (c === quote)
+                quote = null;
+        }
+        else if (c === "'" || c === '"')
+            quote = c;
+        else if (c === "(" || c === "[" || c === "{")
+            depth++;
+        else if (c === ")" || c === "]" || c === "}") {
+            depth--;
+            if (depth === 0)
+                return text.slice(from, i);
+        }
+    }
+    return undefined;
+}
+/** `text` split at the commas outside quotes and brackets. */
+function splitTop(text) {
+    const parts = [];
+    let depth = 0;
+    let quote = null;
+    let start = 0;
+    for (let i = 0; i < text.length; i++) {
+        const c = text[i];
+        if (quote) {
+            if (c === "\\")
+                i++;
+            else if (c === quote)
+                quote = null;
+        }
+        else if (c === "'" || c === '"')
+            quote = c;
+        else if (c === "(" || c === "[" || c === "{")
+            depth++;
+        else if (c === ")" || c === "]" || c === "}")
+            depth--;
+        else if (c === "," && depth === 0) {
+            parts.push(text.slice(start, i));
+            start = i + 1;
+        }
+    }
+    parts.push(text.slice(start));
+    return parts;
+}

package/dist/workspace/dbt-project-common.d.ts

@@ -0,0 +1,40 @@
+/**
+ * What the dbt readers share (#3932, #3935): YAML and line helpers, the
+ * `quoting:` rules, and the project's `model-paths`.
+ */
+import type { KindReadGap } from "./kind-link-readers.js";
+import { type WorkspaceTree } from "./tree.js";
+export declare const DBT_PROJECT_FILE = "dbt_project.yml";
+export declare const DEFAULT_MODEL_PATHS: string[];
+/** The dialects whose naming the reader follows; the member's `dialect` field picks one. */
+export declare const DBT_DIALECTS: readonly ["postgres", "clickhouse"];
+export type Dialect = (typeof DBT_DIALECTS)[number];
+export interface Quoting {
+    schema: boolean;
+    identifier: boolean;
+}
+export declare const isTemplated: (v: string) => boolean;
+export declare const isObject: (v: unknown) => v is Record<string, unknown>;
+/** A name as text: a string, or a number or boolean YAML read as one. */
+export declare function scalar(v: unknown): string | undefined;
+/** Whether an entry is enabled: `enabled`, or `config.enabled`. A templated value is a gap, and the entry is left out. */
+export declare function readEnabled(entry: Record<string, unknown>, file: string, line: number, where: string, gaps: KindReadGap[]): boolean;
+/** `base` with a `quoting:` block's schema and identifier applied. A value that isn't a boolean is a gap and keeps the base. */
+export declare function readQuoting(base: Quoting, raw: unknown, file: string, line: number, where: string, gaps: KindReadGap[]): Quoting;
+/** Every `.yml` and `.yaml` file under tree-relative directory `dir`, skipping dot directories and node_modules. */
+export declare function yamlFiles(tree: WorkspaceTree, dir: string): string[];
+export declare function lines(text: string): string[];
+export declare function escapeRegExp(text: string): string;
+/** The line (from 1) of top-level key `key`, or 1. */
+export declare function keyLine(fileLines: string[], key: string): number;
+/**
+ * The line of the first `name: <value>` entry after line `from`, or `from`
+ * itself. Sources, tables and columns are listed in file order, so
+ * searching on from the parent's line finds each one's own line. A file in
+ * flow style has no such lines, and its entries are reported at the parent.
+ */
+export declare function nameLine(fileLines: string[], value: string | undefined, from: number): number;
+/** The line of the first `<key>:` after line `from`, or `from`. */
+export declare function valueLine(fileLines: string[], key: string, from: number): number;
+export declare function valueLineOf(fileLines: string[], key: string, value: string, from: number): number;
+//# sourceMappingURL=dbt-project-common.d.ts.map

package/dist/workspace/dbt-project-common.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"dbt-project-common.d.ts","sourceRoot":"","sources":["../../src/workspace/dbt-project-common.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAGH,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,qBAAqB,CAAC;AACvD,OAAO,EAAwB,KAAK,aAAa,EAAE,MAAM,QAAQ,CAAC;AAElE,eAAO,MAAM,gBAAgB,oBAAoB,CAAC;AAClD,eAAO,MAAM,mBAAmB,UAAa,CAAC;AAE9C,4FAA4F;AAC5F,eAAO,MAAM,YAAY,YAAI,UAAU,EAAE,YAAY,CAAU,CAAC;AAChE,MAAM,MAAM,OAAO,GAAG,CAAC,OAAO,YAAY,CAAC,CAAC,MAAM,CAAC,CAAC;AAEpD,MAAM,WAAW,OAAO;IACtB,MAAM,EAAE,OAAO,CAAC;IAChB,UAAU,EAAE,OAAO,CAAC;CACrB;AAED,eAAO,MAAM,WAAW,MAAO,MAAM,YAAuB,CAAC;AAC7D,eAAO,MAAM,QAAQ,MAAO,OAAO,KAAG,CAAC,IAAI,MAAM,CAAC,MAAM,EAAE,OAAO,CAA6D,CAAC;AAE/H,yEAAyE;AACzE,wBAAgB,MAAM,CAAC,CAAC,EAAE,OAAO,GAAG,MAAM,GAAG,SAAS,CAIrD;AAED,0HAA0H;AAC1H,wBAAgB,WAAW,CAAC,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAAE,IAAI,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,EAAE,IAAI,EAAE,WAAW,EAAE,GAAG,OAAO,CAOnI;AAED,gIAAgI;AAChI,wBAAgB,WAAW,CAAC,IAAI,EAAE,OAAO,EAAE,GAAG,EAAE,OAAO,EAAE,IAAI,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,EAAE,IAAI,EAAE,WAAW,EAAE,GAAG,OAAO,CAchI;AAED,oHAAoH;AACpH,wBAAgB,SAAS,CAAC,IAAI,EAAE,aAAa,EAAE,GAAG,EAAE,MAAM,GAAG,MAAM,EAAE,CAepE;AAED,wBAAgB,KAAK,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,EAAE,CAE5C;AAED,wBAAgB,YAAY,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CAEjD;AAED,sDAAsD;AACtD,wBAAgB,OAAO,CAAC,SAAS,EAAE,MAAM,EAAE,EAAE,GAAG,EAAE,MAAM,GAAG,MAAM,CAIhE;AAED;;;;;GAKG;AACH,wBAAgB,QAAQ,CAAC,SAAS,EAAE,MAAM,EAAE,EAAE,KAAK,EAAE,MAAM,GAAG,SAAS,EAAE,IAAI,EAAE,MAAM,GAAG,MAAM,CAE7F;AAED,mEAAmE;AACnE,wBAAgB,SAAS,CAAC,SAAS,EAAE,MAAM,EAAE,EAAE,GAAG,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,GAAG,MAAM,CAIhF;AAED,wBAAgB,WAAW,CAAC,SAAS,EAAE,MAAM,EAAE,EAAE,GAAG,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,GAAG,MAAM,CAIjG"}

package/dist/workspace/dbt-project-common.js

@@ -0,0 +1,106 @@
+/**
+ * What the dbt readers share (#3932, #3935): YAML and line helpers, the
+ * `quoting:` rules, and the project's `model-paths`.
+ */
+import { joinPath, skippedDir } from "./tree.js";
+export const DBT_PROJECT_FILE = "dbt_project.yml";
+export const DEFAULT_MODEL_PATHS = ["models"];
+/** The dialects whose naming the reader follows; the member's `dialect` field picks one. */
+export const DBT_DIALECTS = ["postgres", "clickhouse"];
+export const isTemplated = (v) => /\{\{|\{%/.test(v);
+export const isObject = (v) => v !== null && typeof v === "object" && !Array.isArray(v);
+/** A name as text: a string, or a number or boolean YAML read as one. */
+export function scalar(v) {
+    if (typeof v === "string")
+        return v;
+    if (typeof v === "number" || typeof v === "boolean")
+        return String(v);
+    return undefined;
+}
+/** Whether an entry is enabled: `enabled`, or `config.enabled`. A templated value is a gap, and the entry is left out. */
+export function readEnabled(entry, file, line, where, gaps) {
+    const config = isObject(entry.config) ? entry.config : {};
+    const raw = entry.enabled ?? config.enabled;
+    if (raw === undefined || raw === null || raw === true)
+        return true;
+    if (raw === false)
+        return false;
+    gaps.push({ file, line, message: `${where}: enabled is ${JSON.stringify(raw)}, which chant does not render; it was not read` });
+    return false;
+}
+/** `base` with a `quoting:` block's schema and identifier applied. A value that isn't a boolean is a gap and keeps the base. */
+export function readQuoting(base, raw, file, line, where, gaps) {
+    if (raw === undefined || raw === null)
+        return base;
+    if (!isObject(raw)) {
+        gaps.push({ file, line, message: `${where} is not a mapping; the quoting above it applies` });
+        return base;
+    }
+    const out = { ...base };
+    for (const key of ["schema", "identifier"]) {
+        const v = raw[key];
+        if (v === undefined)
+            continue;
+        if (typeof v === "boolean")
+            out[key] = v;
+        else
+            gaps.push({ file, line, message: `${where}.${key} is ${JSON.stringify(v)}, not true or false; the quoting above it applies` });
+    }
+    return out;
+}
+/** Every `.yml` and `.yaml` file under tree-relative directory `dir`, skipping dot directories and node_modules. */
+export function yamlFiles(tree, dir) {
+    if (dir !== "" && tree.stat(dir) !== "dir")
+        return [];
+    const out = [];
+    const walk = (at) => {
+        for (const e of tree.list(at) ?? []) {
+            const path = joinPath(at, e.name);
+            if (e.type === "dir") {
+                if (!skippedDir(e.name))
+                    walk(path);
+            }
+            else if (/\.ya?ml$/.test(e.name)) {
+                out.push(path);
+            }
+        }
+    };
+    walk(dir);
+    return out;
+}
+export function lines(text) {
+    return text.replace(/\r\n/g, "\n").split("\n");
+}
+export function escapeRegExp(text) {
+    return text.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+/** The line (from 1) of top-level key `key`, or 1. */
+export function keyLine(fileLines, key) {
+    const re = new RegExp(`^${escapeRegExp(key)}\\s*:`);
+    const i = fileLines.findIndex((l) => re.test(l));
+    return i < 0 ? 1 : i + 1;
+}
+/**
+ * The line of the first `name: <value>` entry after line `from`, or `from`
+ * itself. Sources, tables and columns are listed in file order, so
+ * searching on from the parent's line finds each one's own line. A file in
+ * flow style has no such lines, and its entries are reported at the parent.
+ */
+export function nameLine(fileLines, value, from) {
+    return value === undefined ? from : valueLineOf(fileLines, "name", value, from);
+}
+/** The line of the first `<key>:` after line `from`, or `from`. */
+export function valueLine(fileLines, key, from) {
+    const re = new RegExp(`^\\s*(?:-\\s+)?${escapeRegExp(key)}\\s*:`);
+    for (let i = Math.max(from, 0); i < fileLines.length; i++)
+        if (re.test(fileLines[i]))
+            return i + 1;
+    return from;
+}
+export function valueLineOf(fileLines, key, value, from) {
+    const re = new RegExp(`^\\s*(?:-\\s+)?${escapeRegExp(key)}\\s*:\\s*(["']?)${escapeRegExp(value)}\\1\\s*(?:#.*)?$`);
+    for (let i = Math.max(from, 0); i < fileLines.length; i++)
+        if (re.test(fileLines[i]))
+            return i + 1;
+    return from;
+}