@lossless.org/client 1.4.0 → 1.5.0

package/ts/sqldb/classes.clickhouseconnection.ts

@@ -11,7 +11,8 @@ export class ClickHouseConnection {
   public readonly backend = 'clickhouse' as const;
   public readonly metrics: SmartClickHouseDb;
   public readonly capabilities: ICapabilities = Object.freeze({ backend: 'clickhouse',
-    transactions: 'unsupported', changeStreams: 'unsupported', objectMetrics: 'unsupported', diskResidentScans: 'available' });
+    transactions: 'unsupported', changeStreams: 'unsupported', compositeGrouping: 'unsupported',
+    objectMetrics: 'unsupported', diskResidentScans: 'available' });
   private client?: plugins.clickhouse.ClickHouseClient;
   private readonly operations = new Map<Operation, () => void>();
   private readonly tasks = new Set<Promise<unknown>>();

package/ts/sqldb/classes.sqlconnection.ts

@@ -1,13 +1,15 @@
-import * as plugins from './plugins.mariadb.js';
+import * as plugins from './plugins.js';
 import { SqlTable } from './classes.sqltable.js';
-import { SqlPool, type SqlPooledConnection } from './internal.sqlpool.js';
+import { SqlPool } from './internal.sqlpool.js';
+import type { ISqlLeaseConnection } from './internal.lease.js';
 import { Operation } from '../core/classes.operation.js';
 import { LosslessClientError, backendError } from '../core/classes.error.js';
 import type { ICapabilities, IOperationOptions, IReadiness } from '../core/interfaces.js';
 import { quoteIdentifier, resultLimits, valueBytes } from './interfaces.js';
-import type { IInsertOptions, IQueryOptions, ISqlMutationResult, ISqlStatement, TSqlValue } from './interfaces.js';
+import type { IInsertOptions, IQueryOptions, ISqlMutationResult, ISqlStatement, ISqlWriteAcknowledgement,
+  TSqlValue } from './interfaces.js';
 
