@intentius/chant-lexicon-sql 0.124.31 → 0.124.33

package/dist/lint/rules/sqlpg005.js

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

package/dist/lint/rules/templates.js

@@ -0,0 +1,25 @@
+/**
+ * Finding the ClickHouse tags in a source file, for the source-level rules
+ * (and the editor). A rule reads the template's raw parts straight from the
+ * TypeScript AST and parses them the way the tag does, with every
+ * interpolation left a reference: lint cannot know the values. The finder is
+ * the shared core's (`../../core/find-templates.ts`); a tag is ClickHouse's
+ * because of the module it is imported from.
+ */
+import { tokenize } from "../../clickhouse/tokens.js";
+import { findSqlTemplates } from "../../core/find-templates.js";
+export { templatePosition, tokenPosition } from "../../core/find-templates.js";
+/**
+ * The ClickHouse tags, by the modules they are imported from. The package
+ * root still exports them, so it counts as ClickHouse too.
+ */
+export const CLICKHOUSE_TEMPLATE_SOURCE = {
+    dialect: "clickhouse",
+    modules: ["@intentius/chant-lexicon-sql", "@intentius/chant-lexicon-sql/clickhouse"],
+    tags: ["database", "table", "view", "dictionary", "func", "user", "role", "policy", "quota", "settingsProfile", "grant"],
+};
+/** Every ClickHouse template in the file (the shared core's finder). */
+export function findTemplates(source) {
+    return findSqlTemplates(source, [CLICKHOUSE_TEMPLATE_SOURCE]);
+}
+export const tokensOf = (found) => tokenize(found.parts);

package/dist/lint/rules/typed-names.js

@@ -0,0 +1,132 @@
+/**
+ * What the typed-column rules (SQLPG005, SQLCH004; chant #3751) share: reading
+ * a tag's type argument, comparing it with the name the template declares, and
+ * reading the names the generated `sql-types.d.ts` lists.
+ *
+ * The type argument is `table<"shop.orders">\`CREATE TABLE ...\``. tsc checks
+ * that it names an entry of the generated file's `SqlSchema` only when the
+ * argument is a constraint, and an unlisted name falls back to unchecked
+ * columns, so a mistyped argument is silent without these rules.
+ */
+import { existsSync, readFileSync } from "node:fs";
+import { dirname, join, resolve } from "node:path";
+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";
+/** A tag's type argument, when it is a string literal: `table<"shop.orders">`. */
+export function typeArgumentName(node) {
+    const arg = node.typeArguments?.[0];
+    if (!arg || node.typeArguments.length !== 1)
+        return undefined;
+    if (!ts.isLiteralTypeNode(arg) || !ts.isStringLiteral(arg.literal))
+        return undefined;
+    return { name: arg.literal.text, node: arg };
+}
+/** Split a dotted name outside quotes and take the quotes off: `shop."Order Items"` is `shop`, `Order Items`. */
+export function splitQualified(name) {
+    const pieces = [];
+    let cur = "";
+    let quote;
+    for (let i = 0; i < name.length; i++) {
+        const c = name[i];
+        if (quote) {
+            if (c === quote && name[i + 1] === quote) {
+                cur += c;
+                i++;
+            }
+            else if (c === quote)
+                quote = undefined;
+            else
+                cur += c;
+        }
+        else if (c === '"' || c === "`")
+            quote = c;
+        else if (c === ".") {
+            pieces.push(cur);
+            cur = "";
+        }
+        else
+            cur += c;
+    }
+    pieces.push(cur);
+    return pieces;
+}
+/**
+ * Whether the declared name (an empty piece is an interpolation, which lint
+ * cannot read) can be the type argument's. Compared from the last piece back.
+ * A template that does not qualify its name takes the argument's schema, since
+ * the build qualifies it with the schema or database the project sets; one
+ * that does qualify it must agree with the argument.
+ */
+export function nameAgrees(declared, argument) {
+    const given = splitQualified(argument);
+    if (declared.length === 0)
+        return true;
+    if (declared.length > given.length)
+        return false;
+    for (let i = 1; i <= declared.length; i++) {
+        const d = declared[declared.length - i];
+        if (d === "")
+            continue;
+        if (d !== given[given.length - i])
+            return false;
+    }
+    return true;
+}
+/** The text of a declared name for a message; an interpolation is `${...}`. */
+export const declaredText = (declared) => declared.map((p) => (p === "" ? "${...}" : p)).join(".");
+/** A qualified name with quoting taken off, so `"shop"."orders"` and `shop.orders` compare equal. */
+export const normalizedName = (name) => splitQualified(name).join("\0");
+/** The names (normalized, see {@link normalizedName}) a `declare module "<module>"` block in a generated file augments `SqlSchema` with. */
+export function namesInGenerated(content, module) {
+    const source = ts.createSourceFile(SQL_TYPES_FILE, content, ts.ScriptTarget.Latest, true);
+    let names;
+    for (const stmt of source.statements) {
+        if (!ts.isModuleDeclaration(stmt) || !ts.isStringLiteral(stmt.name) || stmt.name.text !== module)
+            continue;
+        if (!stmt.body || !ts.isModuleBlock(stmt.body))
+            continue;
+        for (const inner of stmt.body.statements) {
+            if (!ts.isInterfaceDeclaration(inner) || inner.name.text !== "SqlSchema")
+                continue;
+            names ?? (names = new Set());
+            for (const member of inner.members) {
+                const n = member.name;
+                if (n && (ts.isStringLiteral(n) || ts.isIdentifier(n)))
+                    names.add(normalizedName(n.text));
+            }
+        }
+    }
+    return names;
+}
+/**
+ * The generated file nearest above a source file, up to the directory that
+ * holds the project's config. `chant sql types` writes it in `sourceDir` (or
+ * the project root), so the walk finds it from any file below.
+ */
+export function findGeneratedFile(filePath) {
+    let dir = dirname(resolve(filePath));
+    for (;;) {
+        const candidate = join(dir, SQL_TYPES_FILE);
+        if (existsSync(candidate))
+            return candidate;
+        if (existsSync(join(dir, "chant.config.ts")) || existsSync(join(dir, "chant.config.json")))
+            return undefined;
+        const up = dirname(dir);
+        if (up === dir)
+            return undefined;
+        dir = up;
+    }
+}
+/** The names the generated file lists for a dialect's module, or undefined when there is no file or it has no such block. */
+export function generatedNamesFor(filePath, module) {
+    const found = findGeneratedFile(filePath);
+    if (!found)
+        return undefined;
+    try {
+        return namesInGenerated(readFileSync(found, "utf8"), module);
+    }
+    catch {
+        return undefined;
+    }
+}

