@intentius/chant-lexicon-sql 0.124.31 → 0.124.32

package/dist/lint/post-synth/postgres-names.js

@@ -0,0 +1,507 @@
+/**
+ * Names in a Postgres declaration, read against the target major's catalog:
+ * column types, function calls, index access methods and operator classes.
+ * SQLPG119 to SQLPG126 share it.
+ *
+ * The line every check here keeps: a name the catalog or the project can
+ * answer for is checked; a name qualified with a schema the project does not
+ * declare (`billing.money`, `pg_catalog.int4`) is a plain-text reference and
+ * left to the server; a name the core catalog lacks is a warning, not an
+ * error, when the project declares an extension, since extension objects are
+ * not in the catalog (`overlays/extension-objects.ts` covers the common ones).
+ */
+import { COLUMN_TYPES, FUNCTIONS, INDEX_ACCESS_METHODS, KEYWORDS, OPERATOR_CLASSES, POSTGRES_MAJORS } from "../../generated/postgres.js";
+import { EXTENSION_OBJECTS } from "../../postgres/overlays/extension-objects.js";
+import { GRAMMAR_TYPE_SPELLINGS, SERIAL_TYPES, SERIAL_WIDTH_SPELLINGS, TYPE_SPELLINGS } from "../../postgres/overlays/types.js";
+import { isTrivia, tokenizeText } from "../../postgres/tokens.js";
+import { dialectObjects, recordedPostgresMajor } from "../../read/objects.js";
+const presentAt = (p, major) => p === true || (Array.isArray(p) && p.includes(major));
+const majorsOf = (p) => (Array.isArray(p) ? p : []);
+const columnTypes = COLUMN_TYPES;
+/** Every spelling of a built-in type (lower case, single spaces) to its `format_type()` name. */
+const BUILTIN_SPELLINGS = (() => {
+    const m = new Map();
+    for (const [sql, spec] of Object.entries(columnTypes)) {
+        m.set(sql, sql);
+        if (spec.catalogName)
+            m.set(spec.catalogName, sql);
+        for (const a of spec.aliases)
+            if (!m.has(a))
+                m.set(a, sql);
+    }
+    for (const [a, sql] of [...Object.entries(TYPE_SPELLINGS), ...Object.entries(GRAMMAR_TYPE_SPELLINGS)])
+        if (!m.has(a))
+            m.set(a, sql);
+    // `char` alone is `character` (bpchar); quoted, `"char"` is the one-byte type.
+    m.set("char", "character");
+    return m;
+})();
+const SERIALS = { ...SERIAL_TYPES, ...SERIAL_WIDTH_SPELLINGS };
+/** The words that may follow `interval`: its fields. */
+const INTERVAL_FIELDS = new Set(["year", "month", "day", "hour", "minute", "second", "to"]);
+/** The catalog category of a built-in type (`N` numeric, `S` string...). */
+export const categoryOf = (canonical) => columnTypes[canonical]?.category;
+/** The parameters a built-in type takes, from the overlay. */
+export const parametersOf = (canonical) => columnTypes[canonical]?.parameters ?? [];
+// ── Identifiers ────────────────────────────────────────────────────────
+/** An identifier's value: a quoted one as written, a bare one folded to lower case. */
+export function identValue(text) {
+    const t = text.trim();
+    if (t.startsWith('"') && t.endsWith('"') && t.length >= 2)
+        return t.slice(1, -1).replace(/""/g, '"');
+    return t.toLowerCase();
+}
+/** Split on commas at depth 0. */
+export function splitTopLevel(text) {
+    const out = [];
+    let depth = 0;
+    let quote;
+    let cur = "";
+    for (const ch of text) {
+        if (quote) {
+            cur += ch;
+            if (ch === quote)
+                quote = undefined;
+            continue;
+        }
+        if (ch === '"' || ch === "'")
+            quote = ch;
+        else if (ch === "(" || ch === "[")
+            depth++;
+        else if (ch === ")" || ch === "]")
+            depth--;
+        else if (ch === "," && depth === 0) {
+            out.push(cur.trim());
+            cur = "";
+            continue;
+        }
+        cur += ch;
+    }
+    if (cur.trim())
+        out.push(cur.trim());
+    return out;
+}
+/** The bare column names of an `INCLUDE` list as the output keeps it (`b, "X"`, or `(b, c)`). */
+export function includeColumns(text) {
+    if (!text)
+        return [];
+    const inner = text.trim().replace(/^\(/, "").replace(/\)$/, "");
+    return splitTopLevel(inner).filter((s) => /^("([^"]|"")+"|[A-Za-z_][\w$]*)$/.test(s)).map(identValue);
+}
+function significant(text) {
+    try {
+        return tokenizeText(text, 0).filter((t) => !isTrivia(t));
+    }
+    catch {
+        return undefined;
+    }
+}
+const isName = (t) => t?.kind === "ident" || t?.kind === "qident";
+const isPunct = (t, p) => t?.kind === "punct" && t.text === p;
+const nameOf = (t) => (t.kind === "qident" ? identValue(t.text) : t.text.toLowerCase());
+export function projectOf(ctx) {
+    return projectFromObjects(dialectObjects(ctx, "postgres"), recordedPostgresMajor(ctx, POSTGRES_MAJORS[POSTGRES_MAJORS.length - 1]));
+}
+/** 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, major) {
+    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,
+        objects,
+        byExport,
+        schemas,
+        extensions: new Set(exts.map((o) => o.name)),
+    };
+}
+const TYPE_OBJECTS = new Set(["Postgres::Enum", "Postgres::CompositeType", "Postgres::RangeType", "Postgres::Domain", "Postgres::Table", "Postgres::View", "Postgres::MaterializedView"]);
+const ROUTINES = new Set(["Postgres::Function", "Postgres::Procedure"]);
+/** A range type's multirange type's name: as written (its last piece), else as Postgres derives it. */
+function multirangeOf(o) {
+    if (o.type !== "Postgres::RangeType")
+        return undefined;
+    const written = o.multirangeTypeName;
+    if (written) {
+        const last = written.split(".").pop().trim();
+        return /^"/.test(last) ? last.slice(1, -1).replace(/""/g, '"') : last.toLowerCase();
+    }
+    const name = String(o.name);
+    const at = name.indexOf("range");
+    return at >= 0 ? `${name.slice(0, at)}multi${name.slice(at)}` : `${name}_multirange`;
+}
+function declared(p, kinds, schema, name) {
+    return p.objects.find((o) => kinds.has(o.type) && (o.name === name || multirangeOf(o) === name) && (schema === undefined || o.schema === schema));
+}
+/** The extension that provides `name` in `section`, if the overlay knows one; declared ones first. */
+function extensionFor(p, test) {
+    let found;
+    for (const [name, e] of Object.entries(EXTENSION_OBJECTS)) {
+        if (!test(e))
+            continue;
+        if (p.extensions.has(name))
+            return { name, declared: true };
+        found ?? (found = { name, declared: false });
+    }
+    return found;
+}
+function miss(p, ext) {
+    if (ext?.declared)
+        return undefined;
+    if (ext)
+        return { severity: "error", note: `; it comes from the ${ext.name} extension, which the project does not declare` };
+    if (p.extensions.size > 0)
+        return { severity: "warning", note: `; if an extension (${[...p.extensions].sort().join(", ")}) provides it, ignore this` };
+    return { severity: "error", note: "" };
+}
+/** A schema-qualified name the project cannot answer for: one in a schema it does not declare. */
+const outsideProject = (p, schema) => !p.schemas.has(schema);
+/** A type as written in a column, domain or sequence: `numeric(12,2)`, `time(3) with time zone`, `app.mood[]`. Undefined when it is not a plain type name. */
+export function parseType(text) {
+    if (!text)
+        return undefined;
+    const toks = significant(text);
+    if (!toks || toks.length === 0)
+        return undefined;
+    const words = [];
+    let schema;
+    let quoted = false;
+    let modifiers;
+    let array = false;
+    for (let i = 0; i < toks.length; i++) {
+        const t = toks[i];
+        if (isName(t)) {
+            if (t.kind === "ident" && t.text.toLowerCase() === "array" && words.length > 0) {
+                array = true;
+                continue;
+            }
+            if (array)
+                return undefined;
+            if (isPunct(toks[i + 1], ".") && words.length === 0 && schema === undefined && isName(toks[i + 2])) {
+                schema = nameOf(t);
+                i++;
+                continue;
+            }
+            if (t.kind === "qident")
+                quoted = true;
+            words.push(nameOf(t));
+        }
+        else if (isPunct(t, "(")) {
+            let depth = 1;
+            let j = i + 1;
+            for (; j < toks.length && depth > 0; j++) {
+                if (isPunct(toks[j], "("))
+                    depth++;
+                else if (isPunct(toks[j], ")"))
+                    depth--;
+            }
+            if (depth !== 0)
+                return undefined;
+            if (modifiers === undefined) {
+                const start = t.end;
+                const end = toks[j - 1].start;
+                modifiers = splitTopLevel(text.slice(start, end));
+            }
+            i = j - 1;
+        }
+        else if (isPunct(t, "[")) {
+            array = true;
+            let j = i + 1;
+            while (j < toks.length && !isPunct(toks[j], "]"))
+                j++;
+            i = j;
+        }
+        else {
+            return undefined;
+        }
+    }
+    if (words.length === 0)
+        return undefined;
+    if (!quoted && words[0] === "interval" && words.length > 1 && words.slice(1).every((w) => INTERVAL_FIELDS.has(w))) {
+        return { schema, name: "interval", quoted, modifiers, array, fields: words.slice(1).join(" ").toUpperCase() };
+    }
+    return { schema, name: words.join(" "), quoted, modifiers, array };
+}
+/** Resolve a parsed type at the target major. `serial` admits `serial` and friends (a column). */
+export function resolveType(p, t, opts = {}) {
+    if (t.schema !== undefined) {
+        if (outsideProject(p, t.schema))
+            return { kind: "outside" };
+        const d = declared(p, TYPE_OBJECTS, t.schema, t.name);
+        if (d)
+            return { kind: "declared", object: d };
+        const m = miss(p, extensionFor(p, (e) => e.types?.includes(t.name) ?? false));
+        return m ? { kind: "missing", miss: m } : { kind: "outside" };
+    }
+    if (!t.quoted) {
+        if (opts.serial && SERIALS[t.name] && !t.modifiers)
+            return { kind: "builtin", canonical: SERIALS[t.name], serial: true };
+        if (t.name === "float" && t.modifiers?.length === 1 && /^\d+$/.test(t.modifiers[0])) {
+            return { kind: "builtin", canonical: Number(t.modifiers[0]) <= 24 ? "real" : "double precision" };
+        }
+        const canonical = BUILTIN_SPELLINGS.get(t.name) ?? (t.name.startsWith("_") ? BUILTIN_SPELLINGS.get(t.name.slice(1)) : undefined);
+        if (canonical)
+            return { kind: "builtin", canonical };
+    }
+    else {
+        if (t.name === "char")
+            return { kind: "builtin", canonical: '"char"' };
+        const byCatalog = Object.entries(columnTypes).find(([sql, s]) => (s.catalogName ?? sql) === t.name);
+        if (byCatalog)
+            return { kind: "builtin", canonical: byCatalog[0] };
+    }
+    const d = declared(p, TYPE_OBJECTS, undefined, t.name);
+    if (d)
+        return { kind: "declared", object: d };
+    const m = miss(p, extensionFor(p, (e) => e.types?.includes(t.name) ?? false));
+    return m ? { kind: "missing", miss: m } : { kind: "outside" };
+}
+/** A type as the user wrote it, for a message. */
+export const typeLabel = (t) => `${t.schema ? `${t.schema}.` : ""}${t.name}`;
+/**
+ * A comparable identity for a column's type, for a foreign key: a built-in
+ * type's catalog category (`U`, the catch-all, by name), a domain's base type,
+ * an enum or row type by name; `[]` for an array. Undefined when it cannot be
+ * told (a type outside the project).
+ */
+export function typeIdentity(p, text, depth = 0) {
+    const t = parseType(text);
+    if (!t || depth > 5)
+        return undefined;
+    const r = resolveType(p, t, { serial: true });
+    const suffix = t.array ? "[]" : "";
+    if (r.kind === "builtin") {
+        const cat = categoryOf(r.canonical);
+        if (!cat)
+            return undefined;
+        return (cat === "U" ? `U:${r.canonical}` : cat) + suffix;
+    }
+    if (r.kind === "declared") {
+        if (r.object.type === "Postgres::Domain") {
+            const base = typeIdentity(p, r.object.dataType, depth + 1);
+            return base === undefined ? undefined : base + suffix;
+        }
+        return `${r.object.type}:${r.object.sqlName}${suffix}`;
+    }
+    return undefined;
+}
+// ── Calls ──────────────────────────────────────────────────────────────
+/**
+ * Words that take a parenthesis in an expression without being a call to a
+ * function in `pg_proc`. Reserved and column-name key words (`COALESCE`,
+ * `CAST`, `EXTRACT`, `ROW`, `ARRAY`, `EXISTS`, `IN`, `ANY`, `SUBSTRING`...)
+ * are not function names to the grammar and are skipped by their category;
+ * these are the unreserved ones that read the same way.
+ */
+const NOT_CALLS = new Set(["filter", "over", "within", "zone", "varying", "precision", "value", "and", "or", "not", "as", "then", "else", "when"]);
+/** The function calls in an expression: a name directly followed by `(`, outside string literals, not a key word construct. */
+export function callsIn(expr) {
+    if (!expr)
+        return [];
+    const toks = significant(expr);
+    if (!toks)
+        return [];
+    const out = [];
+    for (let i = 0; i < toks.length; i++) {
+        const t = toks[i];
+        if (!isName(t))
+            continue;
+        const prev = toks[i - 1];
+        if (isPunct(prev, "."))
+            continue;
+        // A type's modifiers after a cast: `x::numeric(10, 2)`, `CAST(x AS varchar(3))`.
+        if (prev?.kind === "op" && prev.text === "::")
+            continue;
+        if (prev?.kind === "ident" && prev.text.toLowerCase() === "as")
+            continue;
+        if (isPunct(toks[i + 1], ".") && isName(toks[i + 2]) && isPunct(toks[i + 3], "(")) {
+            out.push({ schema: nameOf(t), name: nameOf(toks[i + 2]) });
+            i += 2;
+            continue;
+        }
+        if (!isPunct(toks[i + 1], "("))
+            continue;
+        if (t.kind === "ident") {
+            const w = t.text.toLowerCase();
+            const cat = KEYWORDS[w];
+            if (cat === "R" || cat === "C" || cat === "T")
+                continue;
+            if (NOT_CALLS.has(w))
+                continue;
+        }
+        out.push({ name: nameOf(t) });
+    }
+    return out;
+}
+/** Resolve a call at the target major. */
+export function resolveCall(p, c) {
+    if (c.schema !== undefined) {
+        if (outsideProject(p, c.schema))
+            return { ok: true };
+        if (declared(p, ROUTINES, c.schema, c.name))
+            return { ok: true };
+        const m = miss(p, extensionFor(p, (e) => providesFunction(e, c.name)));
+        return m ? { ok: false, miss: m } : { ok: true };
+    }
+    const presence = FUNCTIONS[c.name];
+    if (presentAt(presence, p.major))
+        return { ok: true };
+    if (declared(p, ROUTINES, undefined, c.name))
+        return { ok: true };
+    // A function-style cast: `int4(x)`, `text(x)`, or a declared type's name.
+    if (BUILTIN_SPELLINGS.has(c.name) || declared(p, TYPE_OBJECTS, undefined, c.name))
+        return { ok: true };
+    if (presence !== undefined) {
+        const ms = majorsOf(presence);
+        const since = ms[0] > p.major ? ms[0] : undefined;
+        const until = ms[ms.length - 1] < p.major ? ms[ms.length - 1] : undefined;
+        return { ok: false, miss: { severity: "error", note: "" }, since, until };
+    }
+    const m = miss(p, extensionFor(p, (e) => providesFunction(e, c.name)));
+    return m ? { ok: false, miss: m } : { ok: true };
+}
+function providesFunction(e, name) {
+    return (e.functions?.includes(name) ?? false) || (e.functionPrefixes?.some((pre) => name.startsWith(pre)) ?? false);
+}
+/** The expressions of a table, domain or index that may call functions, each with where it sits. */
+export function expressionsOf(o) {
+    const out = [];
+    if (o.type === "Postgres::Table") {
+        const t = o;
+        for (const c of t.columns) {
+            if (c.default)
+                out.push({ where: `column ${c.name}'s DEFAULT`, expr: c.default });
+            if (c.generated?.expr)
+                out.push({ where: `generated column ${c.name}`, expr: c.generated.expr });
+        }
+        for (const k of t.checks)
+            out.push({ where: k.name ? `CHECK ${k.name}` : "a CHECK", expr: k.expr });
+    }
+    else if (o.type === "Postgres::Domain") {
+        if (o.default)
+            out.push({ where: "its DEFAULT", expr: o.default });
+        for (const k of o.checks ?? [])
+            out.push({ where: k.name ? `CHECK ${k.name}` : "a CHECK", expr: k.expr });
+    }
+    else if (o.type === "Postgres::Index") {
+        for (const e of o.elements ?? []) {
+            if (e.column)
+                continue;
+            const el = parseIndexElement(e.expr);
+            out.push({ where: "an index expression", expr: el?.expr ?? e.expr });
+        }
+    }
+    return out;
+}
+const ORDERING = new Set(["asc", "desc", "nulls", "first", "last"]);
+/** An index element (`(lower(x)) text_pattern_ops DESC`, `x gin_trgm_ops`) split into its expression and operator class. */
+export function parseIndexElement(text) {
+    const toks = significant(text);
+    if (!toks || toks.length === 0)
+        return undefined;
+    let i = 0;
+    const skipGroup = (at) => {
+        let depth = 0;
+        for (let j = at; j < toks.length; j++) {
+            if (isPunct(toks[j], "("))
+                depth++;
+            else if (isPunct(toks[j], ")") && --depth === 0)
+                return j + 1;
+        }
+        return toks.length;
+    };
+    if (isPunct(toks[0], "("))
+        i = skipGroup(0);
+    else if (isName(toks[0])) {
+        i = 1;
+        while (isPunct(toks[i], ".") && isName(toks[i + 1]))
+            i += 2;
+        if (isPunct(toks[i], "("))
+            i = skipGroup(i);
+    }
+    else
+        return undefined;
+    const expr = text.slice(toks[0].start, toks[i - 1].end);
+    if (toks[i]?.kind === "ident" && toks[i].text.toLowerCase() === "collate") {
+        i += 2;
+        while (isPunct(toks[i], ".") && isName(toks[i + 1]))
+            i += 2;
+    }
+    const t = toks[i];
+    if (!isName(t) || (t.kind === "ident" && ORDERING.has(t.text.toLowerCase())))
+        return { expr };
+    if (isPunct(toks[i + 1], ".") && isName(toks[i + 2]))
+        return { expr, opclass: { schema: nameOf(t), name: nameOf(toks[i + 2]) } };
+    return { expr, opclass: { name: nameOf(t) } };
+}
+/** An index access method at the target major. */
+export function resolveMethod(p, method) {
+    const presence = INDEX_ACCESS_METHODS[method];
+    if (presentAt(presence, p.major))
+        return { ok: true };
+    if (presence !== undefined)
+        return { ok: false, miss: { severity: "error", note: "" } };
+    const m = miss(p, extensionFor(p, (e) => e.accessMethods?.includes(method) ?? false));
+    return m ? { ok: false, miss: m } : { ok: true };
+}
+/** An operator class for `method` at the target major. */
+export function resolveOpClass(p, method, opclass) {
+    if (opclass.schema !== undefined && outsideProject(p, opclass.schema))
+        return { ok: true };
+    const classes = OPERATOR_CLASSES;
+    if (presentAt(classes[method]?.[opclass.name], p.major))
+        return { ok: true };
+    const ext = extensionFor(p, (e) => e.opclasses?.[method]?.includes(opclass.name) ?? false);
+    if (ext?.declared)
+        return { ok: true };
+    if (!ext) {
+        const others = Object.keys(classes).filter((am) => am !== method && presentAt(classes[am][opclass.name], p.major));
+        const extOthers = Object.entries(EXTENSION_OBJECTS).flatMap(([, e]) => Object.entries(e.opclasses ?? {}).filter(([am, names]) => am !== method && names.includes(opclass.name)).map(([am]) => am));
+        const all = [...new Set([...others, ...extOthers])].sort();
+        if (all.length > 0)
+            return { ok: false, miss: { severity: "error", note: "" }, otherMethods: all };
+    }
+    const m = miss(p, ext);
+    return m ? { ok: false, miss: m } : { ok: true };
+}
+// ── Tables ─────────────────────────────────────────────────────────────
+/** The table an interpolated reference names (`references`, `table`, a grant's object): the entity when it is one, else undefined. */
+export function interpolatedTable(p, ref, sqlName) {
+    if (typeof ref !== "string")
+        return undefined;
+    const o = p.byExport.get(ref);
+    if (!o || o.type !== "Postgres::Table")
+        return undefined;
+    if (sqlName !== undefined && o.sqlName !== sqlName)
+        return undefined;
+    return o;
+}
+/**
+ * Every column a table has, its own and those it inherits or copies from a
+ * declared parent; undefined when some come from somewhere the build cannot
+ * see (a plain-text parent, `LIKE`, `OF type`).
+ */
+export function columnsOf(p, t, seen = new Set()) {
+    if (seen.has(t.export))
+        return undefined;
+    seen.add(t.export);
+    if (t.ofType !== undefined || t.like.length > 0)
+        return undefined;
+    const out = new Map();
+    const parents = [...(t.inherits ?? []), ...(t.partitionOf !== undefined ? [t.partitionOf] : [])];
+    for (const parent of parents) {
+        const pt = interpolatedTable(p, parent, undefined);
+        if (!pt)
+            return undefined;
+        const pc = columnsOf(p, pt, seen);
+        if (!pc)
+            return undefined;
+        for (const [k, v] of pc)
+            out.set(k, v);
+    }
+    // A partition's `col WITH OPTIONS ...` carries no type; the parent's column stands.
+    for (const c of t.columns)
+        if (c.type !== undefined || !out.has(c.name))
+            out.set(c.name, c);
+    return out;
+}

