@quark-fw/clisma 0.1.26 → 0.1.28

package/dist/src/assert-replicated-schema.d.ts

@@ -0,0 +1,2 @@
+import type { AnyTable } from "./table.js";
+export declare function assertReplicatedSchema(nodeCount: number, tables: Record<string, AnyTable>): void;

package/dist/src/assert-replicated-schema.js

@@ -0,0 +1,16 @@
+// src/assert-replicated-schema.ts
+import { isReplicatedEngine } from "./ddl-shared.js";
+// Без кластера в remote_servers DDL не разъезжается сам: таблицу создают на
+// каждой ноде руками. Обычный MergeTree на нескольких нодах — это две
+// независимые таблицы, которые тихо разойдутся по данным, поэтому при
+// нескольких DDL-нодах принимаем только Replicated-движки.
+export function assertReplicatedSchema(nodeCount, tables) {
+    if (nodeCount < 2)
+        return;
+    for (const name in tables) {
+        if (!isReplicatedEngine(tables[name])) {
+            throw new Error(`Table "${name}" must use a Replicated* engine (set \`replication\`) ` +
+                `when DDL targets ${nodeCount} nodes`);
+        }
+    }
+}

package/dist/src/build-count-query.d.ts

@@ -0,0 +1,4 @@
+import { AnyTable } from "./table.js";
+import { WhereInput } from "./where.js";
+import { SQLBuildResult } from "./sql-shared.js";
+export declare function buildCountQuery<T>(database: string, tableName: string, table: AnyTable, where?: WhereInput<T>): SQLBuildResult;

package/dist/src/build-count-query.js

@@ -0,0 +1,13 @@
+// src/build-count-query.ts
+import { countExpr } from "./sql-shared.js";
+import { buildFindManyQuery } from "./build-find-many-query.js";
+export function buildCountQuery(database, tableName, table, where) {
+    const inner = buildFindManyQuery(database, tableName, table, { where });
+    // with no select arg the query starts with "SELECT * FROM ..." —
+    // swap the projection for count()
+    const from = inner.sql.indexOf(" FROM ");
+    return {
+        sql: `SELECT ${countExpr(table)} AS count` + inner.sql.slice(from),
+        params: inner.params,
+    };
+}

package/dist/src/build-create-dictionary-query.d.ts

@@ -0,0 +1,2 @@
+import type { AnyDictionary, DictionaryCredentials } from "./dictionary.js";
+export declare function buildCreateDictionarySQL(database: string, name: string, dict: AnyDictionary, credentials?: DictionaryCredentials, mode?: "create" | "replace"): string;

package/dist/src/build-create-dictionary-query.js

@@ -0,0 +1,51 @@
+// src/build-create-dictionary-query.ts
+import { escapeId } from "./escape-id.js";
+import { quoteString } from "./ddl-shared.js";
+export function buildCreateDictionarySQL(database, name, dict, credentials, 
+// $migrate пересоздаёт словарь: IF NOT EXISTS оставил бы старое
+// определение (источник, учётку, атрибуты) навсегда
+mode = "create") {
+    const columns = [
+        ...Object.entries(dict.key),
+        ...Object.entries(dict.attributes),
+    ]
+        .map(([colName, col]) => `${escapeId(colName)} ${col.clickhouseType}`)
+        .join(",\n");
+    const keys = Object.keys(dict.key).map(escapeId).join(", ");
+    const auth = dict.source.user
+        ? { user: dict.source.user, password: dict.source.password }
+        : credentials;
+    const authSQL = auth
+        ? `USER ${quoteString(auth.user)} PASSWORD ${quoteString(auth.password ?? "")} `
+        : "";
+    // источник — тот же ClickHouse: запрос целиком, либо таблица с фильтром
+    const source = "query" in dict.source
+        ? `CLICKHOUSE(${authSQL}QUERY ${quoteString(dict.source.query)})`
+        : `CLICKHOUSE(${authSQL}DB ${quoteString(dict.source.database ?? database)} ` +
+            `TABLE ${quoteString(dict.source.table)}` +
+            (dict.source.where
+                ? ` WHERE ${quoteString(dict.source.where)}`
+                : "") +
+            ")";
+    const lifetime = typeof dict.lifetime === "number"
+        ? `LIFETIME(${dict.lifetime})`
+        : `LIFETIME(MIN ${dict.lifetime.min} MAX ${dict.lifetime.max})`;
+    const clauses = [
+        `PRIMARY KEY ${keys}`,
+        `SOURCE(${source})`,
+        `LAYOUT(${dict.layout.toUpperCase()}())`,
+        lifetime,
+    ];
+    if (dict.comment)
+        clauses.push(`COMMENT ${quoteString(dict.comment)}`);
+    const verb = mode === "replace"
+        ? "CREATE OR REPLACE DICTIONARY"
+        : "CREATE DICTIONARY IF NOT EXISTS";
+    return `
+    ${verb} ${escapeId(database)}.${escapeId(name)}
+    (
+      ${columns}
+    )
+    ${clauses.join("\n    ")}
+  `.trim();
+}

