@intentius/chant 0.124.45 → 0.124.48

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;
+}

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

@@ -27,10 +27,11 @@
  * - The producer is the member the `sqlMember` field names. Unset, each link
  *   leaves the producer to `resolveLinks`, which picks the one member that
  *   exposes the table.
+ *
+ * The same pass reads the project's models as outputs (#3935); see
+ * `./dbt-models-reader.ts`.
  */
 import type { KindLinkRead, KindReaderInput } from "./kind-link-readers.js";
-export declare const DBT_PROJECT_FILE = "dbt_project.yml";
-/** The dialects whose naming the reader follows; the member's `dialect` field picks one. */
-export declare const DBT_DIALECTS: readonly ["postgres", "clickhouse"];
+export { DBT_DIALECTS, DBT_PROJECT_FILE } from "./dbt-project-common.js";
 export declare function readDbtProject(input: KindReaderInput): KindLinkRead;
 //# sourceMappingURL=dbt-project-reader.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"dbt-project-reader.d.ts","sourceRoot":"","sources":["../../src/workspace/dbt-project-reader.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6BG;AAIH,OAAO,KAAK,EAAE,YAAY,EAA6B,eAAe,EAAE,MAAM,qBAAqB,CAAC;AAGpG,eAAO,MAAM,gBAAgB,oBAAoB,CAAC;AAGlD,4FAA4F;AAC5F,eAAO,MAAM,YAAY,YAAI,UAAU,EAAE,YAAY,CAAU,CAAC;AAWhE,wBAAgB,cAAc,CAAC,KAAK,EAAE,eAAe,GAAG,YAAY,CAqJnE"}
+{"version":3,"file":"dbt-project-reader.d.ts","sourceRoot":"","sources":["../../src/workspace/dbt-project-reader.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAgCG;AAIH,OAAO,KAAK,EAAE,YAAY,EAA6B,eAAe,EAAE,MAAM,qBAAqB,CAAC;AAmBpG,OAAO,EAAE,YAAY,EAAE,gBAAgB,EAAE,MAAM,sBAAsB,CAAC;AAEtE,wBAAgB,cAAc,CAAC,KAAK,EAAE,eAAe,GAAG,YAAY,CAsJnE"}