@intentius/chant-lexicon-sql 0.124.11 → 0.124.13

package/src/lint/post-synth/sql-helpers.ts

@@ -1,41 +1,26 @@
 /**
  * Reading the sql lexicon's build output in a post-synth check: the JSON
- * document the serializer writes (`dialect`, `applyOrder`, `objects`).
+ * document the serializer writes (`dialect`, `applyOrder`, `objects`). The
+ * documents are found by `../../read/objects.ts`, the same path the public
+ * read API (`@intentius/chant-lexicon-sql/read`) takes.
  */
 
 import type { PostSynthContext } from "@intentius/chant/lint/post-synth";
+import { dialectObjects, recordedPostgresMajor, type SqlObjectJson } from "../../read/objects";
 
-export interface OutputObject {
-  export: string;
-  type: string;
-  name: string;
+export interface OutputObject extends SqlObjectJson {
   database?: string;
   engine?: { name: string; args?: string[] };
-  [key: string]: unknown;
 }
 
 /** Every schema object in the build's sql output, ClickHouse dialect. */
 export function clickhouseObjects(ctx: PostSynthContext): OutputObject[] {
-  const out: OutputObject[] = [];
-  for (const doc of ctx.docs ?? []) {
-    if (doc.error || doc.lexicon !== "sql" || doc.format !== "json") continue;
-    const value = doc.value as { dialect?: unknown; objects?: unknown };
-    if (value?.dialect !== "clickhouse" || !Array.isArray(value.objects)) continue;
-    out.push(...(value.objects as OutputObject[]));
-  }
-  return out;
+  return dialectObjects(ctx, "clickhouse") as OutputObject[];
 }
 
 /** Every schema object in the build's sql output, Postgres dialect. */
 export function postgresObjects(ctx: PostSynthContext): OutputObject[] {
-  const out: OutputObject[] = [];
-  for (const doc of ctx.docs ?? []) {
-    if (doc.error || doc.lexicon !== "sql" || doc.format !== "json") continue;
-    const value = doc.value as { dialect?: unknown; objects?: unknown };
-    if (value?.dialect !== "postgres" || !Array.isArray(value.objects)) continue;
-    out.push(...(value.objects as OutputObject[]));
-  }
-  return out;
+  return dialectObjects(ctx, "postgres") as OutputObject[];
 }
 
 /**
@@ -44,10 +29,5 @@ export function postgresObjects(ctx: PostSynthContext): OutputObject[] {
  * output that carries none.
  */
 export function postgresMajorOf(ctx: PostSynthContext, fallback: number): number {
-  for (const doc of ctx.docs ?? []) {
-    if (doc.error || doc.lexicon !== "sql" || doc.format !== "json") continue;
-    const value = doc.value as { dialect?: unknown; postgresMajor?: unknown };
-    if (value?.dialect === "postgres" && typeof value.postgresMajor === "number") return value.postgresMajor;
-  }
-  return fallback;
+  return recordedPostgresMajor(ctx, fallback);
 }

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

@@ -1,5 +1,4 @@
-import { checkOf, isTable, keyElements } from "./clickhouse-helpers";
-import { clickhouseObjects } from "./sql-helpers";
+import { checkOf, keyElements, tablesOf } from "./clickhouse-helpers";
 
 /**
  * SQLCH102: a PRIMARY KEY that is not a prefix of ORDER BY.
@@ -9,7 +8,7 @@ import { clickhouseObjects } from "./sql-helpers";
  * the table at CREATE.
  */
 export const sqlch102 = checkOf({ id: "SQLCH102", description: "A PRIMARY KEY is not a prefix of ORDER BY" }, (ctx, report) => {
-  for (const t of clickhouseObjects(ctx).filter(isTable)) {
+  for (const t of tablesOf(ctx)) {
     if (!t.primaryKey || !t.orderBy) continue;
     const pk = keyElements(t.primaryKey).map((e) => e.replace(/\s+/g, ""));
     const ob = keyElements(t.orderBy).map((e) => e.replace(/\s+/g, ""));

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

@@ -1,5 +1,4 @@
-import { baseEngineName, checkOf, columnByName, engineArguments, isNullableType, isTable, typeFamily } from "./clickhouse-helpers";
-import { clickhouseObjects } from "./sql-helpers";
+import { baseEngineName, checkOf, columnByName, engineArguments, isNullableType, tablesOf, typeFamily } from "./clickhouse-helpers";
 
 const VERSION_TYPES = new Set(["UInt8", "UInt16", "UInt32", "UInt64", "UInt128", "UInt256", "Date", "DateTime", "DateTime64"]);
 
@@ -25,7 +24,7 @@ const SPECIAL: Record<string, Array<{ role: string; index: number; accepts: (fam
  * .../collapsingmergetree, .../versionedcollapsingmergetree (sign: Int8).
  */
 export const sqlch103 = checkOf({ id: "SQLCH103", description: "An engine's version, sign or is_deleted column has an unsupported type" }, (ctx, report) => {
-  for (const t of clickhouseObjects(ctx).filter(isTable)) {
+  for (const t of tablesOf(ctx)) {
     if (!t.engine) continue;
     const roles = SPECIAL[baseEngineName(t.engine)];
     if (!roles) continue;

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

@@ -1,5 +1,4 @@
-import { baseEngineName, checkOf, engineArguments, isTable, splitTop } from "./clickhouse-helpers";
-import { clickhouseObjects } from "./sql-helpers";
+import { baseEngineName, checkOf, engineArguments, splitTop, tablesOf } from "./clickhouse-helpers";
 
 /** The engine arguments that name columns, by base engine. */
 function columnArguments(engine: string, args: string[]): string[] {
@@ -26,7 +25,7 @@ function columnArguments(engine: string, args: string[]): string[] {
  * sign, version, is_deleted and summed columns are columns of the table).
  */
 export const sqlch104 = checkOf({ id: "SQLCH104", description: "A MergeTree engine argument names a column the table does not declare" }, (ctx, report) => {
-  for (const t of clickhouseObjects(ctx).filter(isTable)) {
+  for (const t of tablesOf(ctx)) {
     if (!t.engine || t.columns.length === 0) continue;
     const declared = new Set(t.columns.map((c) => c.name));
     for (const arg of columnArguments(baseEngineName(t.engine), engineArguments(t.engine))) {

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

@@ -1,5 +1,4 @@
-import { bareName, checkOf, isTable, keyElements } from "./clickhouse-helpers";
-import { clickhouseObjects } from "./sql-helpers";
+import { bareName, checkOf, keyElements, tablesOf } from "./clickhouse-helpers";
 
 /**
  * SQLCH105: ORDER BY, PRIMARY KEY, PARTITION BY or SAMPLE BY lists a bare
@@ -10,7 +9,7 @@ import { clickhouseObjects } from "./sql-helpers";
  * judged; an expression is left to the server.
  */
 export const sqlch105 = checkOf({ id: "SQLCH105", description: "A table key clause names a column the table does not declare" }, (ctx, report) => {
-  for (const t of clickhouseObjects(ctx).filter(isTable)) {
+  for (const t of tablesOf(ctx)) {
     if (t.columns.length === 0) continue;
     const declared = new Set(t.columns.map((c) => c.name));
     const clauses: Array<[string, string | undefined]> = [

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

@@ -1,5 +1,4 @@
-import { checkOf, isTable, mentionedNames } from "./clickhouse-helpers";
-import { clickhouseObjects } from "./sql-helpers";
+import { checkOf, mentionedNames, tablesOf } from "./clickhouse-helpers";
 
 /**
  * SQLCH106: a data skipping index expression mentions a column the table does
@@ -11,7 +10,7 @@ import { clickhouseObjects } from "./sql-helpers";
  * SQL parser would guess.
  */
 export const sqlch106 = checkOf({ id: "SQLCH106", description: "A skip index expression names a column the table does not declare" }, (ctx, report) => {
-  for (const t of clickhouseObjects(ctx).filter(isTable)) {
+  for (const t of tablesOf(ctx)) {
     if (t.columns.length === 0) continue;
     const declared = new Set(t.columns.map((c) => c.name));
     for (const index of t.indexes ?? []) {

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

@@ -1,5 +1,4 @@
-import { bareName, checkOf, isTable, splitTop, typeFamily } from "./clickhouse-helpers";
-import { clickhouseObjects } from "./sql-helpers";
+import { bareName, checkOf, splitTop, tablesOf, typeFamily } from "./clickhouse-helpers";
 
 const DATE_TYPES = new Set(["Date", "Date32", "DateTime", "DateTime64"]);
 const TTL_ACTION = /\s+(DELETE|TO\s+DISK|TO\s+VOLUME|RECOMPRESS|GROUP\s+BY|WHERE)\b[\s\S]*$/i;
@@ -13,7 +12,7 @@ const TTL_ACTION = /\s+(DELETE|TO\s+DISK|TO\s+VOLUME|RECOMPRESS|GROUP\s+BY|WHERE
  * a function call is left to the server.
  */
 export const sqlch107 = checkOf({ id: "SQLCH107", description: "A TTL expression is built on a column that is not a Date or DateTime" }, (ctx, report) => {
-  for (const t of clickhouseObjects(ctx).filter(isTable)) {
+  for (const t of tablesOf(ctx)) {
     const ttls: Array<{ where: string; expr: string }> = [];
     if (t.ttl) for (const clause of splitTop(t.ttl)) ttls.push({ where: "table TTL", expr: clause.replace(TTL_ACTION, "") });
     for (const c of t.columns) if (c.ttl) ttls.push({ where: `column ${c.name} TTL`, expr: c.ttl.replace(TTL_ACTION, "") });

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

@@ -1,5 +1,4 @@
-import { checkOf, isTable, splitTop } from "./clickhouse-helpers";
-import { clickhouseObjects } from "./sql-helpers";
+import { checkOf, splitTop, tablesOf } from "./clickhouse-helpers";
 
 const MAX_VALUES = 100;
 
@@ -23,7 +22,7 @@ function allowedValues(expr: string): { column: string; count: number } | undefi
  * https://clickhouse.com/docs/best-practices/select-data-types.
  */
 export const sqlch111 = checkOf({ id: "SQLCH111", description: "A String column limited to a few values is not LowCardinality" }, (ctx, report) => {
-  for (const t of clickhouseObjects(ctx).filter(isTable)) {
+  for (const t of tablesOf(ctx)) {
     for (const c of t.constraints ?? []) {
       if (c.kind !== "CHECK") continue;
       const found = allowedValues(c.expr);

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

@@ -1,5 +1,4 @@
-import { checkOf, isTable, typeFamily } from "./clickhouse-helpers";
-import { clickhouseObjects } from "./sql-helpers";
+import { checkOf, tablesOf, typeFamily } from "./clickhouse-helpers";
 
 const FINE_FUNCTIONS =
   /\b(toStartOfSecond|toStartOfMinute|toStartOfFiveMinutes?|toStartOfTenMinutes|toStartOfFifteenMinutes|toStartOfHour|toRelativeSecondNum|toRelativeMinuteNum|toRelativeHourNum|toUnixTimestamp|toYYYYMMDDhhmmss|toStartOfInterval)\s*\(/;
@@ -15,7 +14,7 @@ const FINE_FUNCTIONS =
  * the sub-day truncation functions.
  */
 export const sqlch112 = checkOf({ id: "SQLCH112", description: "A PARTITION BY expression is finer than a day" }, (ctx, report) => {
-  for (const t of clickhouseObjects(ctx).filter(isTable)) {
+  for (const t of tablesOf(ctx)) {
     const expr = t.partitionBy?.trim();
     if (!expr) continue;
     const col = t.columns.find((c) => c.name === expr.replace(/^\(|\)$/g, "").trim());

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

@@ -1,5 +1,4 @@
-import { checkOf, isMergeTree, isTable } from "./clickhouse-helpers";
-import { clickhouseObjects } from "./sql-helpers";
+import { checkOf, isMergeTree, tablesOf } from "./clickhouse-helpers";
 
 /**
  * SQLCH113: a MergeTree table with neither ORDER BY nor PRIMARY KEY.
@@ -9,7 +8,7 @@ import { clickhouseObjects } from "./sql-helpers";
  * `ORDER BY tuple()` to have none). The server refuses the CREATE.
  */
 export const sqlch113 = checkOf({ id: "SQLCH113", description: "A MergeTree table declares no sort key" }, (ctx, report) => {
-  for (const t of clickhouseObjects(ctx).filter(isTable)) {
+  for (const t of tablesOf(ctx)) {
     if (!isMergeTree(t.engine) || t.orderBy || t.primaryKey) continue;
     report({
       severity: "error",

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

@@ -1,6 +1,5 @@
 import { CODECS } from "../../generated/clickhouse";
-import { checkOf, codecNames, isTable } from "./clickhouse-helpers";
-import { clickhouseObjects } from "./sql-helpers";
+import { checkOf, codecNames, tablesOf } from "./clickhouse-helpers";
 
 /**
  * SQLCH114: a column CODEC names a codec the pinned server does not have.
@@ -10,7 +9,7 @@ import { clickhouseObjects } from "./sql-helpers";
  */
 export const sqlch114 = checkOf({ id: "SQLCH114", description: "A column codec is not one the pinned server has" }, (ctx, report) => {
   const known = new Set(Object.keys(CODECS).map((n) => n.toLowerCase()));
-  for (const t of clickhouseObjects(ctx).filter(isTable)) {
+  for (const t of tablesOf(ctx)) {
     for (const c of t.columns) {
       if (!c.codec) continue;
       for (const name of codecNames(c.codec)) {

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

@@ -1,6 +1,5 @@
 import { CODECS } from "../../generated/clickhouse";
-import { checkOf, codecNames, isTable } from "./clickhouse-helpers";
-import { clickhouseObjects } from "./sql-helpers";
+import { checkOf, codecNames, tablesOf } from "./clickhouse-helpers";
 
 const SENSITIVE = /(^|_)(password|passwd|pwd|secret|api_?key|access_?key|private_?key|token|ssn|social_?security|credit_?card|card_?number|iban)(_|$)/i;
 
@@ -17,7 +16,7 @@ const SENSITIVE = /(^|_)(password|passwd|pwd|secret|api_?key|access_?key|private
  */
 export const sqlch115 = checkOf({ id: "SQLCH115", description: "A secret- or PII-named column carries no comment, TTL or encryption" }, (ctx, report) => {
   const encryption = new Set(Object.entries(CODECS).filter(([, s]) => s.encryption).map(([n]) => n.toLowerCase()));
-  for (const t of clickhouseObjects(ctx).filter(isTable)) {
+  for (const t of tablesOf(ctx)) {
     for (const c of t.columns) {
       if (!SENSITIVE.test(c.name) || c.comment || c.ttl || t.ttl) continue;
       if (c.codec && codecNames(c.codec).some((n) => encryption.has(n.toLowerCase()))) continue;

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

@@ -1,5 +1,4 @@
-import { checkOf, isTable } from "./clickhouse-helpers";
-import { clickhouseObjects } from "./sql-helpers";
+import { checkOf, tablesOf } from "./clickhouse-helpers";
 
 /**
  * SQLCH120: a MergeTree engine written with the legacy positional arguments.
@@ -10,7 +9,7 @@ import { clickhouseObjects } from "./sql-helpers";
  * syntax is a bare `MergeTree` with ORDER BY, PARTITION BY and SETTINGS.
  */
 export const sqlch120 = checkOf({ id: "SQLCH120", description: "A MergeTree engine uses the deprecated positional arguments" }, (ctx, report) => {
-  for (const t of clickhouseObjects(ctx).filter(isTable)) {
+  for (const t of tablesOf(ctx)) {
     if (t.engine?.name !== "MergeTree" || (t.engine.args ?? []).length === 0) continue;
     report({
       severity: "warning",

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

@@ -1,6 +1,5 @@
 import { CODECS, CLICKHOUSE_VERSION } from "../../generated/clickhouse";
-import { checkOf, isTable, splitTop } from "./clickhouse-helpers";
-import { clickhouseObjects } from "./sql-helpers";
+import { checkOf, splitTop, tablesOf } from "./clickhouse-helpers";
 
 type Param = { name: string; kind: string; optional?: boolean; range?: readonly [number, number]; values?: readonly string[] };
 
@@ -17,7 +16,7 @@ const NUMBER = /^-?\d+(\.\d+)?$/;
  */
 export const sqlch125 = checkOf({ id: "SQLCH125", description: "A codec parameter is outside what the codec takes" }, (ctx, report) => {
   const codecs = CODECS as Record<string, { parameters: readonly Param[] | "unknown" } | undefined>;
-  for (const t of clickhouseObjects(ctx).filter(isTable)) {
+  for (const t of tablesOf(ctx)) {
     for (const c of t.columns) {
       if (!c.codec) continue;
       for (const part of splitTop(c.codec)) {

package/src/lint/rules/postgres-templates.ts

@@ -6,7 +6,7 @@
  * ClickHouse's).
  */
 
-import type * as ts from "typescript";
+import type { ts } from "@intentius/chant/lint/typescript";
 import { tokenize, type Token } from "../../postgres/tokens";
 import type { PostgresTag } from "../../postgres/entities";
 import { findSqlTemplates, type FoundTemplate, type TemplateSource } from "../../core/find-templates";

package/src/lint/rules/sqlch003.ts

@@ -1,4 +1,4 @@
-import * as ts from "typescript";
+import { ts } from "@intentius/chant/lint/typescript";
 import type { LintContext, LintDiagnostic, LintRule } from "@intentius/chant/lint/rule";
 import { findTemplates } from "./templates";
 

package/src/lint/rules/sqlpg002.ts

@@ -1,4 +1,4 @@
-import * as ts from "typescript";
+import { ts } from "@intentius/chant/lint/typescript";
 import type { LintContext, LintDiagnostic, LintRule } from "@intentius/chant/lint/rule";
 import { findPostgresTemplates as findTemplates } from "./postgres-templates";
 

package/src/lint/rules/templates.ts

@@ -7,7 +7,7 @@
  * because of the module it is imported from.
  */
 
-import type * as ts from "typescript";
+import type { ts } from "@intentius/chant/lint/typescript";
 import { tokenize, type Token } from "../../clickhouse/tokens";
 import { findSqlTemplates, type FoundTemplate as SqlFoundTemplate, type TemplateSource } from "../../core/find-templates";
 

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

@@ -11,7 +11,7 @@
 
 import { existsSync, readFileSync } from "node:fs";
 import { dirname, join, resolve } from "node:path";
-import * as ts from "typescript";
+import { ts } from "@intentius/chant/lint/typescript";
 
 /** The generated file's name, beside the source (`chant sql types`). */
 export const SQL_TYPES_FILE = "sql-types.d.ts";

package/src/lint/rules/typescript-7.test.ts

@@ -0,0 +1,101 @@
+/**
+ * The sql lint rules run in a project whose `typescript` is TypeScript 7
+ * (chant #3864).
+ *
+ * TypeScript 7's `typescript` package has no JS compiler API. chant core keeps
+ * its own 5.x and parses every file with it, but a rule that imported
+ * `typescript` itself got the project's copy, and every rule threw
+ * `ts.isImportDeclaration is not a function`, so `chant graph` refused the
+ * project. The rules now take `ts` from `@intentius/chant/lint/typescript`.
+ *
+ * In this repo the rules and core resolve the same `typescript`, so the test
+ * lays out the install a user gets: a project whose `node_modules/typescript`
+ * is TypeScript 7 (the root's `typescript-native` alias), a copy of this
+ * lexicon in it (a copy, because module resolution follows the real path),
+ * and chant core keeping its own TypeScript 5. It then runs the rules the way
+ * the CLI does, in a separate node process under tsx, over the examples.
+ */
+import { afterAll, beforeAll, describe, expect, test } from "vitest";
+import { execFileSync } from "node:child_process";
+import { cpSync, existsSync, mkdirSync, mkdtempSync, readdirSync, rmSync, symlinkSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { fileURLToPath } from "node:url";
+
+const lexiconDir = fileURLToPath(new URL("../../../", import.meta.url));
+const repoRoot = join(lexiconDir, "..", "..");
+const nodeModules = join(repoRoot, "node_modules");
+const ts7 = join(nodeModules, "typescript-native");
+const tsxLoader = join(nodeModules, "tsx", "dist", "loader.mjs");
+
+const examples = ["postgres-getting-started", "getting-started"].map((name) => join(lexiconDir, "examples", name, "src"));
+
+/** Runs in the child: every rule over every example file, reporting what threw. */
+const RUNNER = `
+import { createRequire } from "node:module";
+import { readdirSync } from "node:fs";
+import { join } from "node:path";
+import { parseFile } from "@intentius/chant/lint/parser";
+import { rules } from "@intentius/chant-lexicon-sql/lint/rules/index";
+
+// The \`typescript\` the lexicon would get from a bare import.
+const lexiconTs = createRequire(process.argv[3])("typescript/package.json").version;
+const threw = [];
+let checked = 0;
+for (const dir of JSON.parse(process.argv[2])) {
+  for (const name of readdirSync(dir).filter((f) => f.endsWith(".ts"))) {
+    const filePath = join(dir, name);
+    const sourceFile = parseFile(filePath);
+    for (const rule of rules) {
+      try {
+        rule.check({ sourceFile, entities: [], filePath });
+        checked++;
+      } catch (err) {
+        threw.push(rule.id + " " + name + ": " + (err instanceof Error ? err.message : String(err)));
+      }
+    }
+  }
+}
+console.log(JSON.stringify({ lexiconTs, checked, threw }));
+`;
+
+const ready = existsSync(ts7) && existsSync(tsxLoader);
+
+describe.skipIf(!ready)("sql lint rules in a TypeScript 7 project (#3864)", () => {
+  let project: string;
+  let lexiconPackageJson: string;
+
+  beforeAll(() => {
+    project = mkdtempSync(join(tmpdir(), "chant-sql-ts7-"));
+    const modules = join(project, "node_modules");
+    mkdirSync(join(modules, "@intentius"), { recursive: true });
+    symlinkSync(ts7, join(modules, "typescript"), "dir");
+    symlinkSync(join(repoRoot, "packages", "core"), join(modules, "@intentius", "chant"), "dir");
+    for (const dep of ["pg", "zod"]) symlinkSync(join(nodeModules, dep), join(modules, dep), "dir");
+    const copy = join(modules, "@intentius", "chant-lexicon-sql");
+    lexiconPackageJson = join(copy, "package.json");
+    cpSync(join(lexiconDir, "src"), join(copy, "src"), {
+      recursive: true,
+      filter: (src) => !src.endsWith(".test.ts"),
+    });
+    cpSync(join(lexiconDir, "package.json"), join(copy, "package.json"));
+    writeFileSync(join(project, "run.mts"), RUNNER);
+  });
+
+  afterAll(() => {
+    if (project) rmSync(project, { recursive: true, force: true });
+  });
+
+  test("no rule throws, and the lexicon really sees TypeScript 7", () => {
+    for (const dir of examples) expect(readdirSync(dir).length).toBeGreaterThan(0);
+    const out = execFileSync(process.execPath, ["--import", `file://${tsxLoader}`, join(project, "run.mts"), JSON.stringify(examples), lexiconPackageJson], {
+      cwd: project,
+      encoding: "utf-8",
+      env: { ...process.env, TSX_DISABLE_CACHE: "1" },
+    });
+    const { lexiconTs, checked, threw } = JSON.parse(out.trim().split("\n").pop()!);
+    expect(lexiconTs).toMatch(/^7\./);
+    expect(threw).toEqual([]);
+    expect(checked).toBeGreaterThan(0);
+  }, 120_000);
+});

package/src/lsp/completions.ts

@@ -1,4 +1,4 @@
-import * as ts from "typescript";
+import { ts } from "@intentius/chant/lint/typescript";
 import type { CompletionContext, CompletionItem } from "@intentius/chant/lsp/types";
 import { lexiconCompletions } from "@intentius/chant/lsp/lexicon-providers";
 import { catalogIndex, type CatalogIndex } from "./catalog";

package/src/lsp/postgres-template.ts

@@ -4,7 +4,7 @@
  * rules, so the editor and `chant lint` agree on which tags are Postgres's.
  */
 
-import * as ts from "typescript";
+import { ts } from "@intentius/chant/lint/typescript";
 import { isTrivia, tokenize, type Token } from "../postgres/tokens";
 import { parseStatements, type Span } from "../postgres/parser";
 import type { PostgresTag } from "../postgres/entities";

package/src/lsp/postgres.ts

@@ -10,7 +10,7 @@
 
 import { existsSync, readFileSync } from "fs";
 import { dirname, resolve } from "path";
-import * as ts from "typescript";
+import { ts } from "@intentius/chant/lint/typescript";
 import type { CompletionContext, CompletionItem, HoverContext, HoverInfo } from "@intentius/chant/lsp/types";
 import {
   describeRange,

package/src/lsp/refs.ts

@@ -6,7 +6,7 @@
 
 import { existsSync, readFileSync } from "fs";
 import { dirname, resolve } from "path";
-import * as ts from "typescript";
+import { ts } from "@intentius/chant/lint/typescript";
 import { declarations, type Declared } from "./template";
 
 function importedFrom(content: string, local: string, fileName: string): { declared: Declared; file: string } | undefined {

package/src/lsp/template.ts

@@ -5,7 +5,7 @@
  * is and which module's tags count.
  */
 
-import * as ts from "typescript";
+import { ts } from "@intentius/chant/lint/typescript";
 import { isTrivia, tokenize, type Token } from "../clickhouse/tokens";
 import { parseCreate, type Span } from "../clickhouse/parser";
 import { CLICKHOUSE_TEMPLATE_SOURCE, findTemplates, type FoundTemplate, type SqlTag } from "../lint/rules/templates";

package/src/postgres/apply/statements.ts

@@ -789,6 +789,8 @@ export function refusalDetail(changes: readonly PgChange[], name: string, declar
       ? `Run it as the expand-and-contract migration Op: ${ops.join(", ")} from @intentius/chant-lexicon-sql/postgres (add the new column, write both, backfill, switch readers, then drop the old).` +
         (ops.length < changes.length ? " The other changes have no migration Op yet: make them by hand as expand and contract." : "")
       : "No migration Op makes this change yet: make it by hand as expand and contract (add the new, write both, backfill, move readers, then drop the old).";
+  // A clause chant does not read (#3872) is refused for review: what the change takes is not known.
+  if (changes.every((c) => c.rule === "SQLPG299")) return `${name} needs review, since chant does not read the clause, so nothing was sent for it. ${lines.join(" ")}`;
   return `${name} needs expand and contract, which no in-place statement makes, so nothing was sent for it. ${lines.join(" ")} ${instead}`;
 }
 

package/src/postgres/entities.ts

@@ -58,7 +58,7 @@ import { setInterpolationFields } from "@intentius/chant/provenance";
 import { isTrivia, POSTGRES_LEXICAL, SqlSyntaxError, untokenize, type Token } from "./tokens";
 import { identValue, parseStatements, type ColumnNode, type CommentNode, type ConstraintNode, type GrantNode, type NameNode, type RowSecurityNode, type Span, type StatementNode } from "./parser";
 import { keywordCategory, quoteIdent } from "./keywords";
-import { feed, lineage, spanText as text, splice as spliceWith, templateSyntaxError, type TemplateCtx, type TemplateDialect } from "../core/interpolation";
+import { feed, lineage, spanText as text, splice as spliceWith, templateSyntaxError, unparsedClauses, type TemplateCtx, type TemplateDialect, type UnparsedClause } from "../core/interpolation";
 import { SqlObject, isColumnRefOf, isSqlObjectOf, makeSqlEntity } from "../core/entity";
 import type { LineageEdge } from "../core/references";
 import { SqlLiteral, SqlTemplateError, describeValue as describe, stripUnset, templateParts } from "../core/template";
@@ -66,6 +66,7 @@ import { setTypedSlots, type ColumnsIn, type Named, type RowIn, type SlotsIn, ty
 
 export { SQL_LEXICON } from "../core/entity";
 export type { LineageEdge } from "../core/references";
+export type { UnparsedClause } from "../core/interpolation";
 export { SqlLiteral, SqlTemplateError } from "../core/template";
 export { quoteIdent } from "./keywords";
 export type { AnyColumn, Column, ColumnTraits, KeyColumn, Named, NotNullColumn, UncheckedColumn, Unnamed } from "../core/typed";
@@ -155,6 +156,11 @@ interface CommonProps {
   ddl: string;
   /** The template's raw parts, as written, for a source round trip. */
   source: { strings: string[] };
+  /**
+   * Clauses chant's parser does not know (#3872), kept in `ddl` as written
+   * and left to the catalog checks and the server. Absent when there are none.
+   */
+  unparsed?: UnparsedClause[];
 }
 
 export interface SchemaProps extends Omit<CommonProps, "schema"> {
@@ -1182,7 +1188,9 @@ function build(tag: PostgresTag, strings: TemplateStringsArray | readonly string
   const source = { strings: rawParts };
   const dependsOn = [...new Set([...values, ...(joined?.refs ?? [])].filter((v) => isPostgresObject(v) || isColumnRef(v)))];
   const slots: TypedSlot[] = [];
+  const unparsed = unparsedClauses(ctx, nodes.flatMap((n) => ("unknown" in n && n.unknown ? n.unknown : [])));
   const make = <T extends PostgresObject>(type: PostgresEntityType, q: { schema?: string; name: string }, props: object, columnNames?: readonly string[]): T => {
+    if (unparsed) (props as { unparsed?: UnparsedClause[] }).unparsed = unparsed;
     const entity = makeSqlEntity(PostgresObject.prototype as PostgresObject, type, sqlNameOf(q), props, columnNames, dependsOn) as T;
     const fed = ctx.fed.map((paths) => [...paths].sort());
     if (!joined) setInterpolationFields(entity, fed);