package/dist/src/build-delete-query.d.ts

@@ -0,0 +1,4 @@
+import { AnyTable } from "./table.js";
+import { WhereInput } from "./where.js";
+import { SQLBuildResult } from "./sql-shared.js";
+export declare function buildDeleteQuery<T>(database: string, tableName: string, table: AnyTable, where?: WhereInput<T>): SQLBuildResult;

package/dist/src/build-delete-query.js

@@ -0,0 +1,11 @@
+// src/build-delete-query.ts
+import { createBuildContext, escapeId } from "./sql-shared.js";
+export function buildDeleteQuery(database, tableName, table, where) {
+    const ctx = createBuildContext(tableName, table.columns);
+    const whereSQL = where ? ctx.whereSQL(where) : "";
+    return {
+        sql: `ALTER TABLE ${escapeId(database)}.${escapeId(tableName)} ` +
+            `DELETE WHERE ${whereSQL || "1"}`,
+        params: ctx.params,
+    };
+}

package/dist/src/build-find-many-query.d.ts

@@ -0,0 +1,3 @@
+import { AnyTable } from "./table.js";
+import { FindManyArgs, SQLBuildResult } from "./sql-shared.js";
+export declare function buildFindManyQuery<T>(database: string, tableName: string, table: AnyTable, args?: FindManyArgs<T>): SQLBuildResult;

package/dist/src/build-find-many-query.js

@@ -0,0 +1,58 @@
+// src/build-find-many-query.ts
+import { checkPagination, createBuildContext, NO_LIMIT, tableRef, } from "./sql-shared.js";
+export function buildFindManyQuery(database, tableName, table, args = {}) {
+    const ctx = createBuildContext(tableName, table.columns);
+    // SELECT
+    let selectSQL = "*";
+    if (args.select) {
+        const select = args.select;
+        const keys = Object.keys(select).filter((k) => select[k] === true);
+        if (keys.length) {
+            selectSQL = keys.map(ctx.colRef).join(", ");
+        }
+    }
+    const clauses = [
+        `SELECT ${selectSQL} FROM ${tableRef(database, tableName, table, args.final)}`,
+    ];
+    // WHERE
+    if (args.where) {
+        const where = ctx.whereSQL(args.where);
+        if (where)
+            clauses.push(`WHERE ${where}`);
+    }
+    // ORDER BY
+    if (args.orderBy) {
+        const list = Array.isArray(args.orderBy)
+            ? args.orderBy
+            : [args.orderBy];
+        const orders = [];
+        for (const entry of list) {
+            for (const key in entry) {
+                const dir = entry[key];
+                if (dir === undefined)
+                    continue;
+                if (dir !== "asc" && dir !== "desc") {
+                    throw new Error(`Invalid sort direction "${dir}" for column "${key}"`);
+                }
+                orders.push(`${ctx.colRef(key)} ${dir.toUpperCase()}`);
+            }
+        }
+        if (orders.length)
+            clauses.push(`ORDER BY ${orders.join(", ")}`);
+    }
+    // LIMIT / OFFSET
+    if (args.take !== undefined)
+        checkPagination("take", args.take);
+    if (args.skip !== undefined)
+        checkPagination("skip", args.skip);
+    if (args.take !== undefined && args.skip !== undefined) {
+        clauses.push(`LIMIT ${args.take} OFFSET ${args.skip}`);
+    }
+    else if (args.take !== undefined) {
+        clauses.push(`LIMIT ${args.take}`);
+    }
+    else if (args.skip !== undefined) {
+        clauses.push(`LIMIT ${NO_LIMIT} OFFSET ${args.skip}`);
+    }
+    return { sql: clauses.join(" "), params: ctx.params };
+}

