@lossless.org/client 0.1.0

package/dist_ts/objectstorage/plugins.js

@@ -0,0 +1,23 @@
+// plugins.ts
+// node native
+import * as crypto from 'node:crypto';
+import * as path from 'node:path';
+import * as stream from 'node:stream';
+export { crypto, path, stream };
+// @push.rocks scope
+import * as smartmime from '@push.rocks/smartmime';
+import * as smartpath from '@push.rocks/smartpath';
+import * as smartpromise from '@push.rocks/smartpromise';
+import * as smartrx from '@push.rocks/smartrx';
+import * as smartstream from '@push.rocks/smartstream';
+import * as smartstring from '@push.rocks/smartstring';
+import * as smartunique from '@push.rocks/smartunique';
+export { smartmime, smartpath, smartpromise, smartrx, smartstream, smartstring, smartunique };
+// @tsclass
+import * as tsclass from '@tsclass/tsclass';
+export { tsclass, };
+// third party scope
+import * as s3 from '@aws-sdk/client-s3';
+import { Minimatch } from 'minimatch';
+export { s3, Minimatch, };
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicGx1Z2lucy5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uL3RzL29iamVjdHN0b3JhZ2UvcGx1Z2lucy50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxhQUFhO0FBRWIsY0FBYztBQUNkLE9BQU8sS0FBSyxNQUFNLE1BQU0sYUFBYSxDQUFDO0FBQ3RDLE9BQU8sS0FBSyxJQUFJLE1BQU0sV0FBVyxDQUFDO0FBQ2xDLE9BQU8sS0FBSyxNQUFNLE1BQU0sYUFBYSxDQUFDO0FBRXRDLE9BQU8sRUFBRSxNQUFNLEVBQUUsSUFBSSxFQUFFLE1BQU0sRUFBRSxDQUFDO0FBRWhDLG9CQUFvQjtBQUNwQixPQUFPLEtBQUssU0FBUyxNQUFNLHVCQUF1QixDQUFDO0FBQ25ELE9BQU8sS0FBSyxTQUFTLE1BQU0sdUJBQXVCLENBQUM7QUFDbkQsT0FBTyxLQUFLLFlBQVksTUFBTSwwQkFBMEIsQ0FBQztBQUN6RCxPQUFPLEtBQUssT0FBTyxNQUFNLHFCQUFxQixDQUFDO0FBQy9DLE9BQU8sS0FBSyxXQUFXLE1BQU0seUJBQXlCLENBQUM7QUFDdkQsT0FBTyxLQUFLLFdBQVcsTUFBTSx5QkFBeUIsQ0FBQztBQUN2RCxPQUFPLEtBQUssV0FBVyxNQUFNLHlCQUF5QixDQUFDO0FBRXZELE9BQU8sRUFBRSxTQUFTLEVBQUUsU0FBUyxFQUFFLFlBQVksRUFBRSxPQUFPLEVBQUUsV0FBVyxFQUFFLFdBQVcsRUFBRSxXQUFXLEVBQUUsQ0FBQztBQUU5RixXQUFXO0FBQ1gsT0FBTyxLQUFLLE9BQU8sTUFBTSxrQkFBa0IsQ0FBQztBQUU1QyxPQUFPLEVBQ0wsT0FBTyxHQUNSLENBQUE7QUFFRCxvQkFBb0I7QUFDcEIsT0FBTyxLQUFLLEVBQUUsTUFBTSxvQkFBb0IsQ0FBQztBQUN6QyxPQUFPLEVBQUUsU0FBUyxFQUFFLE1BQU0sV0FBVyxDQUFDO0FBRXRDLE9BQU8sRUFDTCxFQUFFLEVBQ0YsU0FBUyxHQUNWLENBQUEifQ==

package/dist_ts/plugins.d.ts

@@ -0,0 +1,4 @@
+export declare const loadNoSql: () => Promise<typeof import("./nosqldb/classes.connection.js")>;
+export declare const loadObjects: () => Promise<typeof import("./objectstorage/classes.connection.js")>;
+export declare const loadSql: () => Promise<typeof import("./sqldb/classes.sqlconnection.js")>;
+export declare const loadClickHouse: () => Promise<typeof import("./sqldb/classes.clickhouseconnection.js")>;

package/dist_ts/plugins.js