package/dist/lint/post-synth/sql-helpers.js

@@ -0,0 +1,23 @@
+/**
+ * Reading the sql lexicon's build output in a post-synth check: the JSON
+ * 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 { dialectObjects, recordedPostgresMajor } from "../../read/objects.js";
+/** Every schema object in the build's sql output, ClickHouse dialect. */
+export function clickhouseObjects(ctx) {
+    return dialectObjects(ctx, "clickhouse");
+}
+/** Every schema object in the build's sql output, Postgres dialect. */
+export function postgresObjects(ctx) {
+    return dialectObjects(ctx, "postgres");
+}
+/**
+ * The Postgres major the build targets, as the serializer recorded it
+ * (`sql.postgresMajor`, else the newest pinned major). `fallback` answers for
+ * output that carries none.
+ */
+export function postgresMajorOf(ctx, fallback) {
+    return recordedPostgresMajor(ctx, fallback);
+}

package/dist/lint/post-synth/sql101.js

@@ -0,0 +1,59 @@
+import { clickhouseObjects, postgresObjects } from "./sql-helpers.js";
+/**
+ * Kinds whose name is not the object's identity on the server, so two
+ * exports may share it: grants; Postgres functions and procedures, which
+ * overload; triggers and policies, named per table; ClickHouse row policies,
+ * also per table.
+ */
+const NOT_UNIQUE = new Set([
+    "ClickHouse::Grant",
+    "ClickHouse::RowPolicy",
+    "Postgres::Grant",
+    "Postgres::DefaultPrivileges",
+    "Postgres::Function",
+    "Postgres::Procedure",
+    "Postgres::Aggregate",
+    "Postgres::Trigger",
+    "Postgres::Policy",
+]);
+const kindOf = (type) => type
+    .replace(/^(ClickHouse|Postgres)::/, "")
+    .replace(/([a-z])([A-Z])/g, "$1 $2")
+    .toLowerCase();
+/**
+ * SQL101: two exports declare the same object, the same kind under the same
+ * qualified name (`shop.events` twice). The build writes both `CREATE`
+ * statements, and the second fails on the server, or replaces the first
+ * under `OR REPLACE`.
+ */
+export const sql101 = {
+    id: "SQL101",
+    description: "Two exports declare the same object",
+    check(ctx) {
+        const out = [];
+        const scan = (dialect, objects) => {
+            const first = new Map();
+            for (const o of objects) {
+                const name = typeof o.sqlName === "string" && o.sqlName !== "" ? o.sqlName : undefined;
+                if (!name || NOT_UNIQUE.has(o.type))
+                    continue;
+                const key = `${o.type}\u0000${name}`;
+                const prior = first.get(key);
+                if (!prior) {
+                    first.set(key, o);
+                    continue;
+                }
+                out.push({
+                    checkId: "SQL101",
+                    severity: "error",
+                    message: `${prior.export} and ${o.export} both declare ${dialect} ${kindOf(o.type)} ${name}; the build would create it twice`,
+                    entity: o.export,
+                    lexicon: "sql",
+                });
+            }
+        };
+        scan("ClickHouse", clickhouseObjects(ctx));
+        scan("Postgres", postgresObjects(ctx));
+        return out;
+    },
+};