package/dist/src/build-index-sql.d.ts

@@ -0,0 +1,2 @@
+import type { IndexDefinition } from "./table.js";
+export declare function buildIndexSQL(index: IndexDefinition): string;

package/dist/src/build-index-sql.js

@@ -0,0 +1,11 @@
+// src/build-index-sql.ts
+import { escapeId } from "./escape-id.js";
+import { renderKeyPart } from "./ddl-shared.js";
+export function buildIndexSQL(index) {
+    const args = index.args?.length ? `(${index.args.join(", ")})` : "";
+    const granularity = index.granularity !== undefined
+        ? ` GRANULARITY ${index.granularity}`
+        : "";
+    return (`INDEX ${escapeId(index.name)} ${renderKeyPart(index.expr)} ` +
+        `TYPE ${index.type}${args}${granularity}`);
+}

package/dist/src/build-lightweight-delete-query.d.ts

@@ -0,0 +1,4 @@
+import { AnyTable } from "./table.js";
+import { WhereInput } from "./where.js";
+import { SQLBuildResult } from "./sql-shared.js";
+export declare function buildLightweightDeleteQuery<T>(database: string, tableName: string, table: AnyTable, where?: WhereInput<T>): SQLBuildResult;

package/dist/src/build-lightweight-delete-query.js

@@ -0,0 +1,11 @@
+// src/build-lightweight-delete-query.ts
+import { createBuildContext, escapeId } from "./sql-shared.js";
+export function buildLightweightDeleteQuery(database, tableName, table, where) {
+    const ctx = createBuildContext(tableName, table.columns);
+    const whereSQL = where ? ctx.whereSQL(where) : "";
+    return {
+        sql: `DELETE FROM ${escapeId(database)}.${escapeId(tableName)} ` +
+            `WHERE ${whereSQL || "1"}`,
+        params: ctx.params,
+    };
+}

package/dist/src/build-update-query.d.ts

@@ -0,0 +1,4 @@
+import { AnyTable } from "./table.js";
+import { WhereInput } from "./where.js";
+import { SQLBuildResult } from "./sql-shared.js";
+export declare function buildUpdateQuery<T>(database: string, tableName: string, table: AnyTable, where: WhereInput<T> | undefined, data: Record<string, unknown>): SQLBuildResult;

package/dist/src/build-update-query.js

@@ -0,0 +1,13 @@
+// src/build-update-query.ts
+import { createBuildContext, escapeId, validateUpdateData, } from "./sql-shared.js";
+export function buildUpdateQuery(database, tableName, table, where, data) {
+    const keys = validateUpdateData(table, tableName, data);
+    const ctx = createBuildContext(tableName, table.columns);
+    const sets = keys.map((k) => `${ctx.colRef(k)} = ${ctx.addParam(data[k], ctx.baseType(k))}`);
+    const whereSQL = where ? ctx.whereSQL(where) : "";
+    return {
+        sql: `ALTER TABLE ${escapeId(database)}.${escapeId(tableName)} ` +
+            `UPDATE ${sets.join(", ")} WHERE ${whereSQL || "1"}`,
+        params: ctx.params,
+    };
+}

package/dist/src/client.d.ts

