@housekit/orm 0.1.47 → 0.1.48

package/dist/builders/select.js

@@ -0,0 +1,562 @@
+import { ClickHouseColumn } from '../core';
+import { sql, eq } from '../expressions';
+import { and } from '../modules/conditional';
+import { QueryCompiler } from '../compiler';
+export class ClickHouseQueryBuilder {
+    client;
+    _select = null;
+    _selectResolver = null;
+    _table = null;
+    _prewhere = null;
+    _sample = null;
+    _settings = null;
+    _distinct = false;
+    _joins = [];
+    _arrayJoins = [];
+    _ctes = [];
+    _where = null;
+    _limit = null;
+    _offset = null;
+    _orderBy = [];
+    _groupBy = [];
+    _having = null;
+    _final = false;
+    _windows = {};
+    _suggestions = [];
+    constructor(client) {
+        this.client = client;
+    }
+    select(fields) {
+        if (fields) {
+            if (typeof fields === 'function') {
+                if (!this._table) {
+                    this._selectResolver = fields;
+                    return this;
+                }
+                this._select = fields(this._table.$columns);
+                this._selectResolver = null;
+                return this;
+            }
+            this._select = fields;
+            this._selectResolver = null;
+            return this;
+        }
+        return this;
+    }
+    from(tableOrSubquery, alias = 'subquery') {
+        if (tableOrSubquery instanceof ClickHouseQueryBuilder) {
+            return this.fromSubquery(tableOrSubquery, alias);
+        }
+        this._table = tableOrSubquery;
+        const defaultFinal = tableOrSubquery.$options?.defaultFinal;
+        if (defaultFinal !== undefined) {
+            this._final = Boolean(defaultFinal);
+        }
+        this.resolveSelect();
+        return this;
+    }
+    fromSubquery(subquery, alias) {
+        this._table = this.createSubqueryTable(alias, subquery);
+        this._final = false;
+        this.resolveSelect();
+        return this;
+    }
+    resolveSelect() {
+        if (!this._selectResolver)
+            return;
+        if (!this._table) {
+            throw new Error('Call .from() before using callback select');
+        }
+        this._select = this._selectResolver(this._table.$columns);
+        this._selectResolver = null;
+    }
+    where(expression) {
+        if (!expression)
+            return this;
+        if (typeof expression === 'object' && 'toSQL' in expression) {
+            this._where = expression;
+            return this;
+        }
+        if (typeof expression === 'object') {
+            const table = this._table;
+            if (!table)
+                return this;
+            const chunks = [];
+            const columns = table.$columns || table;
+            for (const [key, value] of Object.entries(expression)) {
+                const column = table[key] || columns?.[key];
+                if (column && value !== undefined) {
+                    chunks.push(eq(column, value));
+                }
+            }
+            if (chunks.length > 0) {
+                const combined = chunks.length === 1 ? chunks[0] : and(...chunks);
+                if (combined)
+                    this._where = combined;
+            }
+        }
+        return this;
+    }
+    orderBy(col, dir = 'ASC') {
+        if (col && typeof col === 'object' && 'col' in col && 'dir' in col) {
+            this._orderBy.push(col);
+        }
+        else {
+            this._orderBy.push({ col: col, dir });
+        }
+        if (this._table && col instanceof ClickHouseColumn) {
+            const opts = this._table.$options;
+            const orderByOpts = opts?.orderBy;
+            if (orderByOpts) {
+                const target = (Array.isArray(orderByOpts) ? orderByOpts : [orderByOpts]).map((c) => c.toString().trim());
+                if (!target.includes(col.name)) {
+                    this._suggestions.push(`Ordering by ${col.name} not in physical ORDER BY; may be inefficient.`);
+                }
+            }
+        }
+        return this;
+    }
+    groupBy(...cols) {
+        this._groupBy = cols;
+        return this;
+    }
+    having(expression) {
+        this._having = expression;
+        return this;
+    }
+    limit(val) {
+        this._limit = val;
+        return this;
+    }
+    offset(val) {
+        this._offset = val;
+        return this;
+    }
+    distinct() {
+        this._distinct = true;
+        return this;
+    }
+    innerJoin(table, on) {
+        this._joins.push({ type: 'INNER', table: table.$table, on });
+        return this;
+    }
+    leftJoin(table, on) {
+        this._joins.push({ type: 'LEFT', table: table.$table, on });
+        return this;
+    }
+    rightJoin(table, on) {
+        this._joins.push({ type: 'RIGHT', table: table.$table, on });
+        return this;
+    }
+    fullJoin(table, on) {
+        this._joins.push({ type: 'FULL', table: table.$table, on });
+        return this;
+    }
+    crossJoin(table) {
+        this._joins.push({ type: 'CROSS', table: table.$table, on: null });
+        return this;
+    }
+    globalJoin(type, table, on) {
+        this._joins.push({ type: `GLOBAL ${type}`, table: table.$table, on });
+        return this;
+    }
+    globalInnerJoin(table, on) {
+        return this.globalJoin('INNER', table, on);
+    }
+    globalLeftJoin(table, on) {
+        return this.globalJoin('LEFT', table, on);
+    }
+    anyJoin(type, table, on) {
+        this._joins.push({ type: `ANY ${type}`, table: table.$table, on });
+        return this;
+    }
+    anyInnerJoin(table, on) {
+        return this.anyJoin('INNER', table, on);
+    }
+    anyLeftJoin(table, on) {
+        return this.anyJoin('LEFT', table, on);
+    }
+    allJoin(type, table, on) {
+        this._joins.push({ type: `ALL ${type}`, table: table.$table, on });
+        return this;
+    }
+    asofJoin(table, on) {
+        this._joins.push({ type: 'LEFT ASOF', table: table.$table, on });
+        return this;
+    }
+    asofInnerJoin(table, on) {
+        this._joins.push({ type: 'INNER ASOF', table: table.$table, on });
+        return this;
+    }
+    semiJoin(table, on) {
+        this._joins.push({ type: 'LEFT SEMI', table: table.$table, on });
+        return this;
+    }
+    antiJoin(table, on) {
+        this._joins.push({ type: 'LEFT ANTI', table: table.$table, on });
+        return this;
+    }
+    globalAsofJoin(table, on) {
+        this._joins.push({ type: 'GLOBAL LEFT ASOF', table: table.$table, on });
+        return this;
+    }
+    globalAnyJoin(type, table, on) {
+        this._joins.push({ type: `GLOBAL ANY ${type}`, table: table.$table, on });
+        return this;
+    }
+    arrayJoin(column, ...additionalColumns) {
+        this._arrayJoins.push({ column });
+        for (const col of additionalColumns) {
+            this._arrayJoins.push({ column: col });
+        }
+        return this;
+    }
+    arrayJoinMultiple(...columns) {
+        for (const col of columns) {
+            this._arrayJoins.push({ column: col });
+        }
+        return this;
+    }
+    arrayJoinAs(column, alias) {
+        this._arrayJoins.push({ column, alias });
+        return this;
+    }
+    with(name, query) {
+        this._ctes.push({ name, query });
+        return this;
+    }
+    prewhere(expression) {
+        this._prewhere = expression;
+        return this;
+    }
+    sample(ratio, offset) {
+        this._sample = { ratio, offset };
+        return this;
+    }
+    $with(alias, queryBuilder) {
+        const virtualColumns = {};
+        const selection = queryBuilder._select;
+        const sourceTable = queryBuilder._table;
+        if (selection && Object.keys(selection).length > 0) {
+            for (const key of Object.keys(selection)) {
+                const val = selection[key];
+                if (val instanceof ClickHouseColumn) {
+                    const col = new ClickHouseColumn(key, val.type, val.isNull, val.meta);
+                    col.tableName = alias;
+                    virtualColumns[key] = col;
+                }
+                else {
+                    const col = new ClickHouseColumn(key, 'String');
+                    col.tableName = alias;
+                    virtualColumns[key] = col;
+                }
+            }
+        }
+        else if (sourceTable) {
+            for (const [key, col] of Object.entries(sourceTable.$columns)) {
+                const column = col;
+                const clone = new ClickHouseColumn(column.name, column.type, column.isNull, column.meta);
+                clone.tableName = alias;
+                virtualColumns[key] = clone;
+            }
+        }
+        const cteOptions = { kind: 'cte' };
+        const cteTable = {
+            $table: alias,
+            $columns: virtualColumns,
+            $options: cteOptions,
+            toSQL: () => ''
+        };
+        Object.assign(cteTable, virtualColumns);
+        this.with(alias, queryBuilder);
+        const register = (mainQuery) => {
+            mainQuery.with(alias, queryBuilder);
+            return mainQuery;
+        };
+        return { cteTable, register };
+    }
+    final() {
+        this._final = true;
+        return this;
+    }
+    window(name, definition) {
+        this._windows[name] = definition;
+        return this;
+    }
+    settings(settings) {
+        this._settings = settings;
+        return this;
+    }
+    createSubqueryTable(alias, subquery) {
+        const buildVirtualColumns = (aliasName) => {
+            const virtualColumns = {};
+            const subState = subquery.getState();
+            const selection = subState.select;
+            const sourceTable = subState.table;
+            if (selection && Object.keys(selection).length > 0) {
+                for (const [key, val] of Object.entries(selection)) {
+                    if (val instanceof ClickHouseColumn) {
+                        const col = new ClickHouseColumn(key, val.type, val.isNull, val.meta);
+                        col.tableName = aliasName;
+                        virtualColumns[key] = col;
+                    }
+                    else {
+                        const col = new ClickHouseColumn(key, 'String');
+                        col.tableName = aliasName;
+                        virtualColumns[key] = col;
+                    }
+                }
+            }
+            else if (sourceTable) {
+                for (const [key, col] of Object.entries(sourceTable.$columns)) {
+                    const column = col;
+                    const clone = new ClickHouseColumn(key, column.type, column.isNull, column.meta);
+                    clone.tableName = aliasName;
+                    virtualColumns[key] = clone;
+                }
+            }
+            return virtualColumns;
+        };
+        const buildTable = (aliasName) => {
+            const columns = buildVirtualColumns(aliasName);
+            const table = {
+                $table: aliasName,
+                $columns: columns,
+                $options: { kind: 'subquery', subquery },
+                toSQL: () => '',
+                as: (nextAlias) => buildTable(nextAlias)
+            };
+            Object.entries(columns).forEach(([key, col]) => { table[key] = col; });
+            return table;
+        };
+        return buildTable(alias);
+    }
+    getState() {
+        this.resolveSelect();
+        return {
+            select: this._select,
+            table: this._table,
+            prewhere: this._prewhere,
+            sample: this._sample,
+            settings: this._settings,
+            distinct: this._distinct,
+            joins: this._joins,
+            arrayJoins: this._arrayJoins,
+            ctes: this._ctes,
+            where: this._where,
+            limit: this._limit,
+            offset: this._offset,
+            orderBy: this._orderBy,
+            groupBy: this._groupBy,
+            having: this._having,
+            final: this._final,
+            windows: this._windows,
+            suggestions: this._suggestions
+        };
+    }
+    toSQL() {
+        const compiler = new QueryCompiler();
+        const { sql, params, suggestions } = compiler.compileSelect(this.getState());
+        return { query: sql, params, suggestions };
+    }
+    async then(onfulfilled, onrejected) {
+        const compiler = new QueryCompiler();
+        try {
+            const { cachedQuery, values } = compiler.compileWithCache(this.getState(), this.client);
+            const data = (await cachedQuery.execute(values));
+            if (onfulfilled) {
+                return Promise.resolve(onfulfilled(data));
+            }
+            return Promise.resolve(data);
+        }
+        catch (error) {
+            if (onrejected) {
+                return Promise.resolve(onrejected(error));
+            }
+            return Promise.reject(error);
+        }
+    }
+    async *[Symbol.asyncIterator]() {
+        const compiler = new QueryCompiler();
+        const { cachedQuery, values } = compiler.compileWithCache(this.getState(), this.client);
+        const query_params = {};
+        for (let i = 0; i < values.length; i++) {
+            query_params[`p_${i + 1}`] = values[i];
+        }
+        const resultSet = await this.client.query({
+            query: cachedQuery.sql,
+            query_params,
+            format: 'JSONEachRow',
+        });
+        const reader = resultSet.stream();
+        let buffer = '';
+        for await (const chunk of reader) {
+            buffer += chunk.toString();
+            const lines = buffer.split('\n');
+            buffer = lines.pop() ?? '';
+            for (const line of lines) {
+                if (line.trim()) {
+                    try {
+                        yield JSON.parse(line);
+                    }
+                    catch (e) {
+                    }
+                }
+            }
+        }
+        if (buffer.trim()) {
+            try {
+                yield JSON.parse(buffer);
+            }
+            catch (e) {
+            }
+        }
+    }
+    stream() {
+        return this[Symbol.asyncIterator]();
+    }
+    async native() {
+        console.warn('[HouseKit] native() is deprecated. RowBinary streaming is not supported by @clickhouse/client 1.15+. Using JSONEachRow instead.');
+        return this.then(data => data);
+    }
+    async vector() {
+        console.warn('[HouseKit] vector() is deprecated. RowBinary streaming is not supported by @clickhouse/client 1.15+. Using JSONEachRow instead.');
+        const rows = await this.then(data => data);
+        if (rows.length === 0)
+            return {};
+        const result = {};
+        const keys = Object.keys(rows[0]);
+        for (const key of keys) {
+            result[key] = rows.map((row) => row[key]);
+        }
+        return result;
+    }
+    async explain() {
+        const { query, params } = this.toSQL();
+        const resultSet = await this.client.query({
+            query: `EXPLAIN ${query}`,
+            query_params: params
+        });
+        return resultSet.json();
+    }
+    async explainPipeline() {
+        const { query, params } = this.toSQL();
+        const resultSet = await this.client.query({
+            query: `EXPLAIN PIPELINE ${query}`,
+            query_params: params
+        });
+        return resultSet.json();
+    }
+    async findFirst() {
+        const result = await this.limit(1).then();
+        return result.length > 0 ? result[0] : null;
+    }
+    async findUnique() {
+        const result = await this.limit(1).then();
+        return result.length > 0 ? result[0] : null;
+    }
+    async findMany(options) {
+        let query = this;
+        if (options?.limit) {
+            query = query.limit(options.limit);
+        }
+        if (options?.offset) {
+            query = query.offset(options.offset);
+        }
+        return query.then();
+    }
+    async findManyCursor(options) {
+        let query = this;
+        if (options?.limit) {
+            query = query.limit(options.limit);
+        }
+        if (options?.cursor) {
+            const { column, value, direction = 'ASC' } = options.cursor;
+            const operator = direction === 'ASC' ? '>' : '<';
+            query = query.where(sql `${column} ${operator} ${value}`);
+            query = query.orderBy(column, direction);
+        }
+        return query.then();
+    }
+    async count(table, options) {
+        let query;
+        if (table) {
+            query = new ClickHouseQueryBuilder(this.client)
+                .from(table)
+                .select({ count: sql `count(*)` });
+        }
+        else {
+            const countQuery = new ClickHouseQueryBuilder(this.client);
+            countQuery._table = this._table;
+            countQuery._where = this._where;
+            countQuery._joins = [...this._joins];
+            countQuery._ctes = [...this._ctes];
+            countQuery._prewhere = this._prewhere;
+            countQuery._sample = this._sample;
+            countQuery._distinct = this._distinct;
+            countQuery._groupBy = [...this._groupBy];
+            countQuery._having = this._having;
+            countQuery._final = this._final;
+            countQuery._windows = { ...this._windows };
+            countQuery._settings = this._settings ? { ...this._settings } : null;
+            countQuery._suggestions = [...this._suggestions];
+            countQuery._select = { count: sql `count(*)` };
+            query = countQuery;
+        }
+        if (options?.where) {
+            query = query.where(options.where);
+        }
+        const result = await query.limit(1).then();
+        return result[0]?.count || 0;
+    }
+    async exists(options) {
+        let query = this.limit(1);
+        if (options?.where) {
+            query = query.where(options.where);
+        }
+        const result = await query.then();
+        return result.length > 0;
+    }
+    async findManyWithMeta(options) {
+        const limit = options?.limit || 50;
+        const offset = options?.offset || 0;
+        let query = this.limit(limit + 1).offset(offset);
+        const results = await query.then();
+        const hasMore = results.length > limit;
+        const data = hasMore ? results.slice(0, -1) : results;
+        const result = {
+            data,
+            hasMore
+        };
+        if (options?.includeTotal) {
+            const total = await this.count();
+            result.total = total;
+        }
+        return result;
+    }
+    async findAsMap(keyColumn, options) {
+        const results = await this.findMany(options);
+        const map = new Map();
+        for (const record of results) {
+            const key = record[keyColumn instanceof ClickHouseColumn ? keyColumn.name : 'key'];
+            if (key !== undefined && key !== null) {
+                map.set(key, record);
+            }
+        }
+        return map;
+    }
+    async findGrouped(groupColumn, options) {
+        const results = await this.findMany(options);
+        const grouped = {};
+        for (const record of results) {
+            const key = record[groupColumn instanceof ClickHouseColumn ? groupColumn.name : 'group'];
+            if (key !== undefined && key !== null) {
+                if (!grouped[key]) {
+                    grouped[key] = [];
+                }
+                grouped[key].push(record);
+            }
+        }
+        return grouped;
+    }
+}

