@lossless.org/client 0.1.0

package/dist_ts/sqldb/clickhouse/smartclickhouse.classes.querybuilder.js

@@ -0,0 +1,155 @@
+import { ClickhouseResultSet } from './smartclickhouse.classes.resultset.js';
+import { quoteClickHouseIdentifier as quoteIdentifier } from '../interfaces.js';
+import { LosslessClientError } from '../../core/classes.error.js';
+/** Identifier methods quote names. Methods ending in Raw and having() accept trusted SQL expressions. */
+export class ClickhouseQueryBuilder {
+    tableName;
+    database;
+    httpClient;
+    selectColumns = ['*'];
+    whereClauses = [];
+    orderByClauses = [];
+    groupByClauses = [];
+    havingClauses = [];
+    limitValue = null;
+    offsetValue = null;
+    values = {};
+    constructor(tableName, database, httpClient) {
+        this.tableName = tableName;
+        this.database = database;
+        this.httpClient = httpClient;
+    }
+    select(...columns) {
+        this.selectColumns = columns.map(quoteIdentifier);
+        return this;
+    }
+    selectRaw(...expressions) { this.selectColumns = expressions; return this; }
+    where(column, operator, value) {
+        return this.and(column, operator, value);
+    }
+    and(column, operator, value) {
+        this.whereClauses.push({ connector: 'AND', expression: this.buildCondition(column, operator, value) });
+        return this;
+    }
+    or(column, operator, value) {
+        this.whereClauses.push({ connector: 'OR', expression: this.buildCondition(column, operator, value) });
+        return this;
+    }
+    whereRaw(expression) {
+        this.whereClauses.push({ connector: 'AND', expression });
+        return this;
+    }
+    orderBy(column, direction = 'ASC') {
+        if (!['ASC', 'DESC'].includes(direction))
+            throw new RangeError('Invalid sort direction.');
+        this.orderByClauses.push(quoteIdentifier(column) + ' ' + direction);
+        return this;
+    }
+    groupBy(...columns) {
+        this.groupByClauses.push(...columns.map(quoteIdentifier));
+        return this;
+    }
+    having(expression) { this.havingClauses.push(expression); return this; }
+    limit(count) { this.validateCount(count); this.limitValue = count; return this; }
+    offset(count) { this.validateCount(count); this.offsetValue = count; return this; }
+    validateCount(count) {
+        if (!Number.isSafeInteger(count) || count < 0)
+            throw new RangeError('Limit and offset must be nonnegative safe integers.');
+    }
+    async execute(options = {}) {
+        return new ClickhouseResultSet(await this.httpClient.queryTyped(this.toSQL(), this.parameters, options));
+    }
+    async first() { this.limitValue = 1; return (await this.execute()).first(); }
+    async count() {
+        const selected = this.selectColumns;
+        this.selectColumns = ['count() as _count'];
+        let sql;
+        try {
+            sql = this.toSQL();
+        }
+        finally {
+            this.selectColumns = selected;
+        }
+        const rows = await this.httpClient.queryTyped(sql, this.parameters);
+        const count = Number(rows[0]?._count ?? 0);
+        if (!Number.isSafeInteger(count))
+            throw new RangeError('Count exceeds a safe JavaScript integer; select count() as a string.');
+        return count;
+    }
+    async toArray(options = {}) { return (await this.execute(options)).toArray(); }
+    /** SQL contains typed placeholders. Pass parameters alongside it, or use toStatement(). */
+    toSQL() {
+        const parts = ['SELECT ' + this.selectColumns.join(', '), 'FROM ' + quoteIdentifier(this.database) + '.' + quoteIdentifier(this.tableName)];
+        const where = this.buildWhereClause();
+        if (where)
+            parts.push('WHERE ' + where);
+        if (this.groupByClauses.length)
+            parts.push('GROUP BY ' + this.groupByClauses.join(', '));
+        if (this.havingClauses.length)
+            parts.push('HAVING ' + this.havingClauses.join(' AND '));
+        if (this.orderByClauses.length)
+            parts.push('ORDER BY ' + this.orderByClauses.join(', '));
+        if (this.limitValue !== null)
+            parts.push('LIMIT ' + this.limitValue);
+        if (this.offsetValue !== null)
+            parts.push('OFFSET ' + this.offsetValue);
+        return parts.join(' ');
+    }
+    get parameters() { return { ...this.values }; }
+    toStatement() { return { sql: this.toSQL(), values: this.parameters }; }
+    buildWhereClause() {
+        return this.whereClauses.map((clause, index) => (index ? clause.connector + ' ' : '') + '(' + clause.expression + ')').join(' ');
+    }
+    /** Bind a scalar for table mutations as well as predicates. */
+    bind(value) {
+        let type;
+        if (value === null)
+            type = 'Nullable(String)';
+        else if (typeof value === 'string')
+            type = 'String';
+        else if (typeof value === 'boolean')
+            type = 'Bool';
+        else if (typeof value === 'bigint') {
+            if (value < -(2n ** 255n) || value >= 2n ** 255n)
+                throw new RangeError('Integer exceeds Int256.');
+            type = 'Int256';
+            value = value.toString();
+        }
+        else if (typeof value === 'number' && Number.isFinite(value)) {
+            if (Number.isInteger(value) && !Number.isSafeInteger(value))
+                throw new RangeError('Use bigint for large integers.');
+            type = Number.isInteger(value) ? 'Int64' : 'Float64';
+        }
+        else if (value instanceof Date && Number.isFinite(value.getTime())) {
+            type = "DateTime64(3, 'UTC')";
+            value = value.toISOString().replace('T', ' ').replace('Z', '');
+        }
+        else
+            throw new LosslessClientError('invalid_argument', 'Use a supported scalar query parameter.');
+        const key = 'p' + Object.keys(this.values).length;
+        this.values[key] = value;
+        return '{' + key + ':' + type + '}';
+    }
+    buildCondition(column, operator, value) {
+        const name = quoteIdentifier(column);
+        if (!['=', '!=', '>', '>=', '<', '<=', 'LIKE', 'NOT LIKE', 'IN', 'NOT IN', 'BETWEEN'].includes(operator)) {
+            throw new RangeError('Invalid comparison operator.');
+        }
+        if (value === null && (operator === '=' || operator === '!='))
+            return name + (operator === '=' ? ' IS NULL' : ' IS NOT NULL');
+        if (operator === 'IN' || operator === 'NOT IN') {
+            if (!Array.isArray(value))
+                throw new RangeError('IN requires an array.');
+            if (!value.length)
+                return operator === 'IN' ? '0' : '1';
+            return name + ' ' + operator + ' (' + value.map(item => this.bind(item)).join(', ') + ')';
+        }
+        if (operator === 'BETWEEN') {
+            if (!Array.isArray(value) || value.length !== 2)
+                throw new RangeError('BETWEEN requires two values.');
+            return name + ' BETWEEN ' + this.bind(value[0]) + ' AND ' + this.bind(value[1]);
+        }
+        return name + ' ' + operator + ' ' + this.bind(value);
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"smartclickhouse.classes.querybuilder.js","sourceRoot":"","sources":["../../../ts/sqldb/clickhouse/smartclickhouse.classes.querybuilder.ts"],"names":[],"mappings":"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"}

package/dist_ts/sqldb/clickhouse/smartclickhouse.classes.resultset.d.ts

@@ -0,0 +1,13 @@
+import * as plugins from './smartclickhouse.plugins.js';
+export declare class ClickhouseResultSet<T> {
+    rows: T[];
+    rowCount: number;
+    constructor(rows: T[]);
+    first(): T | null;
+    last(): T | null;
+    isEmpty(): boolean;
+    toArray(): T[];
+    map<U>(fn: (row: T) => U): U[];
+    filter(fn: (row: T) => boolean): ClickhouseResultSet<T>;
+    toObservable(): plugins.smartrx.rxjs.Observable<T>;
+}

package/dist_ts/sqldb/clickhouse/smartclickhouse.classes.resultset.js

@@ -0,0 +1,36 @@
+import * as plugins from './smartclickhouse.plugins.js';
+export class ClickhouseResultSet {
+    rows;
+    rowCount;
+    constructor(rows) {
+        this.rows = rows;
+        this.rowCount = rows.length;
+    }
+    first() {
+        return this.rows[0] ?? null;
+    }
+    last() {
+        return this.rows[this.rows.length - 1] ?? null;
+    }
+    isEmpty() {
+        return this.rows.length === 0;
+    }
+    toArray() {
+        return this.rows;
+    }
+    map(fn) {
+        return this.rows.map(fn);
+    }
+    filter(fn) {
+        return new ClickhouseResultSet(this.rows.filter(fn));
+    }
+    toObservable() {
+        return new plugins.smartrx.rxjs.Observable((observer) => {
+            for (const row of this.rows) {
+                observer.next(row);
+            }
+            observer.complete();
+        });
+    }
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoic21hcnRjbGlja2hvdXNlLmNsYXNzZXMucmVzdWx0c2V0LmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vdHMvc3FsZGIvY2xpY2tob3VzZS9zbWFydGNsaWNraG91c2UuY2xhc3Nlcy5yZXN1bHRzZXQudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxLQUFLLE9BQU8sTUFBTSw4QkFBOEIsQ0FBQztBQUV4RCxNQUFNLE9BQU8sbUJBQW1CO0lBQ3ZCLElBQUksQ0FBTTtJQUNWLFFBQVEsQ0FBUztJQUV4QixZQUFZLElBQVM7UUFDbkIsSUFBSSxDQUFDLElBQUksR0FBRyxJQUFJLENBQUM7UUFDakIsSUFBSSxDQUFDLFFBQVEsR0FBRyxJQUFJLENBQUMsTUFBTSxDQUFDO0lBQzlCLENBQUM7SUFFTSxLQUFLO1FBQ1YsT0FBTyxJQUFJLENBQUMsSUFBSSxDQUFDLENBQUMsQ0FBQyxJQUFJLElBQUksQ0FBQztJQUM5QixDQUFDO0lBRU0sSUFBSTtRQUNULE9BQU8sSUFBSSxDQUFDLElBQUksQ0FBQyxJQUFJLENBQUMsSUFBSSxDQUFDLE1BQU0sR0FBRyxDQUFDLENBQUMsSUFBSSxJQUFJLENBQUM7SUFDakQsQ0FBQztJQUVNLE9BQU87UUFDWixPQUFPLElBQUksQ0FBQyxJQUFJLENBQUMsTUFBTSxLQUFLLENBQUMsQ0FBQztJQUNoQyxDQUFDO0lBRU0sT0FBTztRQUNaLE9BQU8sSUFBSSxDQUFDLElBQUksQ0FBQztJQUNuQixDQUFDO0lBRU0sR0FBRyxDQUFJLEVBQWlCO1FBQzdCLE9BQU8sSUFBSSxDQUFDLElBQUksQ0FBQyxHQUFHLENBQUMsRUFBRSxDQUFDLENBQUM7SUFDM0IsQ0FBQztJQUVNLE1BQU0sQ0FBQyxFQUF1QjtRQUNuQyxPQUFPLElBQUksbUJBQW1CLENBQUksSUFBSSxDQUFDLElBQUksQ0FBQyxNQUFNLENBQUMsRUFBRSxDQUFDLENBQUMsQ0FBQztJQUMxRCxDQUFDO0lBRU0sWUFBWTtRQUNqQixPQUFPLElBQUksT0FBTyxDQUFDLE9BQU8sQ0FBQyxJQUFJLENBQUMsVUFBVSxDQUFJLENBQUMsUUFBUSxFQUFFLEVBQUU7WUFDekQsS0FBSyxNQUFNLEdBQUcsSUFBSSxJQUFJLENBQUMsSUFBSSxFQUFFLENBQUM7Z0JBQzVCLFFBQVEsQ0FBQyxJQUFJLENBQUMsR0FBRyxDQUFDLENBQUM7WUFDckIsQ0FBQztZQUNELFFBQVEsQ0FBQyxRQUFRLEVBQUUsQ0FBQztRQUN0QixDQUFDLENBQUMsQ0FBQztJQUNMLENBQUM7Q0FDRiJ9

package/dist_ts/sqldb/clickhouse/smartclickhouse.classes.smartclickhouse.d.ts

@@ -0,0 +1,49 @@
+import { ClickhouseTable } from './smartclickhouse.classes.clickhousetable.js';
+import { TimeDataTable } from './smartclickhouse.classes.timedatatable.js';
+import { ClickhouseHttpClient } from './smartclickhouse.classes.httpclient.js';
+import type { IClickhouseTableOptions } from './smartclickhouse.types.js';
+import type { ClickHouseConnection } from '../classes.clickhouseconnection.js';
+import type { MetricWriter } from './classes.metricwriter.js';
+export interface IClickhouseConstructorOptions {
+    url: string;
+    database: string;
+    username?: string;
+    password?: string;
+    /**
+     * Allow services to exit when waiting for clickhouse startup.
+     * This allows to leave the lifecycle flow to other processes
+     * like a listening server.
+     */
+    unref?: boolean;
+    timeoutMs?: number;
+}
+export declare class SmartClickHouseDb {
+    options: IClickhouseConstructorOptions;
+    clickhouseHttpClient: ClickhouseHttpClient;
+    private readonly writers;
+    private closing?;
+    private stopping;
+    private readonly canonical;
+    constructor(optionsArg: IClickhouseConstructorOptions, connection?: ClickHouseConnection);
+    /**
+     * Starts the connection to the Clickhouse db
+     */
+    start(dropOld?: boolean): Promise<void>;
+    ownWriter<Row>(writer: MetricWriter<Row>): MetricWriter<Row>;
+    closeWriters(): Promise<void>;
+    close(): Promise<void>;
+    createDatabase(dropOld?: boolean): Promise<void>;
+    pingDatabaseUntilAvailable(): Promise<void>;
+    /**
+     * Create a typed ClickHouse table with full configuration
+     */
+    createTable<T extends Record<string, any>>(options: IClickhouseTableOptions<T>): Promise<ClickhouseTable<T>>;
+    /**
+     * Get a TimeDataTable (backward compatible)
+     */
+    getTable(tableName: string): Promise<TimeDataTable>;
+    /**
+     * Execute a raw SQL query and return typed results
+     */
+    query<T = any>(sql: string): Promise<T[]>;
+}

package/dist_ts/sqldb/clickhouse/smartclickhouse.classes.smartclickhouse.js

@@ -0,0 +1,106 @@
+import * as plugins from './smartclickhouse.plugins.js';
+import { ClickhouseTable } from './smartclickhouse.classes.clickhousetable.js';
+import { TimeDataTable } from './smartclickhouse.classes.timedatatable.js';
+import { ClickhouseHttpClient } from './smartclickhouse.classes.httpclient.js';
+import { quoteClickHouseIdentifier as quoteIdentifier } from '../interfaces.js';
+import { Operation } from '../../core/classes.operation.js';
+import { LosslessClientError } from '../../core/classes.error.js';
+export class SmartClickHouseDb {
+    options;
+    clickhouseHttpClient;
+    writers = new Set();
+    closing;
+    stopping = false;
+    canonical;
+    constructor(optionsArg, connection) {
+        this.options = optionsArg;
+        this.canonical = Boolean(connection);
+        if (connection)
+            this.clickhouseHttpClient = new ClickhouseHttpClient(optionsArg, connection);
+    }
+    /**
+     * Starts the connection to the Clickhouse db
+     */
+    async start(dropOld = false) {
+        if (this.clickhouseHttpClient)
+            return;
+        this.clickhouseHttpClient = await ClickhouseHttpClient.createAndStart(this.options);
+        try {
+            await this.createDatabase(dropOld);
+        }
+        catch (error) {
+            await this.clickhouseHttpClient.close();
+            throw error;
+        }
+    }
+    ownWriter(writer) {
+        if (this.stopping)
+            throw new LosslessClientError('closed', 'Metrics connection is closing.');
+        this.writers.add(writer);
+        return writer;
+    }
+    closeWriters() {
+        return this.closing ??= (async () => {
+            this.stopping = true;
+            const results = await Promise.allSettled([...this.writers].map(writer => writer.close()));
+            this.writers.clear();
+            const errors = results.flatMap(result => result.status === 'rejected' ? [result.reason] : []);
+            if (errors.length)
+                throw new AggregateError(errors, 'Metrics writer flush failed.');
+        })();
+    }
+    async close() {
+        try {
+            await this.closeWriters();
+        }
+        finally {
+            await this.clickhouseHttpClient?.close();
+        }
+    }
+    async createDatabase(dropOld = false) {
+        if (dropOld) {
+            await this.clickhouseHttpClient.queryPromise(`DROP DATABASE IF EXISTS ${quoteIdentifier(this.options.database)}`);
+        }
+        await this.clickhouseHttpClient.queryPromise(`CREATE DATABASE IF NOT EXISTS ${quoteIdentifier(this.options.database)}`);
+    }
+    async pingDatabaseUntilAvailable() {
+        const operation = new Operation({ timeoutMs: this.options.timeoutMs });
+        try {
+            while (true) {
+                operation.check();
+                if (await this.clickhouseHttpClient.ping({ signal: operation.signal }))
+                    return;
+                await plugins.smartdelay.delayFor(100, null, this.options.unref);
+            }
+        }
+        finally {
+            operation.dispose();
+        }
+    }
+    // ---- NEW: Generic typed table factory ----
+    /**
+     * Create a typed ClickHouse table with full configuration
+     */
+    async createTable(options) {
+        return ClickhouseTable.create(this, {
+            autoSchemaEvolution: !this.canonical,
+            ...options,
+            database: options.database || this.options.database,
+        });
+    }
+    // ---- BACKWARD COMPAT: TimeDataTable factory ----
+    /**
+     * Get a TimeDataTable (backward compatible)
+     */
+    async getTable(tableName) {
+        return TimeDataTable.getTable(this, tableName);
+    }
+    // ---- RAW QUERY ----
+    /**
+     * Execute a raw SQL query and return typed results
+     */
+    async query(sql) {
+        return this.clickhouseHttpClient.queryTyped(sql);
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/dist_ts/sqldb/clickhouse/smartclickhouse.classes.timedatatable.d.ts

@@ -0,0 +1,51 @@
+import * as plugins from './smartclickhouse.plugins.js';
+import type { SmartClickHouseDb } from './smartclickhouse.classes.smartclickhouse.js';
+import { ClickhouseTable } from './smartclickhouse.classes.clickhousetable.js';
+/**
+ * Creates a pre-configured ClickhouseTable for time-series data.
+ * This is the backward-compatible equivalent of the old TimeDataTable class.
+ *
+ * The table uses MergeTree engine, orders by timestamp, and has auto-schema evolution enabled.
+ */
+export declare function createTimeDataTable(db: SmartClickHouseDb, tableName: string, retainDataForDays?: number): Promise<TimeDataTable>;
+/**
+ * TimeDataTable — a ClickhouseTable pre-configured for time-series data.
+ * Provides backward-compatible convenience methods (addData, getLastEntries, etc.).
+ */
+export declare class TimeDataTable extends ClickhouseTable<any> {
+    /**
+     * Static factory for backward compatibility
+     */
+    static getTable(smartClickHouseDbRefArg: SmartClickHouseDb, tableNameArg: string, retainDataForDays?: number): Promise<TimeDataTable>;
+    constructor(db: SmartClickHouseDb, tableName: string, retainDataForDays?: number);
+    /**
+     * Insert data with auto-schema evolution and object flattening.
+     * Backward-compatible: accepts arbitrary JSON objects with a timestamp field.
+     */
+    addData(dataArg: any): Promise<any>;
+    /**
+     * Get the last N entries ordered by timestamp DESC
+     */
+    getLastEntries(count: number): Promise<any[]>;
+    /**
+     * Get entries newer than a unix timestamp (in milliseconds)
+     */
+    getEntriesNewerThan(unixTimestamp: number): Promise<any[]>;
+    /**
+     * Get entries between two unix timestamps (in milliseconds)
+     */
+    getEntriesBetween(unixTimestampStart: number, unixTimestampEnd: number): Promise<any[]>;
+    /**
+     * Delete entries older than N days
+     */
+    deleteOldEntries(days: number): Promise<void>;
+    private validateTimestamp;
+    /**
+     * Drop the table (backward-compatible alias for drop())
+     */
+    delete(): Promise<void>;
+    /**
+     * Watch for new entries via polling (backward-compatible wrapper)
+     */
+    watchNewEntries(): plugins.smartrx.rxjs.Observable<any>;
+}

package/dist_ts/sqldb/clickhouse/smartclickhouse.classes.timedatatable.js

@@ -0,0 +1,96 @@
+import * as plugins from './smartclickhouse.plugins.js';
+import { ClickhouseTable } from './smartclickhouse.classes.clickhousetable.js';
+/**
+ * Creates a pre-configured ClickhouseTable for time-series data.
+ * This is the backward-compatible equivalent of the old TimeDataTable class.
+ *
+ * The table uses MergeTree engine, orders by timestamp, and has auto-schema evolution enabled.
+ */
+export async function createTimeDataTable(db, tableName, retainDataForDays = 30) {
+    const table = new TimeDataTable(db, tableName, retainDataForDays);
+    await table.setup();
+    return table;
+}
+/**
+ * TimeDataTable — a ClickhouseTable pre-configured for time-series data.
+ * Provides backward-compatible convenience methods (addData, getLastEntries, etc.).
+ */
+export class TimeDataTable extends ClickhouseTable {
+    /**
+     * Static factory for backward compatibility
+     */
+    static async getTable(smartClickHouseDbRefArg, tableNameArg, retainDataForDays = 30) {
+        return createTimeDataTable(smartClickHouseDbRefArg, tableNameArg, retainDataForDays);
+    }
+    constructor(db, tableName, retainDataForDays = 30) {
+        super(db, {
+            tableName,
+            engine: { engine: 'MergeTree' },
+            orderBy: 'timestamp',
+            retainDataForDays,
+            autoSchemaEvolution: true,
+        });
+    }
+    /**
+     * Insert data with auto-schema evolution and object flattening.
+     * Backward-compatible: accepts arbitrary JSON objects with a timestamp field.
+     */
+    async addData(dataArg) {
+        if (!dataArg.timestamp || typeof dataArg.timestamp !== 'number') {
+            throw new Error('timestamp must be of type number');
+        }
+        return this.insert(dataArg);
+    }
+    /**
+     * Get the last N entries ordered by timestamp DESC
+     */
+    async getLastEntries(count) {
+        return this.query()
+            .orderBy('timestamp', 'DESC')
+            .limit(count)
+            .toArray();
+    }
+    /**
+     * Get entries newer than a unix timestamp (in milliseconds)
+     */
+    async getEntriesNewerThan(unixTimestamp) {
+        return this.db.clickhouseHttpClient.queryPromise(`
+      SELECT * FROM ${this.qualifiedName}
+      WHERE timestamp > fromUnixTimestamp64Milli({timestamp:Int64})
+    `, { timestamp: this.validateTimestamp(unixTimestamp) });
+    }
+    /**
+     * Get entries between two unix timestamps (in milliseconds)
+     */
+    async getEntriesBetween(unixTimestampStart, unixTimestampEnd) {
+        return this.db.clickhouseHttpClient.queryPromise(`
+      SELECT * FROM ${this.qualifiedName}
+      WHERE timestamp > fromUnixTimestamp64Milli({start:Int64})
+      AND timestamp < fromUnixTimestamp64Milli({end:Int64})
+    `, { start: this.validateTimestamp(unixTimestampStart), end: this.validateTimestamp(unixTimestampEnd) });
+    }
+    /**
+     * Delete entries older than N days
+     */
+    async deleteOldEntries(days) {
+        await this.deleteOlderThan('timestamp', days + ' DAY');
+    }
+    validateTimestamp(value) {
+        if (!Number.isSafeInteger(value))
+            throw new RangeError('Timestamp must be an integer in milliseconds.');
+        return value;
+    }
+    /**
+     * Drop the table (backward-compatible alias for drop())
+     */
+    async delete() {
+        return this.drop();
+    }
+    /**
+     * Watch for new entries via polling (backward-compatible wrapper)
+     */
+    watchNewEntries() {
+        return this.watch();
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/dist_ts/sqldb/clickhouse/smartclickhouse.plugins.d.ts

@@ -0,0 +1,5 @@
+import * as smartdelay from '@push.rocks/smartdelay';
+import * as smartobject from '@push.rocks/smartobject';
+import * as smartpromise from '@push.rocks/smartpromise';
+import * as smartrx from '@push.rocks/smartrx';
+export { smartdelay, smartobject, smartpromise, smartrx };

package/dist_ts/sqldb/clickhouse/smartclickhouse.plugins.js

@@ -0,0 +1,6 @@
+import * as smartdelay from '@push.rocks/smartdelay';
+import * as smartobject from '@push.rocks/smartobject';
+import * as smartpromise from '@push.rocks/smartpromise';
+import * as smartrx from '@push.rocks/smartrx';
+export { smartdelay, smartobject, smartpromise, smartrx };
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoic21hcnRjbGlja2hvdXNlLnBsdWdpbnMuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi90cy9zcWxkYi9jbGlja2hvdXNlL3NtYXJ0Y2xpY2tob3VzZS5wbHVnaW5zLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sS0FBSyxVQUFVLE1BQU0sd0JBQXdCLENBQUM7QUFDckQsT0FBTyxLQUFLLFdBQVcsTUFBTSx5QkFBeUIsQ0FBQztBQUN2RCxPQUFPLEtBQUssWUFBWSxNQUFNLDBCQUEwQixDQUFDO0FBQ3pELE9BQU8sS0FBSyxPQUFPLE1BQU0scUJBQXFCLENBQUM7QUFDL0MsT0FBTyxFQUFFLFVBQVUsRUFBRSxXQUFXLEVBQUUsWUFBWSxFQUFFLE9BQU8sRUFBRSxDQUFDIn0=

package/dist_ts/sqldb/clickhouse/smartclickhouse.types.d.ts

@@ -0,0 +1,53 @@
+export type TClickhouseColumnType = 'String' | 'UInt8' | 'UInt16' | 'UInt32' | 'UInt64' | 'Int8' | 'Int16' | 'Int32' | 'Int64' | 'Float32' | 'Float64' | 'Bool' | 'Date' | 'Date32' | 'DateTime' | 'DateTime64' | 'UUID' | 'IPv4' | 'IPv6' | (string & {});
+export type TClickhouseEngine = 'MergeTree' | 'ReplacingMergeTree' | 'SummingMergeTree' | 'AggregatingMergeTree' | 'CollapsingMergeTree' | 'VersionedCollapsingMergeTree';
+export interface IEngineConfig {
+    engine: TClickhouseEngine;
+    /** For ReplacingMergeTree: the version column name */
+    versionColumn?: string;
+    /** For CollapsingMergeTree: the sign column name */
+    signColumn?: string;
+}
+export interface IColumnDefinition {
+    name: string;
+    type: TClickhouseColumnType;
+    defaultExpression?: string;
+    codec?: string;
+}
+export interface IClickhouseTableOptions<T = any> {
+    tableName: string;
+    database?: string;
+    engine?: IEngineConfig;
+    orderBy: (keyof T & string) | (keyof T & string)[];
+    partitionBy?: string;
+    primaryKey?: (keyof T & string) | (keyof T & string)[];
+    ttl?: {
+        column: keyof T & string;
+        interval: string;
+    };
+    columns?: IColumnDefinition[];
+    /** Enable auto-schema evolution (add columns from data). Default: true */
+    autoSchemaEvolution?: boolean;
+    /** Data retention in days (shorthand for ttl). If ttl is set, this is ignored. */
+    retainDataForDays?: number;
+}
+export interface IColumnInfo {
+    database: string;
+    table: string;
+    name: string;
+    type: string;
+    position: string;
+    default_kind: string;
+    default_expression: string;
+    data_compressed_bytes: string;
+    data_uncompressed_bytes: string;
+    marks_bytes: string;
+    comment: string;
+    is_in_partition_key: 0 | 1;
+    is_in_sorting_key: 0 | 1;
+    is_in_primary_key: 0 | 1;
+    is_in_sampling_key: 0 | 1;
+    compression_codec: string;
+}
+export type TComparisonOperator = '=' | '!=' | '>' | '>=' | '<' | '<=' | 'LIKE' | 'NOT LIKE' | 'IN' | 'NOT IN' | 'BETWEEN';
+export declare function escapeClickhouseValue(value: any): string;
+export declare function detectClickhouseType(value: any): TClickhouseColumnType | null;

package/dist_ts/sqldb/clickhouse/smartclickhouse.types.js

@@ -0,0 +1,41 @@
+// ============================================================
+// Value Escaping (SQL Injection Prevention)
+// ============================================================
+export function escapeClickhouseValue(value) {
+    if (value === null || value === undefined)
+        return 'NULL';
+    if (typeof value === 'number')
+        return String(value);
+    if (typeof value === 'boolean')
+        return value ? '1' : '0';
+    if (value instanceof Date)
+        return `'${value.toISOString().replace('T', ' ').replace('Z', '')}'`;
+    if (Array.isArray(value)) {
+        return `(${value.map(escapeClickhouseValue).join(', ')})`;
+    }
+    // String: escape single quotes and backslashes
+    return `'${String(value).replace(/\\/g, '\\\\').replace(/'/g, "\\'")}'`;
+}
+// ============================================================
+// ClickHouse Type Detection from JS Values
+// ============================================================
+export function detectClickhouseType(value) {
+    if (value === null || value === undefined)
+        return null;
+    if (typeof value === 'string')
+        return 'String';
+    if (typeof value === 'number')
+        return 'Float64';
+    if (typeof value === 'boolean')
+        return 'UInt8';
+    if (value instanceof Array) {
+        if (value.length === 0)
+            return null;
+        const elementType = detectClickhouseType(value[0]);
+        if (!elementType)
+            return null;
+        return `Array(${elementType})`;
+    }
+    return null;
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoic21hcnRjbGlja2hvdXNlLnR5cGVzLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vdHMvc3FsZGIvY2xpY2tob3VzZS9zbWFydGNsaWNraG91c2UudHlwZXMudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBdUdBLCtEQUErRDtBQUMvRCw0Q0FBNEM7QUFDNUMsK0RBQStEO0FBQy9ELE1BQU0sVUFBVSxxQkFBcUIsQ0FBQyxLQUFVO0lBQzlDLElBQUksS0FBSyxLQUFLLElBQUksSUFBSSxLQUFLLEtBQUssU0FBUztRQUFFLE9BQU8sTUFBTSxDQUFDO0lBQ3pELElBQUksT0FBTyxLQUFLLEtBQUssUUFBUTtRQUFFLE9BQU8sTUFBTSxDQUFDLEtBQUssQ0FBQyxDQUFDO0lBQ3BELElBQUksT0FBTyxLQUFLLEtBQUssU0FBUztRQUFFLE9BQU8sS0FBSyxDQUFDLENBQUMsQ0FBQyxHQUFHLENBQUMsQ0FBQyxDQUFDLEdBQUcsQ0FBQztJQUN6RCxJQUFJLEtBQUssWUFBWSxJQUFJO1FBQUUsT0FBTyxJQUFJLEtBQUssQ0FBQyxXQUFXLEVBQUUsQ0FBQyxPQUFPLENBQUMsR0FBRyxFQUFFLEdBQUcsQ0FBQyxDQUFDLE9BQU8sQ0FBQyxHQUFHLEVBQUUsRUFBRSxDQUFDLEdBQUcsQ0FBQztJQUNoRyxJQUFJLEtBQUssQ0FBQyxPQUFPLENBQUMsS0FBSyxDQUFDLEVBQUUsQ0FBQztRQUN6QixPQUFPLElBQUksS0FBSyxDQUFDLEdBQUcsQ0FBQyxxQkFBcUIsQ0FBQyxDQUFDLElBQUksQ0FBQyxJQUFJLENBQUMsR0FBRyxDQUFDO0lBQzVELENBQUM7SUFDRCwrQ0FBK0M7SUFDL0MsT0FBTyxJQUFJLE1BQU0sQ0FBQyxLQUFLLENBQUMsQ0FBQyxPQUFPLENBQUMsS0FBSyxFQUFFLE1BQU0sQ0FBQyxDQUFDLE9BQU8sQ0FBQyxJQUFJLEVBQUUsS0FBSyxDQUFDLEdBQUcsQ0FBQztBQUMxRSxDQUFDO0FBRUQsK0RBQStEO0FBQy9ELDJDQUEyQztBQUMzQywrREFBK0Q7QUFDL0QsTUFBTSxVQUFVLG9CQUFvQixDQUFDLEtBQVU7SUFDN0MsSUFBSSxLQUFLLEtBQUssSUFBSSxJQUFJLEtBQUssS0FBSyxTQUFTO1FBQUUsT0FBTyxJQUFJLENBQUM7SUFDdkQsSUFBSSxPQUFPLEtBQUssS0FBSyxRQUFRO1FBQUUsT0FBTyxRQUFRLENBQUM7SUFDL0MsSUFBSSxPQUFPLEtBQUssS0FBSyxRQUFRO1FBQUUsT0FBTyxTQUFTLENBQUM7SUFDaEQsSUFBSSxPQUFPLEtBQUssS0FBSyxTQUFTO1FBQUUsT0FBTyxPQUFPLENBQUM7SUFDL0MsSUFBSSxLQUFLLFlBQVksS0FBSyxFQUFFLENBQUM7UUFDM0IsSUFBSSxLQUFLLENBQUMsTUFBTSxLQUFLLENBQUM7WUFBRSxPQUFPLElBQUksQ0FBQztRQUNwQyxNQUFNLFdBQVcsR0FBRyxvQkFBb0IsQ0FBQyxLQUFLLENBQUMsQ0FBQyxDQUFDLENBQUMsQ0FBQztRQUNuRCxJQUFJLENBQUMsV0FBVztZQUFFLE9BQU8sSUFBSSxDQUFDO1FBQzlCLE9BQU8sU0FBUyxXQUFXLEdBQTRCLENBQUM7SUFDMUQsQ0FBQztJQUNELE9BQU8sSUFBSSxDQUFDO0FBQ2QsQ0FBQyJ9