@@ -0,0 +1,36 @@
+import { type ClickHouseClient } from "@clickhouse/client";
+import { TableClient } from "./table-client.js";
+import { AnyTable, InferRow } from "./table.js";
+import type { AnyDictionary } from "./dictionary.js";
+import { MigrationPlan } from "./migrate.js";
+import { type DdlStatement } from "./ensure-tables-on-nodes.js";
+import { type QueryJsonResult, type QueryOptions } from "./query.js";
+type ClientOptions = {
+    url: string;
+    username?: string;
+    password?: string;
+    database?: string;
+    autoCreateDatabase?: boolean;
+    ddlNodes?: string[];
+    requestTimeoutMs?: number;
+};
+export type DdlPlan = MigrationPlan & {
+    settings: DdlStatement[];
+    executed: DdlStatement[];
+};
+export type MigrateOptions = {
+    dryRun?: boolean;
+};
+export declare function createClient<TSchema extends {
+    database?: string;
+    tables: Record<string, AnyTable>;
+    dictionaries?: Record<string, AnyDictionary>;
+}>(schema: TSchema, options: ClientOptions): { [K in keyof TSchema["tables"]]: TableClient<InferRow<TSchema["tables"][K]>>; } & {
+    $init(): Promise<DdlStatement[]>;
+    $migrate(opts?: MigrateOptions): Promise<DdlPlan>;
+    $query<TRow>(sql: string, opts?: QueryOptions): Promise<TRow[]>;
+    $queryJson<TRow, TTotals = TRow>(sql: string, opts?: QueryOptions): Promise<QueryJsonResult<TRow, TTotals>>;
+    $command(sql: string, opts?: Omit<QueryOptions, "columns">): Promise<void>;
+    $close(): Promise<void>;
+};
+export type { ClickHouseClient };

package/dist/src/client.js