package/dist/builders/select.types.js

@@ -0,0 +1 @@
+export {};

package/dist/builders/update.js

@@ -0,0 +1,136 @@
+import { eq } from '../expressions';
+import { and } from '../modules/conditional';
+export class ClickHouseUpdateBuilder {
+    client;
+    table;
+    _set = {};
+    _where = null;
+    _lastMutationId = null;
+    constructor(client, table) {
+        this.client = client;
+        this.table = table;
+    }
+    set(values) {
+        this._set = values;
+        return this;
+    }
+    where(expression) {
+        if (!expression)
+            return this;
+        if (typeof expression === 'object' && 'toSQL' in expression) {
+            this._where = expression;
+            return this;
+        }
+        if (typeof expression === 'object') {
+            const chunks = [];
+            for (const [key, value] of Object.entries(expression)) {
+                const column = this.table.$columns[key];
+                if (column && value !== undefined) {
+                    chunks.push(eq(column, value));
+                }
+            }
+            if (chunks.length > 0) {
+                const combined = chunks.length === 1 ? chunks[0] : and(...chunks);
+                if (combined)
+                    this._where = combined;
+            }
+        }
+        return this;
+    }
+    toSQL() {
+        if (this.table.$options.appendOnly !== false) {
+            throw new Error(`UPDATE is blocked for append-only table ${this.table.$table}. Set appendOnly: false to allow.`);
+        }
+        if (!this._where) {
+            throw new Error("❌ UPDATE requires a WHERE clause in ClickHouse (safety first!)");
+        }
+        if (Object.keys(this._set).length === 0) {
+            throw new Error("❌ UPDATE requires at least one field to set");
+        }
+        const params = {};
+        const setParts = [];
+        let paramCounter = 0;
+        for (const [key, value] of Object.entries(this._set)) {
+            const col = this.table.$columns[key];
+            if (!col)
+                continue;
+            let finalValue = value;
+            if (col.meta?.isJson && typeof value === 'object' && value !== null) {
+                finalValue = JSON.stringify(value);
+            }
+            const paramName = `p_${key}_${++paramCounter}`;
+            params[paramName] = finalValue;
+            setParts.push(`\`${key}\` = {${paramName}:String}`);
+        }
+        const whereRes = this._where.toSQL({ ignoreTablePrefix: true });
+        Object.assign(params, whereRes.params);
+        const tableName = this.table.$table;
+        return {
+            query: `ALTER TABLE \`${tableName}\` UPDATE ${setParts.join(', ')} WHERE ${whereRes.sql}`,
+            params
+        };
+    }
+    async execute() {
+        const { query, params } = this.toSQL();
+        await this.client.command({
+            query,
+            query_params: params,
+        });
+        this._lastMutationId = await fetchLatestMutationId(this.client, this.table.$table);
+    }
+    async wait(options) {
+        if (!this._lastMutationId) {
+            await this.execute();
+        }
+        if (!this._lastMutationId)
+            return;
+        await waitForMutationCompletion(this.client, this.table.$table, this._lastMutationId, options);
+    }
+    async then(onfulfilled, onrejected) {
+        try {
+            await this.execute();
+            if (onfulfilled) {
+                return Promise.resolve(onfulfilled());
+            }
+            return Promise.resolve();
+        }
+        catch (error) {
+            if (onrejected) {
+                return Promise.resolve(onrejected(error));
+            }
+            return Promise.reject(error);
+        }
+    }
+}
+async function fetchLatestMutationId(client, tableName) {
+    const result = await client.query({
+        query: `SELECT mutation_id FROM system.mutations WHERE database = currentDatabase() AND table = {table:String} ORDER BY create_time DESC LIMIT 1 FORMAT JSONEachRow`,
+        query_params: { table: tableName }
+    });
+    const rows = await result.json();
+    return rows[0]?.mutation_id ?? null;
+}
+async function waitForMutationCompletion(client, tableName, mutationId, options) {
+    const pollInterval = options?.pollIntervalMs ?? 500;
+    const timeout = options?.timeoutMs ?? 60_000;
+    const start = Date.now();
+    while (true) {
+        const result = await client.query({
+            query: `SELECT is_done, latest_failed_part, latest_fail_reason FROM system.mutations WHERE database = currentDatabase() AND table = {table:String} AND mutation_id = {mid:String} FORMAT JSONEachRow`,
+            query_params: { table: tableName, mid: mutationId }
+        });
+        const rows = await result.json();
+        const row = rows[0];
+        if (!row)
+            return;
+        if (row.latest_fail_reason) {
+            throw new Error(`Mutation ${mutationId} failed: ${row.latest_fail_reason}`);
+        }
+        if (row.is_done === 1)
+            return;
+        if (Date.now() - start > timeout) {
+            throw new Error(`Mutation ${mutationId} not completed after ${timeout}ms`);
+        }
+        await new Promise(res => setTimeout(res, pollInterval));
+    }
+}