@quark-fw/clisma 0.1.7 → 0.1.9

package/dist/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/build-count-query.js

@@ -0,0 +1,12 @@
+// src/build-count-query.ts
+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 count() AS count" + inner.sql.slice(from),
+        params: inner.params,
+    };
+}

package/dist/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/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/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/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)}`,
+    ];
+    // 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/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/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/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/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/client.d.ts

@@ -1,5 +1,5 @@
 import { TableClient } from "./table-client.js";
-import { InferRow } from "./table.js";
+import { AnyTable, InferRow } from "./table.js";
 import { MigrationPlan } from "./migrate.js";
 type ClientOptions = {
     url: string;
@@ -10,7 +10,7 @@ type ClientOptions = {
 };
 export declare function createClient<TSchema extends {
     database?: string;
-    tables: Record<string, any>;
+    tables: Record<string, AnyTable>;
 }>(schema: TSchema, options: ClientOptions): { [K in keyof TSchema["tables"]]: TableClient<InferRow<TSchema["tables"][K]>>; } & {
     $init(): Promise<void>;
     $migrate(): Promise<MigrationPlan>;

package/dist/client.js

@@ -9,7 +9,7 @@ export function createClient(schema, options) {
         url: options.url,
         username: options.username,
         password: options.password,
-        database
+        database,
     });
     const db = {};
     for (const tableName in schema.tables) {
@@ -20,11 +20,11 @@ export function createClient(schema, options) {
             const rootClient = createCHClient({
                 url: options.url,
                 username: options.username,
-                password: options.password
+                password: options.password,
             });
             try {
                 await rootClient.command({
-                    query: `CREATE DATABASE IF NOT EXISTS ${escapeId(database)}`
+                    query: `CREATE DATABASE IF NOT EXISTS ${escapeId(database)}`,
                 });
             }
             finally {
@@ -50,7 +50,7 @@ export function createClient(schema, options) {
 				ORDER BY table, position
 			`,
             query_params: { db: database },
-            format: "JSONEachRow"
+            format: "JSONEachRow",
         });
         const existing = await result.json();
         const plan = buildMigrationPlan(database, schema.tables, existing);

package/dist/column.d.ts

@@ -3,7 +3,7 @@ export type Column<T> = {
     nullable: boolean;
     __type?: T;
 };
-type NullableColumn<C extends Column<any>> = C extends Column<infer T> ? Column<T | null> : never;
+type NullableColumn<C extends Column<unknown>> = C extends Column<infer T> ? Column<T | null> : never;
 export declare const t: {
     string: () => Column<string>;
     uint8: () => Column<number>;
@@ -11,7 +11,7 @@ export declare const t: {
     int32: () => Column<number>;
     boolean: () => Column<boolean>;
     datetime: () => Column<Date>;
-    nullable<C extends Column<any>>(col: C): NullableColumn<C>;
-    array<C extends Column<any>>(col: C): Column<C extends Column<infer T> ? T[] : never>;
+    nullable<C extends Column<unknown>>(col: C): NullableColumn<C>;
+    array<C extends Column<unknown>>(col: C): Column<C extends Column<infer T> ? T[] : never>;
 };
 export {};

package/dist/column.js

@@ -5,13 +5,6 @@ function makeColumn(clickhouseType, nullable = false) {
         nullable,
     };
 }
-function uint64Id() {
-    return {
-        clickhouseType: "UInt64",
-        nullable: false,
-        autoId: true // phantom field для TS
-    };
-}
 export const t = {
     string: () => makeColumn("String"),
     uint8: () => makeColumn("UInt8"),
@@ -27,5 +20,5 @@ export const t = {
     },
     array(col) {
         return makeColumn(`Array(${col.clickhouseType})`);
-    }
+    },
 };

package/dist/ddl.d.ts

@@ -1,2 +1,2 @@
-import { TableDefinition } from "./table.js";
-export declare function buildCreateTableSQL(database: string, tableName: string, table: TableDefinition<any>): string;
+import { AnyTable } from "./table.js";
+export declare function buildCreateTableSQL(database: string, tableName: string, table: AnyTable): string;

package/dist/ddl.js