@@ -0,0 +1,139 @@
+import { createClient as createCHClient, } from "@clickhouse/client";
+import { TableClient } from "./table-client.js";
+import { escapeId } from "./escape-id.js";
+import { buildMigrationPlan, buildSettingsPlan, parseEngineSettings, } from "./migrate.js";
+import { assertReplicatedSchema } from "./assert-replicated-schema.js";
+import { ensureTablesOnNodes, } from "./ensure-tables-on-nodes.js";
+import { ensureDictionariesOnNodes } from "./ensure-dictionaries-on-nodes.js";
+import { MigrationError } from "./migration-error.js";
+import { runCommand, runQuery, runQueryJson, } from "./query.js";
+export function createClient(schema, options) {
+    const database = options.database ?? schema.database ?? "default";
+    const dictionaries = schema.dictionaries ?? {};
+    const connect = (url, withDatabase) => createCHClient({
+        url,
+        username: options.username,
+        password: options.password,
+        ...(withDatabase ? { database } : {}),
+        ...(options.requestTimeoutMs
+            ? { request_timeout: options.requestTimeoutMs }
+            : {}),
+    });
+    const ch = connect(options.url, true);
+    // клиенты DDL-нод создаются один раз; основная нода переиспользует `ch`
+    const ddlUrls = options.ddlNodes?.length ? options.ddlNodes : [options.url];
+    const nodes = ddlUrls.map((url) => ({
+        url,
+        client: url === options.url ? ch : connect(url, true),
+    }));
+    // источник истины схемы: `url` может быть балансировщиком или нодой вне
+    // ddlNodes, и план с него разошёлся бы с тем, куда пишется DDL
+    const primary = nodes[0];
+    const db = {};
+    for (const tableName in schema.tables) {
+        db[tableName] = new TableClient(database, tableName, schema.tables[tableName], ch);
+    }
+    const ensureDatabase = async () => {
+        if (!options.autoCreateDatabase)
+            return;
+        for (const node of nodes) {
+            const rootClient = connect(node.url, false);
+            try {
+                await rootClient.command({
+                    query: `CREATE DATABASE IF NOT EXISTS ${escapeId(database)}`,
+                });
+            }
+            finally {
+                await rootClient.close();
+            }
+        }
+    };
+    const ensureEverywhere = async (dictionaryMode) => [
+        ...(await ensureTablesOnNodes(nodes, database, schema.tables)),
+        ...(await ensureDictionariesOnNodes(nodes, database, dictionaries, options.username
+            ? { user: options.username, password: options.password }
+            : undefined, dictionaryMode)),
+    ];
+    const readTableSettings = async (client) => {
+        const result = await client.query({
+            query: `SELECT name, engine_full FROM system.tables WHERE database = {db:String}`,
+            query_params: { db: database },
+            format: "JSONEachRow",
+        });
+        const out = {};
+        for (const row of await result.json()) {
+            out[row.name] = parseEngineSettings(row.engine_full);
+        }
+        return out;
+    };
+    db.$init = async () => {
+        assertReplicatedSchema(nodes.length, schema.tables);
+        await ensureDatabase();
+        return ensureEverywhere("create");
+    };
+    db.$migrate = async (opts) => {
+        assertReplicatedSchema(nodes.length, schema.tables);
+        if (!opts?.dryRun)
+            await ensureDatabase();
+        const result = await primary.client.query({
+            query: `
+				SELECT table, name, type
+				FROM system.columns
+				WHERE database = {db:String}
+				ORDER BY table, position
+			`,
+            query_params: { db: database },
+            format: "JSONEachRow",
+        });
+        const existing = await result.json();
+        const plan = buildMigrationPlan(database, schema.tables, existing);
+        const settings = [];
+        for (const node of nodes) {
+            for (const sql of buildSettingsPlan(database, schema.tables, await readTableSettings(node.client))) {
+                settings.push({ node: node.url, sql });
+            }
+        }
+        // dryRun: только план — ни CREATE DATABASE, ни DDL на нодах
+        if (opts?.dryRun)
+            return { ...plan, settings, executed: [] };
+        // план (CREATE недостающих, ALTER ADD/MODIFY) выполняется на первой
+        // ноде: реплицируемый ALTER сам разъезжается по репликам, а недостающие
+        // на репликах таблицы докладывает ensureTablesOnNodes копией SHOW CREATE.
+        // Сбой посередине — MigrationError со списком уже выполненного
+        const executed = [];
+        const run = async (node, sql) => {
+            try {
+                await node.client.command({ query: sql });
+            }
+            catch (cause) {
+                throw new MigrationError({
+                    executed,
+                    failed: { node: node.url, sql },
+                    cause,
+                });
+            }
+            executed.push({ node: node.url, sql });
+        };
+        for (const statement of plan.statements)
+            await run(primary, statement);
+        try {
+            executed.push(...(await ensureEverywhere("replace")));
+        }
+        catch (cause) {
+            throw new MigrationError({ executed, cause });
+        }
+        for (const statement of settings) {
+            const node = nodes.find((n) => n.url === statement.node);
+            await run(node, statement.sql);
+        }
+        return { ...plan, settings, executed };
+    };
+    db.$query = (sql, opts) => runQuery(ch, sql, opts);
+    db.$queryJson = (sql, opts) => runQueryJson(ch, sql, opts);
+    db.$command = (sql, opts) => runCommand(ch, sql, opts);
+    db.$close = async () => {
+        for (const node of nodes)
+            await node.client.close();
+    };
+    return db;
+}

package/dist/src/column.d.ts