package/dist/live-dialect.js

@@ -0,0 +1,32 @@
+/**
+ * Which dialect a live read is for. A build holds one dialect, so a read of
+ * declared entities follows their types; a read with nothing declared (import)
+ * follows the binding: the environment's profile URL (`postgres://` is
+ * Postgres), else `sql.dialect`, else whichever of `POSTGRES_URL` and
+ * `CLICKHOUSE_URL` is set, else ClickHouse, the first dialect.
+ */
+import { isPostgresUrl, loadSqlConfig } from "./postgres/live/bind.js";
+export function dialectOfEntities(entities) {
+    for (const e of entities?.values() ?? [])
+        if (e.entityType.startsWith("Postgres::"))
+            return "postgres";
+    return "clickhouse";
+}
+export function dialectOfBinding(input) {
+    const env = input.env ?? process.env;
+    const profile = input.environment !== undefined ? input.config?.sql?.profiles?.[input.environment] : undefined;
+    if (profile)
+        return isPostgresUrl(profile.url) ? "postgres" : "clickhouse";
+    const configured = input.config?.sql?.dialect;
+    const named = Array.isArray(configured) ? (configured.length === 1 ? configured[0] : undefined) : configured;
+    if (named)
+        return named;
+    if (env.POSTGRES_URL && !env.CLICKHOUSE_URL)
+        return "postgres";
+    return "clickhouse";
+}
+/** The binding's dialect, loading the project config from `cwd` when none is passed. */
+export async function resolveBindingDialect(options) {
+    const config = options.config ?? (await loadSqlConfig(options.cwd ?? process.cwd()));
+    return dialectOfBinding({ environment: options.environment, config, env: options.env });
+}

package/dist/lsp/catalog.js