@@ -2,9 +2,7 @@
 import { escapeId } from "./sql.js";
 export function buildCreateTableSQL(database, tableName, table) {
     const columnsSQL = Object.entries(table.columns)
-        .map(([name, col]) => {
-        return `${escapeId(name)} ${col.clickhouseType}`;
-    })
+        .map(([name, col]) => `${escapeId(name)} ${col.clickhouseType}`)
         .join(",\n");
     return `
     CREATE TABLE IF NOT EXISTS ${escapeId(database)}.${escapeId(tableName)}

package/dist/migrate.d.ts

@@ -1,4 +1,4 @@
-import { TableDefinition } from "./table.js";
+import { AnyTable } from "./table.js";
 export type DbColumn = {
     table: string;
     name: string;
@@ -8,4 +8,4 @@ export type MigrationPlan = {
     statements: string[];
     warnings: string[];
 };
-export declare function buildMigrationPlan(database: string, tables: Record<string, TableDefinition<any>>, existing: DbColumn[]): MigrationPlan;
+export declare function buildMigrationPlan(database: string, tables: Record<string, AnyTable>, existing: DbColumn[]): MigrationPlan;

package/dist/rows.d.ts

@@ -1,2 +1,2 @@
-import { Column } from "./column.js";
-export declare function deserializeRows<T>(rows: any[], columns: Record<string, Column<any>>): T[];
+import { AnyColumns } from "./table.js";
+export declare function deserializeRows<T>(rows: Record<string, unknown>[], columns: AnyColumns): T[];

package/dist/rows.js

@@ -1,6 +1,11 @@
 // src/rows.ts
 const BIGINT_TYPES = new Set([
-    "UInt64", "Int64", "UInt128", "Int128", "UInt256", "Int256"
+    "UInt64",
+    "Int64",
+    "UInt128",
+    "Int128",
+    "UInt256",
+    "Int256",
 ]);
 function convertValue(value, chType) {
     if (value === null || value === undefined)
@@ -10,7 +15,7 @@ function convertValue(value, chType) {
         return convertValue(value, nullable[1]);
     const array = /^Array\((.+)\)$/.exec(chType);
     if (array) {
-        return value.map(v => convertValue(v, array[1]));
+        return value.map((v) => convertValue(v, array[1]));
     }
     if (BIGINT_TYPES.has(chType))
         return BigInt(value);
@@ -20,7 +25,7 @@ function convertValue(value, chType) {
     return value;
 }
 export function deserializeRows(rows, columns) {
-    return rows.map(row => {
+    return rows.map((row) => {
         const out = {};
         for (const k in row) {
             const col = columns[k];

package/dist/schema.d.ts

@@ -1,5 +1,6 @@
-export type ClismaSchema<TTables extends Record<string, any>> = {
+import { AnyTable } from "./table.js";
+export type ClismaSchema<TTables extends Record<string, AnyTable>> = {
     database?: string;
     tables: TTables;
 };
-export declare function createClisma<TTables extends Record<string, any>>(schema: ClismaSchema<TTables>): ClismaSchema<TTables>;
+export declare function createClisma<TTables extends Record<string, AnyTable>>(schema: ClismaSchema<TTables>): ClismaSchema<TTables>;

package/dist/sql-shared.d.ts

@@ -0,0 +1,30 @@
+import { AnyColumns, AnyTable } from "./table.js";
+import { WhereInput } from "./where.js";
+export type SQLBuildResult = {
+    sql: string;
+    params: Record<string, unknown>;
+};
+export type OrderByInput<T> = {
+    [K in keyof T]?: "asc" | "desc";
+};
+export type FindManyArgs<T> = {
+    where?: WhereInput<T>;
+    select?: {
+        [K in keyof T]?: boolean;
+    };
+    orderBy?: OrderByInput<T> | OrderByInput<T>[];
+    take?: number;
+    skip?: number;
+};
+export declare function escapeId(name: string): string;
+export declare const NO_LIMIT = "18446744073709551615";
+export declare function createBuildContext(tableName: string, columns: AnyColumns): {
+    params: Record<string, unknown>;
+    colRef: (key: string) => string;
+    baseType: (key: string) => string;
+    addParam: (value: unknown, type: string) => string;
+    whereSQL: (where: Record<string, unknown>) => string;
+};
+export declare function tableRef(database: string, tableName: string, table: AnyTable): string;
+export declare function checkPagination(name: string, value: number): void;
+export declare function validateUpdateData(table: AnyTable, tableName: string, data: Record<string, unknown>): string[];

package/dist/sql-shared.js

@@ -0,0 +1,162 @@
+// src/sql-shared.ts
+// Shared helpers and types for the SQL builders (build-*.ts).
+export function escapeId(name) {
+    return "`" + name.replace(/\\/g, "\\\\").replace(/`/g, "\\`") + "`";
+}
+// UInt64 max — used to emulate a bare OFFSET (skip without take)
+export const NO_LIMIT = "18446744073709551615";
+// DateTime is second-precision; the client would send Date with
+// a fractional part, which ClickHouse rejects — send unix seconds.
+function serialize(value) {
+    if (value instanceof Date) {
+        return Math.floor(value.getTime() / 1000);
+    }
+    if (Array.isArray(value)) {
+        return value.map(serialize);
+    }
+    return value;
+}
+export function createBuildContext(tableName, columns) {
+    const params = {};
+    let paramIndex = 0;
+    function colRef(key) {
+        if (!columns[key]) {
+            throw new Error(`Unknown column "${key}" in table "${tableName}"`);
+        }
+        return escapeId(key);
+    }
+    function baseType(key) {
+        const chType = columns[key].clickhouseType;
+        const m = /^Nullable\((.+)\)$/.exec(chType);
+        return m ? m[1] : chType;
+    }
+    function addParam(value, type) {
+        const name = `p${paramIndex++}`;
+        params[name] = serialize(value);
+        return `{${name}:${type}}`;
+    }
+    function buildFieldFilter(key, filter) {
+        const col = colRef(key);
+        const conditions = [];
+        for (const op in filter) {
+            const value = filter[op];
+            if (value === undefined)
+                continue;
+            switch (op) {
+                case "equals":
+                    conditions.push(value === null
+                        ? `${col} IS NULL`
+                        : `${col} = ${addParam(value, baseType(key))}`);
+                    break;
+                case "not":
+                    conditions.push(value === null
+                        ? `${col} IS NOT NULL`
+                        : `${col} != ${addParam(value, baseType(key))}`);
+                    break;
+                case "in":
+                    conditions.push(value.length === 0
+                        ? "0"
+                        : `${col} IN ${addParam(value, `Array(${baseType(key)})`)}`);
+                    break;
+                case "notIn":
+                    if (value.length > 0) {
+                        conditions.push(`${col} NOT IN ${addParam(value, `Array(${baseType(key)})`)}`);
+                    }
+                    break;
+                case "lt":
+                case "lte":
+                case "gt":
+                case "gte": {
+                    const cmp = { lt: "<", lte: "<=", gt: ">", gte: ">=" }[op];
+                    conditions.push(`${col} ${cmp} ${addParam(value, baseType(key))}`);
+                    break;
+                }
+                case "contains":
+                    conditions.push(`position(${col}, ${addParam(value, "String")}) > 0`);
+                    break;
+                case "startsWith":
+                    conditions.push(`startsWith(${col}, ${addParam(value, "String")})`);
+                    break;
+                case "endsWith":
+                    conditions.push(`endsWith(${col}, ${addParam(value, "String")})`);
+                    break;
+                default:
+                    throw new Error(`Unknown operator "${op}" for column "${key}"`);
+            }
+        }
+        return conditions;
+    }
+    function isFilterObject(value) {
+        return (value !== null &&
+            typeof value === "object" &&
+            !(value instanceof Date) &&
+            !Array.isArray(value));
+    }
+    function whereSQL(where) {
+        const parts = [];
+        for (const key in where) {
+            const value = where[key];
+            if (value === undefined)
+                continue;
+            if (key === "AND") {
+                const list = (Array.isArray(value) ? value : [value]);
+                for (const w of list) {
+                    const c = whereSQL(w);
+                    if (c)
+                        parts.push(`(${c})`);
+                }
+            }
+            else if (key === "OR") {
+                const conds = value
+                    .map((w) => whereSQL(w))
+                    .filter(Boolean)
+                    .map((c) => `(${c})`);
+                if (conds.length)
+                    parts.push(`(${conds.join(" OR ")})`);
+            }
+            else if (key === "NOT") {
+                const list = (Array.isArray(value) ? value : [value]);
+                for (const w of list) {
+                    const c = whereSQL(w);
+                    if (c)
+                        parts.push(`NOT (${c})`);
+                }
+            }
+            else if (value === null) {
+                parts.push(`${colRef(key)} IS NULL`);
+            }
+            else if (isFilterObject(value)) {
+                parts.push(...buildFieldFilter(key, value));
+            }
+            else {
+                parts.push(`${colRef(key)} = ${addParam(value, baseType(key))}`);
+            }
+        }
+        return parts.join(" AND ");
+    }
+    return { params, colRef, baseType, addParam, whereSQL };
+}
+export function tableRef(database, tableName, table) {
+    const ref = `${escapeId(database)}.${escapeId(tableName)}`;
+    // replacing tables must read the latest row versions
+    return table.mutations === "replacing" ? `${ref} FINAL` : ref;
+}
+export function checkPagination(name, value) {
+    if (!Number.isInteger(value) || value < 0) {
+        throw new Error(`"${name}" must be a non-negative integer, got: ${value}`);
+    }
+}
+// shared by buildUpdateQuery and the replacing-strategy update path
+export function validateUpdateData(table, tableName, data) {
+    const keys = Object.keys(data).filter((k) => data[k] !== undefined);
+    if (keys.length === 0) {
+        throw new Error(`updateMany requires non-empty data`);
+    }
+    for (const key of keys) {
+        if (table.orderBy.includes(key)) {
+            throw new Error(`Cannot update ORDER BY key column "${key}" ` +
+                `of table "${tableName}"`);
+        }
+    }
+    return keys;
+}