@@ -0,0 +1,5 @@
+export const loadNoSql = () => import('./nosqldb/classes.connection.js');
+export const loadObjects = () => import('./objectstorage/classes.connection.js');
+export const loadSql = () => import('./sqldb/classes.sqlconnection.js');
+export const loadClickHouse = () => import('./sqldb/classes.clickhouseconnection.js');
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicGx1Z2lucy5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uL3RzL3BsdWdpbnMudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsTUFBTSxDQUFDLE1BQU0sU0FBUyxHQUFHLEdBQUcsRUFBRSxDQUFDLE1BQU0sQ0FBQyxpQ0FBaUMsQ0FBQyxDQUFDO0FBQ3pFLE1BQU0sQ0FBQyxNQUFNLFdBQVcsR0FBRyxHQUFHLEVBQUUsQ0FBQyxNQUFNLENBQUMsdUNBQXVDLENBQUMsQ0FBQztBQUNqRixNQUFNLENBQUMsTUFBTSxPQUFPLEdBQUcsR0FBRyxFQUFFLENBQUMsTUFBTSxDQUFDLGtDQUFrQyxDQUFDLENBQUM7QUFDeEUsTUFBTSxDQUFDLE1BQU0sY0FBYyxHQUFHLEdBQUcsRUFBRSxDQUFDLE1BQU0sQ0FBQyx5Q0FBeUMsQ0FBQyxDQUFDIn0=

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

@@ -0,0 +1,39 @@
+import type { ICapabilities, IOperationOptions, IReadiness } from '../core/interfaces.js';
+import type { IClickHouseConnectionOptions, IClickHouseStatement, IInsertOptions, IQueryOptions } from './interfaces.js';
+import { SmartClickHouseDb } from './clickhouse/smartclickhouse.classes.smartclickhouse.js';
+/** ClickHouse HTTP connection. The server executes filtering, projection and aggregation. */
+export declare class ClickHouseConnection {
+    readonly options: IClickHouseConnectionOptions;
+    readonly backend: "clickhouse";
+    readonly metrics: SmartClickHouseDb;
+    readonly capabilities: ICapabilities;
+    private client?;
+    private readonly operations;
+    private readonly tasks;
+    private closed;
+    private closing?;
+    private connecting?;
+    private readonly writerCleanup;
+    constructor(options: IClickHouseConnectionOptions);
+    connect(options?: IOperationOptions): Promise<void>;
+    private begin;
+    private end;
+    private track;
+    ready(options?: IOperationOptions): Promise<IReadiness>;
+    execute(statement: IClickHouseStatement, options?: IOperationOptions): Promise<{
+        queryId: string;
+        completion: 'acknowledged';
+    }>;
+    stream<Row = Record<string, unknown>>(statement: IClickHouseStatement, options?: IOperationOptions): AsyncGenerator<Row>;
+    query<Row = Record<string, unknown>>(statement: IClickHouseStatement, options?: IQueryOptions): Promise<Row[]>;
+    insert(table: string, rows: AsyncIterable<Record<string, unknown>> | Iterable<Record<string, unknown>>, options?: IInsertOptions): Promise<{
+        queryId: string;
+        completion: 'acknowledged';
+    }>;
+    insertQualified(database: string, table: string, rows: AsyncIterable<Record<string, unknown>> | Iterable<Record<string, unknown>>, options?: IInsertOptions): Promise<{
+        queryId: string;
+        completion: 'acknowledged';
+    }>;
+    close(): Promise<void>;
+    private validate;
+}

package/dist_ts/sqldb/classes.clickhouseconnection.js

