@intentius/chant-lexicon-sql 0.124.30 → 0.124.32

package/dist/clickhouse/entities.js

@@ -0,0 +1,593 @@
+/**
+ * The ClickHouse entities: `database`, `table`, `view`, `dictionary` and
+ * `func` (#3682) tagged templates that parse their DDL at fold time into one
+ * Declarable each (chant #3196, #3197).
+ *
+ * ```ts
+ * import { table, view } from "@intentius/chant-lexicon-sql/clickhouse";
+ *
+ * export const events = table`
+ *   CREATE TABLE events (user_id UUID, kind LowCardinality(String), ts DateTime)
+ *   ENGINE = MergeTree ORDER BY (user_id, ts)`;
+ *
+ * export const activeUsers = view`
+ *   CREATE MATERIALIZED VIEW active_users
+ *   ENGINE = AggregatingMergeTree ORDER BY ${events.columns.user_id} AS
+ *   SELECT ${events.columns.user_id}, count() AS n FROM ${events} GROUP BY ${events.columns.user_id}`;
+ * ```
+ *
+ * The export name is the object's identity in chant; the name in the SQL is the
+ * object's name in the database.
+ *
+ * What an interpolation means is decided by its value:
+ *
+ * - a `table`, `view` or `database` entity is a reference to that object, and
+ *   renders as its (database-qualified) name;
+ * - `entity.columns.<name>` is a reference to one column, and renders as the
+ *   column's name;
+ * - a string is SQL text, spliced into the statement before it is parsed, so a
+ *   composite can supply a name, a type, an engine or an expression;
+ * - a number or bigint is a numeric literal, a boolean `true`/`false`, `null`
+ *   is `NULL`;
+ * - `literal(value)` is a quoted, escaped string literal, for the case where a
+ *   string is meant as a value (`DEFAULT ${literal(plan)}`).
+ *
+ * Anything else, `undefined` included, is refused with the position it was
+ * interpolated at. `${events.user_id}` is `undefined` (columns are reached
+ * through `.columns`), and the refusal says so.
+ */
+import { setInterpolationFields } from "@intentius/chant/provenance";
+import { CLICKHOUSE_LEXICAL, isTrivia, SqlSyntaxError, untokenize } from "./tokens.js";
+import { parseCreate, unquote } from "./parser.js";
+import { parseAccess } from "./access.js";
+import { feed, lineage, spanText as text, splice as spliceWith, templateSyntaxError, unparsedClauses } from "../core/interpolation.js";
+import { SqlObject, isColumnRefOf, isSqlObjectOf, makeSqlEntity } from "../core/entity.js";
+import { SqlLiteral, SqlTemplateError, describeValue as describe, stripUnset as strip, templateParts } from "../core/template.js";
+import { setTypedSlots } from "../core/typed.js";
+export { SQL_LEXICON } from "../core/entity.js";
+export { SqlLiteral, SqlTemplateError, templateParts, unescapeTemplateDelimiters } from "../core/template.js";
+export const CLICKHOUSE_ENTITY_TYPES = {
+    database: "ClickHouse::Database",
+    table: "ClickHouse::Table",
+    view: "ClickHouse::View",
+    materializedView: "ClickHouse::MaterializedView",
+    dictionary: "ClickHouse::Dictionary",
+    function: "ClickHouse::Function",
+    user: "ClickHouse::User",
+    role: "ClickHouse::Role",
+    rowPolicy: "ClickHouse::RowPolicy",
+    grant: "ClickHouse::Grant",
+    quota: "ClickHouse::Quota",
+    settingsProfile: "ClickHouse::SettingsProfile",
+};
+/**
+ * A string as a quoted, escaped ClickHouse string literal. An interpolated
+ * plain string is SQL text; wrap it in `literal()` when it is a value.
+ */
+export function literal(value) {
+    if (value === null)
+        return new SqlLiteral("NULL");
+    if (typeof value !== "string")
+        return new SqlLiteral(String(value));
+    return new SqlLiteral(`'${value.replace(/\\/g, "\\\\").replace(/'/g, "\\'")}'`);
+}
+// ── Entities ───────────────────────────────────────────────────────────
+/** The members a ClickHouse entity has besides its props (the shared core's {@link SqlObject}). */
+export class ClickHouseObject extends SqlObject {
+}
+function makeEntity(entityType, sqlName, props, columnNames, dependsOn) {
+    return makeSqlEntity(ClickHouseObject.prototype, entityType, sqlName, props, columnNames, dependsOn);
+}
+export function isClickHouseObject(value) {
+    return isSqlObjectOf(value, "ClickHouse::");
+}
+/** A column reference: an AttrRef whose parent is a ClickHouse table or view. */
+export function isColumnRef(value) {
+    return isColumnRefOf(value, isClickHouseObject);
+}
+// ── Rendering interpolations ───────────────────────────────────────────
+/** A name as ClickHouse reads it: bare when it is a plain identifier, backquoted otherwise. */
+export function quoteIdentifier(name) {
+    return /^[A-Za-z_][A-Za-z0-9_]*$/.test(name) ? name : `\`${name.replace(/`/g, "``")}\``;
+}
+function renderReference(value) {
+    if (isClickHouseObject(value))
+        return value.sqlName;
+    if (isColumnRef(value))
+        return quoteIdentifier(value.attribute);
+    throw new TypeError(`not a reference: ${describe(value)}`);
+}
+// ── Building ───────────────────────────────────────────────────────────
+/** ClickHouse as the shared template machinery reads it (`../core/interpolation.ts`). */
+export const CLICKHOUSE_TEMPLATES = {
+    lexical: CLICKHOUSE_LEXICAL,
+    isObject: isClickHouseObject,
+    isColumnRef,
+    renderReference,
+    identValue: unquote,
+    unnamedOutput: (n) => `_${n}`,
+};
+/** The tag's splice: plain values become SQL text, references stay `ref` tokens. */
+const splice = (tag, parts, values) => spliceWith(CLICKHOUSE_TEMPLATES, tag, parts, values);
+const req = (s) => s ?? "";
+/** A `'quoted'` string literal's value. */
+function stringValue(s) {
+    if (s === undefined)
+        return undefined;
+    if (!/^'.*'$/s.test(s))
+        return s;
+    return s.slice(1, -1).replace(/''/g, "'").replace(/\\(.)/g, "$1");
+}
+function columnDef(ctx, c) {
+    for (const span of [c.nameSpan, c.type, c.default?.expr, c.codec, c.ttl, c.comment, c.statistics, c.settings])
+        feed(ctx, span, "columns");
+    const def = { name: c.name || req(text(ctx, c.nameSpan)) };
+    const set = (k, v) => {
+        if (v !== undefined)
+            def[k] = v;
+    };
+    set("type", text(ctx, c.type));
+    set("nullable", c.nullable);
+    if (c.default) {
+        const expr = text(ctx, c.default.expr);
+        def.default = expr === undefined ? { kind: c.default.kind } : { kind: c.default.kind, expr };
+    }
+    set("codec", text(ctx, c.codec));
+    set("ttl", text(ctx, c.ttl));
+    set("comment", stringValue(text(ctx, c.comment)));
+    set("statistics", text(ctx, c.statistics));
+    set("settings", text(ctx, c.settings));
+    return def;
+}
+function storageProps(ctx, node) {
+    const out = {};
+    if (node.engine) {
+        feed(ctx, node.engine.nameSpan, "engine.name");
+        const name = node.engine.name || req(text(ctx, node.engine.nameSpan));
+        out.engine = node.engine.args ? { name, args: node.engine.args.map((a) => req(text(ctx, a, "engine.args"))) } : { name };
+    }
+    const put = (k, span) => {
+        const v = text(ctx, span, k);
+        if (v !== undefined)
+            out[k] = v;
+    };
+    put("orderBy", node.orderBy);
+    put("primaryKey", node.primaryKey);
+    put("partitionBy", node.partitionBy);
+    put("sampleBy", node.sampleBy);
+    put("ttl", node.ttl);
+    feed(ctx, node.settingsClause, "settings");
+    if (node.settings)
+        out.settings = Object.fromEntries(node.settings.map((s) => [s.key, req(text(ctx, s.value, "settings"))]));
+    return out;
+}
+/** `name` or `db.name` from a qualified-name span; an interpolated database entity names the database. */
+function qualified(ctx, span) {
+    const sig = ctx.tokens.slice(span.from, span.to).filter((t) => !isTrivia(t));
+    const pieces = [];
+    const splices = [];
+    for (const t of sig) {
+        if (t.kind === "punct" && t.text === ".")
+            continue;
+        if (t.kind === "ref") {
+            const v = ctx.values[t.part];
+            const refPieces = isClickHouseObject(v) && v.entityType === CLICKHOUSE_ENTITY_TYPES.database
+                ? [v.props.name]
+                : renderReference(v).split(".");
+            for (const piece of refPieces) {
+                pieces.push(piece);
+                splices.push(undefined);
+            }
+        }
+        else {
+            pieces.push(unquote(t.text));
+            splices.push(t.splice);
+        }
+    }
+    const last = pieces.length - 1;
+    splices.forEach((splice, i) => {
+        if (splice !== undefined)
+            ctx.fed[splice].add(i === last ? "name" : "database");
+    });
+    return pieces.length >= 2 ? { database: pieces[pieces.length - 2], name: pieces[pieces.length - 1] } : { name: pieces[0] ?? "" };
+}
+/**
+ * The `${}` that stand alone as an element of a sort key (`ORDER BY ${t.columns.a}`,
+ * `ORDER BY (${t.columns.a}, b)`), each a column that must not be Nullable
+ * (#3751). An element inside an expression (`ifNull(${...}, '')`) is not one.
+ */
+function sortKeySlots(ctx, span) {
+    if (!span)
+        return [];
+    let sig = ctx.tokens.slice(span.from, span.to).filter((t) => !isTrivia(t));
+    const isPunct = (i, p) => sig[i]?.kind === "punct" && sig[i].text === p;
+    if (isPunct(0, "(") && isPunct(sig.length - 1, ")")) {
+        let depth = 0;
+        let closesAt = -1;
+        for (let i = 0; i < sig.length && closesAt < 0; i++) {
+            if (isPunct(i, "("))
+                depth++;
+            else if (isPunct(i, ")") && --depth === 0)
+                closesAt = i;
+        }
+        if (closesAt === sig.length - 1)
+            sig = sig.slice(1, -1);
+    }
+    const out = [];
+    let depth = 0;
+    let element = [];
+    const flush = () => {
+        const t = element[0];
+        if (element.length === 1 && t?.kind === "ref" && isColumnRef(ctx.values[t.part]))
+            out.push({ index: t.part, kind: "sortKey" });
+        element = [];
+    };
+    for (const t of sig) {
+        if (t.kind === "punct" && t.text === "(")
+            depth++;
+        else if (t.kind === "punct" && t.text === ")")
+            depth--;
+        if (depth === 0 && t.kind === "punct" && t.text === ",")
+            flush();
+        else
+            element.push(t);
+    }
+    flush();
+    return out;
+}
+function build(tag, strings, values) {
+    const parts = templateParts(strings);
+    const tokens = splice(tag, parts, values);
+    let node;
+    try {
+        node = parseCreate(tokens);
+    }
+    catch (err) {
+        if (!(err instanceof SqlSyntaxError))
+            throw err;
+        throw templateSyntaxError(tag, parts, err);
+    }
+    const ctx = { d: CLICKHOUSE_TEMPLATES, tokens, values, fed: values.map(() => new Set()) };
+    for (const t of tokens)
+        if (t.splice !== undefined)
+            ctx.fed[t.splice].add("ddl");
+    if (node.statement !== (tag === "func" ? "function" : tag)) {
+        const holds = node.statement === "database"
+            ? "CREATE DATABASE"
+            : node.statement === "table"
+                ? "CREATE TABLE"
+                : node.statement === "dictionary"
+                    ? "CREATE DICTIONARY"
+                    : node.statement === "function"
+                        ? "CREATE FUNCTION"
+                        : "CREATE VIEW";
+        throw new SqlTemplateError(tag, `holds a ${holds}; use the ${node.statement === "function" ? "func" : node.statement} tag`, 0, 0);
+    }
+    const { database, name } = qualified(ctx, node.name);
+    const sqlName = database ? `${quoteIdentifier(database)}.${quoteIdentifier(name)}` : quoteIdentifier(name);
+    const ddl = req(untokenize(tokens, (i) => renderReference(values[i])).trim().replace(/;\s*$/, ""));
+    const source = { strings: parts };
+    const dependsOn = [...new Set(values.filter((v) => isClickHouseObject(v) || isColumnRef(v)))];
+    const common = {
+        name,
+        database,
+        onCluster: text(ctx, node.onCluster, "onCluster"),
+        comment: stringValue(text(ctx, node.comment, "comment")),
+        unparsed: unparsedClauses(ctx, node.unknown),
+    };
+    const done = (entity) => {
+        setInterpolationFields(entity, ctx.fed.map((paths) => [...paths].sort()));
+        if (node.statement === "table" || node.statement === "view")
+            setTypedSlots(entity, [...sortKeySlots(ctx, node.orderBy), ...sortKeySlots(ctx, node.primaryKey)]);
+        return entity;
+    };
+    if (node.statement === "database") {
+        feed(ctx, node.engine?.nameSpan, "engine.name");
+        const engine = node.engine
+            ? node.engine.args
+                ? { name: node.engine.name, args: node.engine.args.map((a) => req(text(ctx, a, "engine.args"))) }
+                : { name: node.engine.name }
+            : undefined;
+        const settings = node.settings
+            ? Object.fromEntries(node.settings.map((s) => [s.key, req(text(ctx, s.value, "settings"))]))
+            : undefined;
+        const props = strip({ ...common, engine, settings, ddl, source });
+        return done(makeEntity(CLICKHOUSE_ENTITY_TYPES.database, quoteIdentifier(name), props, undefined, dependsOn));
+    }
+    if (node.statement === "table") {
+        const columns = node.columns.map((c) => columnDef(ctx, c));
+        const props = strip({
+            ...common,
+            orReplace: node.orReplace,
+            ifNotExists: node.ifNotExists,
+            columns,
+            indexes: node.indexes.map((i) => strip({
+                name: i.name,
+                expr: req(text(ctx, i.expr, "indexes")),
+                type: req(text(ctx, i.type, "indexes")),
+                granularity: text(ctx, i.granularity, "indexes"),
+            })),
+            projections: node.projections.map((p) => ({ name: p.name, definition: req(text(ctx, p.body, "projections")) })),
+            constraints: node.constraints.map((c) => ({ name: c.name, kind: c.kind, expr: req(text(ctx, c.expr, "constraints")) })),
+            asFunction: text(ctx, node.asFunction, "asFunction"),
+            ...storageProps(ctx, node),
+            ddl,
+            source,
+        });
+        return done(makeEntity(CLICKHOUSE_ENTITY_TYPES.table, sqlName, props, columns.map((c) => c.name), dependsOn));
+    }
+    if (node.statement === "function") {
+        for (const p of node.params)
+            feed(ctx, p.span, "params");
+        const props = strip({
+            name,
+            onCluster: common.onCluster,
+            orReplace: node.orReplace,
+            ifNotExists: node.ifNotExists,
+            params: node.params.map((p) => p.name || req(text(ctx, p.span))),
+            body: req(text(ctx, node.body, "body")),
+            ddl,
+            source,
+        });
+        return done(makeEntity(CLICKHOUSE_ENTITY_TYPES.function, quoteIdentifier(name), props, undefined, dependsOn));
+    }
+    if (node.statement === "dictionary") {
+        const columns = node.attributes.map((a) => {
+            for (const span of [a.nameSpan, a.type, a.default, a.expression])
+                feed(ctx, span, "columns");
+            return strip({
+                name: a.name || req(text(ctx, a.nameSpan)),
+                type: req(text(ctx, a.type)),
+                default: text(ctx, a.default),
+                expression: text(ctx, a.expression),
+                flags: a.flags.length > 0 ? a.flags : undefined,
+            });
+        });
+        const settings = text(ctx, node.settings, "settings");
+        const props = strip({
+            ...common,
+            orReplace: node.orReplace,
+            ifNotExists: node.ifNotExists,
+            columns,
+            primaryKey: req(text(ctx, node.primaryKey, "primaryKey")),
+            dataSource: req(text(ctx, node.source, "dataSource")),
+            layout: req(text(ctx, node.layout, "layout")),
+            lifetime: text(ctx, node.lifetime, "lifetime"),
+            range: text(ctx, node.range, "range"),
+            settings: settings === undefined ? undefined : dictionarySettings(settings),
+            ddl,
+            source,
+        });
+        return done(makeEntity(CLICKHOUSE_ENTITY_TYPES.dictionary, sqlName, props, columns.map((c) => c.name), dependsOn));
+    }
+    const lin = lineage(ctx, node.select);
+    let to;
+    if (node.to) {
+        const target = node.to.refs.length === 1 ? values[node.to.refs[0]] : undefined;
+        to = isClickHouseObject(target) ? target : text(ctx, node.to, "to");
+    }
+    const columns = node.columns.map((c) => columnDef(ctx, c));
+    const props = strip({
+        ...common,
+        orReplace: node.orReplace,
+        ifNotExists: node.ifNotExists,
+        refresh: text(ctx, node.refresh, "refresh"),
+        append: node.append,
+        to,
+        columns,
+        ...storageProps(ctx, node),
+        populate: node.populate,
+        empty: node.empty,
+        security: text(ctx, node.security, "security"),
+        select: req(text(ctx, node.select, "select")),
+        reads: lin.reads,
+        lineage: lin.edges,
+        ddl,
+        source,
+    });
+    const outputs = columns.length > 0 ? columns.map((c) => c.name) : lin.edges.map((e) => e.output);
+    const type = node.materialized ? CLICKHOUSE_ENTITY_TYPES.materializedView : CLICKHOUSE_ENTITY_TYPES.view;
+    feed(ctx, node.select, "lineage");
+    return done(makeEntity(type, sqlName, props, outputs, dependsOn));
+}
+/** `a = 1, b = 'x'` as a record of each setting's value as written. */
+function dictionarySettings(text) {
+    const out = {};
+    let depth = 0;
+    let cur = "";
+    const flush = () => {
+        const at = cur.indexOf("=");
+        if (at > 0)
+            out[cur.slice(0, at).trim()] = cur.slice(at + 1).trim();
+        cur = "";
+    };
+    for (const ch of text) {
+        if (ch === "(")
+            depth++;
+        else if (ch === ")")
+            depth--;
+        if (ch === "," && depth === 0)
+            flush();
+        else
+            cur += ch;
+    }
+    flush();
+    return out;
+}
+/** `` database`CREATE DATABASE ...` ``: one ClickHouse database, parsed at build time. */
+export function database(strings, ...values) {
+    return build("database", strings, values);
+}
+/**
+ * `` table`CREATE TABLE ...` ``: one ClickHouse table, parsed at build time.
+ * Given its qualified name as the type argument (`` table<"shop.events">`...` ``),
+ * its columns are the ones `chant sql types` declared for that name.
+ */
+export function table(strings, ...values) {
+    return build("table", strings, values);
+}
+/**
+ * `` view`CREATE [MATERIALIZED] VIEW ...` ``: one view or materialized view,
+ * with the tables it reads and its column lineage. Takes its qualified name
+ * as the type argument, as {@link table} does.
+ */
+export function view(strings, ...values) {
+    return build("view", strings, values);
+}
+/**
+ * `` dictionary`CREATE DICTIONARY ...` ``: one dictionary, its attributes,
+ * key, source, layout and lifetime, parsed at build time (#3682). Its
+ * attributes are columns: `${rates.columns.rate}`.
+ */
+export function dictionary(strings, ...values) {
+    return build("dictionary", strings, values);
+}
+/**
+ * `` func`CREATE FUNCTION ...` ``: one SQL user-defined function, a lambda
+ * with a name (#3682). It belongs to no database, and has no comment, so it
+ * carries no ownership marker: chant replaces it when its declaration
+ * changes and never drops it.
+ */
+export function func(strings, ...values) {
+    return build("func", strings, values);
+}
+const ACCESS_STATEMENT = { user: "user", role: "role", policy: "rowPolicy", quota: "quota", settingsProfile: "settingsProfile", grant: "grant" };
+const ACCESS_HOLDS = {
+    user: ["CREATE USER", "user"],
+    role: ["CREATE ROLE", "role"],
+    rowPolicy: ["CREATE ROW POLICY", "policy"],
+    quota: ["CREATE QUOTA", "quota"],
+    settingsProfile: ["CREATE SETTINGS PROFILE", "settingsProfile"],
+    grant: ["GRANT", "grant"],
+};
+function buildAccess(tag, strings, values) {
+    const parts = templateParts(strings);
+    const tokens = splice(tag, parts, values);
+    let node;
+    try {
+        node = parseAccess(tokens);
+    }
+    catch (err) {
+        if (!(err instanceof SqlSyntaxError))
+            throw err;
+        throw templateSyntaxError(tag, parts, err);
+    }
+    if (node.statement !== ACCESS_STATEMENT[tag]) {
+        const [holds, use] = ACCESS_HOLDS[node.statement];
+        throw new SqlTemplateError(tag, `holds a ${holds}; use the ${use} tag`, 0, 0);
+    }
+    if (node.revoke)
+        throw new SqlTemplateError(tag, "holds a REVOKE; declare the grants a grantee keeps, and a plan revokes the rest", 0, 0);
+    const ctx = { d: CLICKHOUSE_TEMPLATES, tokens, values, fed: values.map(() => new Set()) };
+    for (const t of tokens)
+        if (t.splice !== undefined)
+            ctx.fed[t.splice].add("ddl");
+    const ddl = req(untokenize(tokens, (i) => renderReference(values[i])).trim().replace(/;\s*$/, ""));
+    const source = { strings: parts };
+    const dependsOn = [...new Set(values.filter((v) => isClickHouseObject(v) || isColumnRef(v)))];
+    const done = (entity) => {
+        setInterpolationFields(entity, ctx.fed.map((paths) => [...paths].sort()));
+        return entity;
+    };
+    const rendered = (span) => span ? untokenize(tokens.slice(span.from, span.to), (i) => renderReference(values[i])).trim() || undefined : undefined;
+    const name = node.name ? unquote(rendered(node.name) ?? "") : "";
+    const c = node.clauses;
+    const common = { name, onCluster: text(ctx, node.onCluster, "onCluster"), orReplace: node.orReplace || undefined, ifNotExists: node.ifNotExists || undefined };
+    if (node.statement === "user") {
+        const props = strip({
+            ...common,
+            identified: c.notIdentified ? "NOT IDENTIFIED" : rendered(c.identified),
+            host: rendered(c.host),
+            validUntil: rendered(c.validUntil),
+            defaultRole: rendered(c.defaultRole),
+            defaultDatabase: rendered(c.defaultDatabase),
+            grantees: rendered(c.grantees),
+            settings: rendered(c.settings),
+            ddl,
+            source,
+        });
+        return done(makeEntity(CLICKHOUSE_ENTITY_TYPES.user, quoteIdentifier(name), props, undefined, dependsOn));
+    }
+    if (node.statement === "role") {
+        const props = strip({ ...common, settings: rendered(c.settings), ddl, source });
+        return done(makeEntity(CLICKHOUSE_ENTITY_TYPES.role, quoteIdentifier(name), props, undefined, dependsOn));
+    }
+    if (node.statement === "quota") {
+        const props = strip({ ...common, keyed: rendered(c.keyed), intervals: rendered(c.for), to: rendered(c.to), ddl, source });
+        return done(makeEntity(CLICKHOUSE_ENTITY_TYPES.quota, quoteIdentifier(name), props, undefined, dependsOn));
+    }
+    if (node.statement === "settingsProfile") {
+        const props = strip({ ...common, settings: rendered(c.settings), to: rendered(c.to), ddl, source });
+        return done(makeEntity(CLICKHOUSE_ENTITY_TYPES.settingsProfile, quoteIdentifier(name), props, undefined, dependsOn));
+    }
+    if (node.statement === "rowPolicy") {
+        const { database, name: tableName } = qualified(ctx, node.table);
+        const props = strip({
+            ...common,
+            database,
+            table: tableName,
+            as: rendered(c.as)?.toUpperCase(),
+            for: rendered(c.for),
+            using: req(rendered(c.using)),
+            to: rendered(c.to),
+            ddl,
+            source,
+        });
+        return done(makeEntity(CLICKHOUSE_ENTITY_TYPES.rowPolicy, quoteIdentifier(name), props, undefined, dependsOn));
+    }
+    const items = node.items.map((i) => rendered(i) ?? "");
+    const to = node.grantees.map((g) => unquote(rendered(g) ?? ""));
+    const props = strip({
+        name: to.join(", "),
+        onCluster: common.onCluster,
+        privileges: node.target ? items : undefined,
+        roles: node.target ? undefined : items.map(unquote),
+        on: rendered(node.target),
+        to,
+        withGrantOption: node.withOption === "GRANT" || undefined,
+        withAdminOption: node.withOption === "ADMIN" || undefined,
+        ddl,
+        source,
+    });
+    return done(makeEntity(CLICKHOUSE_ENTITY_TYPES.grant, "", props, undefined, dependsOn));
+}
+/**
+ * `` user`CREATE USER ...` ``: one user (#3682). A password is the
+ * environment's: `IDENTIFIED BY` is refused, and a user declared without
+ * `IDENTIFIED` is compared without it and is not created by chant.
+ */
+export function user(strings, ...values) {
+    return buildAccess("user", strings, values);
+}
+/** `` role`CREATE ROLE ...` ``: one role (#3682). Interpolate it where a grant or a user names it. */
+export function role(strings, ...values) {
+    return buildAccess("role", strings, values);
+}
+/** `` policy`CREATE ROW POLICY ...` ``: one row policy on one table (#3682). */
+export function policy(strings, ...values) {
+    return buildAccess("policy", strings, values);
+}
+/**
+ * `` quota`CREATE QUOTA ...` ``: one quota (#3911), its key, its intervals'
+ * limits and whom it applies to. A plan changes it with `ALTER QUOTA`, one
+ * clause or interval at a time, and never drops it.
+ */
+export function quota(strings, ...values) {
+    return buildAccess("quota", strings, values);
+}
+/**
+ * `` settingsProfile`CREATE SETTINGS PROFILE ...` ``: one settings profile
+ * (#3911), its settings, their constraints and the profiles it inherits.
+ * Interpolate it where a user, a role or another profile names it.
+ */
+export function settingsProfile(strings, ...values) {
+    return buildAccess("settingsProfile", strings, values);
+}
+/**
+ * `` grant`GRANT ...` ``: privileges or roles granted to users or roles
+ * (#3682). Every grant declaration naming a grantee adds up to its complete
+ * list: a plan revokes what it holds besides.
+ */
+export function grant(strings, ...values) {
+    return buildAccess("grant", strings, values);
+}