@intentius/chant-lexicon-sql 0.122.0 → 0.123.0

package/src/core/typed.ts

@@ -0,0 +1,143 @@
+/**
+ * Typed columns (#3751): the types that carry a relation's columns from the
+ * declarations `chant sql types` generates to `tsc`, in every dialect.
+ *
+ * Each dialect declares an empty `SqlSchema` interface keyed by qualified
+ * name, and the generated `sql-types.d.ts` augments it. A tag given the name
+ * as its type argument (`` table<"shop.orders">`CREATE TABLE ...` ``) returns
+ * a relation whose `columns` are that entry's, each a {@link Column} branded
+ * with its SQL type. The tag's interpolations are typed by the entry's
+ * `slots`: the generator writes, per `${}` position, the column a foreign key
+ * or a sort key there must be ({@link KeyColumn}, {@link NotNullColumn}).
+ *
+ * A relation with no type argument, or one the generated file does not list
+ * yet, keeps unchecked columns: any name type-checks and every slot takes
+ * them, so a project adopts the type argument one declaration at a time.
+ *
+ * The runtime half is the record of those slots: a tag notes which `${}`
+ * feeds a foreign key's column list or a sort key, off the serialized output
+ * as `setInterpolationFields` keeps its record, for the generator to read.
+ */
+
+import type { AttrRef } from "@intentius/chant/attrref";
+
+declare const columnBrand: unique symbol;
+declare const checkedBrand: unique symbol;
+declare const relationName: unique symbol;
+declare const unnamedBrand: unique symbol;
+
+/** What the generator knows about a column. */
+export interface ColumnTraits {
+  /** The row type `RowOf` gives the column, before `| null`. */
+  readonly ts: unknown;
+  readonly nullable: boolean;
+  /**
+   * How the column compares in a key. Postgres: the catalog category letter
+   * (`N`, `S`), or the type itself for the user-defined category, an enum or
+   * a row type; a domain compares as its base. ClickHouse: the type family.
+   */
+  readonly cmp: string;
+}
+
+/**
+ * A column reference branded with its SQL type, spelled as the catalog
+ * spells it. `Checked` is true for a column the generated declarations type,
+ * false for an unchecked one; it is a discriminant, so a slot's error names
+ * the checked member it wanted.
+ */
+export interface Column<SqlType extends string = string, T extends ColumnTraits = ColumnTraits, Checked extends boolean = true> extends AttrRef {
+  readonly [columnBrand]: { readonly sqlType: SqlType; readonly traits: T };
+  readonly [checkedBrand]: Checked;
+}
+
+/** A column of a relation the declarations do not cover: any name type-checks, and it fits every slot. */
+export type UncheckedColumn = Column<string, ColumnTraits, false>;
+
+/** Any column, checked or not: what a relation annotated without a name (`PostgresTable`) holds. */
+export type AnyColumn = Column<string, ColumnTraits, boolean>;
+
+/**
+ * What a slot takes besides its checked column: an unchecked relation's
+ * column, which reads as `| undefined` under `noUncheckedIndexedAccess`. A
+ * checked relation's columns are named properties, so nothing of theirs gets
+ * through here.
+ */
+type Unchecked = UncheckedColumn | undefined;
+
+/** A `${}` that must be a column comparing as `Cmp`: the referenced column of a foreign key. */
+export type KeyColumn<Cmp extends string> = Unchecked | Column<string, { readonly ts: unknown; readonly nullable: boolean; readonly cmp: Cmp }>;
+
+/** A `${}` that must be a column that cannot be NULL: an element of a ClickHouse sort key. */
+export type NotNullColumn = Unchecked | Column<string, { readonly ts: unknown; readonly nullable: false; readonly cmp: string }>;
+
+/**
+ * The name a relation's type carries when its tag has no type argument. Its
+ * columns are unchecked, and `RowOf` refuses it.
+ */
+export type Unnamed = string & { readonly [unnamedBrand]: true };
+
+/** Carries a relation's declared name on its type, so `RowOf<typeof t>` can find its entry. */
+export interface Named<N extends string> {
+  readonly [relationName]?: N;
+}
+
+/**
+ * The columns of relation `N` in `Registry` (a dialect's `SqlSchema`):
+ * unchecked for an {@link Unnamed} relation or a name the registry does not
+ * list, any column for the bare annotation (`N` is `string`), and the
+ * entry's own otherwise.
+ */
+export type ColumnsIn<Registry, N extends string> = [N] extends [Unnamed]
+  ? Readonly<Record<string, UncheckedColumn>>
+  : string extends N
+    ? Readonly<Record<string, AnyColumn>>
+    : N extends keyof Registry
+      ? Registry[N] extends { readonly columns: infer C } ? C : never
+      : Readonly<Record<string, UncheckedColumn>>;
+
+/** The interpolations a tag for relation `N` takes: the entry's slots, then anything. */
+export type SlotsIn<Registry, N extends string> = N extends keyof Registry
+  ? Registry[N] extends { readonly slots: infer S extends readonly unknown[] } ? [...S, ...unknown[]] : unknown[]
+  : unknown[];
+
+type RowFromColumns<C> = {
+  -readonly [K in keyof C]: C[K] extends Column<string, infer T> ? (T["nullable"] extends true ? T["ts"] | null : T["ts"]) : unknown;
+};
+
+/** A relation's row: `T` is its name or a relation's type carrying one. */
+export type RowIn<Registry, T> = T extends string
+  ? RowFromColumns<ColumnsIn<Registry, T>>
+  : T extends Named<infer N> ? RowFromColumns<ColumnsIn<Registry, N>> : never;
+
+// ── The slot record ─────────────────────────────────────────────────────
+
+/**
+ * One `${}` the generator types. `references`: a column in a foreign key's
+ * referenced column list, paired with `column`, the referencing table's own
+ * column at that position. `sortKey`: a bare element of a ClickHouse
+ * `ORDER BY` or `PRIMARY KEY`.
+ */
+export type TypedSlot = { readonly index: number; readonly kind: "references"; readonly column: string } | { readonly index: number; readonly kind: "sortKey" };
+
+const TYPED_SLOTS = Symbol.for("chant.sql.typedSlots");
+
+/** Record the typed slots on an entity: non-enumerable and symbol-keyed, so no serializer sees it. */
+export function setTypedSlots(entity: object, slots: readonly TypedSlot[]): void {
+  if (slots.length === 0 || !Object.isExtensible(entity)) return;
+  Object.defineProperty(entity, TYPED_SLOTS, { value: Object.freeze([...slots]), enumerable: false, writable: false, configurable: true });
+}
+
+/** What {@link setTypedSlots} recorded on an entity; empty when nothing was. */
+export function getTypedSlots(entity: object): readonly TypedSlot[] {
+  return ((entity as Record<symbol, unknown>)[TYPED_SLOTS] as readonly TypedSlot[] | undefined) ?? [];
+}
+
+/**
+ * A relation's key in `SqlSchema`: `schema.name` (Postgres) or
+ * `database.name` (ClickHouse), unquoted and with Postgres's folding
+ * applied, or the name alone when the DDL does not qualify it.
+ */
+export function relationKey(props: { readonly schema?: string; readonly database?: string; readonly name: string }): string {
+  const qualifier = props.schema ?? props.database;
+  return qualifier ? `${qualifier}.${props.name}` : props.name;
+}