@@ -0,0 +1,225 @@
+import * as plugins from './plugins.clickhouse.js';
+import { Operation } from '../core/classes.operation.js';
+import { LosslessClientError, backendError } from '../core/classes.error.js';
+import { quoteClickHouseIdentifier as quoteIdentifier, resultLimits, valueBytes } from './interfaces.js';
+import { SmartClickHouseDb } from './clickhouse/smartclickhouse.classes.smartclickhouse.js';
+/** ClickHouse HTTP connection. The server executes filtering, projection and aggregation. */
+export class ClickHouseConnection {
+    options;
+    backend = 'clickhouse';
+    metrics;
+    capabilities = Object.freeze({ backend: 'clickhouse',
+        transactions: 'unsupported', changeStreams: 'unsupported', objectMetrics: 'unsupported', diskResidentScans: 'available' });
+    client;
+    operations = new Map();
+    tasks = new Set();
+    closed = false;
+    closing;
+    connecting;
+    writerCleanup = new plugins.asyncHooks.AsyncLocalStorage();
+    constructor(options) {
+        this.options = options;
+        const url = new URL(options.url);
+        if (!['http:', 'https:'].includes(url.protocol) || !options.database || url.username || url.password ||
+            url.search || url.hash || url.pathname !== '/') {
+            throw new LosslessClientError('invalid_argument', 'ClickHouse requires an HTTP(S) URL, separate credentials and a database.');
+        }
+        const limit = options.connectionLimit ?? 10;
+        if (!Number.isSafeInteger(limit) || limit < 1 || limit > 1024) {
+            throw new LosslessClientError('invalid_argument', 'connectionLimit must be between 1 and 1024.');
+        }
+        const budget = new Operation({ timeoutMs: options.timeoutMs });
+        budget.dispose();
+        this.metrics = new SmartClickHouseDb(options, this);
+    }
+    connect(options = {}) {
+        if (this.closed || this.closing)
+            return Promise.reject(new LosslessClientError('closed', 'ClickHouse connection is closed.'));
+        if (this.connecting)
+            return this.connecting;
+        if (this.client)
+            return Promise.resolve();
+        this.client = plugins.clickhouse.createClient({ url: this.options.url,
+            database: this.options.database, username: this.options.username, password: this.options.password,
+            log: { level: plugins.clickhouse.ClickHouseLogLevel.OFF },
+            max_open_connections: this.options.connectionLimit ?? 10, request_timeout: this.options.timeoutMs ?? 30_000 });
+        this.connecting = (async () => {
+            try {
+                await this.query({ sql: 'SELECT 1 AS ready' }, { ...options, maxRows: 1 });
+            }
+            catch (error) {
+                const client = this.client;
+                this.client = undefined;
+                await client?.close();
+                throw error;
+            }
+            finally {
+                this.connecting = undefined;
+            }
+        })();
+        return this.connecting;
+    }
+    begin(options) {
+        if (!this.client || this.closed || (this.closing && !this.writerCleanup.getStore())) {
+            throw new LosslessClientError(this.closed || this.closing ? 'closed' : 'not_connected', 'ClickHouse connection is not open.');
+        }
+        const operation = new Operation(options, this.options.timeoutMs);
+        this.operations.set(operation, () => { });
+        try {
+            operation.check();
+        }
+        catch (error) {
+            this.end(operation);
+            throw error;
+        }
+        return { client: this.client, operation };
+    }
+    end(operation) {
+        operation.dispose();
+        this.operations.delete(operation);
+    }
+    track(task) {
+        this.tasks.add(task);
+        void task.finally(() => this.tasks.delete(task)).catch(() => { });
+        return task;
+    }
+    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' };
+        }
+    }
+    execute(statement, options = {}) {
+        this.validate(statement);
+        return this.track((async () => {
+            const { client, operation } = this.begin(options);
+            try {
+                const result = await client.command({ query: statement.sql, query_params: statement.values,
+                    abort_signal: operation.signal, clickhouse_settings: { wait_end_of_query: 1, mutations_sync: '2' } });
+                return { queryId: result.query_id, completion: 'acknowledged' };
+            }
+            catch (error) {
+                // HTTP transport loss does not establish whether the server committed a mutation.
+                if (operation.signal.aborted || !(error instanceof Error && 'code' in error && /^\d+$/.test(String(error.code)))) {
+                    throw new LosslessClientError('ambiguous_write', 'ClickHouse mutation outcome is unknown.', { cause: error });
+                }
+                throw backendError(error);
+            }
+            finally {
+                this.end(operation);
+            }
+        })());
+    }
+    async *stream(statement, options = {}) {
+        this.validate(statement);
+        const { client, operation } = this.begin(options);
+        let result;
+        try {
+            result = await this.track(client.query({ query: statement.sql, query_params: statement.values,
+                format: 'JSONEachRow', abort_signal: operation.signal,
+                clickhouse_settings: { output_format_json_quote_64bit_integers: 1, output_format_json_quote_decimals: 1 } }));
+            const current = result;
+            this.operations.set(operation, () => current.close());
+            const stream = result.stream();
+            stream.on('error', () => { });
+            stream.once('close', () => this.end(operation));
+            for await (const batch of stream) {
+                operation.check();
+                for (const row of batch) {
+                    operation.check();
+                    yield row.json();
+                }
+            }
+            operation.check();
+        }
+        catch (error) {
+            throw operation.signal.aborted ? operation.signal.reason : backendError(error);
+        }
+        finally {
+            result?.close();
+            this.end(operation);
+        }
+    }
+    async query(statement, options = {}) {
+        const limits = resultLimits(options), 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', 'ClickHouse result exceeded its materialization limit. Use stream().');
+            }
+            rows.push(row);
+        }
+        return rows;
+    }
+    insert(table, rows, options = {}) {
+        return this.insertQualified(this.options.database, table, rows, options);
+    }
+    insertQualified(database, table, rows, options = {}) {
+        const target = `${quoteIdentifier(database)}.${quoteIdentifier(table)}`;
+        const maxBytes = options.maxBatchBytes ?? 4 * 1024 * 1024;
+        if (!Number.isSafeInteger(maxBytes) || maxBytes < 1)
+            throw new LosslessClientError('invalid_argument', 'maxBatchBytes must be a positive integer.');
+        return this.track((async () => {
+            const { client, operation } = this.begin(options);
+            const source = plugins.stream.Readable.from((async function* () {
+                for await (const row of operation.iterate(rows)) {
+                    operation.check();
+                    if (valueBytes(row) > maxBytes)
+                        throw new LosslessClientError('invalid_argument', 'ClickHouse row exceeds maxBatchBytes.');
+                    yield row;
+                }
+            })(), { objectMode: true, highWaterMark: 1 });
+            source.on('error', () => { });
+            this.operations.set(operation, () => source.destroy());
+            try {
+                const result = await client.insert({ table: target, values: source, format: 'JSONEachRow',
+                    abort_signal: operation.signal, clickhouse_settings: { async_insert: 0, wait_end_of_query: 1 } });
+                return { queryId: result.query_id, completion: 'acknowledged' };
+            }
+            catch (error) {
+                throw new LosslessClientError('ambiguous_write', 'ClickHouse insert may have stored part or all of the input.', { cause: error });
+            }
+            finally {
+                source.destroy();
+                this.end(operation);
+            }
+        })());
+    }
+    close() {
+        return this.closing ??= (async () => {
+            let writerError;
+            try {
+                await this.writerCleanup.run(true, () => this.metrics.closeWriters());
+            }
+            catch (error) {
+                writerError = error;
+            }
+            this.closed = true;
+            for (const [operation, dispose] of this.operations) {
+                operation.cancel();
+                dispose();
+            }
+            await Promise.allSettled([...this.tasks]);
+            if (this.connecting)
+                await Promise.allSettled([this.connecting]);
+            const client = this.client;
+            this.client = undefined;
+            await client?.close();
+            for (const operation of this.operations.keys())
+                this.end(operation);
+            if (writerError)
+                throw writerError;
+        })();
+    }
+    validate(statement) {
+        if (!statement || typeof statement.sql !== 'string' || !statement.sql.trim() ||
+            (statement.values !== undefined && (!statement.values || typeof statement.values !== 'object' || Array.isArray(statement.values)))) {
+            throw new LosslessClientError('invalid_argument', 'ClickHouse requires SQL text and a named parameter object.');
+        }
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"classes.clickhouseconnection.js","sourceRoot":"","sources":["../../ts/sqldb/classes.clickhouseconnection.ts"],"names":[],"mappings":"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"}

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