@@ -0,0 +1,44 @@
+/**
+ * The ClickHouse catalog the editor and the MCP tools read: the committed
+ * snapshot of the pinned server's `system.*` tables, parsed once and indexed
+ * by name. No server is needed; the snapshot is what generation reads too.
+ */
+import { readFileSync } from "fs";
+import { join } from "path";
+import { moduleSourceDir } from "@intentius/chant/module-source";
+import { parseCatalog } from "../spec/catalog.js";
+const SNAPSHOT = join(moduleSourceDir(import.meta.url), "..", "spec", "clickhouse-catalog.snapshot.json");
+let cached = null;
+const byName = (rows, foldCase) => {
+    const map = new Map();
+    for (const row of rows) {
+        map.set(row.name, row);
+        if (foldCase?.(row))
+            map.set(row.name.toLowerCase(), row);
+    }
+    return map;
+};
+/** The catalog, or undefined when the snapshot cannot be read. */
+export function catalogIndex() {
+    if (cached)
+        return cached;
+    try {
+        const catalog = parseCatalog(readFileSync(SNAPSHOT, "utf-8"));
+        cached = {
+            catalog,
+            engines: byName(catalog.tableEngines),
+            databaseEngines: byName(catalog.databaseEngines),
+            types: byName(catalog.typeFamilies, (t) => t.caseInsensitive),
+            codecs: byName(catalog.codecs),
+            indexTypes: byName(catalog.skipIndexTypes),
+            mergeTreeSettings: byName(catalog.mergeTreeSettings),
+            querySettings: byName(catalog.querySettings),
+            functions: byName(catalog.functions, (f) => f.caseInsensitive),
+            formats: byName(catalog.formats),
+        };
+        return cached;
+    }
+    catch {
+        return undefined;
+    }
+}

package/dist/lsp/completions.js