package/src/lint/audit-catalog.ts

@@ -34,6 +34,12 @@ export const sqlAuditCatalog: Record<string, RuleMeta> = {
     "A column interpolated without .columns reads the entity's own field instead",
     "Write ${table.columns.name}.",
   ),
+  SQLCH004: sourceRule(
+    "SQLCH004",
+    "correctness",
+    "A typed ClickHouse tag's type argument does not name the object its template declares, or is not in sql-types.d.ts",
+    "Make the type argument the qualified name the template declares, then run chant sql types.",
+  ),
   SQLPG001: sourceRule(
     "SQLPG001",
     "correctness",
@@ -58,6 +64,12 @@ export const sqlAuditCatalog: Record<string, RuleMeta> = {
     "A declared extension the configured Postgres provider does not allow",
     "Use an extension the provider lists, or set sql.provider to the service the project deploys to.",
   ),
+  SQLPG005: sourceRule(
+    "SQLPG005",
+    "correctness",
+    "A typed Postgres tag's type argument does not name the object its template declares, or is not in sql-types.d.ts",
+    "Make the type argument the qualified name the template declares, then run chant sql types.",
+  ),
   SQLCH101: auditRule(
     "SQLCH101",
     "merge-worthy",
@@ -74,6 +86,14 @@ export const sqlAuditCatalog: Record<string, RuleMeta> = {
     "Keep one declaration of the object and import it where the other was used.",
     { category: "correctness" },
   ),
+  SQL102: auditRule(
+    "SQL102",
+    "merge-worthy",
+    "guidance",
+    "sql-types.d.ts differs from what the build declares",
+    "Run chant sql types to rewrite the file.",
+    { category: "correctness" },
+  ),
   ...sqlPostSynthAuditEntries,
   ...postgresPostSynthAuditEntries,
 };

package/src/lint/post-synth/index.ts

@@ -1,6 +1,7 @@
 // Code generated by chant generate. DO NOT EDIT.
 import type { PostSynthCheck } from "@intentius/chant/lint/post-synth";
 import { sql101 } from "./sql101";
+import { sql102 } from "./sql102";
 import { sqlch101 } from "./sqlch101";
 import { sqlch102 } from "./sqlch102";
 import { sqlch103 } from "./sqlch103";
@@ -57,6 +58,7 @@ import { sqlpg126 } from "./sqlpg126";
 
 export const postSynthChecks: PostSynthCheck[] = [
   sql101,
+  sql102,
   sqlch101,
   sqlch102,
   sqlch103,

package/src/lint/post-synth/postgres-names.ts

@@ -120,12 +120,16 @@ export interface PgProject {
 }
 
 export function projectOf(ctx: PostSynthContext): PgProject {
-  const objects = postgresObjects(ctx);
+  return projectFromObjects(postgresObjects(ctx), targetMajor(ctx));
+}
+
+/** The project a set of output objects declares, at `major`: for a reader that holds the build output itself (`chant sql types`). */
+export function projectFromObjects(objects: OutputObject[], major: number): PgProject {
   const byExport = new Map(objects.map((o) => [o.export, o]));
   const schemas = new Set(objects.filter((o) => o.type === "Postgres::Schema").map((o) => o.name));
   const exts = objects.filter((o) => o.type === "Postgres::Extension");
   return {
-    major: targetMajor(ctx),
+    major,
     objects,
     byExport,
     schemas,

package/src/lint/post-synth/sql102.ts

@@ -0,0 +1,34 @@
+import type { PostSynthCheck } from "@intentius/chant/lint/post-synth";
+import { sqlTypesPath, sqlTypesState } from "../../sql-types";
+
+/**
+ * SQL102: `sql-types.d.ts` no longer matches what the build declares.
+ *
+ * tsc checks a typed tag's columns, and the foreign-key and sort-key slots,
+ * against the generated file, never against the template text, so a stale file
+ * keeps checking the old types. The check renders the declarations in memory
+ * (the render `chant sql types` writes) and compares them with the file in the
+ * project's source directory. Silent when the context carries no project
+ * directory (a hand-built one) or the file does not exist, so a project that
+ * has not adopted typed columns, or keeps the file elsewhere, sees nothing.
+ * `chant sql types --check` is the same comparison without a build, and a
+ * workspace `generated` entry runs it under `chant workspace check --generated`.
+ */
+export const sql102: PostSynthCheck = {
+  id: "SQL102",
+  description: "sql-types.d.ts differs from what the build declares",
+  check(ctx) {
+    if (!ctx.projectDir) return [];
+    const file = sqlTypesPath(ctx.projectDir, ctx.projectConfig);
+    const state = sqlTypesState(ctx.entities, file, { projectDir: ctx.projectDir, config: ctx.projectConfig });
+    if (state !== "stale") return [];
+    return [
+      {
+        checkId: "SQL102",
+        severity: "error",
+        message: `${file} differs from what the build declares, so tsc checks columns against out-of-date types; run \`chant sql types\` to rewrite it`,
+        lexicon: "sql",
+      },
+    ];
+  },
+};

package/src/lint/rules/index.ts

@@ -2,12 +2,14 @@ import type { LintRule } from "@intentius/chant/lint/rule";
 import { sqlch001 } from "./sqlch001";
 import { sqlch002 } from "./sqlch002";
 import { sqlch003 } from "./sqlch003";
+import { sqlch004 } from "./sqlch004";
 import { sqlpg001 } from "./sqlpg001";
 import { sqlpg002 } from "./sqlpg002";
 import { sqlpg003 } from "./sqlpg003";
 import { sqlpg004 } from "./sqlpg004";
+import { sqlpg005 } from "./sqlpg005";
 
-export { sqlch001, sqlch002, sqlch003, sqlpg001, sqlpg002, sqlpg003, sqlpg004 };
+export { sqlch001, sqlch002, sqlch003, sqlch004, sqlpg001, sqlpg002, sqlpg003, sqlpg004, sqlpg005 };
 
 /** The lexicon's source-level lint rules, returned by `lintRules()`. */
-export const rules: LintRule[] = [sqlch001, sqlch002, sqlch003, sqlpg001, sqlpg002, sqlpg003, sqlpg004];
+export const rules: LintRule[] = [sqlch001, sqlch002, sqlch003, sqlch004, sqlpg001, sqlpg002, sqlpg003, sqlpg004, sqlpg005];

package/src/lint/rules/sqlch004.ts

@@ -0,0 +1,81 @@
+import type { LintContext, LintDiagnostic, LintRule } from "@intentius/chant/lint/rule";
+import { parseCreate, unquote } from "../../clickhouse/parser";
+import { isTrivia, SqlSyntaxError } from "../../clickhouse/tokens";
+import { findTemplates, tokensOf } from "./templates";
+import { declaredText, generatedNamesFor, nameAgrees, normalizedName, SQL_TYPES_FILE, typeArgumentName } from "./typed-names";
+
+const MODULE = "@intentius/chant-lexicon-sql/clickhouse";
+
+/**
+ * SQLCH004: a typed ClickHouse tag whose type argument does not name the
+ * object its template declares, or is not in the generated `sql-types.d.ts`.
+ *
+ * `table<"shop.events">\`CREATE TABLE shop.events ...\``, and the same for
+ * `view` and `dictionary`, types `.columns` from the generated file's
+ * `SqlSchema["shop.events"]`. tsc does not compare the argument with the
+ * template's text, and an argument the file does not list falls back to
+ * unchecked columns, so a typo checks nothing and says nothing. The rule reads
+ * the declared name from the template (a database supplied by an interpolation
+ * is not known to lint, and is left out of the comparison) and the listed
+ * names from the nearest `sql-types.d.ts` above the file. With no generated
+ * file, only the first check runs. A name missing from the file is a warning,
+ * since an object added since the last `chant sql types` is stale and
+ * `chant sql types --check` is what fails on it.
+ */
+export const sqlch004: LintRule = {
+  id: "SQLCH004",
+  severity: "error",
+  category: "correctness",
+  description: "A ClickHouse tag's type argument does not name the object its template declares, or is not in sql-types.d.ts",
+
+  check(context: LintContext): LintDiagnostic[] {
+    const source = context.sourceFile;
+    const out: LintDiagnostic[] = [];
+    let listed: Set<string> | undefined | null = null;
+    for (const found of findTemplates(source)) {
+      if (found.tag !== "table" && found.tag !== "view" && found.tag !== "dictionary") continue;
+      const arg = typeArgumentName(found.node);
+      if (!arg) continue;
+      const at = (() => {
+        const { line, character } = source.getLineAndCharacterOfPosition(arg.node.getStart(source));
+        return { line: line + 1, column: character + 1 };
+      })();
+      let declared: string[] | undefined;
+      try {
+        const tokens = tokensOf(found);
+        const node = parseCreate(tokens);
+        if (node.statement === found.tag) {
+          declared = tokens
+            .slice(node.name.from, node.name.to)
+            .filter((t) => !isTrivia(t) && !(t.kind === "punct" && t.text === "."))
+            .map((t) => (t.kind === "ref" ? "" : unquote(t.text)));
+        }
+      } catch (err) {
+        if (err instanceof SqlSyntaxError) continue; // SQLCH001 reports it
+        throw err;
+      }
+      if (!declared) continue; // SQLCH001: the tag holds another statement
+      if (!nameAgrees(declared, arg.name)) {
+        out.push({
+          ruleId: "SQLCH004",
+          severity: "error",
+          message: `${found.tag}<"${arg.name}"> names another object than the template declares (${declaredText(declared)}); the type argument is the qualified name the build renders`,
+          file: context.filePath,
+          ...at,
+        });
+        continue;
+      }
+      if (listed === null) listed = generatedNamesFor(context.filePath, MODULE);
+      if (listed && !listed.has(normalizedName(arg.name))) {
+        out.push({
+          ruleId: "SQLCH004",
+          severity: "warning",
+          message: `"${arg.name}" is not in ${SQL_TYPES_FILE}, so its columns are unchecked; run \`chant sql types\` to add it`,
+          file: context.filePath,
+          ...at,
+        });
+      }
+    }
+    return out;
+  },
+};

package/src/lint/rules/sqlpg005.ts

@@ -0,0 +1,73 @@
+import type { LintContext, LintDiagnostic, LintRule } from "@intentius/chant/lint/rule";
+import { parseStatements, SqlSyntaxError } from "../../postgres/parser";
+import { findPostgresTemplates, postgresTokensOf } from "./postgres-templates";
+import { declaredText, generatedNamesFor, nameAgrees, normalizedName, SQL_TYPES_FILE, typeArgumentName } from "./typed-names";
+
+const MODULE = "@intentius/chant-lexicon-sql/postgres";
+
+/**
+ * SQLPG005: a typed Postgres tag whose type argument does not name the object
+ * its template declares, or is not in the generated `sql-types.d.ts`.
+ *
+ * `table<"shop.orders">\`CREATE TABLE shop.orders ...\`` types `.columns` from
+ * the generated file's `SqlSchema["shop.orders"]`. tsc does not compare the
+ * argument with the template's text, and an argument the file does not list
+ * falls back to unchecked columns, so a typo checks nothing and says nothing.
+ * The rule reads the declared name from the template (a schema supplied by an
+ * interpolation is not known to lint, and is left out of the comparison) and
+ * the listed names from the nearest `sql-types.d.ts` above the file. With no
+ * generated file, only the first check runs. A name missing from the file is
+ * a warning, since a table added since the last `chant sql types` is stale
+ * and `chant sql types --check` is what fails on it.
+ */
+export const sqlpg005: LintRule = {
+  id: "SQLPG005",
+  severity: "error",
+  category: "correctness",
+  description: "A Postgres tag's type argument does not name the object its template declares, or is not in sql-types.d.ts",
+
+  check(context: LintContext): LintDiagnostic[] {
+    const source = context.sourceFile;
+    const out: LintDiagnostic[] = [];
+    let listed: Set<string> | undefined | null = null;
+    for (const found of findPostgresTemplates(source)) {
+      if (found.tag !== "table" && found.tag !== "view") continue;
+      const arg = typeArgumentName(found.node);
+      if (!arg) continue;
+      const at = (() => {
+        const { line, character } = source.getLineAndCharacterOfPosition(arg.node.getStart(source));
+        return { line: line + 1, column: character + 1 };
+      })();
+      let declared: string[] | undefined;
+      try {
+        const node = parseStatements(postgresTokensOf(found))[0];
+        if (node && (node.statement === "table" || node.statement === "view")) declared = node.name.pieces;
+      } catch (err) {
+        if (err instanceof SqlSyntaxError) continue; // SQLPG001 reports it
+        throw err;
+      }
+      if (!declared) continue; // SQLPG001: the tag holds another statement
+      if (!nameAgrees(declared, arg.name)) {
+        out.push({
+          ruleId: "SQLPG005",
+          severity: "error",
+          message: `${found.tag}<"${arg.name}"> names another object than the template declares (${declaredText(declared)}); the type argument is the qualified name the build renders`,
+          file: context.filePath,
+          ...at,
+        });
+        continue;
+      }
+      if (listed === null) listed = generatedNamesFor(context.filePath, MODULE);
+      if (listed && !listed.has(normalizedName(arg.name))) {
+        out.push({
+          ruleId: "SQLPG005",
+          severity: "warning",
+          message: `"${arg.name}" is not in ${SQL_TYPES_FILE}, so its columns are unchecked; run \`chant sql types\` to add it`,
+          file: context.filePath,
+          ...at,
+        });
+      }
+    }
+    return out;
+  },
+};

package/src/lint/rules/typed-names.test.ts

@@ -0,0 +1,151 @@
+import * as ts from "typescript";
+import { mkdirSync, mkdtempSync, realpathSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { describe, expect, test } from "vitest";
+import type { LintContext } from "@intentius/chant/lint/rule";
+import { sqlch004 } from "./sqlch004";
+import { sqlpg005 } from "./sqlpg005";
+import { nameAgrees, namesInGenerated, normalizedName, splitQualified } from "./typed-names";
+
+const PG = "@intentius/chant-lexicon-sql/postgres";
+const CH = "@intentius/chant-lexicon-sql/clickhouse";
+
+const ctx = (code: string, filePath = "schema.ts"): LintContext => ({
+  sourceFile: ts.createSourceFile(filePath, code, ts.ScriptTarget.Latest, true),
+  entities: [],
+  filePath,
+});
+
+const generated = (module: string, names: string[]): string =>
+  `// Generated by chant — do not edit directly.\nimport type { Column } from "${module}";\n\ndeclare module "${module}" {\n  interface SqlSchema {\n` +
+  names.map((n) => `    /** src/schema.ts */\n    ${JSON.stringify(n)}: { columns: { id: Column<"bigint", { ts: string; nullable: false; cmp: "N" }> } };\n`).join("") +
+  "  }\n}\n";
+
+/** A project directory with the generated file in src/ and a source file under src/db/. */
+function project(module: string, names: string[] | undefined): string {
+  const root = realpathSync(mkdtempSync(join(tmpdir(), "chant-3751-")));
+  mkdirSync(join(root, "src", "db"), { recursive: true });
+  writeFileSync(join(root, "chant.config.json"), "{}");
+  if (names) writeFileSync(join(root, "src", "sql-types.d.ts"), generated(module, names));
+  return join(root, "src", "db", "schema.ts");
+}
+
+describe("typed-names helpers", () => {
+  test("splitQualified takes quotes off and splits outside them", () => {
+    expect(splitQualified('shop."Order.Items"')).toEqual(["shop", "Order.Items"]);
+    expect(splitQualified("orders")).toEqual(["orders"]);
+    expect(normalizedName('"shop"."orders"')).toBe(normalizedName("shop.orders"));
+  });
+
+  test("nameAgrees compares from the last piece and skips interpolations", () => {
+    expect(nameAgrees(["shop", "orders"], "shop.orders")).toBe(true);
+    expect(nameAgrees(["orders"], "shop.orders")).toBe(true);
+    expect(nameAgrees(["", "orders"], "shop.orders")).toBe(true);
+    expect(nameAgrees(["shop", "orders"], "orders")).toBe(false);
+    expect(nameAgrees(["shop", "orders"], "shop.ordrs")).toBe(false);
+    expect(nameAgrees(["other", "orders"], "shop.orders")).toBe(false);
+  });
+
+  test("namesInGenerated reads only the module's SqlSchema", () => {
+    const text = generated(PG, ["shop.orders", "shop.users"]);
+    expect(namesInGenerated(text, PG)).toEqual(new Set([normalizedName("shop.orders"), normalizedName("shop.users")]));
+    expect(namesInGenerated(text, CH)).toBeUndefined();
+  });
+});
+
+const PGX = `import { table, view } from "${PG}";\n`;
+const CHX = `import { table, view, dictionary } from "${CH}";\n`;
+
+describe("SQLPG005: a typed Postgres tag's type argument", () => {
+  test("a name that agrees with the template, with no generated file, is clean", () => {
+    const code = `${PGX}export const o = table<"shop.orders">\`CREATE TABLE shop.orders (id bigint)\`;`;
+    expect(sqlpg005.check(ctx(code))).toEqual([]);
+  });
+
+  test("a different name is an error, at the type argument", () => {
+    const code = `${PGX}export const o = table<"shop.ordrs">\`CREATE TABLE shop.orders (id bigint)\`;`;
+    const [d, ...rest] = sqlpg005.check(ctx(code));
+    expect(rest).toEqual([]);
+    expect(d).toMatchObject({ ruleId: "SQLPG005", severity: "error", line: 2, column: 24 });
+    expect(d!.message).toContain("shop.orders");
+  });
+
+  test("a schema that is an interpolation is left out of the comparison", () => {
+    const ok = `${PGX}import { shopSchema } from "./s";\nexport const o = table<"shop.orders">\`CREATE TABLE \${shopSchema}.orders (id bigint)\`;`;
+    expect(sqlpg005.check(ctx(ok))).toEqual([]);
+    const bad = ok.replace("shop.orders", "shop.items");
+    expect(sqlpg005.check(ctx(bad))).toHaveLength(1);
+  });
+
+  test("a view is read too, and quoting and case folding follow Postgres", () => {
+    const ok = `${PGX}export const v = view<"app.order_totals">\`CREATE VIEW App."order_totals" AS SELECT 1\`;`;
+    expect(sqlpg005.check(ctx(ok))).toEqual([]);
+    const bad = `${PGX}export const v = view<"app.Order_Totals">\`CREATE VIEW app.order_totals AS SELECT 1\`;`;
+    expect(sqlpg005.check(ctx(bad))).toHaveLength(1);
+  });
+
+  test("a tag with no type argument, or a non-literal one, is not read", () => {
+    expect(sqlpg005.check(ctx(`${PGX}export const o = table\`CREATE TABLE shop.orders (id bigint)\`;`))).toEqual([]);
+    expect(sqlpg005.check(ctx(`${PGX}export const o = table<string>\`CREATE TABLE shop.orders (id bigint)\`;`))).toEqual([]);
+  });
+
+  test("a tag from another module, or the ClickHouse tag, is not read", () => {
+    expect(sqlpg005.check(ctx(`import { table } from "./mine";\nexport const o = table<"x.y">\`not sql\`;`))).toEqual([]);
+    expect(sqlpg005.check(ctx(`${CHX}export const o = table<"a.b">\`CREATE TABLE c.d (id UInt64) ENGINE = Log\`;`))).toEqual([]);
+  });
+
+  test("a template that does not parse is SQLPG001's to report", () => {
+    expect(sqlpg005.check(ctx(`${PGX}export const o = table<"a.b">\`CREATE TABLE\`;`))).toEqual([]);
+  });
+
+  test("a name the generated file lacks is a warning; one it lists is clean", () => {
+    const file = project(PG, ["shop.users"]);
+    const code = `${PGX}export const o = table<"shop.orders">\`CREATE TABLE shop.orders (id bigint)\`;\nexport const u = table<"shop.users">\`CREATE TABLE shop.users (id bigint)\`;`;
+    const diags = sqlpg005.check(ctx(code, file));
+    expect(diags).toHaveLength(1);
+    expect(diags[0]).toMatchObject({ ruleId: "SQLPG005", severity: "warning", line: 2 });
+    expect(diags[0]!.message).toMatch(/not in sql-types\.d\.ts.*chant sql types/);
+  });
+
+  test("a generated file with no block for the dialect is silent", () => {
+    const file = project(CH, ["shop.events"]);
+    const code = `${PGX}export const o = table<"shop.orders">\`CREATE TABLE shop.orders (id bigint)\`;`;
+    expect(sqlpg005.check(ctx(code, file))).toEqual([]);
+  });
+});
+
+describe("SQLCH004: a typed ClickHouse tag's type argument", () => {
+  const ddl = (db: string) => `CREATE TABLE ${db}.events (id UInt64) ENGINE = Log`;
+
+  test("a name that agrees is clean; a different one is an error", () => {
+    expect(sqlch004.check(ctx(`${CHX}export const e = table<"shop.events">\`${ddl("shop")}\`;`))).toEqual([]);
+    const [d] = sqlch004.check(ctx(`${CHX}export const e = table<"shop.event">\`${ddl("shop")}\`;`));
+    expect(d).toMatchObject({ ruleId: "SQLCH004", severity: "error", line: 2 });
+  });
+
+  test("a database that is an interpolation is left out, and a name differing in case is a different name", () => {
+    expect(sqlch004.check(ctx(`${CHX}import { db } from "./d";\nexport const e = table<"shop.events">\`${ddl("${db}")}\`;`))).toEqual([]);
+    expect(sqlch004.check(ctx(`${CHX}export const e = table<"shop.Events">\`${ddl("shop")}\`;`))).toHaveLength(1);
+  });
+
+  test("a dictionary and a view are read", () => {
+    const dict = `${CHX}export const d = dictionary<"shop.codes">\`CREATE DICTIONARY shop.codes (id UInt64) PRIMARY KEY id SOURCE(CLICKHOUSE(TABLE 'c')) LAYOUT(FLAT()) LIFETIME(0)\`;`;
+    expect(sqlch004.check(ctx(dict))).toEqual([]);
+    expect(sqlch004.check(ctx(dict.replace("shop.codes\"", "shop.cods\"")))).toHaveLength(1);
+    const view = `${CHX}export const v = view<"shop.v1">\`CREATE VIEW shop.v2 AS SELECT 1\`;`;
+    expect(sqlch004.check(ctx(view))).toHaveLength(1);
+  });
+
+  test("a name the generated file lacks is a warning", () => {
+    const file = project(CH, ["shop.other"]);
+    const [d] = sqlch004.check(ctx(`${CHX}export const e = table<"shop.events">\`${ddl("shop")}\`;`, file));
+    expect(d).toMatchObject({ ruleId: "SQLCH004", severity: "warning" });
+    expect(sqlch004.check(ctx(`${CHX}export const e = table<"shop.other">\`CREATE TABLE shop.other (id UInt64) ENGINE = Log\`;`, file))).toEqual([]);
+  });
+
+  test("without a generated file only the name comparison runs", () => {
+    const file = project(CH, undefined);
+    expect(sqlch004.check(ctx(`${CHX}export const e = table<"shop.events">\`${ddl("shop")}\`;`, file))).toEqual([]);
+  });
+});