-/** Options of a MariaDB-protocol connection. `tls` is the driver's own TLS configuration. */
+/** Options of a MariaDB-protocol connection. `tls` is this client's own TLS configuration, passed to the driver. */
 export interface ISqlConnectionOptions {
   backend: 'sqldb' | 'mariadb';
   host: string;
@@ -17,11 +19,11 @@ export interface ISqlConnectionOptions {
   database: string;
   connectionLimit?: number;
   timeoutMs?: number;
-  tls?: plugins.mariadb.ConnectionConfig['ssl'];
+  tls?: boolean | (plugins.tls.SecureContextOptions & { rejectUnauthorized?: boolean });
 }
 
 interface ILease {
-  connection: SqlPooledConnection;
+  connection: ISqlLeaseConnection;
   operation: Operation;
   close: () => Promise<void>;
   done: Promise<void>;
@@ -54,7 +56,7 @@ const boundValues = (statement: ISqlStatement): TSqlValue[] =>
     ? value.toISOString().replace('T', ' ').replace('Z', '')
     : value instanceof Uint8Array ? Buffer.from(value) : value);
 
-const mutationResult = (result: plugins.mariadb.UpsertResult): ISqlMutationResult => ({
+const mutationResult = (result: ISqlWriteAcknowledgement): ISqlMutationResult => ({
   affectedRows: result.affectedRows,
   ...(result.insertId === undefined ? {} : { insertId: BigInt(result.insertId) }),
   completion: 'acknowledged',
@@ -81,7 +83,7 @@ export class SqlConnection {
     }
     this.backend = options.backend;
     this.capabilities = Object.freeze({ backend: this.backend, transactions: 'available',
-      changeStreams: 'unsupported', objectMetrics: 'unsupported',
+      changeStreams: 'unsupported', compositeGrouping: 'unsupported', objectMetrics: 'unsupported',
       diskResidentScans: this.backend === 'sqldb' ? 'unsupported' : 'available' });
   }
 
@@ -130,7 +132,7 @@ export class SqlConnection {
     const operation = new Operation(options, this.options.timeoutMs);
     this.pendingOperations.add(operation);
     const acquisition = (async (): Promise<ILease> => {
-      let connection: SqlPooledConnection | undefined;
+      let connection: ISqlLeaseConnection | undefined;
       try {
         operation.check();
         connection = await pool.getConnection(operation);
@@ -174,7 +176,7 @@ export class SqlConnection {
     try {
       lease.operation.check();
       dispatched = true;
-      const result = await lease.connection.execute<plugins.mariadb.UpsertResult>(statement.sql, boundValues(statement));
+      const result = await lease.connection.execute<ISqlWriteAcknowledgement>(statement.sql, boundValues(statement));
       return mutationResult(result);
     } catch (error) {
       if (dispatched && (lease.operation.signal.aborted || !lease.connection.isValid())) {
@@ -328,7 +330,8 @@ export class SqlTransaction {
 
   public execute(statement: ISqlStatement): Promise<ISqlMutationResult> {
     validateStatement(statement);
-    return this.run(async () => mutationResult(await this.lease.connection.execute(statement.sql, boundValues(statement))));
+    return this.run(async () => mutationResult(
+      await this.lease.connection.execute<ISqlWriteAcknowledgement>(statement.sql, boundValues(statement))));
   }
 
   public query<Row = Record<string, unknown>>(statement: ISqlStatement, options: Pick<IQueryOptions, 'maxRows' | 'maxBytes'> = {}): Promise<Row[]> {

package/ts/sqldb/interfaces.ts

@@ -9,6 +9,11 @@ export interface ISqlMutationResult {
   insertId?: bigint;
   completion: 'acknowledged';
 }
+/** What a write acknowledgement carries on the wire; the driver's own result satisfies it. */
+export interface ISqlWriteAcknowledgement {
+  affectedRows: number;
+  insertId?: number | bigint;
+}
 export interface IInsertOptions extends IOperationOptions { batchSize?: number; maxBatchBytes?: number }
 export interface IClickHouseConnectionOptions {
   backend: 'clickhouse';

package/ts/sqldb/internal.lease.ts

@@ -0,0 +1,16 @@
+import * as plugins from './plugins.js';
+
+/**
+ * What a pooled connection offers the holder of its lease. The pool speaks the driver's types;
+ * this seam is the client's own, so the connection and transaction declarations never name the driver.
+ */
+export interface ISqlLeaseConnection {
+  execute<Result>(sql: string, values?: readonly unknown[]): Promise<Result>;
+  beginTransaction(): Promise<void>;
+  commit(): Promise<void>;
+  rollback(): Promise<void>;
+  queryStream(sql: string, values?: readonly unknown[]): plugins.stream.Readable;
+  isValid(): boolean;
+  destroy(): void;
+  release(): Promise<void>;
+}

package/ts/sqldb/internal.sqlpool.ts

@@ -1,4 +1,5 @@
 import * as plugins from './plugins.mariadb.js';
+import type { ISqlLeaseConnection } from './internal.lease.js';
 import type { Operation } from '../core/classes.operation.js';
 import { LosslessClientError } from '../core/classes.error.js';
 
@@ -112,7 +113,7 @@ export class SqlPool {
 }
 
 /** A lease can never affect a physical connection after returning ownership to the pool. */
-export class SqlPooledConnection {
+export class SqlPooledConnection implements ISqlLeaseConnection {
   private readonly tasks = new Set<Promise<unknown>>();
   private readonly streams = new Set<plugins.stream.Readable>();
   private released = false;

package/ts/sqldb/plugins.mariadb.ts

@@ -1,4 +1,4 @@
+// The MariaDB driver plus the shared Node built-ins. Only modules that speak to the driver import this.
 import * as mariadb from 'mariadb';
-import * as stream from 'node:stream';
-import * as net from 'node:net';
-export { mariadb, stream, net };
+export * from './plugins.js';
+export { mariadb };

package/ts/sqldb/plugins.ts

@@ -0,0 +1,7 @@
+// Node built-ins the relational families share. Driver packages stay in their own plugin modules,
+// so a declaration that needs none of them never reaches an optional peer.
+import * as net from 'node:net';
+import * as stream from 'node:stream';
+import * as tls from 'node:tls';
+
+export { net, stream, tls };