package/dist/lint/post-synth/sql102.js

@@ -0,0 +1,34 @@
+import { sqlTypesPath, sqlTypesState } from "../../sql-types.js";
+/**
+ * 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 = {
+    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/dist/lint/post-synth/sqlch101.js

@@ -0,0 +1,34 @@
+import { DATABASE_ENGINES, TABLE_ENGINES, CLICKHOUSE_VERSION } from "../../generated/clickhouse.js";
+import { clickhouseObjects } from "./sql-helpers.js";
+/**
+ * SQLCH101: a table, materialized view or database names an engine the pinned
+ * ClickHouse server does not have.
+ *
+ * The engine list is the pinned server's own (`system.table_engines`,
+ * `system.database_engines`), so a misspelling (`MergTree`) or an engine a
+ * release removed fails here, at build, rather than at `CREATE` against a
+ * server.
+ */
+export const sqlch101 = {
+    id: "SQLCH101",
+    description: "A ClickHouse object names an engine the pinned server does not have",
+    check(ctx) {
+        const out = [];
+        for (const obj of clickhouseObjects(ctx)) {
+            const engine = obj.engine?.name;
+            if (!engine)
+                continue;
+            const known = obj.type === "ClickHouse::Database" ? engine in DATABASE_ENGINES : engine in TABLE_ENGINES;
+            if (known)
+                continue;
+            out.push({
+                checkId: "SQLCH101",
+                severity: "error",
+                message: `${obj.export} (${obj.name}) uses engine "${engine}", which ClickHouse ${CLICKHOUSE_VERSION} does not have`,
+                entity: obj.export,
+                lexicon: "sql",
+            });
+        }
+        return out;
+    },
+};

package/dist/lint/post-synth/sqlch102.js

@@ -0,0 +1,23 @@
+import { checkOf, keyElements, tablesOf } from "./clickhouse-helpers.js";
+/**
+ * SQLCH102: a PRIMARY KEY that is not a prefix of ORDER BY.
+ *
+ * Doc: https://clickhouse.com/docs/engines/table-engines/mergetree-family/mergetree
+ * ("The primary key must be a prefix of the sorting key"); the server refuses
+ * 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 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, ""));
+        if (pk.every((e, i) => ob[i] === e))
+            continue;
+        report({
+            severity: "error",
+            message: `${t.export} (${t.name}) has PRIMARY KEY ${t.primaryKey}, which is not a prefix of ORDER BY ${t.orderBy}`,
+            entity: t.export,
+        });
+    }
+});