package/dist/sql.d.ts

@@ -1,25 +1,6 @@
-import { TableDefinition } from "./table.js";
-import { WhereInput } from "./where.js";
-export type SQLBuildResult = {
-    sql: string;
-    params: Record<string, any>;
-};
-export type OrderByInput<T> = {
-    [K in keyof T]?: "asc" | "desc";
-};
-export type FindManyArgs<T> = {
-    where?: WhereInput<T>;
-    select?: {
-        [K in keyof T]?: boolean;
-    };
-    orderBy?: OrderByInput<T> | OrderByInput<T>[];
-    take?: number;
-    skip?: number;
-};
-export declare function escapeId(name: string): string;
-export declare function buildFindManyQuery(database: string, tableName: string, table: TableDefinition<any>, args?: FindManyArgs<any>): SQLBuildResult;
-export declare function buildCountQuery(database: string, tableName: string, table: TableDefinition<any>, where?: WhereInput<any>): SQLBuildResult;
-export declare function validateUpdateData(table: TableDefinition<any>, tableName: string, data: Record<string, any>): string[];
-export declare function buildUpdateQuery(database: string, tableName: string, table: TableDefinition<any>, where: WhereInput<any> | undefined, data: Record<string, any>): SQLBuildResult;
-export declare function buildDeleteQuery(database: string, tableName: string, table: TableDefinition<any>, where?: WhereInput<any>): SQLBuildResult;
-export declare function buildLightweightDeleteQuery(database: string, tableName: string, table: TableDefinition<any>, where?: WhereInput<any>): SQLBuildResult;
+export { escapeId, validateUpdateData, type FindManyArgs, type OrderByInput, type SQLBuildResult, } from "./sql-shared.js";
+export { buildFindManyQuery } from "./build-find-many-query.js";
+export { buildCountQuery } from "./build-count-query.js";
+export { buildUpdateQuery } from "./build-update-query.js";
+export { buildDeleteQuery } from "./build-delete-query.js";
+export { buildLightweightDeleteQuery } from "./build-lightweight-delete-query.js";

