@lossless.org/client 0.1.0

package/dist_ts/sqldb/classes.sqlconnection.js

@@ -0,0 +1,376 @@
+import * as plugins from './plugins.mariadb.js';
+import { SqlTable } from './classes.sqltable.js';
+import { SqlPool } from './internal.sqlpool.js';
+import { Operation } from '../core/classes.operation.js';
+import { LosslessClientError, backendError } from '../core/classes.error.js';
+import { quoteIdentifier, resultLimits, valueBytes } from './interfaces.js';
+const validateStatement = (statement) => {
+    if (!statement || typeof statement.sql !== 'string' || !statement.sql.trim()) {
+        throw new LosslessClientError('invalid_argument', 'A SQL statement is required.');
+    }
+    if (statement.values !== undefined && !Array.isArray(statement.values)) {
+        throw new LosslessClientError('invalid_argument', 'SQL values must be an array.');
+    }
+    for (const value of statement.values ?? []) {
+        if (value !== null && !['string', 'number', 'bigint', 'boolean'].includes(typeof value) &&
+            !(value instanceof Date) && !(value instanceof Uint8Array)) {
+            throw new LosslessClientError('invalid_argument', 'SQL parameters must be supported scalar, date or binary values.');
+        }
+        if (value instanceof Date && !Number.isFinite(value.getTime())) {
+            throw new LosslessClientError('invalid_argument', 'Invalid date parameter.');
+        }
+        if (typeof value === 'number' && (!Number.isFinite(value) ||
+            (Number.isInteger(value) && !Number.isSafeInteger(value)))) {
+            throw new LosslessClientError('invalid_argument', 'Use bigint or a decimal string for exact large numbers.');
+        }
+    }
+};
+const boundValues = (statement) => (statement.values ?? []).map(value => value instanceof Date
+    ? value.toISOString().replace('T', ' ').replace('Z', '')
+    : value instanceof Uint8Array ? Buffer.from(value) : value);
+const mutationResult = (result) => ({
+    affectedRows: result.affectedRows,
+    ...(result.insertId === undefined ? {} : { insertId: BigInt(result.insertId) }),
+    completion: 'acknowledged',
+});
+/** One MariaDB-protocol pool. SQLDB uses the same wire adapter with its own capabilities. */
+export class SqlConnection {
+    options;
+    backend;
+    capabilities;
+    pool;
+    closing;
+    connecting;
+    closed = false;
+    acquisitions = new Set();
+    leases = new Set();
+    pendingOperations = new Set();
+    constructor(options) {
+        this.options = options;
+        if (!['sqldb', 'mariadb'].includes(options.backend) || !options.host || !options.database || !options.user) {
+            throw new LosslessClientError('invalid_argument', 'SQL backend, host, user and database are required.');
+        }
+        if (options.backend === 'sqldb' && options.tls) {
+            throw new LosslessClientError('unsupported_capability', 'SQLDB does not yet support TLS.');
+        }
+        this.backend = options.backend;
+        this.capabilities = Object.freeze({ backend: this.backend, transactions: 'available',
+            changeStreams: 'unsupported', objectMetrics: 'unsupported',
+            diskResidentScans: this.backend === 'sqldb' ? 'unsupported' : 'available' });
+    }
+    connect(options = {}) {
+        if (this.closed || this.closing)
+            return Promise.reject(new LosslessClientError('closed', 'SQL connection is closed.'));
+        if (this.connecting)
+            return this.connecting;
+        if (this.pool)
+            return Promise.resolve();
+        const limit = this.options.connectionLimit ?? 10;
+        if (!Number.isSafeInteger(limit) || limit < 1 || limit > 1024) {
+            return Promise.reject(new LosslessClientError('invalid_argument', 'connectionLimit must be between 1 and 1024.'));
+        }
+        this.pool = new SqlPool({
+            host: this.options.host, port: this.options.port ?? 3306, user: this.options.user,
+            password: this.options.password, database: this.options.database,
+            connectTimeout: this.options.timeoutMs ?? 30_000,
+            ssl: this.options.tls, bigIntAsNumber: false, decimalAsNumber: false,
+            dateStrings: true, timezone: this.backend === 'mariadb' ? '+00:00' : undefined,
+            multipleStatements: false,
+        }, limit);
+        this.connecting = (async () => {
+            try {
+                await this.query({ sql: 'SELECT 1 AS ready' }, { ...options, maxRows: 1 });
+            }
+            catch (error) {
+                const pool = this.pool;
+                this.pool = undefined;
+                await pool?.end();
+                throw error;
+            }
+            finally {
+                this.connecting = undefined;
+            }
+        })();
+        return this.connecting;
+    }
+    async ready(options = {}) {
+        try {
+            await this.query({ sql: 'SELECT 1 AS ready' }, { ...options, maxRows: 1 });
+            return { ready: true };
+        }
+        catch (error) {
+            return { ready: false, reason: error instanceof LosslessClientError ? error.code : 'unavailable' };
+        }
+    }
+    table(name) {
+        return new SqlTable(this, name);
+    }
+    acquire(options) {
+        if (!this.pool || this.closed || this.closing) {
+            return Promise.reject(new LosslessClientError(this.closed ? 'closed' : 'not_connected', 'SQL connection is not open.'));
+        }
+        const pool = this.pool;
+        const operation = new Operation(options, this.options.timeoutMs);
+        this.pendingOperations.add(operation);
+        const acquisition = (async () => {
+            let connection;
+            try {
+                operation.check();
+                connection = await pool.getConnection(operation);
+                operation.check();
+                const acquired = connection;
+                const settled = Promise.withResolvers();
+                let disposal;
+                const abort = () => acquired.destroy();
+                const lease = { connection: acquired, operation, done: settled.promise,
+                    close: () => disposal ??= (async () => {
+                        try {
+                            await acquired.release();
+                        }
+                        finally {
+                            operation.signal.removeEventListener('abort', abort);
+                            operation.dispose();
+                            this.pendingOperations.delete(operation);
+                            this.leases.delete(lease);
+                            settled.resolve();
+                        }
+                    })(),
+                };
+                operation.signal.addEventListener('abort', abort, { once: true });
+                this.leases.add(lease);
+                return lease;
+            }
+            catch (error) {
+                connection?.destroy();
+                await connection?.release();
+                operation.dispose();
+                this.pendingOperations.delete(operation);
+                throw operation.signal.aborted ? operation.signal.reason : backendError(error);
+            }
+        })();
+        this.acquisitions.add(acquisition);
+        void acquisition.finally(() => this.acquisitions.delete(acquisition)).catch(() => { });
+        return acquisition;
+    }
+    async execute(statement, options = {}) {
+        validateStatement(statement);
+        const lease = await this.acquire(options);
+        let dispatched = false;
+        try {
+            lease.operation.check();
+            dispatched = true;
+            const result = await lease.connection.execute(statement.sql, boundValues(statement));
+            return mutationResult(result);
+        }
+        catch (error) {
+            if (dispatched && (lease.operation.signal.aborted || !lease.connection.isValid())) {
+                throw new LosslessClientError('ambiguous_write', 'SQL write outcome is unknown after connection loss.', { cause: error });
+            }
+            throw backendError(error);
+        }
+        finally {
+            await lease.close();
+        }
+    }
+    async query(statement, options = {}) {
+        const limits = resultLimits(options);
+        const rows = [];
+        let bytes = 0;
+        for await (const row of this.stream(statement, options)) {
+            bytes += valueBytes(row);
+            if (rows.length >= limits.rows || bytes > limits.bytes) {
+                throw new LosslessClientError('result_limit', 'SQL result exceeded its materialization limit. Use stream().');
+            }
+            rows.push(row);
+        }
+        return rows;
+    }
+    async *stream(statement, options = {}) {
+        validateStatement(statement);
+        const lease = await this.acquire(options);
+        let readable;
+        let completed = false;
+        try {
+            lease.operation.check();
+            readable = lease.connection.queryStream(statement.sql, boundValues(statement));
+            // A paused consumer still owns a socket. Stream close independently returns its lease.
+            readable.on('error', () => { });
+            readable.once('close', () => { void lease.close().catch(() => { }); });
+            for await (const row of readable) {
+                lease.operation.check();
+                yield row;
+            }
+            lease.operation.check();
+            completed = true;
+        }
+        catch (error) {
+            throw lease.operation.signal.aborted ? lease.operation.signal.reason : backendError(error);
+        }
+        finally {
+            if (!completed)
+                lease.connection.destroy();
+            readable?.destroy();
+            await lease.close();
+        }
+    }
+    async insert(table, rows, options = {}) {
+        const tableName = quoteIdentifier(table);
+        const batchSize = options.batchSize ?? 500;
+        const maxBytes = options.maxBatchBytes ?? 4 * 1024 * 1024;
+        if (!Number.isSafeInteger(batchSize) || batchSize < 1 || !Number.isSafeInteger(maxBytes) || maxBytes < 1) {
+            throw new LosslessClientError('invalid_argument', 'Insert batch limits must be positive integers.');
+        }
+        const operation = new Operation(options, this.options.timeoutMs);
+        if (!this.pool || this.closed || this.closing) {
+            operation.dispose();
+            throw new LosslessClientError(this.closed ? 'closed' : 'not_connected', 'SQL connection is not open.');
+        }
+        this.pendingOperations.add(operation);
+        let columns;
+        let batch = [], bytes = 0, affectedRows = 0;
+        const flush = async () => {
+            if (!batch.length)
+                return;
+            const result = await this.execute({ sql: `INSERT INTO ${tableName} (${columns.map(quoteIdentifier).join(',')}) VALUES ${batch.map(() => '(' + columns.map(() => '?').join(',') + ')').join(',')}`,
+                values: batch.flat() }, { signal: operation.signal, timeoutMs: options.timeoutMs });
+            affectedRows += result.affectedRows;
+            batch = [];
+            bytes = 0;
+        };
+        try {
+            for await (const row of operation.iterate(rows)) {
+                operation.check();
+                columns ??= Object.keys(row);
+                if (!columns.length || Object.keys(row).length !== columns.length || columns.some(key => !Object.hasOwn(row, key))) {
+                    throw new LosslessClientError('invalid_argument', 'Every inserted row must have the same columns.');
+                }
+                const size = valueBytes(row);
+                if (size > maxBytes)
+                    throw new LosslessClientError('invalid_argument', 'Insert row exceeds maxBatchBytes.');
+                if (batch.length && (batch.length >= batchSize || bytes + size > maxBytes))
+                    await flush();
+                batch.push(columns.map(key => row[key]));
+                bytes += size;
+            }
+            await flush();
+            return { affectedRows, completion: 'acknowledged' };
+        }
+        catch (error) {
+            if (affectedRows)
+                throw new LosslessClientError(error instanceof LosslessClientError && error.code === 'ambiguous_write'
+                    ? 'ambiguous_write' : 'partial_write', 'Bulk insert stopped after acknowledged batches.', { cause: error, acknowledgedRows: affectedRows });
+            throw error;
+        }
+        finally {
+            operation.dispose();
+            this.pendingOperations.delete(operation);
+        }
+    }
+    async transaction(callback, options = {}) {
+        const lease = await this.acquire(options);
+        const transaction = new SqlTransaction(lease);
+        let committing = false;
+        try {
+            await lease.connection.beginTransaction();
+            const value = await lease.operation.wait(callback(transaction));
+            await transaction.finish();
+            lease.operation.check();
+            committing = true;
+            await lease.connection.commit();
+            return value;
+        }
+        catch (error) {
+            await transaction.finish().catch(() => { });
+            if (committing && !lease.connection.isValid()) {
+                throw new LosslessClientError('ambiguous_write', 'Transaction commit outcome is unknown.', { cause: error });
+            }
+            if (lease.operation.signal.aborted)
+                throw lease.operation.signal.reason;
+            try {
+                await lease.connection.rollback();
+            }
+            catch (rollbackError) {
+                throw new AggregateError([error, rollbackError], 'Transaction and rollback failed.');
+            }
+            throw error;
+        }
+        finally {
+            await lease.close();
+        }
+    }
+    close() {
+        return this.closing ??= (async () => {
+            this.closed = true;
+            for (const operation of this.pendingOperations)
+                operation.cancel();
+            await Promise.allSettled([...this.acquisitions]);
+            for (const lease of this.leases)
+                lease.operation.cancel();
+            await Promise.all([...this.leases].map(lease => lease.close()));
+            await this.connecting?.catch(() => { });
+            const pool = this.pool;
+            this.pool = undefined;
+            await pool?.end();
+        })();
+    }
+}
+/** Bound to a single transaction callback and physical connection. */
+export class SqlTransaction {
+    lease;
+    active;
+    failure;
+    finished = false;
+    constructor(lease) {
+        this.lease = lease;
+    }
+    run(action) {
+        if (this.finished || this.active)
+            return Promise.reject(new LosslessClientError('invalid_argument', 'Transaction is closed or already has an active operation.'));
+        if (this.failure)
+            return Promise.reject(this.failure);
+        this.lease.operation.check();
+        const result = action().catch(error => { this.failure = error; throw error; });
+        this.active = result;
+        void result.finally(() => { if (this.active === result)
+            this.active = undefined; }).catch(() => { });
+        return result;
+    }
+    execute(statement) {
+        validateStatement(statement);
+        return this.run(async () => mutationResult(await this.lease.connection.execute(statement.sql, boundValues(statement))));
+    }
+    query(statement, options = {}) {
+        validateStatement(statement);
+        const limits = resultLimits(options);
+        return this.run(async () => {
+            const rows = [];
+            let bytes = 0;
+            const source = this.lease.connection.queryStream(statement.sql, boundValues(statement));
+            try {
+                for await (const row of source) {
+                    this.lease.operation.check();
+                    bytes += valueBytes(row);
+                    if (rows.length >= limits.rows || bytes > limits.bytes) {
+                        throw new LosslessClientError('result_limit', 'Transaction result exceeded its materialization limit.');
+                    }
+                    rows.push(row);
+                }
+                return rows;
+            }
+            catch (error) {
+                this.lease.connection.destroy();
+                throw error;
+            }
+            finally {
+                source.destroy();
+            }
+        });
+    }
+    async finish() {
+        this.finished = true;
+        await this.active;
+        if (this.failure)
+            throw this.failure;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"classes.sqlconnection.js","sourceRoot":"","sources":["../../ts/sqldb/classes.sqlconnection.ts"],"names":[],"mappings":"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"}

package/dist_ts/sqldb/classes.sqltable.d.ts

@@ -0,0 +1,29 @@
+import type { SqlConnection } from './classes.sqlconnection.js';
+import type { IInsertOptions, IQueryOptions, ISqlStatement, TSqlValue } from './interfaces.js';
+import type { IOperationOptions } from '../core/interfaces.js';
+export type TSqlSelector<Row> = Partial<{
+    [Key in keyof Row]: TSqlValue;
+}>;
+export interface ISqlSelectOptions<Row> extends IQueryOptions {
+    columns?: (keyof Row & string)[];
+    orderBy?: {
+        column: keyof Row & string;
+        direction?: 'ASC' | 'DESC';
+    }[];
+    limit?: number;
+}
+/** A typed handle to an existing relational table. Schema creation is explicit SQL or a migration. */
+export declare class SqlTable<Row extends {
+    [Key in keyof Row]: TSqlValue;
+}> {
+    private readonly connection;
+    readonly name: string;
+    constructor(connection: SqlConnection, name: string);
+    private where;
+    selectStatement(selector?: TSqlSelector<Row>, options?: ISqlSelectOptions<Row>): ISqlStatement;
+    query(selector?: TSqlSelector<Row>, options?: ISqlSelectOptions<Row>): Promise<Row[]>;
+    stream(selector?: TSqlSelector<Row>, options?: ISqlSelectOptions<Row>): AsyncGenerator<Row>;
+    insert(rows: Iterable<Row> | AsyncIterable<Row>, options?: IInsertOptions): Promise<import("./interfaces.js").ISqlMutationResult>;
+    update(selector: TSqlSelector<Row>, changes: Partial<Row>, options?: IOperationOptions): Promise<import("./interfaces.js").ISqlMutationResult>;
+    delete(selector: TSqlSelector<Row>, options?: IOperationOptions): Promise<import("./interfaces.js").ISqlMutationResult>;
+}

package/dist_ts/sqldb/classes.sqltable.js

@@ -0,0 +1,70 @@
+import { quoteIdentifier } from './interfaces.js';
+import { LosslessClientError } from '../core/classes.error.js';
+/** A typed handle to an existing relational table. Schema creation is explicit SQL or a migration. */
+export class SqlTable {
+    connection;
+    name;
+    constructor(connection, name) {
+        this.connection = connection;
+        this.name = name;
+        quoteIdentifier(name);
+    }
+    where(selector, required = false) {
+        const entries = Object.entries(selector);
+        if (required && !entries.length)
+            throw new LosslessClientError('invalid_argument', 'A nonempty selector is required for table mutations.');
+        const values = [];
+        const sql = entries.map(([key, value]) => {
+            if (value === undefined)
+                throw new LosslessClientError('invalid_argument', 'Undefined selector values are not allowed.');
+            if (value === null)
+                return quoteIdentifier(key) + ' IS NULL';
+            values.push(value);
+            return quoteIdentifier(key) + ' = ?';
+        }).join(' AND ');
+        return { sql: sql ? ' WHERE ' + sql : '', values };
+    }
+    selectStatement(selector = {}, options = {}) {
+        const where = this.where(selector);
+        if (options.columns?.length === 0)
+            throw new LosslessClientError('invalid_argument', 'Select at least one column.');
+        let sql = 'SELECT ' + (options.columns?.map(quoteIdentifier).join(', ') ?? '*') + ' FROM ' + quoteIdentifier(this.name) + where.sql;
+        if (options.orderBy?.length)
+            sql += ' ORDER BY ' + options.orderBy.map(order => {
+                const direction = order.direction ?? 'ASC';
+                if (!['ASC', 'DESC'].includes(direction))
+                    throw new LosslessClientError('invalid_argument', 'Invalid sort direction.');
+                return quoteIdentifier(order.column) + ' ' + direction;
+            }).join(', ');
+        if (options.limit !== undefined) {
+            if (!Number.isSafeInteger(options.limit) || options.limit < 0)
+                throw new LosslessClientError('invalid_argument', 'Limit must be a nonnegative safe integer.');
+            sql += ' LIMIT ' + options.limit;
+        }
+        return { sql, values: where.values };
+    }
+    query(selector = {}, options = {}) {
+        return this.connection.query(this.selectStatement(selector, options), options);
+    }
+    stream(selector = {}, options = {}) {
+        return this.connection.stream(this.selectStatement(selector, options), options);
+    }
+    insert(rows, options = {}) {
+        return this.connection.insert(this.name, rows, options);
+    }
+    update(selector, changes, options = {}) {
+        const where = this.where(selector, true);
+        const entries = Object.entries(changes);
+        if (!entries.length || entries.some(([, value]) => value === undefined)) {
+            throw new LosslessClientError('invalid_argument', 'Supply at least one defined changed value.');
+        }
+        return this.connection.execute({ sql: 'UPDATE ' + quoteIdentifier(this.name) + ' SET ' +
+                entries.map(([key]) => quoteIdentifier(key) + ' = ?').join(', ') + where.sql,
+            values: [...entries.map(([, value]) => value), ...where.values] }, options);
+    }
+    delete(selector, options = {}) {
+        const where = this.where(selector, true);
+        return this.connection.execute({ sql: 'DELETE FROM ' + quoteIdentifier(this.name) + where.sql, values: where.values }, options);
+    }
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY2xhc3Nlcy5zcWx0YWJsZS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uL3RzL3NxbGRiL2NsYXNzZXMuc3FsdGFibGUudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBR0EsT0FBTyxFQUFFLGVBQWUsRUFBRSxNQUFNLGlCQUFpQixDQUFDO0FBQ2xELE9BQU8sRUFBRSxtQkFBbUIsRUFBRSxNQUFNLDBCQUEwQixDQUFDO0FBUy9ELHNHQUFzRztBQUN0RyxNQUFNLE9BQU8sUUFBUTtJQUNVO0lBQTJDO0lBQXhFLFlBQTZCLFVBQXlCLEVBQWtCLElBQVk7UUFBdkQsZUFBVSxHQUFWLFVBQVUsQ0FBZTtRQUFrQixTQUFJLEdBQUosSUFBSSxDQUFRO1FBQUksZUFBZSxDQUFDLElBQUksQ0FBQyxDQUFDO0lBQUMsQ0FBQztJQUV4RyxLQUFLLENBQUMsUUFBMkIsRUFBRSxRQUFRLEdBQUcsS0FBSztRQUN6RCxNQUFNLE9BQU8sR0FBRyxNQUFNLENBQUMsT0FBTyxDQUFDLFFBQVEsQ0FBQyxDQUFDO1FBQ3pDLElBQUksUUFBUSxJQUFJLENBQUMsT0FBTyxDQUFDLE1BQU07WUFBRSxNQUFNLElBQUksbUJBQW1CLENBQUMsa0JBQWtCLEVBQUUsc0RBQXNELENBQUMsQ0FBQztRQUMzSSxNQUFNLE1BQU0sR0FBZ0IsRUFBRSxDQUFDO1FBQy9CLE1BQU0sR0FBRyxHQUFHLE9BQU8sQ0FBQyxHQUFHLENBQUMsQ0FBQyxDQUFDLEdBQUcsRUFBRSxLQUFLLENBQUMsRUFBRSxFQUFFO1lBQ3ZDLElBQUksS0FBSyxLQUFLLFNBQVM7Z0JBQUUsTUFBTSxJQUFJLG1CQUFtQixDQUFDLGtCQUFrQixFQUFFLDRDQUE0QyxDQUFDLENBQUM7WUFDekgsSUFBSSxLQUFLLEtBQUssSUFBSTtnQkFBRSxPQUFPLGVBQWUsQ0FBQyxHQUFHLENBQUMsR0FBRyxVQUFVLENBQUM7WUFDN0QsTUFBTSxDQUFDLElBQUksQ0FBQyxLQUFrQixDQUFDLENBQUM7WUFDaEMsT0FBTyxlQUFlLENBQUMsR0FBRyxDQUFDLEdBQUcsTUFBTSxDQUFDO1FBQ3ZDLENBQUMsQ0FBQyxDQUFDLElBQUksQ0FBQyxPQUFPLENBQUMsQ0FBQztRQUNqQixPQUFPLEVBQUUsR0FBRyxFQUFFLEdBQUcsQ0FBQyxDQUFDLENBQUMsU0FBUyxHQUFHLEdBQUcsQ0FBQyxDQUFDLENBQUMsRUFBRSxFQUFFLE1BQU0sRUFBRSxDQUFDO0lBQ3JELENBQUM7SUFFTSxlQUFlLENBQUMsV0FBOEIsRUFBRSxFQUFFLFVBQWtDLEVBQUU7UUFDM0YsTUFBTSxLQUFLLEdBQUcsSUFBSSxDQUFDLEtBQUssQ0FBQyxRQUFRLENBQUMsQ0FBQztRQUNuQyxJQUFJLE9BQU8sQ0FBQyxPQUFPLEVBQUUsTUFBTSxLQUFLLENBQUM7WUFBRSxNQUFNLElBQUksbUJBQW1CLENBQUMsa0JBQWtCLEVBQUUsNkJBQTZCLENBQUMsQ0FBQztRQUNwSCxJQUFJLEdBQUcsR0FBRyxTQUFTLEdBQUcsQ0FBQyxPQUFPLENBQUMsT0FBTyxFQUFFLEdBQUcsQ0FBQyxlQUFlLENBQUMsQ0FBQyxJQUFJLENBQUMsSUFBSSxDQUFDLElBQUksR0FBRyxDQUFDLEdBQUcsUUFBUSxHQUFHLGVBQWUsQ0FBQyxJQUFJLENBQUMsSUFBSSxDQUFDLEdBQUcsS0FBSyxDQUFDLEdBQUcsQ0FBQztRQUNwSSxJQUFJLE9BQU8sQ0FBQyxPQUFPLEVBQUUsTUFBTTtZQUFFLEdBQUcsSUFBSSxZQUFZLEdBQUcsT0FBTyxDQUFDLE9BQU8sQ0FBQyxHQUFHLENBQUMsS0FBSyxDQUFDLEVBQUU7Z0JBQzdFLE1BQU0sU0FBUyxHQUFHLEtBQUssQ0FBQyxTQUFTLElBQUksS0FBSyxDQUFDO2dCQUMzQyxJQUFJLENBQUMsQ0FBQyxLQUFLLEVBQUUsTUFBTSxDQUFDLENBQUMsUUFBUSxDQUFDLFNBQVMsQ0FBQztvQkFBRSxNQUFNLElBQUksbUJBQW1CLENBQUMsa0JBQWtCLEVBQUUseUJBQXlCLENBQUMsQ0FBQztnQkFDdkgsT0FBTyxlQUFlLENBQUMsS0FBSyxDQUFDLE1BQU0sQ0FBQyxHQUFHLEdBQUcsR0FBRyxTQUFTLENBQUM7WUFDekQsQ0FBQyxDQUFDLENBQUMsSUFBSSxDQUFDLElBQUksQ0FBQyxDQUFDO1FBQ2QsSUFBSSxPQUFPLENBQUMsS0FBSyxLQUFLLFNBQVMsRUFBRSxDQUFDO1lBQ2hDLElBQUksQ0FBQyxNQUFNLENBQUMsYUFBYSxDQUFDLE9BQU8sQ0FBQyxLQUFLLENBQUMsSUFBSSxPQUFPLENBQUMsS0FBSyxHQUFHLENBQUM7Z0JBQUUsTUFBTSxJQUFJLG1CQUFtQixDQUFDLGtCQUFrQixFQUFFLDJDQUEyQyxDQUFDLENBQUM7WUFDOUosR0FBRyxJQUFJLFNBQVMsR0FBRyxPQUFPLENBQUMsS0FBSyxDQUFDO1FBQ25DLENBQUM7UUFDRCxPQUFPLEVBQUUsR0FBRyxFQUFFLE1BQU0sRUFBRSxLQUFLLENBQUMsTUFBTSxFQUFFLENBQUM7SUFDdkMsQ0FBQztJQUVNLEtBQUssQ0FBQyxXQUE4QixFQUFFLEVBQUUsVUFBa0MsRUFBRTtRQUNqRixPQUFPLElBQUksQ0FBQyxVQUFVLENBQUMsS0FBSyxDQUFNLElBQUksQ0FBQyxlQUFlLENBQUMsUUFBUSxFQUFFLE9BQU8sQ0FBQyxFQUFFLE9BQU8sQ0FBQyxDQUFDO0lBQ3RGLENBQUM7SUFDTSxNQUFNLENBQUMsV0FBOEIsRUFBRSxFQUFFLFVBQWtDLEVBQUU7UUFDbEYsT0FBTyxJQUFJLENBQUMsVUFBVSxDQUFDLE1BQU0sQ0FBTSxJQUFJLENBQUMsZUFBZSxDQUFDLFFBQVEsRUFBRSxPQUFPLENBQUMsRUFBRSxPQUFPLENBQUMsQ0FBQztJQUN2RixDQUFDO0lBQ00sTUFBTSxDQUFDLElBQXdDLEVBQUUsVUFBMEIsRUFBRTtRQUNsRixPQUFPLElBQUksQ0FBQyxVQUFVLENBQUMsTUFBTSxDQUFDLElBQUksQ0FBQyxJQUFJLEVBQUUsSUFBSSxFQUFFLE9BQU8sQ0FBQyxDQUFDO0lBQzFELENBQUM7SUFDTSxNQUFNLENBQUMsUUFBMkIsRUFBRSxPQUFxQixFQUFFLFVBQTZCLEVBQUU7UUFDL0YsTUFBTSxLQUFLLEdBQUcsSUFBSSxDQUFDLEtBQUssQ0FBQyxRQUFRLEVBQUUsSUFBSSxDQUFDLENBQUM7UUFDekMsTUFBTSxPQUFPLEdBQUcsTUFBTSxDQUFDLE9BQU8sQ0FBQyxPQUFPLENBQUMsQ0FBQztRQUN4QyxJQUFJLENBQUMsT0FBTyxDQUFDLE1BQU0sSUFBSSxPQUFPLENBQUMsSUFBSSxDQUFDLENBQUMsQ0FBQyxFQUFFLEtBQUssQ0FBQyxFQUFFLEVBQUUsQ0FBQyxLQUFLLEtBQUssU0FBUyxDQUFDLEVBQUUsQ0FBQztZQUN4RSxNQUFNLElBQUksbUJBQW1CLENBQUMsa0JBQWtCLEVBQUUsNENBQTRDLENBQUMsQ0FBQztRQUNsRyxDQUFDO1FBQ0QsT0FBTyxJQUFJLENBQUMsVUFBVSxDQUFDLE9BQU8sQ0FBQyxFQUFFLEdBQUcsRUFBRSxTQUFTLEdBQUcsZUFBZSxDQUFDLElBQUksQ0FBQyxJQUFJLENBQUMsR0FBRyxPQUFPO2dCQUNwRixPQUFPLENBQUMsR0FBRyxDQUFDLENBQUMsQ0FBQyxHQUFHLENBQUMsRUFBRSxFQUFFLENBQUMsZUFBZSxDQUFDLEdBQUcsQ0FBQyxHQUFHLE1BQU0sQ0FBQyxDQUFDLElBQUksQ0FBQyxJQUFJLENBQUMsR0FBRyxLQUFLLENBQUMsR0FBRztZQUM1RSxNQUFNLEVBQUUsQ0FBQyxHQUFHLE9BQU8sQ0FBQyxHQUFHLENBQUMsQ0FBQyxDQUFDLEVBQUUsS0FBSyxDQUFDLEVBQUUsRUFBRSxDQUFDLEtBQWtCLENBQUMsRUFBRSxHQUFHLEtBQUssQ0FBQyxNQUFPLENBQUMsRUFBRSxFQUFFLE9BQU8sQ0FBQyxDQUFDO0lBQzlGLENBQUM7SUFDTSxNQUFNLENBQUMsUUFBMkIsRUFBRSxVQUE2QixFQUFFO1FBQ3hFLE1BQU0sS0FBSyxHQUFHLElBQUksQ0FBQyxLQUFLLENBQUMsUUFBUSxFQUFFLElBQUksQ0FBQyxDQUFDO1FBQ3pDLE9BQU8sSUFBSSxDQUFDLFVBQVUsQ0FBQyxPQUFPLENBQUMsRUFBRSxHQUFHLEVBQUUsY0FBYyxHQUFHLGVBQWUsQ0FBQyxJQUFJLENBQUMsSUFBSSxDQUFDLEdBQUcsS0FBSyxDQUFDLEdBQUcsRUFBRSxNQUFNLEVBQUUsS0FBSyxDQUFDLE1BQU0sRUFBRSxFQUFFLE9BQU8sQ0FBQyxDQUFDO0lBQ2xJLENBQUM7Q0FDRiJ9

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

@@ -0,0 +1,27 @@
+export interface IMetricWriterOptions {
+    batchSize?: number;
+    maxBatchBytes?: number;
+    flushIntervalMs?: number;
+}
+/** Await write() for backpressure. flush()/close() settle only after server acknowledgement. */
+export declare class MetricWriter<Row> {
+    private readonly send;
+    private readonly options;
+    private batch;
+    private bytes;
+    private active?;
+    private failure?;
+    private closed;
+    private closing?;
+    private timer?;
+    private readonly batchSize;
+    private readonly maxBytes;
+    constructor(send: (rows: Row[]) => Promise<void>, options?: IMetricWriterOptions);
+    private check;
+    private perform;
+    private sendBatch;
+    write(row: Row): Promise<void>;
+    private schedule;
+    flush(): Promise<void>;
+    close(): Promise<void>;
+}

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

@@ -0,0 +1,89 @@
+import { valueBytes } from '../interfaces.js';
+import { LosslessClientError } from '../../core/classes.error.js';
+/** Await write() for backpressure. flush()/close() settle only after server acknowledgement. */
+export class MetricWriter {
+    send;
+    options;
+    batch = [];
+    bytes = 0;
+    active;
+    failure;
+    closed = false;
+    closing;
+    timer;
+    batchSize;
+    maxBytes;
+    constructor(send, options = {}) {
+        this.send = send;
+        this.options = options;
+        this.batchSize = options.batchSize ?? 500;
+        this.maxBytes = options.maxBatchBytes ?? 4 * 1024 * 1024;
+        for (const limit of [this.batchSize, this.maxBytes, options.flushIntervalMs ?? 1000]) {
+            if (!Number.isSafeInteger(limit) || limit < 1)
+                throw new RangeError('Writer limits must be positive integers.');
+        }
+    }
+    check() {
+        if (this.failure)
+            throw this.failure;
+        if (this.closed)
+            throw new LosslessClientError('closed', 'Metric writer is closed.');
+        if (this.active)
+            throw new LosslessClientError('invalid_argument', 'Await the preceding writer operation before writing again.');
+    }
+    perform(action) {
+        const task = action().catch(error => { this.failure = error; throw error; });
+        this.active = task;
+        void task.finally(() => {
+            if (this.active === task)
+                this.active = undefined;
+            this.schedule();
+        }).catch(() => { });
+        return task;
+    }
+    async sendBatch() {
+        clearTimeout(this.timer);
+        this.timer = undefined;
+        if (!this.batch.length)
+            return;
+        await this.send(this.batch);
+        this.batch = [];
+        this.bytes = 0;
+    }
+    write(row) {
+        this.check();
+        const size = valueBytes(row);
+        if (size > this.maxBytes)
+            throw new LosslessClientError('invalid_argument', 'Metric row exceeds maxBatchBytes.');
+        return this.perform(async () => {
+            if (this.batch.length && this.bytes + size > this.maxBytes)
+                await this.sendBatch();
+            this.batch.push(structuredClone(row));
+            this.bytes += size;
+            if (this.batch.length >= this.batchSize)
+                await this.sendBatch();
+        });
+    }
+    schedule() {
+        if (this.timer || this.closed || this.failure || !this.batch.length)
+            return;
+        this.timer = setTimeout(() => {
+            this.timer = undefined;
+            if (!this.closed && !this.failure && !this.active)
+                void this.flush().catch(() => { });
+        }, this.options.flushIntervalMs ?? 1000);
+        this.timer.unref();
+    }
+    flush() { this.check(); return this.perform(() => this.sendBatch()); }
+    close() {
+        return this.closing ??= (async () => {
+            this.closed = true;
+            clearTimeout(this.timer);
+            await this.active;
+            if (this.failure)
+                throw this.failure;
+            await this.sendBatch();
+        })();
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/dist_ts/sqldb/clickhouse/index.d.ts

@@ -0,0 +1,9 @@
+export * from './smartclickhouse.classes.smartclickhouse.js';
+export * from './smartclickhouse.classes.clickhousetable.js';
+export * from './smartclickhouse.classes.httpclient.js';
+export * from './smartclickhouse.classes.querybuilder.js';
+export * from './smartclickhouse.classes.resultset.js';
+export * from './smartclickhouse.classes.timedatatable.js';
+export * from './smartclickhouse.types.js';
+export { MetricWriter } from './classes.metricwriter.js';
+export type { IMetricWriterOptions } from './classes.metricwriter.js';