@intentius/chant-lexicon-sql 0.0.0-stage → 0.112.1

package/src/lsp/postgres-catalog.ts

@@ -0,0 +1,234 @@
+/**
+ * The Postgres catalogs the editor and the MCP tools read: the committed
+ * snapshots of the pinned servers (one per supported major), parsed once.
+ * No server is needed; the snapshots are what generation reads too.
+ *
+ * A name's availability is read straight off the snapshots: it is in a major
+ * when that major's snapshot lists it, so `since` and `until` here agree with
+ * the generated types' `@since` / `@until`.
+ */
+
+import { existsSync, readFileSync } from "fs";
+import { dirname, join, resolve } from "path";
+import { fileURLToPath } from "url";
+import { parseCatalog, type PostgresCatalog } from "../spec/postgres-catalog";
+import { POSTGRES_LATEST_MAJOR, POSTGRES_MAJORS } from "../spec/postgres-pin";
+import { STORAGE_PARAMETER_TYPES } from "../postgres/overlays/storage";
+
+const SPEC = join(dirname(fileURLToPath(import.meta.url)), "..", "spec");
+
+let cached: Map<number, PostgresCatalog> | null = null;
+
+/** Every supported major's catalog, or undefined when a snapshot cannot be read. */
+export function postgresCatalogs(): Map<number, PostgresCatalog> | undefined {
+  if (cached) return cached;
+  try {
+    const map = new Map<number, PostgresCatalog>();
+    for (const major of POSTGRES_MAJORS) map.set(major, parseCatalog(readFileSync(join(SPEC, `postgres-catalog-${major}.snapshot.json`), "utf-8")));
+    cached = map;
+    return map;
+  } catch {
+    return undefined;
+  }
+}
+
+/** Where a name is available: the first major with it when that is not the oldest, the last when that is not the newest. */
+export interface Availability {
+  since?: number;
+  until?: number;
+}
+
+export interface Entry<Row> {
+  name: string;
+  /** The row from the newest major that has the name. */
+  row: Row;
+  majors: number[];
+  range: Availability;
+  detail?: string;
+}
+
+export const SECTIONS = ["types", "accessMethods", "functions", "keywords", "settings", "extensions", "storageParameters"] as const;
+export type Section = (typeof SECTIONS)[number];
+
+export interface TypeRow {
+  /** The SQL spelling. */
+  sqlName: string;
+  catalogName: string;
+  kind: string;
+  category: string;
+  aliasOf?: string;
+}
+export interface MethodRow {
+  name: string;
+  type: "index" | "table";
+  properties: string[];
+}
+export interface FunctionRow {
+  name: string;
+  kinds: string;
+  overloads: number;
+}
+export interface KeywordRow {
+  word: string;
+  code: string;
+  description: string;
+}
+export interface SettingRow {
+  name: string;
+  type: string;
+  context: string;
+  category: string;
+  unit: string | null;
+  default: string | null;
+  min: string | null;
+  max: string | null;
+}
+export interface ExtensionRow {
+  name: string;
+  defaultVersion: string;
+  description: string | null;
+}
+export interface StorageRow {
+  name: string;
+  targets: string[];
+  type?: unknown;
+}
+
+/** SQL spellings with no `pg_type` row of their own. */
+const SPELLINGS: Record<string, string> = {
+  int: "integer",
+  dec: "numeric",
+  decimal: "numeric",
+  float: "double precision",
+  serial: "integer",
+  bigserial: "bigint",
+  smallserial: "smallint",
+  serial4: "integer",
+  serial8: "bigint",
+  serial2: "smallint",
+};
+
+const unquote = (s: string): string => (s.startsWith('"') ? s.slice(1, -1) : s);
+
+function rowsOf(section: Section, catalog: PostgresCatalog): Array<{ key: string; row: unknown; detail?: string }> {
+  switch (section) {
+    case "types": {
+      const out: Array<{ key: string; row: TypeRow; detail?: string }> = [];
+      const have = new Set<string>();
+      for (const t of catalog.types) {
+        if (t.kind === "p" || t.name.startsWith("_")) continue;
+        const sqlName = unquote(t.sqlName);
+        have.add(sqlName);
+        out.push({ key: sqlName, row: { sqlName, catalogName: t.name, kind: t.kind, category: t.category } });
+        if (t.name !== sqlName) {
+          have.add(t.name);
+          out.push({ key: t.name, row: { sqlName, catalogName: t.name, kind: t.kind, category: t.category, aliasOf: sqlName }, detail: `alias of ${sqlName}` });
+        }
+      }
+      for (const [alias, target] of Object.entries(SPELLINGS)) {
+        const base = out.find((o) => o.key === target)?.row as TypeRow | undefined;
+        if (base && !have.has(alias)) out.push({ key: alias, row: { ...base, aliasOf: target }, detail: `alias of ${target}` });
+      }
+      return out;
+    }
+    case "accessMethods":
+      return catalog.accessMethods.map((a) => ({
+        key: a.name,
+        row: { name: a.name, type: a.type === "i" ? "index" : "table", properties: a.properties ?? [] } satisfies MethodRow,
+      }));
+    case "functions":
+      return catalog.functions.filter((f) => !f.internal).map((f) => ({ key: f.name, row: { name: f.name, kinds: f.kinds, overloads: f.overloads } satisfies FunctionRow }));
+    case "keywords":
+      return catalog.keywords.map((k) => ({ key: k.word, row: k }));
+    case "settings":
+      return catalog.settings.map((s) => ({ key: s.name, row: s }));
+    case "extensions":
+      return catalog.extensions.map((e) => ({ key: e.name, row: e }));
+    case "storageParameters": {
+      const by = new Map<string, string[]>();
+      for (const [target, names] of Object.entries(catalog.storageParameters)) for (const n of names) by.set(n, [...(by.get(n) ?? []), target]);
+      return [...by].map(([name, targets]) => ({ key: name, row: { name, targets, type: STORAGE_PARAMETER_TYPES[name] } satisfies StorageRow }));
+    }
+  }
+}
+
+const oldest = POSTGRES_MAJORS[0]!;
+
+/** `since`/`until` for the majors a name is in. */
+export function rangeOf(majors: readonly number[]): Availability {
+  const first = Math.min(...majors);
+  const last = Math.max(...majors);
+  return { ...(first > oldest ? { since: first } : {}), ...(last < POSTGRES_LATEST_MAJOR ? { until: last } : {}) };
+}
+
+/** "14 to 17", "16 and later" or "" when in every major. */
+export function describeRange(r: Availability): string {
+  if (r.since !== undefined && r.until !== undefined) return `Postgres ${r.since} to ${r.until}`;
+  if (r.since !== undefined) return `Postgres ${r.since} and later`;
+  if (r.until !== undefined) return `up to Postgres ${r.until}`;
+  return "";
+}
+
+const sections = new Map<Section, Map<string, Entry<unknown>>>();
+
+/** A section across every major, one entry per name. */
+export function section<Row>(name: Section): Map<string, Entry<Row>> | undefined {
+  const hit = sections.get(name);
+  if (hit) return hit as Map<string, Entry<Row>>;
+  const catalogs = postgresCatalogs();
+  if (!catalogs) return undefined;
+  const map = new Map<string, Entry<unknown>>();
+  for (const major of POSTGRES_MAJORS) {
+    for (const { key, row, detail } of rowsOf(name, catalogs.get(major)!)) {
+      const e = map.get(key);
+      if (e) {
+        e.row = row;
+        e.majors.push(major);
+        if (detail) e.detail = detail;
+      } else map.set(key, { name: key, row, majors: [major], range: {}, ...(detail ? { detail } : {}) });
+    }
+  }
+  for (const e of map.values()) e.range = rangeOf(e.majors);
+  sections.set(name, map);
+  return map as Map<string, Entry<Row>>;
+}
+
+/** The entries of a section that exist at `major`. */
+export function entriesAt<Row>(name: Section, major: number): Entry<Row>[] {
+  const s = section<Row>(name);
+  return s ? [...s.values()].filter((e) => e.majors.includes(major)) : [];
+}
+
+/** The entry for `name` at `major`, matching case-insensitively for names Postgres folds. */
+export function entryAt<Row>(name: Section, key: string, major: number): Entry<Row> | undefined {
+  const s = section<Row>(name);
+  const e = s?.get(key) ?? s?.get(key.toLowerCase());
+  return e && e.majors.includes(major) ? e : undefined;
+}
+
+/** `postgresMajor` in the nearest `chant.config.*` above a file, when it names a supported one. */
+export function configuredMajor(fileName: string): number | undefined {
+  let dir = dirname(resolve(fileName));
+  for (let i = 0; i < 12; i++) {
+    for (const name of ["chant.config.ts", "chant.config.json", "chant.config.mts", "chant.config.js", "chant.config.mjs"]) {
+      const file = join(dir, name);
+      if (!existsSync(file)) continue;
+      try {
+        const m = /["']?postgresMajor["']?\s*:\s*(\d+)/.exec(readFileSync(file, "utf-8"));
+        const major = m ? Number(m[1]) : undefined;
+        return major !== undefined && POSTGRES_MAJORS.includes(major) ? major : undefined;
+      } catch {
+        return undefined;
+      }
+    }
+    const up = dirname(dir);
+    if (up === dir) break;
+    dir = up;
+  }
+  return undefined;
+}
+
+/** The major a file is written for: the project's configured one, else the newest. */
+export function majorFor(fileName: string): number {
+  return configuredMajor(fileName) ?? POSTGRES_LATEST_MAJOR;
+}

package/src/lsp/postgres-template.ts

@@ -0,0 +1,161 @@
+/**
+ * Finding where the cursor is inside a Postgres template, and what the SQL
+ * before it says should come next. Shares the template finder with the lint
+ * rules, so the editor and `chant lint` agree on which tags are Postgres's.
+ */
+
+import * as ts from "typescript";
+import { isTrivia, tokenize, type Token } from "../postgres/tokens";
+import { parseStatements, type Span } from "../postgres/parser";
+import type { PostgresTag } from "../postgres/entities";
+import { POSTGRES_TEMPLATE_SOURCES, findPostgresTemplates, type PostgresFoundTemplate } from "../lint/rules/postgres-templates";
+import { locateIn, type Located as CoreLocated } from "../core/find-templates";
+
+export type PostgresLocated = CoreLocated<PostgresTag>;
+
+/** The Postgres template the source offset `at` is inside, and where in it. */
+export function locatePostgres(content: string, at: number, fileName = "file.ts"): PostgresLocated | undefined {
+  return locateIn(content, at, POSTGRES_TEMPLATE_SOURCES, fileName);
+}
+
+/** Significant tokens of the template up to `offset` in `part`; undefined when the text before it does not tokenize. */
+export function postgresTokensBefore(found: PostgresFoundTemplate, part: number, offset: number): Token[] | undefined {
+  try {
+    const parts = [...found.parts.slice(0, part), found.parts[part]!.slice(0, offset)];
+    return tokenize(parts).filter((t) => !isTrivia(t));
+  } catch {
+    return undefined;
+  }
+}
+
+export type PostgresExpect = "index-method" | "table-method" | "type" | "storage-parameter" | "extension" | "function" | "keyword";
+
+const upper = (t: Token | undefined): string => (t?.kind === "ident" ? t.text.toUpperCase() : "");
+const isPunct = (t: Token | undefined, text: string): boolean => t?.kind === "punct" && t.text === text;
+
+const EXPRESSION_AFTER = new Set(["DEFAULT", "WHERE", "SELECT", "AND", "OR", "WHEN", "THEN", "ELSE", "HAVING", "BY", "ON", "NOT", "CHECK", "AS", "USING"]);
+const EXPRESSION_CONTEXT = new Set(["SELECT", "DEFAULT", "CHECK", "WHERE", "GENERATED", "HAVING"]);
+const NOT_A_COLUMN = new Set(["CONSTRAINT", "PRIMARY", "UNIQUE", "CHECK", "FOREIGN", "EXCLUDE", "LIKE"]);
+
+/** What the SQL before the cursor expects; undefined where a name of the user's own goes. */
+export function postgresExpectAfter(sig: readonly Token[], tag: PostgresTag): PostgresExpect | undefined {
+  const last = sig[sig.length - 1];
+  if (!last) return undefined;
+  const prev = sig[sig.length - 2];
+
+  if (tag === "extension" && (upper(last) === "EXTENSION" || upper(last) === "EXISTS")) return "extension";
+  if (upper(last) === "USING") {
+    if (tag === "index" || upper(prev) === "EXCLUDE" || (prev === undefined ? false : sig.some((t) => upper(t) === "EXCLUDE"))) return "index-method";
+    return tag === "table" || tag === "view" ? "table-method" : undefined;
+  }
+  if (last.kind === "op" && last.text === "::") return "type";
+  if ((tag === "domain" || tag === "sequence") && upper(last) === "AS") return "type";
+
+  const open: number[] = [];
+  sig.forEach((t, i) => {
+    if (isPunct(t, "(")) open.push(i);
+    else if (isPunct(t, ")")) open.pop();
+  });
+  const opener = open[open.length - 1];
+  const before = opener === undefined ? undefined : sig[opener - 1];
+  const afterOpenOrComma = isPunct(last, "(") || isPunct(last, ",");
+
+  if (afterOpenOrComma && opener !== undefined && upper(before) === "WITH") return "storage-parameter";
+
+  // A table's column list: a name goes first, then a type.
+  const columnList = tag === "table" && open.length === 1 && opener === sig.findIndex((t) => isPunct(t, "("));
+  if (columnList) {
+    if (afterOpenOrComma) return undefined;
+    if ((last.kind === "ident" || last.kind === "qident") && (isPunct(prev, "(") || isPunct(prev, ",")) && !NOT_A_COLUMN.has(upper(last))) return "type";
+  }
+
+  if (EXPRESSION_AFTER.has(upper(last))) return "function";
+  if ((afterOpenOrComma || last.kind === "op") && sig.some((t) => EXPRESSION_CONTEXT.has(upper(t)))) return "function";
+  if (afterOpenOrComma && !columnList) return undefined;
+  if (last.kind === "ident" || last.kind === "qident" || isPunct(last, ")")) return "keyword";
+  return undefined;
+}
+
+/** The storage-parameter target a template's `WITH (...)` is for. */
+export function storageTarget(sig: readonly Token[], tag: PostgresTag): string {
+  if (tag === "index") {
+    const i = sig.findIndex((t) => upper(t) === "USING");
+    const method = i >= 0 && sig[i + 1]?.kind === "ident" ? sig[i + 1]!.text.toLowerCase() : "btree";
+    return `index:${method}`;
+  }
+  if (tag === "view") return sig.some((t) => upper(t) === "MATERIALIZED") ? "materialized view" : "view";
+  return "table";
+}
+
+// ── Declarations in a file ─────────────────────────────────────────────
+
+export interface PostgresDeclared {
+  /** The const the template is bound to. */
+  name: string;
+  tag: PostgresTag;
+  /** The kind, as a reader says it: `table`, `materialized view`, `enum type`. */
+  kind: string;
+  /** The name the DDL gives the object, interpolations written back as `${...}`. */
+  sqlName: string;
+  columns: Array<{ name: string; type?: string }>;
+}
+
+function spanText(found: PostgresFoundTemplate, tokens: Token[], span: Span | undefined, source: ts.SourceFile): string | undefined {
+  if (!span || span.to <= span.from) return undefined;
+  return tokens
+    .slice(span.from, span.to)
+    .map((t) => (t.kind === "ref" ? `\${${found.expressions[t.part]?.getText(source) ?? "..."}}` : t.text))
+    .join("")
+    .trim();
+}
+
+/** Every `const x = table\`...\`` (and the other tags) in the content that parses, by const name. */
+export function postgresDeclarations(content: string, fileName = "file.ts"): PostgresDeclared[] {
+  const source = ts.createSourceFile(fileName, content, ts.ScriptTarget.Latest, true);
+  const out: PostgresDeclared[] = [];
+  for (const found of findPostgresTemplates(source)) {
+    const decl = found.node.parent;
+    if (!decl || !ts.isVariableDeclaration(decl) || !ts.isIdentifier(decl.name)) continue;
+    try {
+      const tokens = tokenize(found.parts);
+      const node = parseStatements(tokens)[0];
+      if (!node) continue;
+      const text = (span: Span | undefined) => spanText(found, tokens, span, source);
+      let sqlName: string | undefined;
+      let kind: string = found.tag;
+      let columns: PostgresDeclared["columns"] = [];
+      switch (node.statement) {
+        case "table":
+          sqlName = text(node.name.span);
+          columns = node.columns.map((c) => ({ name: c.name || text(c.nameSpan) || "", ...(text(c.type) ? { type: text(c.type)! } : {}) }));
+          break;
+        case "view":
+          sqlName = text(node.name.span);
+          kind = node.materialized ? "materialized view" : "view";
+          columns = node.columnNames.map((c) => ({ name: c.name || text(c.span) || "" }));
+          break;
+        case "enum":
+          sqlName = text(node.name.span);
+          kind = "enum type";
+          break;
+        case "index":
+          sqlName = node.name ? text(node.name.span) : undefined;
+          break;
+        case "schema":
+          sqlName = node.name ? text(node.name.span) : undefined;
+          break;
+        case "sequence":
+        case "domain":
+        case "extension":
+          sqlName = text(node.name.span);
+          break;
+        default:
+          continue;
+      }
+      out.push({ name: decl.name.text, tag: found.tag, kind, sqlName: sqlName ?? decl.name.text, columns });
+    } catch {
+      // A template that does not parse is SQLPG001's to report; it has nothing to offer.
+    }
+  }
+  return out;
+}

package/src/lsp/postgres.test.ts

@@ -0,0 +1,150 @@
+import { mkdtempSync, rmSync, writeFileSync } from "fs";
+import { tmpdir } from "os";
+import { join } from "path";
+import { describe, expect, test } from "vitest";
+import { runLint } from "@intentius/chant/lint/engine";
+import { toLspDiagnostics } from "@intentius/chant/cli/lsp/diagnostics";
+import { completions } from "./completions";
+import { hover } from "./hover";
+import { sqlPlugin } from "../plugin";
+
+const IMPORT = 'import { table, view, index, type as pgType, extension } from "@intentius/chant-lexicon-sql/postgres";\n';
+
+/** A source with `|` marking the cursor. */
+function at(source: string, uri = "file:///schema.ts") {
+  const content = IMPORT + source;
+  const offset = content.indexOf("|");
+  const text = content.replace("|", "");
+  const before = text.slice(0, offset).split("\n");
+  const line = before.length - 1;
+  const linePrefix = before[line]!;
+  return { uri, content: text, position: { line, character: linePrefix.length }, wordAtCursor: /\w*$/.exec(linePrefix)![0], linePrefix, word: "", lineText: "" };
+}
+const labels = (source: string, uri?: string) => completions(at(source, uri)).map((i) => i.label);
+
+describe("postgres completions", () => {
+  test("types where a column's type goes, aliases included", () => {
+    expect(labels("export const t = table`CREATE TABLE t (id big|`;")).toContain("bigint");
+    expect(labels("export const t = table`CREATE TABLE t (id int|`;")).toEqual(expect.arrayContaining(["int4", "int"]));
+    expect(labels("export const t = table`CREATE TABLE t (id varc|`;")).toContain("varchar");
+    expect(labels("export const t = table`CREATE TABLE t (id uu|`;")).toContain("uuid");
+  });
+
+  test("no type while a column name is typed", () => {
+    expect(labels("export const t = table`CREATE TABLE t (id bigint, na|`;")).toEqual([]);
+  });
+
+  test("a type after ::", () => {
+    expect(labels("export const t = table`CREATE TABLE t (a text DEFAULT 1::big|`;")).toContain("bigint");
+  });
+
+  test("index access methods after USING", () => {
+    const l = labels("export const i = index`CREATE INDEX i_idx ON t USING g|`;");
+    expect(l).toEqual(expect.arrayContaining(["gin", "gist"]));
+    expect(l).not.toContain("heap");
+  });
+
+  test("table access methods after USING in a table", () => {
+    expect(labels("export const t = table`CREATE TABLE t (a int) USING he|`;")).toContain("heap");
+  });
+
+  test("storage parameters inside WITH (, by relation kind", () => {
+    const items = completions(at("export const t = table`CREATE TABLE t (a int) WITH (fillf|`;"));
+    expect(items.find((i) => i.label === "fillfactor")?.insertText).toBe("fillfactor = ");
+    expect(labels("export const t = table`CREATE TABLE t (a int) WITH (autosumm|`;")).toEqual([]);
+    expect(labels("export const i = index`CREATE INDEX i_idx ON t USING brin (a) WITH (autosumm|`;")).toContain("autosummarize");
+  });
+
+  test("functions in expressions", () => {
+    expect(labels("export const t = table`CREATE TABLE t (a timestamptz DEFAULT now|`;")).toContain("now");
+    expect(labels("export const t = table`CREATE TABLE t (a int DEFAULT array_so|`;")).toContain("array_sort");
+  });
+
+  test("a configured major hides names newer than it", () => {
+    const dir = mkdtempSync(join(tmpdir(), "sql-pgmajor-"));
+    try {
+      writeFileSync(join(dir, "chant.config.ts"), 'export default { lexicons: ["sql"], sql: { dialect: "postgres", postgresMajor: 15 } };\n');
+      const uri = `file://${join(dir, "schema.ts")}`;
+      expect(labels("export const t = table`CREATE TABLE t (a int DEFAULT array_so|`;", uri)).not.toContain("array_sort");
+      expect(labels("export const t = table`CREATE TABLE t (a int DEFAULT any_va|`;", uri)).not.toContain("any_value");
+      expect(labels("export const t = table`CREATE TABLE t (a int DEFAULT any_va|`;")).toContain("any_value");
+    } finally {
+      rmSync(dir, { recursive: true, force: true });
+    }
+  });
+
+  test("key words", () => {
+    expect(labels("export const t = table`CREATE TABLE t (a int NOT NULL DEFER|`;")).toContain("DEFERRABLE");
+  });
+
+  test("extensions", () => {
+    expect(labels("export const e = extension`CREATE EXTENSION pgcr|`;")).toContain("pgcrypto");
+  });
+
+  test("ClickHouse templates are left to the ClickHouse provider", () => {
+    const src = 'import { table } from "@intentius/chant-lexicon-sql/clickhouse";\nexport const t = table`CREATE TABLE t (a UInt8) ENGINE = Repl|`;';
+    const offset = src.indexOf("|");
+    const text = src.replace("|", "");
+    const before = text.slice(0, offset).split("\n");
+    const linePrefix = before[before.length - 1]!;
+    const items = completions({ uri: "file:///c.ts", content: text, position: { line: before.length - 1, character: linePrefix.length }, wordAtCursor: "Repl", linePrefix });
+    expect(items.map((i) => i.label)).toContain("ReplacingMergeTree");
+  });
+});
+
+describe("postgres completions inside ${}", () => {
+  const decls = "export const users = table`CREATE TABLE users (id bigint PRIMARY KEY, email text NOT NULL)`;\nexport const mood = pgType`CREATE TYPE mood AS ENUM ('a')`;\n";
+  test("offer declared objects with their kind", () => {
+    const items = completions(at(decls + "export const o = table`CREATE TABLE o (u bigint REFERENCES ${|})`;"));
+    expect(items.map((i) => i.label)).toEqual(["users", "mood"]);
+    expect(items[0]!.detail).toContain("table users");
+    expect(items[1]!.detail).toContain("enum type");
+  });
+  test("columns with their types", () => {
+    expect(labels(decls + "export const o = table`CREATE TABLE o (u bigint REFERENCES ${users.|})`;")).toEqual(["columns"]);
+    const items = completions(at(decls + "export const o = table`CREATE TABLE o (u bigint REFERENCES ${users} (${users.columns.|}))`;"));
+    expect(items.map((i) => [i.label, i.detail])).toEqual([["id", "bigint"], ["email", "text"]]);
+  });
+});
+
+const hoverAt = (source: string, uri?: string) => hover(at(source, uri) as never);
+
+describe("postgres hover", () => {
+  test("a type and its alias", () => {
+    expect(hoverAt("export const t = table`CREATE TABLE t (id int4|)`;")?.contents).toContain("alias of `integer`");
+  });
+  test("an access method", () => {
+    expect(hoverAt("export const i = index`CREATE INDEX i_idx ON t USING gi|n (a)`;")?.contents).toContain("index access method");
+  });
+  test("a storage parameter with its range", () => {
+    expect(hoverAt("export const t = table`CREATE TABLE t (a int) WITH (fillfa|ctor = 70)`;")?.contents).toMatch(/integer, range 10\.\.100/);
+  });
+  test("a function with its since", () => {
+    expect(hoverAt("export const t = table`CREATE TABLE t (a int DEFAULT array_so|rt(x))`;")?.contents).toContain("Postgres 18 and later");
+  });
+  test("a key word", () => {
+    expect(hoverAt("export const t = table`CREATE TABLE t (a int NOT NU|LL)`;")?.contents).toContain("key word");
+  });
+  test("a reference and a column with its type", () => {
+    const decls = "export const users = table`CREATE TABLE users (id bigint, email text)`;\n";
+    const t = hoverAt(decls + "export const o = table`CREATE TABLE o (u bigint REFERENCES ${us|ers})`;")?.contents;
+    expect(t).toContain("Postgres table `users`");
+    expect(t).toContain("`email text`");
+    expect(hoverAt(decls + "export const o = table`CREATE TABLE o (u bigint REFERENCES users (${users.columns.em|ail}))`;")?.contents).toContain("type `text`");
+  });
+});
+
+describe("sql diagnostics for Postgres in the editor", () => {
+  test("DDL that does not parse is SQLPG001 at the token", async () => {
+    const dir = mkdtempSync(join(tmpdir(), "sql-pglsp-"));
+    try {
+      const file = join(dir, "schema.ts");
+      writeFileSync(file, 'import { table } from "@intentius/chant-lexicon-sql/postgres";\nexport const t = table`CREATE TABLE t (\n  a int,\n  b ARRAY[4]\n)`;\n');
+      const { diagnostics } = await runLint([file], sqlPlugin.lintRules!());
+      const [d] = toLspDiagnostics(diagnostics.filter((x) => x.ruleId === "SQLPG001"));
+      expect(d).toMatchObject({ code: "SQLPG001", severity: 1, range: { start: { line: 3 } } });
+    } finally {
+      rmSync(dir, { recursive: true, force: true });
+    }
+  });
+});