package/dist/sql.js

@@ -1,255 +1,9 @@
 // src/sql.ts
-export function escapeId(name) {
-    return "`" + name.replace(/\\/g, "\\\\").replace(/`/g, "\\`") + "`";
-}
-// UInt64 max — used to emulate a bare OFFSET (skip without take)
-const NO_LIMIT = "18446744073709551615";
-// DateTime is second-precision; the client would send Date with
-// a fractional part, which ClickHouse rejects — send unix seconds.
-function serialize(value) {
-    if (value instanceof Date) {
-        return Math.floor(value.getTime() / 1000);
-    }
-    if (Array.isArray(value)) {
-        return value.map(serialize);
-    }
-    return value;
-}
-function createBuildContext(tableName, columns) {
-    const params = {};
-    let paramIndex = 0;
-    function colRef(key) {
-        if (!columns[key]) {
-            throw new Error(`Unknown column "${key}" in table "${tableName}"`);
-        }
-        return escapeId(key);
-    }
-    function baseType(key) {
-        const chType = columns[key].clickhouseType;
-        const m = /^Nullable\((.+)\)$/.exec(chType);
-        return m ? m[1] : chType;
-    }
-    function addParam(value, type) {
-        const name = `p${paramIndex++}`;
-        params[name] = serialize(value);
-        return `{${name}:${type}}`;
-    }
-    function buildFieldFilter(key, filter) {
-        const col = colRef(key);
-        const conditions = [];
-        for (const op in filter) {
-            const value = filter[op];
-            if (value === undefined)
-                continue;
-            switch (op) {
-                case "equals":
-                    conditions.push(value === null
-                        ? `${col} IS NULL`
-                        : `${col} = ${addParam(value, baseType(key))}`);
-                    break;
-                case "not":
-                    conditions.push(value === null
-                        ? `${col} IS NOT NULL`
-                        : `${col} != ${addParam(value, baseType(key))}`);
-                    break;
-                case "in":
-                    conditions.push(value.length === 0
-                        ? "0"
-                        : `${col} IN ${addParam(value, `Array(${baseType(key)})`)}`);
-                    break;
-                case "notIn":
-                    if (value.length > 0) {
-                        conditions.push(`${col} NOT IN ${addParam(value, `Array(${baseType(key)})`)}`);
-                    }
-                    break;
-                case "lt":
-                case "lte":
-                case "gt":
-                case "gte": {
-                    const cmp = { lt: "<", lte: "<=", gt: ">", gte: ">=" }[op];
-                    conditions.push(`${col} ${cmp} ${addParam(value, baseType(key))}`);
-                    break;
-                }
-                case "contains":
-                    conditions.push(`position(${col}, ${addParam(value, "String")}) > 0`);
-                    break;
-                case "startsWith":
-                    conditions.push(`startsWith(${col}, ${addParam(value, "String")})`);
-                    break;
-                case "endsWith":
-                    conditions.push(`endsWith(${col}, ${addParam(value, "String")})`);
-                    break;
-                default:
-                    throw new Error(`Unknown operator "${op}" for column "${key}"`);
-            }
-        }
-        return conditions;
-    }
-    function isFilterObject(value) {
-        return (value !== null &&
-            typeof value === "object" &&
-            !(value instanceof Date) &&
-            !Array.isArray(value));
-    }
-    function whereSQL(where) {
-        const parts = [];
-        for (const key in where) {
-            const value = where[key];
-            if (value === undefined)
-                continue;
-            if (key === "AND") {
-                const list = Array.isArray(value) ? value : [value];
-                for (const w of list) {
-                    const c = whereSQL(w);
-                    if (c)
-                        parts.push(`(${c})`);
-                }
-            }
-            else if (key === "OR") {
-                const conds = value
-                    .map((w) => whereSQL(w))
-                    .filter(Boolean)
-                    .map((c) => `(${c})`);
-                if (conds.length)
-                    parts.push(`(${conds.join(" OR ")})`);
-            }
-            else if (key === "NOT") {
-                const list = Array.isArray(value) ? value : [value];
-                for (const w of list) {
-                    const c = whereSQL(w);
-                    if (c)
-                        parts.push(`NOT (${c})`);
-                }
-            }
-            else if (value === null) {
-                parts.push(`${colRef(key)} IS NULL`);
-            }
-            else if (isFilterObject(value)) {
-                parts.push(...buildFieldFilter(key, value));
-            }
-            else {
-                parts.push(`${colRef(key)} = ${addParam(value, baseType(key))}`);
-            }
-        }
-        return parts.join(" AND ");
-    }
-    return { params, colRef, baseType, addParam, whereSQL };
-}
-function tableRef(database, tableName, table) {
-    const ref = `${escapeId(database)}.${escapeId(tableName)}`;
-    // replacing tables must read the latest row versions
-    return table.mutations === "replacing" ? `${ref} FINAL` : ref;
-}
-function checkPagination(name, value) {
-    if (!Number.isInteger(value) || value < 0) {
-        throw new Error(`"${name}" must be a non-negative integer, got: ${value}`);
-    }
-}
-export function buildFindManyQuery(database, tableName, table, args = {}) {
-    const ctx = createBuildContext(tableName, table.columns);
-    // SELECT
-    let selectSQL = "*";
-    if (args.select) {
-        const keys = Object.keys(args.select).filter(k => args.select[k] === true);
-        if (keys.length) {
-            selectSQL = keys.map(ctx.colRef).join(", ");
-        }
-    }
-    const clauses = [
-        `SELECT ${selectSQL} FROM ${tableRef(database, tableName, table)}`
-    ];
-    // 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 };
-}
-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 count() AS count" + inner.sql.slice(from),
-        params: inner.params
-    };
-}
-// shared by buildUpdateQuery and the replacing-strategy update path
-export function validateUpdateData(table, tableName, data) {
-    const keys = Object.keys(data).filter(k => data[k] !== undefined);
-    if (keys.length === 0) {
-        throw new Error(`updateMany requires non-empty data`);
-    }
-    for (const key of keys) {
-        if (table.orderBy.includes(key)) {
-            throw new Error(`Cannot update ORDER BY key column "${key}" ` +
-                `of table "${tableName}"`);
-        }
-    }
-    return keys;
-}
-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
-    };
-}
-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
-    };
-}
-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
-    };
-}
+// Public surface of the SQL builders; implementation is split by function
+// (one function per file), shared helpers live in sql-shared.ts.
+export { escapeId, validateUpdateData, } from "./sql-shared.js";
+export { buildFindManyQuery } from "./build-find-many-query.js";
+export { buildCountQuery } from "./build-count-query.js";
+export { buildUpdateQuery } from "./build-update-query.js";
+export { buildDeleteQuery } from "./build-delete-query.js";
+export { buildLightweightDeleteQuery } from "./build-lightweight-delete-query.js";

package/dist/table-client.d.ts

@@ -1,5 +1,5 @@
 import type { ClickHouseClient } from "@clickhouse/client";
-import { TableDefinition } from "./table.js";
+import { AnyTable } from "./table.js";
 import { Simplify } from "./types.js";
 import { WhereInput } from "./where.js";
 import { FindManyArgs } from "./sql.js";
@@ -15,12 +15,12 @@ type OptionalCreateKeys<T> = NullableKeys<T> | ("id" & keyof T);
 export type CreateData<T> = Simplify<Omit<T, OptionalCreateKeys<T>> & {
     [K in OptionalCreateKeys<T>]?: T[K];
 }>;
-export declare class TableClient<T> {
+export declare class TableClient<T extends Record<string, unknown>> {
     private database;
     private tableName;
     private table;
     private client;
-    constructor(database: string, tableName: string, table: TableDefinition<any>, client: ClickHouseClient);
+    constructor(database: string, tableName: string, table: AnyTable, client: ClickHouseClient);
     private get tableRef();
     private runQuery;
     findMany<A extends FindManyArgs<T>>(args?: A): Promise<FindManyResult<T, A>[]>;

package/dist/table-client.js

@@ -1,5 +1,5 @@
 // src/table-client.ts
-import { buildFindManyQuery, buildCountQuery, buildUpdateQuery, buildDeleteQuery, buildLightweightDeleteQuery, validateUpdateData, escapeId } from "./sql.js";
+import { buildFindManyQuery, buildCountQuery, buildUpdateQuery, buildDeleteQuery, buildLightweightDeleteQuery, validateUpdateData, escapeId, } from "./sql.js";
 import { deserializeRows } from "./rows.js";
 // process-unique id: ms timestamp in the high bits + 20-bit counter
 let idCounter = 0n;
@@ -31,8 +31,8 @@ export class TableClient {
                 date_time_output_format: "iso",
                 // force 64-bit ints to arrive as strings so BigInt() is
                 // lossless even if the server default was changed
-                output_format_json_quote_64bit_integers: 1
-            }
+                output_format_json_quote_64bit_integers: 1,
+            },
         });
         return result.json();
     }
@@ -42,7 +42,10 @@ export class TableClient {
         return deserializeRows(rows, this.table.columns);
     }
     async findFirst(args) {
-        const rows = await this.findMany({ ...args, take: 1 });
+        const rows = await this.findMany({
+            ...args,
+            take: 1,
+        });
         return rows[0] ?? null;
     }
     async count(args) {
@@ -65,11 +68,13 @@ export class TableClient {
             // subsequent read returns: omitted nullable columns are null,
             // DateTime values are stored with second precision
             for (const colName in this.table.columns) {
-                if (full[colName] === undefined && this.table.columns[colName].nullable) {
+                if (full[colName] === undefined &&
+                    this.table.columns[colName].nullable) {
                     full[colName] = null;
                 }
                 else if (full[colName] instanceof Date) {
-                    full[colName] = new Date(Math.floor(full[colName].getTime() / 1000) * 1000);
+                    full[colName] = new Date(Math.floor(full[colName].getTime() / 1000) *
+                        1000);
                 }
             }
             const obj = {};
@@ -103,8 +108,8 @@ export class TableClient {
                 // with wait_for_async_insert=0 on the server, inserts are
                 // acked before flush: errors are swallowed and rows are not
                 // immediately readable — force read-your-writes semantics
-                wait_for_async_insert: 1
-            }
+                wait_for_async_insert: 1,
+            },
         });
     }
     async insert(rows) {
@@ -133,7 +138,7 @@ export class TableClient {
             const patch = {};
             for (const k of keys)
                 patch[k] = args.data[k];
-            const { wire } = this.prepareRows(rows.map(r => ({ ...r, ...patch })));
+            const { wire } = this.prepareRows(rows.map((r) => ({ ...r, ...patch })));
             await this.insertWire(wire);
             return { count: rows.length };
         }
@@ -148,8 +153,8 @@ export class TableClient {
             query_params: params,
             clickhouse_settings: {
                 // wait for the mutation so subsequent reads see the change
-                mutations_sync: "1"
-            }
+                mutations_sync: "1",
+            },
         });
         return { count };
     }
@@ -162,7 +167,7 @@ export class TableClient {
             await this.client.command({
                 query: sql,
                 query_params: params,
-                clickhouse_settings: { mutations_sync: "1" }
+                clickhouse_settings: { mutations_sync: "1" },
             });
         }
         else {
@@ -171,7 +176,7 @@ export class TableClient {
             await this.client.command({
                 query: sql,
                 query_params: params,
-                clickhouse_settings: { lightweight_deletes_sync: "2" }
+                clickhouse_settings: { lightweight_deletes_sync: "2" },
             });
         }
         return { count };

package/dist/table.d.ts

@@ -1,13 +1,15 @@
 import { Column } from "./column.js";
 import { Simplify } from "./types.js";
 export type MutationStrategy = "alter" | "lightweight" | "replacing";
-export type TableDefinition<TColumns extends Record<string, Column<any>>> = {
+export type TableDefinition<TColumns extends Record<string, Column<unknown>>> = {
     engine: string;
     orderBy: string[];
     mutations?: MutationStrategy;
     columns: TColumns;
 };
-export declare function table<TColumns extends Record<string, Column<any>>>(def: TableDefinition<TColumns>): TableDefinition<TColumns>;
+export type AnyColumns = Record<string, Column<unknown>>;
+export type AnyTable = TableDefinition<AnyColumns>;
+export declare function table<TColumns extends Record<string, Column<unknown>>>(def: TableDefinition<TColumns>): TableDefinition<TColumns>;
 export type InferRow<TTable> = TTable extends TableDefinition<infer TColumns> ? Simplify<{
     [K in keyof TColumns]: TColumns[K] extends Column<infer T> ? T : never;
 }> : never;

package/dist/where.d.ts

@@ -14,11 +14,11 @@ export type ScalarFilter<T> = {
     not?: T | null;
     in?: T[];
     notIn?: T[];
-} & (T extends number | bigint | Date | string ? ComparableFilter<T> : {}) & (T extends string ? StringFilter : {});
+} & (T extends number | bigint | Date | string ? ComparableFilter<T> : unknown) & (T extends string ? StringFilter : unknown);
 export type WhereInput<T> = {
     AND?: WhereInput<T> | WhereInput<T>[];
     OR?: WhereInput<T>[];
     NOT?: WhereInput<T> | WhereInput<T>[];
 } & {
-    [K in keyof T]?: T[K] extends readonly any[] ? never : T[K] | ScalarFilter<NonNullable<T[K]>> | null;
+    [K in keyof T]?: T[K] extends readonly unknown[] ? never : T[K] | ScalarFilter<NonNullable<T[K]>> | null;
 };

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@quark-fw/clisma",
-	"version": "0.1.7",
+	"version": "0.1.9",
 	"description": "Prisma-like typed client and schema migrator for ClickHouse",
 	"keywords": [
 		"clickhouse",