@@ -0,0 +1,46 @@
+export type ColumnDefault = {
+    kind: "DEFAULT" | "MATERIALIZED" | "ALIAS";
+    expr: string;
+};
+export type Column<T> = {
+    clickhouseType: string;
+    nullable: boolean;
+    default?: ColumnDefault;
+    codec?: string;
+    comment?: string;
+    __type?: T;
+};
+type NullableColumn<C extends Column<unknown>> = C extends Column<infer T> ? Column<T | null> : never;
+type ColumnType<C extends Column<unknown>> = C extends Column<infer T> ? T : never;
+export declare const t: {
+    string: () => Column<string>;
+    uint8: () => Column<number>;
+    uint16: () => Column<number>;
+    uint32: () => Column<number>;
+    uint64: () => Column<bigint>;
+    int8: () => Column<number>;
+    int16: () => Column<number>;
+    int32: () => Column<number>;
+    int64: () => Column<bigint>;
+    float32: () => Column<number>;
+    float64: () => Column<number>;
+    decimal: (precision: number, scale: number) => Column<string>;
+    boolean: () => Column<boolean>;
+    date: () => Column<Date>;
+    date32: () => Column<Date>;
+    datetime: () => Column<Date>;
+    datetime64: (precision?: number, timezone?: string) => Column<Date>;
+    ipv4: () => Column<string>;
+    ipv6: () => Column<string>;
+    enum8<TValues extends Record<string, number>>(values: TValues): Column<keyof TValues & string>;
+    lowCardinality<C extends Column<unknown>>(col: C): C;
+    map<K extends Column<unknown>, V extends Column<unknown>>(key: K, value: V): Column<Record<string, ColumnType<V>>>;
+    nullable<C extends Column<unknown>>(col: C): NullableColumn<C>;
+    array<C extends Column<unknown>>(col: C): Column<ColumnType<C>[]>;
+    default<C extends Column<unknown>>(col: C, expr: string): C;
+    materialized<C extends Column<unknown>>(col: C, expr: string): C;
+    alias<C extends Column<unknown>>(col: C, expr: string): C;
+    codec<C extends Column<unknown>>(col: C, codec: string): C;
+    comment<C extends Column<unknown>>(col: C, comment: string): C;
+};
+export {};

package/dist/src/column.js

@@ -0,0 +1,79 @@
+// src/column.ts
+function makeColumn(clickhouseType, nullable = false) {
+    return {
+        clickhouseType,
+        nullable,
+    };
+}
+export const t = {
+    string: () => makeColumn("String"),
+    uint8: () => makeColumn("UInt8"),
+    uint16: () => makeColumn("UInt16"),
+    uint32: () => makeColumn("UInt32"),
+    // 64-битные целые не помещаются в number без потерь — только bigint
+    uint64: () => makeColumn("UInt64"),
+    int8: () => makeColumn("Int8"),
+    int16: () => makeColumn("Int16"),
+    int32: () => makeColumn("Int32"),
+    int64: () => makeColumn("Int64"),
+    float32: () => makeColumn("Float32"),
+    float64: () => makeColumn("Float64"),
+    // Decimal отдаётся строкой: number потерял бы точность, а bigint не знает
+    // про дробную часть — арифметику ведёт вызывающий код
+    decimal: (precision, scale) => makeColumn(`Decimal(${precision}, ${scale})`),
+    boolean: () => makeColumn("Bool"),
+    date: () => makeColumn("Date"),
+    date32: () => makeColumn("Date32"),
+    datetime: () => makeColumn("DateTime"),
+    datetime64: (precision = 3, timezone) => makeColumn(timezone
+        ? `DateTime64(${precision}, '${timezone}')`
+        : `DateTime64(${precision})`),
+    ipv4: () => makeColumn("IPv4"),
+    ipv6: () => makeColumn("IPv6"),
+    // Enum8: TS-тип — объединение имён значений, на проводе те же строки
+    enum8(values) {
+        const items = Object.entries(values)
+            .map(([name, code]) => `'${name.replace(/'/g, "''")}' = ${code}`)
+            .join(", ");
+        return makeColumn(`Enum8(${items})`);
+    },
+    // LowCardinality не меняет TS-тип и признак nullable: это только способ
+    // хранения словарём, который для строк с малым числом значений даёт
+    // и сжатие, и быстрый GROUP BY
+    lowCardinality(col) {
+        return {
+            ...col,
+            clickhouseType: `LowCardinality(${col.clickhouseType})`,
+        };
+    },
+    map(key, value) {
+        return makeColumn(`Map(${key.clickhouseType}, ${value.clickhouseType})`);
+    },
+    nullable(col) {
+        return {
+            ...col,
+            clickhouseType: `Nullable(${col.clickhouseType})`,
+            nullable: true,
+        };
+    },
+    array(col) {
+        return makeColumn(`Array(${col.clickhouseType})`);
+    },
+    // модификаторы возвращают копию: одна фабрика может описывать несколько
+    // колонок разных таблиц, общий объект нельзя мутировать
+    default(col, expr) {
+        return { ...col, default: { kind: "DEFAULT", expr } };
+    },
+    materialized(col, expr) {
+        return { ...col, default: { kind: "MATERIALIZED", expr } };
+    },
+    alias(col, expr) {
+        return { ...col, default: { kind: "ALIAS", expr } };
+    },
+    codec(col, codec) {
+        return { ...col, codec };
+    },
+    comment(col, comment) {
+        return { ...col, comment };
+    },
+};

