@intentius/chant-lexicon-sql 0.124.30 → 0.124.32

package/dist/lint/rules/sqlch001.js

@@ -0,0 +1,79 @@
+import { parseCreate } from "../../clickhouse/parser.js";
+import { parseAccess } from "../../clickhouse/access.js";
+import { SqlSyntaxError } from "../../clickhouse/tokens.js";
+import { findTemplates, templatePosition, tokensOf } from "./templates.js";
+const ACCESS_TAGS = new Set(["user", "role", "policy", "quota", "settingsProfile", "grant"]);
+const ACCESS_STATEMENT = {
+    user: "CREATE USER",
+    role: "CREATE ROLE",
+    rowPolicy: "CREATE ROW POLICY",
+    quota: "CREATE QUOTA",
+    settingsProfile: "CREATE SETTINGS PROFILE",
+    grant: "GRANT",
+};
+const STATEMENT = { database: "CREATE DATABASE", table: "CREATE TABLE", view: "CREATE VIEW", dictionary: "CREATE DICTIONARY", function: "CREATE FUNCTION" };
+/** The tag a statement belongs in: `func` for a function, the statement's own name otherwise. */
+const tagOf = (statement) => (statement === "function" ? "func" : statement);
+/**
+ * SQLCH001: the DDL in a ClickHouse template (`database`, `table`, `view`, `dictionary`, `func`, `user`, `role`, `policy`, `quota`, `settingsProfile`, `grant`) does not parse, or holds another statement than its tag.
+ *
+ * The same parse runs when the build calls the tag, and fails the build there.
+ * This rule reports it in the editor and in `chant lint`, at the token, before
+ * anything is built. Interpolations are references here, since lint cannot
+ * know their values, so an error inside text a string interpolation supplies
+ * is left to the build.
+ */
+export const sqlch001 = {
+    id: "SQLCH001",
+    severity: "error",
+    category: "correctness",
+    description: "ClickHouse DDL in a database, table or view template does not parse",
+    check(context) {
+        const source = context.sourceFile;
+        const out = [];
+        for (const found of findTemplates(source)) {
+            let tokens;
+            try {
+                tokens = tokensOf(found);
+                if (ACCESS_TAGS.has(found.tag)) {
+                    const node = parseAccess(tokens);
+                    const tag = node.statement === "rowPolicy" ? "policy" : node.statement;
+                    if (tag !== found.tag || node.revoke) {
+                        out.push({
+                            ruleId: "SQLCH001",
+                            severity: "error",
+                            message: node.revoke
+                                ? `${found.tag}\`...\` holds a REVOKE; declare the grants a grantee keeps, and a plan revokes the rest`
+                                : `${found.tag}\`...\` holds a ${ACCESS_STATEMENT[node.statement]}; use the ${tag} tag`,
+                            file: context.filePath,
+                            ...templatePosition(source, found, 0, 0),
+                        });
+                    }
+                    continue;
+                }
+                const node = parseCreate(tokens);
+                if (tagOf(node.statement) !== found.tag) {
+                    out.push({
+                        ruleId: "SQLCH001",
+                        severity: "error",
+                        message: `${found.tag}\`...\` holds a ${STATEMENT[node.statement]}; use the ${tagOf(node.statement)} tag`,
+                        file: context.filePath,
+                        ...templatePosition(source, found, 0, 0),
+                    });
+                }
+            }
+            catch (err) {
+                if (!(err instanceof SqlSyntaxError))
+                    throw err;
+                out.push({
+                    ruleId: "SQLCH001",
+                    severity: "error",
+                    message: `ClickHouse DDL does not parse: ${err.message}`,
+                    file: context.filePath,
+                    ...templatePosition(source, found, err.part, err.offset),
+                });
+            }
+        }
+        return out;
+    },
+};

package/dist/lint/rules/sqlch002.js