@@ -0,0 +1,50 @@
+import { SqlTable } from './classes.sqltable.js';
+import { type SqlPooledConnection } from './internal.sqlpool.js';
+import { Operation } from '../core/classes.operation.js';
+import type { ICapabilities, IOperationOptions, IReadiness } from '../core/interfaces.js';
+import type { IInsertOptions, IQueryOptions, ISqlConnectionOptions, ISqlMutationResult, ISqlStatement, TSqlValue } from './interfaces.js';
+interface ILease {
+    connection: SqlPooledConnection;
+    operation: Operation;
+    close: () => Promise<void>;
+    done: Promise<void>;
+}
+/** One MariaDB-protocol pool. SQLDB uses the same wire adapter with its own capabilities. */
+export declare class SqlConnection {
+    readonly options: ISqlConnectionOptions;
+    readonly backend: 'sqldb' | 'mariadb';
+    readonly capabilities: ICapabilities;
+    private pool?;
+    private closing?;
+    private connecting?;
+    private closed;
+    private readonly acquisitions;
+    private readonly leases;
+    private readonly pendingOperations;
+    constructor(options: ISqlConnectionOptions);
+    connect(options?: IOperationOptions): Promise<void>;
+    ready(options?: IOperationOptions): Promise<IReadiness>;
+    table<Row extends {
+        [Key in keyof Row]: TSqlValue;
+    }>(name: string): SqlTable<Row>;
+    private acquire;
+    execute(statement: ISqlStatement, options?: IOperationOptions): Promise<ISqlMutationResult>;
+    query<Row = Record<string, unknown>>(statement: ISqlStatement, options?: IQueryOptions): Promise<Row[]>;
+    stream<Row = Record<string, unknown>>(statement: ISqlStatement, options?: IOperationOptions): AsyncGenerator<Row>;
+    insert(table: string, rows: AsyncIterable<Record<string, TSqlValue>> | Iterable<Record<string, TSqlValue>>, options?: IInsertOptions): Promise<ISqlMutationResult>;
+    transaction<Result>(callback: (transaction: SqlTransaction) => Promise<Result>, options?: IOperationOptions): Promise<Result>;
+    close(): Promise<void>;
+}
+/** Bound to a single transaction callback and physical connection. */
+export declare class SqlTransaction {
+    private readonly lease;
+    private active?;
+    private failure?;
+    private finished;
+    constructor(lease: ILease);
+    private run;
+    execute(statement: ISqlStatement): Promise<ISqlMutationResult>;
+    query<Row = Record<string, unknown>>(statement: ISqlStatement, options?: Pick<IQueryOptions, 'maxRows' | 'maxBytes'>): Promise<Row[]>;
+    finish(): Promise<void>;
+}
+export {};