@lossless.org/client 0.1.0

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

@@ -0,0 +1,123 @@
+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 type { IClickhouseTableOptions } from './smartclickhouse.types.js';
+import type { ClickHouseConnection } from '../classes.clickhouseconnection.js';
+import { quoteClickHouseIdentifier as quoteIdentifier } from '../interfaces.js';
+import { Operation } from '../../core/classes.operation.js';
+import type { MetricWriter } from './classes.metricwriter.js';
+import { LosslessClientError } from '../../core/classes.error.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 class SmartClickHouseDb {
+  public options: IClickhouseConstructorOptions;
+  public clickhouseHttpClient!: ClickhouseHttpClient;
+  private readonly writers = new Set<MetricWriter<unknown>>();
+  private closing?: Promise<void>;
+  private stopping = false;
+  private readonly canonical: boolean;
+
+  constructor(optionsArg: IClickhouseConstructorOptions, connection?: ClickHouseConnection) {
+    this.options = optionsArg;
+    this.canonical = Boolean(connection);
+    if (connection) this.clickhouseHttpClient = new ClickhouseHttpClient(optionsArg, connection);
+  }
+
+  /**
+   * Starts the connection to the Clickhouse db
+   */
+  public 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; }
+  }
+
+  public ownWriter<Row>(writer: MetricWriter<Row>): MetricWriter<Row> {
+    if (this.stopping) throw new LosslessClientError('closed', 'Metrics connection is closing.');
+    this.writers.add(writer as MetricWriter<unknown>);
+    return writer;
+  }
+
+  public closeWriters(): Promise<void> {
+    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.');
+    })();
+  }
+
+  public async close(): Promise<void> {
+    try { await this.closeWriters(); }
+    finally { await this.clickhouseHttpClient?.close(); }
+  }
+
+  public async createDatabase(dropOld: boolean = 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)}`
+    );
+  }
+
+  public 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
+   */
+  public async createTable<T extends Record<string, any>>(
+    options: IClickhouseTableOptions<T>,
+  ): Promise<ClickhouseTable<T>> {
+    return ClickhouseTable.create<T>(this, {
+      autoSchemaEvolution: !this.canonical,
+      ...options,
+      database: options.database || this.options.database,
+    });
+  }
+
+  // ---- BACKWARD COMPAT: TimeDataTable factory ----
+
+  /**
+   * Get a TimeDataTable (backward compatible)
+   */
+  public async getTable(tableName: string): Promise<TimeDataTable> {
+    return TimeDataTable.getTable(this, tableName);
+  }
+
+  // ---- RAW QUERY ----
+
+  /**
+   * Execute a raw SQL query and return typed results
+   */
+  public async query<T = any>(sql: string): Promise<T[]> {
+    return this.clickhouseHttpClient.queryTyped<T>(sql);
+  }
+}

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

@@ -0,0 +1,114 @@
+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 async function createTimeDataTable(
+  db: SmartClickHouseDb,
+  tableName: string,
+  retainDataForDays: number = 30,
+): Promise<TimeDataTable> {
+  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<any> {
+  /**
+   * Static factory for backward compatibility
+   */
+  public static async getTable(
+    smartClickHouseDbRefArg: SmartClickHouseDb,
+    tableNameArg: string,
+    retainDataForDays: number = 30,
+  ): Promise<TimeDataTable> {
+    return createTimeDataTable(smartClickHouseDbRefArg, tableNameArg, retainDataForDays);
+  }
+
+  constructor(db: SmartClickHouseDb, tableName: string, retainDataForDays: number = 30) {
+    super(db, {
+      tableName,
+      engine: { engine: 'MergeTree' },
+      orderBy: 'timestamp' as any,
+      retainDataForDays,
+      autoSchemaEvolution: true,
+    });
+  }
+
+  /**
+   * Insert data with auto-schema evolution and object flattening.
+   * Backward-compatible: accepts arbitrary JSON objects with a timestamp field.
+   */
+  public async addData(dataArg: any): Promise<any> {
+    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
+   */
+  public async getLastEntries(count: number): Promise<any[]> {
+    return this.query()
+      .orderBy('timestamp' as any, 'DESC')
+      .limit(count)
+      .toArray();
+  }
+
+  /**
+   * Get entries newer than a unix timestamp (in milliseconds)
+   */
+  public async getEntriesNewerThan(unixTimestamp: number): Promise<any[]> {
+    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)
+   */
+  public async getEntriesBetween(unixTimestampStart: number, unixTimestampEnd: number): Promise<any[]> {
+    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
+   */
+  public async deleteOldEntries(days: number): Promise<void> {
+    await this.deleteOlderThan('timestamp', days + ' DAY');
+  }
+
+  private validateTimestamp(value: number): number {
+    if (!Number.isSafeInteger(value)) throw new RangeError('Timestamp must be an integer in milliseconds.');
+    return value;
+  }
+
+  /**
+   * Drop the table (backward-compatible alias for drop())
+   */
+  public async delete(): Promise<void> {
+    return this.drop();
+  }
+
+  /**
+   * Watch for new entries via polling (backward-compatible wrapper)
+   */
+  public watchNewEntries(): plugins.smartrx.rxjs.Observable<any> {
+    return this.watch();
+  }
+}

package/ts/sqldb/clickhouse/smartclickhouse.plugins.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/ts/sqldb/clickhouse/smartclickhouse.types.ts

@@ -0,0 +1,134 @@
+// ============================================================
+// Column Data Types
+// ============================================================
+export type TClickhouseColumnType =
+  | 'String'
+  | 'UInt8' | 'UInt16' | 'UInt32' | 'UInt64'
+  | 'Int8' | 'Int16' | 'Int32' | 'Int64'
+  | 'Float32' | 'Float64'
+  | 'Bool'
+  | 'Date' | 'Date32'
+  | 'DateTime' | 'DateTime64'
+  | 'UUID'
+  | 'IPv4' | 'IPv6'
+  | (string & {}); // allow arbitrary ClickHouse types like "DateTime64(3, 'Europe/Berlin')"
+
+// ============================================================
+// Engine Configuration
+// ============================================================
+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;
+}
+
+// ============================================================
+// Column Definition
+// ============================================================
+export interface IColumnDefinition {
+  name: string;
+  type: TClickhouseColumnType;
+  defaultExpression?: string;
+  codec?: string;
+}
+
+// ============================================================
+// Table Options
+// ============================================================
+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; // e.g., '30 DAY', '1 MONTH'
+  };
+  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;
+}
+
+// ============================================================
+// Column Info from system.columns
+// ============================================================
+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;
+}
+
+// ============================================================
+// Comparison Operators for Query Builder
+// ============================================================
+export type TComparisonOperator =
+  | '='
+  | '!='
+  | '>'
+  | '>='
+  | '<'
+  | '<='
+  | 'LIKE'
+  | 'NOT LIKE'
+  | 'IN'
+  | 'NOT IN'
+  | 'BETWEEN';
+
+// ============================================================
+// Value Escaping (SQL Injection Prevention)
+// ============================================================
+export function escapeClickhouseValue(value: any): string {
+  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: any): TClickhouseColumnType | null {
+  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})` as TClickhouseColumnType;
+  }
+  return null;
+}