@@ -0,0 +1,124 @@
+import { parseCreate, unquote } from "../../clickhouse/parser.js";
+import { isTrivia, SqlSyntaxError } from "../../clickhouse/tokens.js";
+import { findTemplates, tokenPosition, tokensOf } from "./templates.js";
+/** The column's type, as written, reads `Nullable(...)`, also inside `LowCardinality(...)`. */
+function isNullable(tokens, c) {
+    if (c.nullable === true)
+        return true;
+    if (!c.type)
+        return false;
+    const words = tokens.slice(c.type.from, c.type.to).filter((t) => t.kind === "ident").map((t) => t.text.toLowerCase());
+    return words[0] === "nullable" || (words[0] === "lowcardinality" && words[1] === "nullable");
+}
+/**
+ * The column names a key names as a key part: bare, or inside the key's tuple
+ * parentheses, not an argument of a function (`ifNull(a, '')` makes a
+ * non-Nullable key part of a Nullable column) and not a qualified part.
+ */
+function keyColumns(tokens, span) {
+    const sig = tokens.slice(span.from, span.to).filter((t) => !isTrivia(t));
+    const out = [];
+    const frames = []; // true for a function call's parentheses
+    sig.forEach((t, i) => {
+        const prev = sig[i - 1];
+        if (t.kind === "punct" && t.text === "(") {
+            frames.push(prev !== undefined && (prev.kind === "ident" || prev.kind === "qident"));
+            return;
+        }
+        if (t.kind === "punct" && t.text === ")") {
+            frames.pop();
+            return;
+        }
+        if (t.kind !== "ident" && t.kind !== "qident")
+            return;
+        if (frames.includes(true))
+            return;
+        const next = sig[i + 1];
+        if (next?.kind === "punct" && next.text === "(")
+            return;
+        if (prev?.kind === "punct" && prev.text === ".")
+            return;
+        out.push({ name: unquote(t.text), token: t });
+    });
+    return out;
+}
+function allowsNullableKey(tokens, node) {
+    if (node.statement !== "table" && node.statement !== "view")
+        return false;
+    if (!node.settings)
+        return false;
+    const s = node.settings.find((x) => x.key === "allow_nullable_key");
+    if (!s)
+        return false;
+    const v = tokens.slice(s.value.from, s.value.to).map((t) => t.text).join("").trim().toLowerCase().replace(/'/g, "");
+    return v === "1" || v === "true";
+}
+/**
+ * SQLCH002: a `Nullable` column in a table's sort key or primary key.
+ *
+ * ClickHouse refuses to create the table ("Sorting key contains nullable
+ * columns") unless the table sets `allow_nullable_key = 1`, and with it a
+ * `NULL` sorts as a value of its own. The rule reads the types written in the
+ * column list; a key over a column of an inferred type is left to the server.
+ */
+export const sqlch002 = {
+    id: "SQLCH002",
+    severity: "error",
+    category: "correctness",
+    description: "A Nullable column in a ClickHouse sort key or primary key",
+    check(context) {
+        const source = context.sourceFile;
+        const out = [];
+        for (const found of findTemplates(source)) {
+            const tokens = tokensOf(found);
+            let node;
+            try {
+                node = parseCreate(tokens);
+            }
+            catch (err) {
+                if (err instanceof SqlSyntaxError)
+                    continue; // SQLCH001 reports it
+                throw err;
+            }
+            if ((node.statement !== "table" && node.statement !== "view") || allowsNullableKey(tokens, node))
+                continue;
+            const nullable = new Set(node.columns.filter((c) => c.name && isNullable(tokens, c)).map((c) => c.name));
+            if (nullable.size === 0)
+                continue;
+            const reported = new Set();
+            for (const [clause, span] of [
+                ["sort key", node.orderBy],
+                ["primary key", node.primaryKey],
+            ]) {
+                if (!span)
+                    continue;
+                for (const { name, token } of keyColumns(tokens, span)) {
+                    if (!nullable.has(name) || reported.has(`${clause}:${name}`))
+                        continue;
+                    reported.add(`${clause}:${name}`);
+                    out.push({
+                        ruleId: "SQLCH002",
+                        severity: "error",
+                        message: `column "${name}" is Nullable and is in the ${clause}; ClickHouse refuses this unless the table ` +
+                            "sets allow_nullable_key = 1. Make the column non-Nullable (a default such as '' or 0 in place of NULL), " +
+                            "or drop it from the key",
+                        file: context.filePath,
+                        ...tokenPosition(source, found, token),
+                    });
+                }
+            }
+            for (const c of node.columns) {
+                if (c.primaryKey && nullable.has(c.name)) {
+                    out.push({
+                        ruleId: "SQLCH002",
+                        severity: "error",
+                        message: `column "${c.name}" is Nullable and is declared PRIMARY KEY; ClickHouse refuses this unless the table sets allow_nullable_key = 1`,
+                        file: context.filePath,
+                        ...tokenPosition(source, found, tokens[c.nameSpan.from]),
+                    });
+                }
+            }
+        }
+        return out;
+    },
+};

package/dist/lint/rules/sqlch003.js

@@ -0,0 +1,69 @@
+import { ts } from "@intentius/chant/lint/typescript";
+import { findTemplates } from "./templates.js";
+/** The entity's own members: an interpolation of one of them is never a column. */
+const OWN_MEMBERS = new Set(["kind", "lexicon", "entityType", "props", "sqlName", "dependsOn"]);
+/**
+ * Identifiers that hold a ClickHouse entity, as far as one file can tell:
+ * bound to a sql tag here, or imported from another file of the project.
+ */
+function entityBindings(source, tagged) {
+    const out = new Set();
+    for (const stmt of source.statements) {
+        if (ts.isImportDeclaration(stmt) && ts.isStringLiteral(stmt.moduleSpecifier) && stmt.moduleSpecifier.text.startsWith(".")) {
+            const named = stmt.importClause?.namedBindings;
+            if (named && ts.isNamedImports(named))
+                for (const el of named.elements)
+                    out.add(el.name.text);
+        }
+        if (ts.isVariableStatement(stmt)) {
+            for (const d of stmt.declarationList.declarations) {
+                if (ts.isIdentifier(d.name) && d.initializer && tagged.has(d.initializer))
+                    out.add(d.name.text);
+            }
+        }
+    }
+    return out;
+}
+/**
+ * SQLCH003: a column written as `${events.kind}` instead of `${events.columns.kind}`.
+ *
+ * Columns are reached through `.columns`. `kind`, `lexicon`, `entityType`,
+ * `props`, `sqlName` and `dependsOn` are the entity's own fields, so
+ * `${events.kind}` is the string `"resource"`, which the tag splices in as SQL
+ * text: the statement builds and means something else. This rule flags it for
+ * an entity the file declares or imports from another project file.
+ */
+export const sqlch003 = {
+    id: "SQLCH003",
+    severity: "error",
+    category: "correctness",
+    description: "A column interpolated without .columns reads the entity's own field instead",
+    check(context) {
+        const source = context.sourceFile;
+        const found = findTemplates(source);
+        if (found.length === 0)
+            return [];
+        const entities = entityBindings(source, new Set(found.map((f) => f.node)));
+        const out = [];
+        for (const f of found) {
+            for (const expr of f.expressions) {
+                if (!ts.isPropertyAccessExpression(expr) || !ts.isIdentifier(expr.expression))
+                    continue;
+                const owner = expr.expression.text;
+                const member = expr.name.text;
+                if (!entities.has(owner) || !OWN_MEMBERS.has(member))
+                    continue;
+                const { line, character } = source.getLineAndCharacterOfPosition(expr.getStart(source));
+                out.push({
+                    ruleId: "SQLCH003",
+                    severity: "error",
+                    message: `\${${owner}.${member}} is the entity's own "${member}" field, not a column; write \${${owner}.columns.${member}}`,
+                    file: context.filePath,
+                    line: line + 1,
+                    column: character + 1,
+                });
+            }
+        }
+        return out;
+    },
+};

package/dist/lint/rules/sqlch004.js

@@ -0,0 +1,83 @@
+import { parseCreate, unquote } from "../../clickhouse/parser.js";
+import { isTrivia, SqlSyntaxError } from "../../clickhouse/tokens.js";
+import { findTemplates, tokensOf } from "./templates.js";
+import { declaredText, generatedNamesFor, nameAgrees, normalizedName, SQL_TYPES_FILE, typeArgumentName } from "./typed-names.js";
+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 = {
+    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) {
+        const source = context.sourceFile;
+        const out = [];
+        let listed = 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;
+            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/dist/lint/rules/sqlpg001.js

@@ -0,0 +1,68 @@
+import { parseStatements, SqlSyntaxError } from "../../postgres/parser.js";
+import { followOnStray, STATEMENT_NAMES, STATEMENTS_OF } from "../../postgres/entities.js";
+import { findPostgresTemplates, postgresTokensOf, templatePosition, tokenPosition } from "./postgres-templates.js";
+/** The tag that declares each statement. */
+const TAG_OF = Object.fromEntries(Object.entries(STATEMENTS_OF).flatMap(([tag, statements]) => statements.map((statement) => [statement, tag])));
+/**
+ * SQLPG001: the DDL in a Postgres template does not parse, or does not hold
+ * what its tag declares.
+ *
+ * The same parse runs when the build calls the tag, and fails the build there.
+ * This rule reports it in the editor and in `chant lint`, at the token, as a
+ * line and column of the `.ts` file, before anything is built. It also reports
+ * what the tag refuses after parsing: another statement than the tag's, a
+ * second CREATE in one template, and an index with no name (its name is its
+ * identity on the server). Interpolations are references here, since lint
+ * cannot know their values, so an error inside text a string interpolation
+ * supplies is left to the build.
+ */
+export const sqlpg001 = {
+    id: "SQLPG001",
+    severity: "error",
+    category: "correctness",
+    description: "Postgres DDL in a tagged template does not parse, or holds another statement than its tag",
+    check(context) {
+        const source = context.sourceFile;
+        const out = [];
+        const report = (message, at) => out.push({ ruleId: "SQLPG001", severity: "error", message, file: context.filePath, ...at });
+        for (const found of findPostgresTemplates(source)) {
+            const tokens = (() => {
+                try {
+                    return postgresTokensOf(found);
+                }
+                catch (err) {
+                    if (!(err instanceof SqlSyntaxError))
+                        throw err;
+                    report(`Postgres DDL does not parse: ${err.message}`, templatePosition(source, found, err.part, err.offset));
+                    return undefined;
+                }
+            })();
+            if (!tokens)
+                continue;
+            try {
+                const [node, ...rest] = parseStatements(tokens);
+                if (!STATEMENTS_OF[found.tag].includes(node.statement)) {
+                    const use = TAG_OF[node.statement];
+                    report(use
+                        ? `${found.tag}\`...\` holds a ${STATEMENT_NAMES[node.statement]}; use the ${use} tag`
+                        : `${found.tag}\`...\` starts with a ${STATEMENT_NAMES[node.statement]}; it goes after the CREATE it belongs to`, templatePosition(source, found, 0, 0));
+                    continue;
+                }
+                const stray = followOnStray(found.tag, rest);
+                if (stray) {
+                    report(`${found.tag}\`...\` holds a second statement (${STATEMENT_NAMES[stray.statement]}); a template declares one object, followed only by COMMENT ON statements for it${found.tag === "table" ? " and ALTER TABLE ... ROW LEVEL SECURITY" : ""}`, templatePosition(source, found, 0, 0));
+                }
+                if (node.statement === "index" && !node.name) {
+                    const on = tokens.find((t) => t.kind === "ident" && t.text.toUpperCase() === "ON");
+                    report("an index needs a name: the name is its identity on the server, and an unnamed index gets a generated one", on ? tokenPosition(source, found, on) : templatePosition(source, found, 0, 0));
+                }
+            }
+            catch (err) {
+                if (!(err instanceof SqlSyntaxError))
+                    throw err;
+                report(`Postgres DDL does not parse: ${err.message}`, err.token ? tokenPosition(source, found, err.token) : templatePosition(source, found, err.part, err.offset));
+            }
+        }
+        return out;
+    },
+};

package/dist/lint/rules/sqlpg002.js

@@ -0,0 +1,69 @@
+import { ts } from "@intentius/chant/lint/typescript";
+import { findPostgresTemplates as findTemplates } from "./postgres-templates.js";
+/** The entity's own members: an interpolation of one of them is never a column. */
+const OWN_MEMBERS = new Set(["kind", "lexicon", "entityType", "props", "sqlName", "dependsOn"]);
+/**
+ * Identifiers that hold a Postgres entity, as far as one file can tell:
+ * bound to a sql tag here, or imported from another file of the project.
+ */
+function entityBindings(source, tagged) {
+    const out = new Set();
+    for (const stmt of source.statements) {
+        if (ts.isImportDeclaration(stmt) && ts.isStringLiteral(stmt.moduleSpecifier) && stmt.moduleSpecifier.text.startsWith(".")) {
+            const named = stmt.importClause?.namedBindings;
+            if (named && ts.isNamedImports(named))
+                for (const el of named.elements)
+                    out.add(el.name.text);
+        }
+        if (ts.isVariableStatement(stmt)) {
+            for (const d of stmt.declarationList.declarations) {
+                if (ts.isIdentifier(d.name) && d.initializer && tagged.has(d.initializer))
+                    out.add(d.name.text);
+            }
+        }
+    }
+    return out;
+}
+/**
+ * SQLPG002: a column written as `${events.kind}` instead of `${events.columns.kind}`.
+ *
+ * Columns are reached through `.columns`. `kind`, `lexicon`, `entityType`,
+ * `props`, `sqlName` and `dependsOn` are the entity's own fields, so
+ * `${events.kind}` is the string `"resource"`, which the tag splices in as SQL
+ * text: the statement builds and means something else. This rule flags it for
+ * an entity the file declares or imports from another project file.
+ */
+export const sqlpg002 = {
+    id: "SQLPG002",
+    severity: "error",
+    category: "correctness",
+    description: "A column interpolated without .columns reads the entity's own field instead",
+    check(context) {
+        const source = context.sourceFile;
+        const found = findTemplates(source);
+        if (found.length === 0)
+            return [];
+        const entities = entityBindings(source, new Set(found.map((f) => f.node)));
+        const out = [];
+        for (const f of found) {
+            for (const expr of f.expressions) {
+                if (!ts.isPropertyAccessExpression(expr) || !ts.isIdentifier(expr.expression))
+                    continue;
+                const owner = expr.expression.text;
+                const member = expr.name.text;
+                if (!entities.has(owner) || !OWN_MEMBERS.has(member))
+                    continue;
+                const { line, character } = source.getLineAndCharacterOfPosition(expr.getStart(source));
+                out.push({
+                    ruleId: "SQLPG002",
+                    severity: "error",
+                    message: `\${${owner}.${member}} is the entity's own "${member}" field, not a column; write \${${owner}.columns.${member}}`,
+                    file: context.filePath,
+                    line: line + 1,
+                    column: character + 1,
+                });
+            }
+        }
+        return out;
+    },
+};

package/dist/lint/rules/sqlpg003.js

@@ -0,0 +1,58 @@
+import { isTrivia, SqlSyntaxError } from "../../postgres/tokens.js";
+import { findPostgresTemplates, postgresTokensOf, tokenPosition } from "./postgres-templates.js";
+const REGCLASS_FUNCTIONS = ["NEXTVAL", "CURRVAL", "SETVAL"];
+/**
+ * SQLPG003: an object named in a string where Postgres reads a `regclass`:
+ * `nextval('app.ticket_seq')`, `currval(...)`, `setval(...)`, or
+ * `'app.ticket_seq'::regclass`.
+ *
+ * A name inside a string is text to the build, so it records no reference:
+ * the table does not depend on the sequence, the creation order can put the
+ * table first, and the create fails. Interpolating the object instead,
+ * `nextval(${ticketSeq})`, renders the same `regclass` literal the catalog
+ * prints (`nextval('app.ticket_seq'::regclass)`) and keeps the edge. A
+ * sequence another tool owns is the exception, which is why this is a
+ * warning.
+ */
+export const sqlpg003 = {
+    id: "SQLPG003",
+    severity: "warning",
+    category: "correctness",
+    description: "A sequence or relation named in a regclass string makes no reference; interpolate the object",
+    check(context) {
+        const source = context.sourceFile;
+        const out = [];
+        for (const found of findPostgresTemplates(source)) {
+            let tokens;
+            try {
+                tokens = postgresTokensOf(found);
+            }
+            catch (err) {
+                if (err instanceof SqlSyntaxError)
+                    continue;
+                throw err;
+            }
+            const sig = tokens.filter((t) => !isTrivia(t));
+            sig.forEach((t, k) => {
+                if (t.kind !== "string" || !t.text.startsWith("'"))
+                    return;
+                const prev = sig[k - 1];
+                const fn = sig[k - 2];
+                const inCall = prev?.kind === "punct" && prev.text === "(" && fn?.kind === "ident" && REGCLASS_FUNCTIONS.includes(fn.text.toUpperCase());
+                const cast = sig[k + 1]?.kind === "op" && sig[k + 1].text === "::" && sig[k + 2]?.kind === "ident" && sig[k + 2].text.toLowerCase() === "regclass";
+                if (!inCall && !cast)
+                    return;
+                const named = t.text.slice(1, -1).replace(/''/g, "'");
+                const how = inCall ? `${fn.text}(\${...})` : "${...}::regclass";
+                out.push({
+                    ruleId: "SQLPG003",
+                    severity: "warning",
+                    message: `'${named}' names an object in a string, which records no reference, so the build can create this object before it; interpolate the declared object instead: ${how}`,
+                    file: context.filePath,
+                    ...tokenPosition(source, found, t),
+                });
+            });
+        }
+        return out;
+    },
+};

package/dist/lint/rules/sqlpg004.js

@@ -0,0 +1,77 @@
+import { isTrivia, SqlSyntaxError } from "../../postgres/tokens.js";
+import { isPostgresProvider, providerAllowsExtension, providerData } from "../../postgres/providers/index.js";
+import { findPostgresTemplates, postgresTokensOf, tokenPosition } from "./postgres-templates.js";
+/**
+ * The provider a lint run is for: `sql.provider`, else the one provider every
+ * profile that names one agrees on. No answer (self-hosted, or profiles that
+ * disagree) leaves the rule silent. The lint engine passes the whole project
+ * config as `projectConfig`.
+ */
+export function providerFromConfig(config) {
+    const sql = config?.sql;
+    if (!sql)
+        return undefined;
+    if (isPostgresProvider(sql.provider))
+        return sql.provider;
+    const named = new Set(Object.values(sql.profiles ?? {}).map((p) => p.provider).filter(isPostgresProvider));
+    return named.size === 1 ? [...named][0] : undefined;
+}
+const unquote = (t) => (t.kind === "qident" ? t.text.slice(1, -1).replace(/""/g, '"') : t.text.toLowerCase());
+/**
+ * SQLPG004: a declared extension the configured provider does not allow.
+ *
+ * `extension\`CREATE EXTENSION pg_stat_monitor\`` builds, and fails when
+ * applied to a provider whose list lacks it. The lists are the providers'
+ * documentation snapshots (see postgres/providers/types.ts), so a provider
+ * that added an extension since reports it here until the list is refreshed;
+ * disable the rule for that line. When a provider's list is partial, a name
+ * outside it is not reported.
+ */
+export const sqlpg004 = {
+    id: "SQLPG004",
+    severity: "error",
+    category: "correctness",
+    description: "A declared extension the configured Postgres provider does not allow",
+    check(context) {
+        const provider = providerFromConfig(context.projectConfig);
+        if (!provider)
+            return [];
+        const label = providerData(provider).label;
+        const source = context.sourceFile;
+        const out = [];
+        for (const found of findPostgresTemplates(source)) {
+            if (found.tag !== "extension")
+                continue;
+            let tokens;
+            try {
+                tokens = postgresTokensOf(found);
+            }
+            catch (err) {
+                if (err instanceof SqlSyntaxError)
+                    continue;
+                throw err;
+            }
+            const sig = tokens.filter((t) => !isTrivia(t));
+            const word = (k) => (sig[k]?.kind === "ident" ? sig[k].text.toUpperCase() : "");
+            if (word(0) !== "CREATE" || word(1) !== "EXTENSION")
+                continue;
+            let k = 2;
+            if (word(k) === "IF" && word(k + 1) === "NOT" && word(k + 2) === "EXISTS")
+                k += 3;
+            const nameToken = sig[k];
+            if (!nameToken || (nameToken.kind !== "ident" && nameToken.kind !== "qident"))
+                continue;
+            const name = unquote(nameToken);
+            if (providerAllowsExtension(provider, name) !== false)
+                continue;
+            out.push({
+                ruleId: "SQLPG004",
+                severity: "error",
+                message: `${label} does not allow the extension "${name}"; CREATE EXTENSION would fail there. Use an extension it lists, or change sql.provider`,
+                file: context.filePath,
+                ...tokenPosition(source, found, nameToken),
+            });
+        }
+        return out;
+    },
+};