package/dist/src/ddl-shared.d.ts

@@ -0,0 +1,13 @@
+import type { EngineSpec } from "./engine.js";
+import type { Expr, KeyPart } from "./expr.js";
+import type { AnyTable } from "./table.js";
+export declare function isExpr(part: KeyPart): part is Expr;
+export declare function renderKeyPart(part: KeyPart): string;
+export declare function renderKeyList(parts: KeyPart[]): string;
+export declare function keyColumns(parts: KeyPart[]): string[];
+export declare function quoteString(value: string): string;
+export declare function engineFamily(engine: string | EngineSpec): string;
+export declare function isReplicatedEngine(table: AnyTable): boolean;
+export declare function isReplacingEngine(engine: string | EngineSpec): boolean;
+export declare function collapsingOf(engine: string | EngineSpec): EngineSpec["collapsing"] | undefined;
+export declare function renderEngine(table: AnyTable): string;

package/dist/src/ddl-shared.js

@@ -0,0 +1,54 @@
+// src/ddl-shared.ts
+// Общие хелперы рендера DDL: разбор движка и ключей, экранирование.
+import { escapeId } from "./escape-id.js";
+export function isExpr(part) {
+    return typeof part === "object" && part !== null && "__expr" in part;
+}
+export function renderKeyPart(part) {
+    return isExpr(part) ? part.__expr : escapeId(part);
+}
+export function renderKeyList(parts) {
+    return `(${parts.map(renderKeyPart).join(", ")})`;
+}
+// имена колонок ключа без выражений — для проверок «ключ нельзя менять»
+export function keyColumns(parts) {
+    return parts.filter((p) => typeof p === "string");
+}
+export function quoteString(value) {
+    return `'${value.replace(/\\/g, "\\\\").replace(/'/g, "\\'")}'`;
+}
+export function engineFamily(engine) {
+    if (typeof engine !== "string")
+        return engine.family;
+    // у сырой строки семейство — имя до скобки, без префикса Replicated
+    return engine
+        .replace(/^Replicated/, "")
+        .replace(/\(.*$/s, "")
+        .trim();
+}
+export function isReplicatedEngine(table) {
+    if (typeof table.engine === "string") {
+        return table.engine.startsWith("Replicated");
+    }
+    return table.replication !== undefined;
+}
+export function isReplacingEngine(engine) {
+    return engineFamily(engine).includes("ReplacingMergeTree");
+}
+export function collapsingOf(engine) {
+    return typeof engine === "string" ? undefined : engine.collapsing;
+}
+export function renderEngine(table) {
+    if (typeof table.engine === "string")
+        return table.engine;
+    const { family, args } = table.engine;
+    if (!table.replication) {
+        return args.length ? `${family}(${args.join(", ")})` : family;
+    }
+    const replicated = [
+        quoteString(table.replication.path),
+        quoteString(table.replication.replica),
+        ...args,
+    ];
+    return `Replicated${family}(${replicated.join(", ")})`;
+}

package/dist/src/ddl.d.ts

@@ -0,0 +1,5 @@
+import { AnyTable } from "./table.js";
+import type { Column } from "./column.js";
+export declare function renderSettings(settings: Record<string, string | number>): string;
+export declare function buildColumnSQL(name: string, col: Column<unknown>): string;
+export declare function buildCreateTableSQL(database: string, tableName: string, table: AnyTable): string;