package/ts/sqldb/index.ts

@@ -0,0 +1,6 @@
+export { SqlConnection, SqlTransaction } from './classes.sqlconnection.js';
+export { ClickHouseConnection } from './classes.clickhouseconnection.js';
+export { SqlTable } from './classes.sqltable.js';
+export type { ISqlSelectOptions, TSqlSelector } from './classes.sqltable.js';
+export * from './interfaces.js';
+export * from './clickhouse/index.js';

package/ts/sqldb/interfaces.ts

@@ -0,0 +1,61 @@
+import type * as plugins from './plugins.mariadb.js';
+import type { IOperationOptions } from '../core/interfaces.js';
+import { LosslessClientError } from '../core/classes.error.js';
+
+export type TSqlValue = null | string | number | bigint | boolean | Date | Uint8Array;
+export interface ISqlStatement { sql: string; values?: readonly TSqlValue[] }
+export interface IQueryOptions extends IOperationOptions { maxRows?: number; maxBytes?: number }
+export interface ISqlConnectionOptions {
+  backend: 'sqldb' | 'mariadb';
+  host: string;
+  port?: number;
+  user: string;
+  password: string;
+  database: string;
+  connectionLimit?: number;
+  timeoutMs?: number;
+  tls?: plugins.mariadb.ConnectionConfig['ssl'];
+}
+export interface ISqlMutationResult {
+  affectedRows: number;
+  insertId?: bigint;
+  completion: 'acknowledged';
+}
+export interface IInsertOptions extends IOperationOptions { batchSize?: number; maxBatchBytes?: number }
+export interface IClickHouseConnectionOptions {
+  backend: 'clickhouse';
+  url: string;
+  database: string;
+  username?: string;
+  password?: string;
+  connectionLimit?: number;
+  timeoutMs?: number;
+}
+export interface IClickHouseStatement {
+  sql: string;
+  /** ClickHouse {name:Type} parameters; identifiers are never interpolated as values. */
+  values?: Record<string, unknown>;
+}
+
+export const resultLimits = (options: IQueryOptions): { rows: number; bytes: number } => {
+  const rows = options.maxRows ?? 10_000;
+  const bytes = options.maxBytes ?? 16 * 1024 * 1024;
+  if (!Number.isSafeInteger(rows) || rows < 1 || !Number.isSafeInteger(bytes) || bytes < 1) {
+    throw new LosslessClientError('invalid_argument', 'Result limits must be positive safe integers.');
+  }
+  return { rows, bytes };
+};
+
+export const valueBytes = (value: unknown): number => Buffer.byteLength(JSON.stringify(value,
+  (_key, item) => typeof item === 'bigint' ? item.toString() : item));
+
+export const quoteIdentifier = (value: string): string => {
+  if (typeof value !== 'string' || !value.length || Buffer.byteLength(value) > 256 || /[\0\r\n]/.test(value)) {
+    throw new LosslessClientError('invalid_argument', 'Invalid SQL identifier.');
+  }
+  return '`' + value.replace(/`/g, '``') + '`';
+};
+
+/** ClickHouse also interprets backslash escapes inside backtick identifiers. */
+export const quoteClickHouseIdentifier = (value: string): string =>
+  quoteIdentifier(value).replace(/\\/g, '\\\\');

package/ts/sqldb/internal.sqlpool.ts

@@ -0,0 +1,179 @@
+import * as plugins from './plugins.mariadb.js';
+import type { Operation } from '../core/classes.operation.js';
+import { LosslessClientError } from '../core/classes.error.js';
+
+interface IWaiter { operation: Operation; resolve: () => void; reject: (error: unknown) => void; abort: () => void }
+interface IPhysicalConnection { raw: plugins.mariadb.Connection; socket: plugins.net.Socket }
+
+/**
+ * Owns admission and connector handles from creation onward. The connector's promise-pool
+ * acquisition cannot be cancelled. Its supported stream factory lets this pool own the
+ * TCP socket before authentication, while the connector owns the wire protocol and TLS.
+ */
+export class SqlPool {
+  private readonly connections = new Set<IPhysicalConnection>();
+  private readonly idle: IPhysicalConnection[] = [];
+  private readonly waiters = new Set<IWaiter>();
+  private readonly active = new Set<SqlPooledConnection>();
+  private occupied = 0;
+  private closed = false;
+  private closing?: Promise<void>;
+
+  constructor(private readonly config: plugins.mariadb.ConnectionConfig, private readonly limit: number) {}
+
+  private async take(operation: Operation): Promise<() => void> {
+    operation.check();
+    if (this.closed) throw new LosslessClientError('closed', 'SQL pool is closed.');
+    if (this.occupied >= this.limit) {
+      await new Promise<void>((resolve, reject) => {
+        const waiter: IWaiter = { operation, resolve, reject, abort: () => {
+          this.waiters.delete(waiter); reject(operation.signal.reason);
+        } };
+        this.waiters.add(waiter);
+        operation.signal.addEventListener('abort', waiter.abort, { once: true });
+      });
+    } else this.occupied++;
+    let returned = false;
+    return () => {
+      if (returned) return;
+      returned = true;
+      const next = this.waiters.values().next().value as IWaiter | undefined;
+      if (next) {
+        this.waiters.delete(next);
+        next.operation.signal.removeEventListener('abort', next.abort);
+        next.resolve();
+      } else this.occupied--;
+    };
+  }
+
+  private async create(operation: Operation): Promise<IPhysicalConnection> {
+    const socket = plugins.net.createConnection({ host: this.config.host!, port: this.config.port! });
+    socket.setNoDelay(true);
+    socket.on('error', () => {});
+    const abort = () => socket.destroy(new LosslessClientError('closed', 'SQL connection cancelled during authentication.'));
+    operation.signal.addEventListener('abort', abort, { once: true });
+    try {
+      operation.check();
+      const raw = await plugins.mariadb.createConnection({ ...this.config, stream: callback => callback(undefined, socket) });
+      raw.on('error', () => {});
+      operation.check();
+      const physical = { raw, socket };
+      this.connections.add(physical);
+      return physical;
+    } catch (error) { socket.destroy(); throw error; }
+    finally { operation.signal.removeEventListener('abort', abort); }
+  }
+
+  public async getConnection(operation: Operation): Promise<SqlPooledConnection> {
+    const giveBack = await this.take(operation);
+    let lease: SqlPooledConnection | undefined;
+    try {
+      operation.check();
+      let current = this.idle.pop();
+      while (current && !current.raw.isValid()) {
+        current.socket.destroy(); this.connections.delete(current); current = this.idle.pop();
+      }
+      current ??= await this.create(operation);
+      const physical = current;
+      lease = new SqlPooledConnection(current, operation, async reusable => {
+        this.active.delete(lease!);
+        if (reusable && !this.closed && physical.raw.isValid()) this.idle.push(physical);
+        else { physical.socket.destroy(); this.connections.delete(physical); }
+        giveBack();
+      });
+      this.active.add(lease);
+      operation.check();
+      return lease;
+    } catch (error) {
+      if (lease) { lease.destroy(); await lease.release(); }
+      else giveBack();
+      throw operation.signal.aborted ? operation.signal.reason : error;
+    }
+  }
+
+  public end(): Promise<void> {
+    return this.closing ??= (async () => {
+      this.closed = true;
+      for (const waiter of this.waiters) {
+        waiter.operation.signal.removeEventListener('abort', waiter.abort);
+        waiter.reject(new LosslessClientError('closed', 'SQL pool closed during admission.'));
+      }
+      this.waiters.clear();
+      for (const lease of this.active) lease.destroy();
+      for (const connection of this.connections) {
+        connection.socket.destroy(new LosslessClientError('closed', 'SQL connection closed.'));
+      }
+      const results = await Promise.allSettled([...this.active].map(lease => lease.release()));
+      this.idle.length = 0; this.connections.clear();
+      const errors = results.flatMap(result => result.status === 'rejected' ? [result.reason] : []);
+      if (errors.length) throw new AggregateError(errors, 'SQL pool cleanup failed.');
+    })();
+  }
+}
+
+/** A lease can never affect a physical connection after returning ownership to the pool. */
+export class SqlPooledConnection {
+  private readonly tasks = new Set<Promise<unknown>>();
+  private readonly streams = new Set<plugins.stream.Readable>();
+  private released = false;
+  private releasing?: Promise<void>;
+  private readonly abort = () => this.destroy();
+  constructor(private readonly physical: IPhysicalConnection, private readonly operation: Operation,
+    private readonly giveBack: (reusable: boolean) => Promise<void>) {
+    operation.signal.addEventListener('abort', this.abort, { once: true });
+  }
+  private get raw(): plugins.mariadb.Connection { return this.physical.raw; }
+  private check(): void {
+    this.operation.check();
+    if (this.released || this.releasing) throw new LosslessClientError('closed', 'SQL lease is closed.');
+  }
+  private run<Result>(dispatch: () => Promise<Result>): Promise<Result> {
+    this.check();
+    const task = dispatch();
+    this.tasks.add(task);
+    void task.finally(() => this.tasks.delete(task)).catch(() => {});
+    return task;
+  }
+  public execute<Result = plugins.mariadb.UpsertResult>(sql: string, values: readonly unknown[] = []): Promise<Result> {
+    return this.run<Result>(() => this.raw.execute(sql, values));
+  }
+  public beginTransaction(): Promise<void> { return this.run(() => this.raw.beginTransaction()); }
+  public commit(): Promise<void> { return this.run(() => this.raw.commit()); }
+  public rollback(): Promise<void> { return this.run(() => this.raw.rollback()); }
+  public queryStream(sql: string, values: readonly unknown[] = []): plugins.stream.Readable {
+    this.check();
+    const stream = this.raw.queryStream(sql, values);
+    stream.on('error', () => {});
+    this.streams.add(stream);
+    const done = new Promise<void>(resolve => stream.once('close', () => { this.streams.delete(stream); resolve(); }));
+    this.tasks.add(done);
+    void done.finally(() => this.tasks.delete(done));
+    return stream;
+  }
+  public isValid(): boolean { return !this.released && this.raw.isValid(); }
+  public destroy(): void {
+    if (!this.released) {
+      const error = new LosslessClientError('closed', 'SQL connection closed.');
+      for (const stream of this.streams) stream.destroy(error);
+      this.physical.socket.destroy(error);
+    }
+  }
+  public release(): Promise<void> {
+    return this.releasing ??= (async () => {
+      let resetError: unknown;
+      try {
+        await Promise.allSettled([...this.tasks]);
+        if (this.raw.isValid() && !this.operation.signal.aborted) {
+          try {
+            await this.raw.reset();
+          } catch (error) { resetError = error; this.destroy(); }
+        }
+      } finally {
+        this.released = true;
+        this.operation.signal.removeEventListener('abort', this.abort);
+        await this.giveBack(!resetError && !this.operation.signal.aborted);
+      }
+      if (resetError) throw resetError;
+    })();
+  }
+}

package/ts/sqldb/plugins.clickhouse.ts

@@ -0,0 +1,4 @@
+import * as clickhouse from '@clickhouse/client';
+import * as stream from 'node:stream';
+import * as asyncHooks from 'node:async_hooks';
+export { clickhouse, stream, asyncHooks };

package/ts/sqldb/plugins.mariadb.ts

@@ -0,0 +1,4 @@
+import * as mariadb from 'mariadb';
+import * as stream from 'node:stream';
+import * as net from 'node:net';
+export { mariadb, stream, net };