@intentius/chant 0.124.22 → 0.124.24

package/src/workspace/checks/links.ts

@@ -17,31 +17,58 @@
  * | WSP096 | a consumer states the same link twice |
  * | WSP097 | an entry lists `outputs` for a kind that doesn't take them from the entry |
  * | WSP098 | a link states a `protocol` and its kind is not `telemetry` (#2558) |
+ * | WSP099 | a kind's link reader could not read part of a member's files without guessing (#3932) |
+ *
+ * Links a kind's reader finds in a member's own files (#3932), such as a dbt
+ * project's sources, are checked by WSP093 to WSP095 like declared ones, and
+ * their findings name the member's file and line instead of the declaration.
  */
 
 import type { WorkspaceCheck, WorkspaceCheckContext, WorkspaceDiagnostic } from "../checks";
 import type { Member } from "../declaration";
 import { sourceMemberHandles } from "../member-handles";
+import { readKindLinks, type KindLinkRead } from "../kind-link-readers";
 import { DEFAULT_LINK_KIND, LINK_KINDS, TELEMETRY_LINK_KIND, linkTargetProblem, resolveLinks, type AmbiguousRow, type LinkRow, type LinkTableRow } from "../links";
 
 const tables = new WeakMap<WorkspaceCheckContext, LinkTableRow[]>();
+const reads = new WeakMap<WorkspaceCheckContext, Map<string, KindLinkRead>>();
+
+/** What each member's kind reader found (#3932), read once per check run. */
+function kindReads(ctx: WorkspaceCheckContext): Map<string, KindLinkRead> {
+  let read = reads.get(ctx);
+  if (!read) {
+    read = readKindLinks(ctx.declaration, ctx.tree, ctx.kinds);
+    reads.set(ctx, read);
+  }
+  return read;
+}
 
 /** The link rows for a check run, resolved once and shared by every link check. */
 export function linkTable(ctx: WorkspaceCheckContext): LinkTableRow[] {
   let rows = tables.get(ctx);
   if (!rows) {
-    rows = resolveLinks(ctx.declaration, sourceMemberHandles(ctx.declaration, ctx.tree, ctx.groups, ctx.kinds));
+    rows = resolveLinks(ctx.declaration, sourceMemberHandles(ctx.declaration, ctx.tree, ctx.groups, ctx.kinds, ctx.facts?.lexiconOutputs), undefined, kindReads(ctx));
     tables.set(ctx, rows);
   }
   return rows;
 }
 
-const declaredRows = (ctx: WorkspaceCheckContext) => linkTable(ctx).filter((r): r is LinkRow => r.status !== "ambiguous" && r.origin === "declared");
+/** The declared links, and the links a kind's reader found: the rows a member states. */
+const statedRows = (ctx: WorkspaceCheckContext) => linkTable(ctx).filter((r): r is LinkRow => r.status !== "ambiguous" && r.origin !== "inferred:joinKey");
 
-function linkFinding(check: WorkspaceCheck, row: LinkRow, field: string, message: string): WorkspaceDiagnostic {
-  return { checkId: check.id, severity: check.severity, message, entity: row.consumer, pointer: `${row.pointer}/${field}` };
+/** A finding at a declared link's field in the declaration, or at the file and line a reader's link came from. */
+function linkFinding(check: WorkspaceCheck, ctx: WorkspaceCheckContext, row: LinkTableRow, field: string, message: string): WorkspaceDiagnostic {
+  const base = { checkId: check.id, severity: check.severity, message, entity: row.consumer };
+  if (row.origin === "kind-reader" && row.file !== undefined) {
+    const member = ctx.declaration.members.find((m) => m.name === row.consumer);
+    return { ...base, pointer: member?.pointer ?? "", treeFile: row.file, line: row.line ?? 1, column: 1 };
+  }
+  return { ...base, pointer: `${(row as LinkRow).pointer}/${field}` };
 }
 
+/** Where a reader's link came from, for its message; empty for a declared link. */
+const statedAt = (row: LinkRow) => (row.origin === "kind-reader" ? ` (read by ${row.reader} from ${row.file}:${row.line})` : "");
+
 const describeLink = (row: LinkRow) => `${row.consumer}'s link to ${row.producer} output ${row.output}`;
 
 export const LINK_CHECKS: readonly WorkspaceCheck[] = [
@@ -87,9 +114,9 @@ export const LINK_CHECKS: readonly WorkspaceCheck[] = [
     severity: "error",
     configurable: true,
     check(ctx) {
-      return declaredRows(ctx)
+      return statedRows(ctx)
         .filter((r) => r.status === "missing")
-        .map((r) => linkFinding(this, r, "output", `${describeLink(r)} does not resolve: ${r.reason}`));
+        .map((r) => linkFinding(this, ctx, r, "output", `${describeLink(r)}${statedAt(r)} does not resolve: ${r.reason}`));
     },
   },
   {
@@ -99,9 +126,9 @@ export const LINK_CHECKS: readonly WorkspaceCheck[] = [
     severity: "info",
     configurable: true,
     check(ctx) {
-      return declaredRows(ctx)
+      return statedRows(ctx)
         .filter((r) => r.status === "unresolved")
-        .map((r) => linkFinding(this, r, "output", `${describeLink(r)} is kept unresolved: ${r.reason}`));
+        .map((r) => linkFinding(this, ctx, r, "output", `${describeLink(r)}${statedAt(r)} is kept unresolved: ${r.reason}`));
     },
   },
   {
@@ -115,6 +142,10 @@ export const LINK_CHECKS: readonly WorkspaceCheck[] = [
       return linkTable(ctx)
         .filter((r): r is AmbiguousRow => r.status === "ambiguous")
         .map((r) => {
+          if (r.origin === "kind-reader") {
+            const choices = r.candidates.map((c) => c.producer).join(", ");
+            return linkFinding(this, ctx, r, "", `${r.consumer}'s link to ${r.input} (read by ${r.reader}) has no single producer: ${r.reason}${choices ? `. Candidates: ${choices}` : ""}`);
+          }
           const choices = r.candidates.map((c) => `${c.producer} output ${c.output} (${c.label})`).join(", ");
           const first = r.candidates[0];
           return {
@@ -201,4 +232,22 @@ export const LINK_CHECKS: readonly WorkspaceCheck[] = [
       );
     },
   },
+  {
+    id: "WSP099",
+    name: "kind-reader-gap",
+    description:
+      "A kind's link reader read every link in a member's files that it could read without guessing (#3932). A value it would have to render, such as a Jinja template in a dbt source, is reported here with its file and line, and the links it would state are not checked.",
+    severity: "info",
+    configurable: true,
+    check(ctx) {
+      const out: WorkspaceDiagnostic[] = [];
+      for (const [member, read] of kindReads(ctx)) {
+        const pointer = ctx.declaration.members.find((m) => m.name === member)?.pointer ?? "";
+        for (const gap of read.gaps) {
+          out.push({ checkId: this.id, severity: this.severity, message: `${member} (read by ${read.reader}): ${gap.message}`, entity: member, pointer, treeFile: gap.file, line: gap.line, column: 1 });
+        }
+      }
+      return out;
+    },
+  },
 ];

package/src/workspace/checks.e2e.test.ts

@@ -75,7 +75,7 @@ describe("the WSP catalog", () => {
     expect(list.filter((id) => /^WSP(07|08|09|10)\d$/.test(id))).toEqual([
       "WSP071", "WSP072", "WSP073",
       "WSP081", "WSP082", "WSP083",
-      "WSP091", "WSP092", "WSP093", "WSP094", "WSP095", "WSP096", "WSP097", "WSP098",
+      "WSP091", "WSP092", "WSP093", "WSP094", "WSP095", "WSP096", "WSP097", "WSP098", "WSP099",
       "WSP101", "WSP102", "WSP103", "WSP104", "WSP105", "WSP106",
     ]);
   });

package/src/workspace/checks.ts

@@ -24,7 +24,7 @@
  * | WSP001 to WSP011 | the declaration and member kinds (this file) |
  * | WSP071, WSP072 | member ledgers |
  * | WSP081 to WSP083 | recorded pipelines |
- * | WSP091 to WSP098 | member links (#2539, #2558) |
+ * | WSP091 to WSP099 | member links (#2539, #2558), and those a kind's reader finds in a member's files (#3932) |
  * | WSP101 to WSP106 | generated files |
  * | WSP111 to WSP114 | records read with `--kind` (#2549) |
  * | WSP115 | the record kinds the declaration names (#2680) |
@@ -59,6 +59,7 @@ import { BOX_CHECKS } from "./checks/boxes";
 import { DIAGRAM_CHECKS } from "./checks/diagrams";
 import { loadDeclaredKinds, type DeclaredKind } from "./declared-kinds";
 import { resolveBoxIntents, type ResolvedBoxIntent } from "./box-intent";
+import { gatherLexiconOutputs, type MemberLexiconOutputs } from "./lexicon-outputs";
 
 /**
  * What the checks beyond the declaration read, gathered from the checkout
@@ -80,6 +81,8 @@ export interface WorkspaceFacts {
   live?: LiveLinkFacts;
   /** The decision record each box's intent names, read from the working tree (#2850). */
   boxIntents?: readonly ResolvedBoxIntent[];
+  /** The outputs linked members' lexicons report about their declarations, read by folding their source (#3931). */
+  lexiconOutputs?: ReadonlyMap<string, MemberLexiconOutputs>;
 }
 
 /** What every declaration check reads. */
@@ -355,7 +358,7 @@ export const WORKSPACE_CHECKS: readonly WorkspaceCheck[] = [
   ...LEDGER_CHECKS,
   // Recorded pipelines (#2542).
   ...PIPELINE_CHECKS,
-  // Member links (#2539, #2558), WSP091 to WSP098.
+  // Member links (#2539, #2558, #3932), WSP091 to WSP099.
   ...LINK_CHECKS,
   // Generated files (#2541).
   ...GENERATED_CHECKS,
@@ -521,7 +524,11 @@ export async function runDeclarationChecks(
   const declaredKinds = options.gather === false ? undefined : await loadDeclaredKinds(declaration, tree, root, { load: !options.tree, acceptance: !options.tree });
   // A box's intent is read from the working tree's records, so not under --at (#2850).
   const boxIntents = declaredKinds && !options.tree ? await resolveBoxIntents(declaration, root, declaredKinds) : undefined;
+  // A linked member's lexicons name its tables and columns as outputs (#3931); reading them folds its source, never runs it.
+  const lexiconOutputs =
+    options.gather === false ? undefined : await gatherLexiconOutputs(root, declaration, options.tree ? workingTree(root) : tree, groups, registry, { atRevision: options.tree !== undefined });
   const facts: WorkspaceFacts = {
+    ...(lexiconOutputs && lexiconOutputs.size > 0 ? { lexiconOutputs } : {}),
     ...gathered,
     ...(options.records ? { records: options.records } : {}),
     ...(declaredKinds ? { declaredKinds } : {}),

package/src/workspace/compose-graph.test.ts

@@ -104,6 +104,61 @@ describe("composeWorkspaceGraph", () => {
   });
 });
 
+describe("CI edges, pipelines and dangling references (#3922)", () => {
+  /** A github member as `chant graph` reports it after #3910. */
+  const ci = (workflow: string, job: string): GraphIR => ({
+    version: 1,
+    nodes: [
+      { id: workflow, kind: "Workflow", lexicon: "github", attrs: {} },
+      { id: job, kind: "Job", lexicon: "github", attrs: {} },
+      { id: "deploy", kind: "Job", lexicon: "github", attrs: {} },
+    ],
+    edges: [
+      { from: "deploy", to: job, kind: "needs", viaAttr: "needs" },
+      { from: job, to: workflow, kind: "calls", viaAttr: "uses", crossPipeline: true },
+    ],
+    groups: { byLexicon: { github: [job, "deploy", workflow] }, byPipeline: { ci: [job, "deploy", workflow] } },
+    dangling: [
+      { from: "deploy", kind: "needs", path: "needs", value: "lint" },
+      { from: job, kind: "calls", path: "uses", value: "other/repo/.github/workflows/x.yml@main", crossPipeline: true },
+    ],
+  });
+  const doc = composeWorkspaceGraph({ name: "acme", root: "." }, [
+    { member: member("svc", "svc"), ir: ci("ciWorkflow", "build") },
+    { member: member("app", "app"), ir: ci("ciWorkflow", "test") },
+    { member: member("db", "db"), ir: db },
+  ]);
+
+  test("edges keep their kind and crossPipeline", () => {
+    expect(doc.edges.filter((e) => e.member === "svc")).toEqual([
+      { from: "svc/build", to: "svc/ciWorkflow", kind: "calls", viaAttr: "uses", crossPipeline: true, member: "svc" },
+      { from: "svc/deploy", to: "svc/build", kind: "needs", viaAttr: "needs", member: "svc" },
+    ]);
+  });
+
+  test("byPipeline keys and ids are prefixed with the member", () => {
+    expect(doc.groups.byPipeline).toEqual({
+      "app/ci": ["app/ciWorkflow", "app/deploy", "app/test"],
+      "svc/ci": ["svc/build", "svc/ciWorkflow", "svc/deploy"],
+    });
+  });
+
+  test("dangling references keep their fields, with from prefixed and the member named, sorted", () => {
+    expect(doc.dangling).toEqual([
+      { from: "app/deploy", kind: "needs", path: "needs", value: "lint", member: "app" },
+      { from: "app/test", kind: "calls", path: "uses", value: "other/repo/.github/workflows/x.yml@main", crossPipeline: true, member: "app" },
+      { from: "svc/build", kind: "calls", path: "uses", value: "other/repo/.github/workflows/x.yml@main", crossPipeline: true, member: "svc" },
+      { from: "svc/deploy", kind: "needs", path: "needs", value: "lint", member: "svc" },
+    ]);
+  });
+
+  test("no dangling section and no byPipeline when no member reports either", () => {
+    const plain = composeWorkspaceGraph({ name: "acme", root: "." }, [{ member: member("db", "db"), ir: db }]);
+    expect("dangling" in plain).toBe(false);
+    expect(plain.groups.byPipeline).toBeUndefined();
+  });
+});
+
 describe("the links section (#2539)", () => {
   test("inferred joins carry their label, and a declared link suppresses the inferred edge it covers", () => {
     const consumer: GraphIR = {

package/src/workspace/compose-graph.ts

@@ -11,8 +11,12 @@
  *   `runtimeOwner` and export and import nodes are rewritten the same way.
  * - `groups.byMember` maps each member to its node ids. `byLexicon` and
  *   `byComposite` keep their keys (a lexicon or composite type is the same
- *   thing in every member) and merge the ids. `byStack`, `byContainer` and
- *   `byWave` name things inside one member, so their keys are prefixed too.
+ *   thing in every member) and merge the ids. `byStack`, `byContainer`,
+ *   `byWave` and `byPipeline` name things inside one member, so their keys
+ *   are prefixed too.
+ * - Edges keep their `kind` and `crossPipeline` (#3910). A member's dangling
+ *   references (`ir.dangling`) land on the top-level `dangling` list with
+ *   `from` prefixed and a `member` field, like edges (#3922).
  * - `links` holds the member links (#2524 D6, #2539): the declared links and
  *   the joins inferred from members' `imports` and `exports` with the core
  *   `joinKey()`, labelled `exact` or `folded` (`./links.ts`). A declared link
@@ -33,9 +37,10 @@ import type { FactoryView, ListingView } from "./box-factory";
 import type { Declaration } from "./declaration";
 import type { KindRegistry } from "./kinds";
 import { graphLinks, type LinkTableRow } from "./links";
+import type { KindLinkRead } from "./kind-link-readers";
 import type { RecordLinkRow } from "./record-assets";
 import type { ReasonCode } from "./reason-codes";
-import { GRAPH_IR_VERSION, type GraphIR, type IRExport, type IRGroups, type IRImport, type IREdge, type IRNode } from "../graph-ir";
+import { GRAPH_IR_VERSION, type GraphIR, type IRExport, type IRDanglingRef, type IRGroups, type IRImport, type IREdge, type IRNode } from "../graph-ir";
 
 /** The version of the composed document `chant workspace graph` writes. */
 export const WORKSPACE_GRAPH_VERSION = 1;
@@ -164,6 +169,8 @@ export const COLLECTOR_META_KEY = "collector";
 /** `nested` names the nested workspace's member a node was read through (#2551); absent for the outer workspace's own nodes. */
 export type ComposedNode = IRNode & { member: string; nested?: string };
 export type ComposedEdge = IREdge & { member: string };
+/** A member's dangling reference (#3910, #3922): `from` is prefixed like a node id. `nested` as on {@link ComposedNode}. */
+export type ComposedDangling = IRDanglingRef & { member: string; nested?: string };
 
 export interface WorkspaceGraph {
   version: number;
@@ -175,6 +182,12 @@ export interface WorkspaceGraph {
   exports: (IRExport & { member: string })[];
   imports: (IRImport & { member: string })[];
   derivedAttrs?: Record<string, string[]>;
+  /**
+   * The members' dangling CI references (#3910, #3922): each `ir.dangling`
+   * entry with `from` prefixed by its member and a `member` field, sorted by
+   * `from`, `path` and `value`. Absent when no member has one.
+   */
+  dangling?: ComposedDangling[];
   /**
    * Member links (#2524 D6, #2539), declared and inferred, then the links of
    * the records read with `--kind` (#2549). Empty when no declaration is given.
@@ -288,6 +301,13 @@ function prefixRefs(value: unknown, member: string): unknown {
   return out;
 }
 
+/** The groups whose keys name something inside one member, so are prefixed with it. */
+export const SCOPED_GROUPS = ["byStack", "byContainer", "byWave", "byPipeline"] as const;
+type ScopedGroup = (typeof SCOPED_GROUPS)[number];
+
+/** The order the composed `dangling` list is sorted in. */
+export const danglingKey = (d: IRDanglingRef): string => `${d.from}\u0000${d.path}\u0000${d.value}`;
+
 function mergeInto(target: Record<string, string[]>, key: string, ids: string[]): void {
   (target[key] ??= []).push(...ids);
 }
@@ -302,12 +322,13 @@ function sorted(rec: Record<string, string[]>): Record<string, string[]> {
  * Compose the members' IRs into the workspace document. Members keep the
  * order they are given in. With `links`, the `links` section is filled from
  * the declaration; `kinds` lets a member that isn't composed but whose kind
- * lists its outputs (`other`, kinds from a package) be a link target.
+ * lists its outputs (`other`, kinds from a package) be a link target, and
+ * `read` holds the links each member's kind reader found in its files (#3932).
  */
 export function composeWorkspaceGraph(
   workspace: { name: string; root: string },
   inputs: ComposeInput[],
-  links?: { declaration: Declaration; kinds?: KindRegistry },
+  links?: { declaration: Declaration; kinds?: KindRegistry; read?: ReadonlyMap<string, KindLinkRead> },
 ): WorkspaceGraph {
   const nodes: ComposedNode[] = [];
   const edges: ComposedEdge[] = [];
@@ -315,7 +336,8 @@ export function composeWorkspaceGraph(
   const imports: WorkspaceGraph["imports"] = [];
   const byMember: Record<string, string[]> = {};
   const shared: Record<"byLexicon" | "byComposite", Record<string, string[]>> = { byLexicon: {}, byComposite: {} };
-  const scoped: Record<"byStack" | "byContainer" | "byWave", Record<string, string[]>> = { byStack: {}, byContainer: {}, byWave: {} };
+  const scoped: Record<ScopedGroup, Record<string, string[]>> = { byStack: {}, byContainer: {}, byWave: {}, byPipeline: {} };
+  const dangling: ComposedDangling[] = [];
   const derivedAttrs: Record<string, Set<string>> = {};
   const collectors: MemberCollector[] = [];
 
@@ -335,9 +357,10 @@ export function composeWorkspaceGraph(
     for (const key of ["byLexicon", "byComposite"] as const) {
       for (const [k, v] of Object.entries(ir.groups[key] ?? {})) mergeInto(shared[key], k, v.map((id) => prefix(m, id)));
     }
-    for (const key of ["byStack", "byContainer", "byWave"] as const) {
+    for (const key of SCOPED_GROUPS) {
       for (const [k, v] of Object.entries(ir.groups[key] ?? {})) mergeInto(scoped[key], prefix(m, k), v.map((id) => prefix(m, id)));
     }
+    for (const d of ir.dangling ?? []) dangling.push({ ...d, from: prefix(m, d.from), member: m });
     for (const e of ir.exports ?? []) exports.push({ ...e, ...(e.node ? { node: prefix(m, e.node) } : {}), member: m });
     for (const i of ir.imports ?? []) imports.push({ ...i, node: prefix(m, i.node), member: m });
     for (const [kind, attrs] of Object.entries(ir.derivedAttrs ?? {})) for (const a of attrs) (derivedAttrs[kind] ??= new Set()).add(a);
@@ -358,7 +381,7 @@ export function composeWorkspaceGraph(
 
   const groups: WorkspaceGraph["groups"] = { byMember };
   for (const key of ["byLexicon", "byComposite"] as const) if (Object.keys(shared[key]).length) groups[key] = sorted(shared[key]);
-  for (const key of ["byStack", "byContainer", "byWave"] as const) if (Object.keys(scoped[key]).length) groups[key] = sorted(scoped[key]);
+  for (const key of SCOPED_GROUPS) if (Object.keys(scoped[key]).length) groups[key] = sorted(scoped[key]);
 
   const doc: WorkspaceGraph = {
     version: WORKSPACE_GRAPH_VERSION,
@@ -370,11 +393,12 @@ export function composeWorkspaceGraph(
     exports,
     imports,
     links: links
-      ? graphLinks(links.declaration, { composed: inputs.filter((i) => i.ir).map((i) => i.member.name), collectors, exports, imports }, links.kinds)
+      ? graphLinks(links.declaration, { composed: inputs.filter((i) => i.ir).map((i) => i.member.name), collectors, exports, imports }, links.kinds, links.read)
       : [],
     collectors,
     records: [],
   };
+  if (dangling.length) doc.dangling = dangling.sort((a, b) => danglingKey(a).localeCompare(danglingKey(b)));
   if (Object.keys(derivedAttrs).length) {
     doc.derivedAttrs = Object.fromEntries(Object.keys(derivedAttrs).sort().map((k) => [k, [...derivedAttrs[k]].sort()]));
   }

package/src/workspace/dbt-kind.e2e.test.ts

@@ -0,0 +1,95 @@
+/**
+ * The `dbt` kind end to end (#3932): the sql lexicon pinned as a package,
+ * its kinds file found through node_modules, and this checkout's chant CLI
+ * running `workspace check` and `workspace graph`. The producer is a real
+ * sql member, a chant project that declares `orders`, whose tables and
+ * columns are outputs through the sql lexicon's hook (#3931).
+ */
+
+import { spawnSync } from "node:child_process";
+import { readFileSync, symlinkSync } from "node:fs";
+import { join } from "node:path";
+import { pathToFileURL } from "node:url";
+import { afterAll, describe, expect, test } from "vitest";
+import { cleanScratch, contract, declaration, REPO, repo } from "./__fixtures__/contract-repo";
+import schema from "./graph.schema.json";
+
+afterAll(cleanScratch);
+
+const TIMEOUT = 120_000;
+const LEXICON = "@intentius/chant-lexicon-sql";
+const VERSION = (JSON.parse(readFileSync(join(REPO, "lexicons", "sql", "package.json"), "utf-8")) as { version: string }).version;
+
+function chant(cwd: string, ...argv: string[]) {
+  return spawnSync(process.execPath, ["--import", pathToFileURL(join(REPO, "node_modules/tsx/dist/loader.mjs")).href, join(REPO, "packages/core/src/cli/main.ts"), ...argv], {
+    cwd,
+    encoding: "utf-8",
+    timeout: TIMEOUT,
+    env: { ...process.env, NO_COLOR: "1", TSX_DISABLE_CACHE: "1" },
+  });
+}
+
+const SQL_CONFIG = `import type { ChantConfig } from "@intentius/chant";\nexport default { lexicons: ["sql"], sql: { dialect: "postgres" } } satisfies ChantConfig;\n`;
+
+const orders = (columns: string[]) =>
+  [
+    `import { table } from "@intentius/chant-lexicon-sql/postgres";`,
+    ``,
+    `export const orders = table\``,
+    `  CREATE TABLE orders (`,
+    ...columns.map((c, i) => `    ${c}${i < columns.length - 1 ? "," : ""}`),
+    `  )\`;`,
+    ``,
+  ].join("\n");
+
+function workspace(columns: string[]): string {
+  const root = repo({
+    "chant.workspace.json": declaration(
+      [
+        { name: "db", dir: "db", kind: "chant" },
+        { name: "analytics", dir: "analytics", kind: "dbt", fields: { sqlMember: "db" } },
+      ],
+      { pins: [{ package: LEXICON, version: VERSION }] },
+    ),
+    "db/chant.config.ts": SQL_CONFIG,
+    "db/src/orders.ts": orders(columns),
+    "analytics/dbt_project.yml": "name: analytics\nversion: '1.0'\nprofile: analytics\n",
+    "analytics/models/staging/sources.yml": "version: 2\n\nsources:\n  - name: shop\n    schema: public\n    tables:\n      - name: orders\n        columns:\n          - name: id\n          - name: customer_id\n",
+    ".gitignore": "node_modules\n",
+  });
+  symlinkSync(join(REPO, "node_modules"), join(root, "node_modules"), "dir");
+  return root;
+}
+
+describe("a dbt member through the pinned sql lexicon (#3932)", () => {
+  test(
+    "check passes while the sql member has public.orders.customer_id, and fails naming the dbt source file once it is dropped",
+    () => {
+      const ok = chant(workspace(["id bigint PRIMARY KEY", "customer_id bigint NOT NULL"]), "workspace", "check");
+      expect(ok.status, ok.stdout + ok.stderr).toBe(0);
+
+      const dropped = chant(workspace(["id bigint PRIMARY KEY"]), "workspace", "check");
+      expect(dropped.status).toBe(1);
+      const text = dropped.stdout + dropped.stderr;
+      expect(text).toContain("analytics/models/staging/sources.yml:10");
+      expect(text).toContain("WSP093");
+      expect(text).toMatch(/link to db output public\.orders\.customer_id .*does not resolve/);
+    },
+    TIMEOUT,
+  );
+
+  test(
+    "workspace graph lists the dbt member's links with their file and line",
+    () => {
+      const run = chant(workspace(["id bigint PRIMARY KEY"]), "workspace", "graph");
+      const doc = JSON.parse(run.stdout) as { links: { origin: string; consumer: string; producer: string; output: string; status: string; file?: string; line?: number }[] };
+      contract(schema).expectValid(doc);
+      expect(doc.links.filter((l) => l.origin === "kind-reader").map((l) => `${l.consumer} -> ${l.producer}.${l.output} ${l.status} ${l.file}:${l.line}`)).toEqual([
+        "analytics -> db.public.orders resolved analytics/models/staging/sources.yml:7",
+        "analytics -> db.public.orders.id resolved analytics/models/staging/sources.yml:9",
+        "analytics -> db.public.orders.customer_id missing analytics/models/staging/sources.yml:10",
+      ]);
+    },
+    TIMEOUT,
+  );
+});