@@ -0,0 +1,136 @@
+import { ts } from "@intentius/chant/lint/typescript";
+import { lexiconCompletions } from "@intentius/chant/lsp/lexicon-providers";
+import { catalogIndex } from "./catalog.js";
+import { postgresCompletions } from "./postgres.js";
+import { registryIndex } from "./registry.js";
+import { declarations, expectAfter, locate, offsetAt, tokensBefore, wordAround } from "./template.js";
+const LIMIT = 200;
+/**
+ * Completions for the sql lexicon.
+ *
+ * Inside a `table`, `view` or `database` template they come from the catalog of
+ * the pinned ClickHouse server: engines after `ENGINE =`, type families where a
+ * column's type goes, codecs inside `CODEC(...)`, skip index types after `TYPE`,
+ * settings after `SETTINGS`, functions in expressions. Inside `${` they are the
+ * tables and views declared in the file and their columns. Anywhere else, the
+ * entity classes from the generated registry.
+ */
+export function completions(ctx) {
+    const pg = postgresCompletions(ctx);
+    if (pg)
+        return pg;
+    const refs = interpolationCompletions(ctx);
+    if (refs)
+        return refs;
+    const at = offsetAt(ctx.content, ctx.position);
+    const where = locate(ctx.content, at, fileName(ctx.uri));
+    if (where && where.part >= 0) {
+        const index = catalogIndex();
+        if (!index)
+            return [];
+        const text = where.found.parts[where.part];
+        const word = wordAround(text, where.offset);
+        const sig = tokensBefore(where.found, where.part, word.start);
+        if (!sig)
+            return [];
+        const expect = expectAfter(sig, where.found.tag);
+        if (!expect)
+            return [];
+        const prefix = text.slice(word.start, where.offset);
+        return fromCatalog(index, expect, where.found.tag, prefix);
+    }
+    if (where)
+        return [];
+    return lexiconCompletions(ctx, registryIndex(), "sql entity");
+}
+const fileName = (uri) => (uri.startsWith("file://") ? decodeURIComponent(uri.slice(7)) : uri) || "file.ts";
+const matches = (name, prefix, fold) => prefix === "" || (fold ? name.toLowerCase().startsWith(prefix.toLowerCase()) : name.startsWith(prefix));
+function fromCatalog(index, expect, tag, prefix) {
+    const items = [];
+    const add = (item) => {
+        if (items.length < LIMIT)
+            items.push(item);
+    };
+    const { catalog } = index;
+    switch (expect) {
+        case "engine":
+            if (tag === "database") {
+                for (const e of catalog.databaseEngines)
+                    if (matches(e.name, prefix, true))
+                        add({ label: e.name, kind: "value", detail: e.syntax, documentation: e.summary });
+            }
+            else {
+                for (const e of catalog.tableEngines)
+                    if (matches(e.name, prefix, true))
+                        add({ label: e.name, kind: "value", detail: e.syntax, documentation: e.summary });
+            }
+            break;
+        case "type":
+            for (const t of catalog.typeFamilies)
+                if (matches(t.name, prefix, t.caseInsensitive))
+                    add({ label: t.name, kind: "value", detail: t.aliasOf ? `alias of ${t.aliasOf}` : "type family" });
+            break;
+        case "codec":
+            for (const c of catalog.codecs)
+                if (matches(c.name, prefix, true))
+                    add({ label: c.name, kind: "value", detail: codecKind(c), documentation: c.summary });
+            break;
+        case "index-type":
+            for (const i of catalog.skipIndexTypes)
+                if (matches(i.name, prefix, false))
+                    add({ label: i.name, kind: "value", detail: i.syntax, documentation: i.summary });
+            break;
+        case "merge-tree-setting":
+        case "query-setting": {
+            const rows = expect === "merge-tree-setting" ? catalog.mergeTreeSettings : catalog.querySettings;
+            for (const s of rows) {
+                if (s.obsolete || !matches(s.name, prefix, false))
+                    continue;
+                add({ label: s.name, insertText: `${s.name} = `, kind: "property", detail: `${s.type}, default ${s.default || "''"}`, documentation: s.summary });
+            }
+            break;
+        }
+        case "function":
+            if (prefix === "")
+                break;
+            for (const f of catalog.functions)
+                if (!f.aliasOf && matches(f.name, prefix, f.caseInsensitive))
+                    add({ label: f.name, kind: "intrinsic", detail: f.aggregate ? "aggregate function" : "function" });
+            break;
+    }
+    return items;
+}
+function codecKind(c) {
+    return c.encryption ? "encryption codec" : c.timeseries ? "time series codec" : c.compression ? "compression codec" : "codec";
+}
+/** `${` offers the file's tables and views; `${t.` offers `columns`; `${t.columns.` offers its columns. */
+function interpolationCompletions(ctx) {
+    const before = ctx.content.slice(0, offsetAt(ctx.content, ctx.position));
+    if (!before.includes("chant-lexicon-sql") && !ctx.content.includes("chant-lexicon-sql"))
+        return undefined;
+    const m = /\$\{\s*(?:([A-Za-z_$][\w$]*)\.(columns\.)?)?[\w$]*$/.exec(ctx.linePrefix);
+    if (!m)
+        return undefined;
+    // Inside a template: an odd number of backticks before the cursor.
+    if ((before.match(/`/g)?.length ?? 0) % 2 === 0)
+        return undefined;
+    // The template being written is not something it can refer to.
+    const self = locate(ctx.content, offsetAt(ctx.content, ctx.position), fileName(ctx.uri))?.found.node.parent;
+    const selfName = self && ts.isVariableDeclaration(self) && ts.isIdentifier(self.name) ? self.name.text : undefined;
+    const declared = declarations(ctx.content, fileName(ctx.uri)).filter((d) => d.name !== selfName);
+    const [, owner, columns] = m;
+    if (!owner) {
+        return declared.map((d) => ({
+            label: d.name,
+            kind: "resource",
+            detail: `${d.materialized ? "materialized view" : d.tag} ${d.sqlName}`,
+            documentation: d.columns.length ? `Columns: ${d.columns.map((c) => c.name).join(", ")}` : undefined,
+        }));
+    }
+    const entity = declared.find((d) => d.name === owner);
+    if (!entity)
+        return [];
+    if (!columns)
+        return entity.columns.length ? [{ label: "columns", kind: "property", detail: `columns of ${entity.sqlName}` }] : [];
+    return entity.columns.map((c) => ({ label: c.name, kind: "property", detail: c.type ?? "column" }));
+}

package/dist/lsp/hover.js

@@ -0,0 +1,115 @@
+import { lexiconHover } from "@intentius/chant/lsp/lexicon-providers";
+import { catalogIndex } from "./catalog.js";
+import { postgresHover } from "./postgres.js";
+import { registryIndex } from "./registry.js";
+import { resolveReference } from "./refs.js";
+import { expectAfter, locate, offsetAt, tokensBefore, wordAround } from "./template.js";
+/**
+ * Hover for the sql lexicon.
+ *
+ * Inside a template, a word is looked up in the catalog where the SQL before it
+ * says what kind of word it is (an engine after `ENGINE =`, a type where a type
+ * goes, a setting after `SETTINGS`), and a function when it is followed by `(`.
+ * A `${ref}` shows the table, view or column it points at, with its type.
+ * Anywhere else, the entity classes from the generated registry.
+ */
+export function hover(ctx) {
+    const pg = postgresHover(ctx);
+    if (pg.handled)
+        return pg.info;
+    const at = offsetAt(ctx.content, ctx.position);
+    const where = locate(ctx.content, at, fileName(ctx.uri));
+    if (where) {
+        if (where.part < 0)
+            return where.expression < 0 ? undefined : reference(ctx, where.expression, where);
+        return catalogHover(where);
+    }
+    return lexiconHover(ctx, registryIndex(), entityHover);
+}
+const fileName = (uri) => (uri.startsWith("file://") ? decodeURIComponent(uri.slice(7)) : uri) || "file.ts";
+function entityHover(className, entry) {
+    const [dialect] = entry.resourceType.split("::");
+    return { contents: `**${className}**\n\n${dialect} type: \`${entry.resourceType}\`` };
+}
+function reference(ctx, expression, where) {
+    const expr = where.found.expressions[expression];
+    const info = resolveReference(ctx.content, expr.getText(where.source), fileName(ctx.uri));
+    return info ? { contents: info } : undefined;
+}
+function catalogHover(where) {
+    const index = catalogIndex();
+    if (!index)
+        return undefined;
+    const text = where.found.parts[where.part];
+    const word = wordAround(text, where.offset);
+    const name = text.slice(word.start, word.end);
+    if (!name)
+        return undefined;
+    const sig = tokensBefore(where.found, where.part, word.start);
+    if (!sig)
+        return undefined;
+    const expect = expectAfter(sig, where.found.tag);
+    const followedByParen = /^\s*\(/.test(text.slice(word.end));
+    const code = (s) => `\`${s}\``;
+    let contents;
+    const function_ = () => {
+        const f = index.functions.get(name) ?? index.functions.get(name.toLowerCase());
+        if (!f || !followedByParen)
+            return undefined;
+        const alias = f.aliasOf ? `\n\nAlias of ${code(f.aliasOf)}.` : "";
+        return `**${f.name}**: ${f.aggregate ? "aggregate function" : "function"}${f.caseInsensitive ? ", case-insensitive" : ""}${alias}`;
+    };
+    switch (expect) {
+        case "engine": {
+            const e = where.found.tag === "database" ? index.databaseEngines.get(name) : index.engines.get(name);
+            if (e) {
+                const caps = where.found.tag === "database" ? [] : Object.entries(index.engines.get(name).capabilities).filter(([, on]) => on).map(([k]) => k);
+                contents = `**${e.name}** engine\n\n${code(e.syntax)}\n\n${e.summary}${caps.length ? `\n\nSupports: ${caps.join(", ")}.` : ""}`;
+            }
+            break;
+        }
+        case "type": {
+            const t = index.types.get(name) ?? index.types.get(name.toLowerCase());
+            if (t) {
+                contents = `**${t.name}**: ClickHouse type family${t.aliasOf ? `, alias of ${code(t.aliasOf)}` : ""}${t.caseInsensitive ? ", case-insensitive" : ""}`;
+            }
+            break;
+        }
+        case "codec": {
+            const c = index.codecs.get(name);
+            if (c)
+                contents = `**${c.name}** codec${c.experimental ? " (experimental)" : ""}\n\n${c.summary}`;
+            break;
+        }
+        case "index-type": {
+            const i = index.indexTypes.get(name);
+            if (i)
+                contents = `**${i.name}** skip index\n\n${code(i.syntax)}\n\n${i.summary}`;
+            break;
+        }
+        case "merge-tree-setting":
+        case "query-setting":
+            contents = settingHover(index, name, expect === "merge-tree-setting");
+            break;
+        case "function":
+            contents = function_();
+            break;
+    }
+    // A later setting in a list follows its value, not a comma-or-SETTINGS: look it up by name when it is followed by `=`.
+    if (!contents && /^\s*=(?!=)/.test(text.slice(word.end)))
+        contents = settingHover(index, name, where.found.tag !== "view");
+    if (!contents)
+        contents = function_();
+    return contents ? { contents } : undefined;
+}
+function settingHover(index, name, mergeTreeFirst) {
+    const row = mergeTreeFirst
+        ? (index.mergeTreeSettings.get(name) ?? index.querySettings.get(name))
+        : (index.querySettings.get(name) ?? index.mergeTreeSettings.get(name));
+    if (!row)
+        return undefined;
+    const scope = index.mergeTreeSettings.get(name) === row ? "MergeTree setting" : "query setting";
+    const range = row.min !== undefined || row.max !== undefined ? `, range ${row.min ?? ""}..${row.max ?? ""}` : "";
+    const flags = [row.obsolete ? "obsolete" : "", row.readonly ? "read-only" : "", row.tier !== "Production" ? row.tier.toLowerCase() : ""].filter(Boolean);
+    return `**${row.name}**: ${scope}\n\nType \`${row.type}\`, default \`${row.default || "''"}\`${range}${flags.length ? ` (${flags.join(", ")})` : ""}\n\n${row.summary}`;
+}