@lossless.org/client 1.2.0 → 1.4.0

package/ts/nosqldb/classes.namespaceinspection.ts

@@ -173,7 +173,7 @@ export const inspectSmartdataNamespace = async (
           });
         }
         const topology = inspectCollectionTopologySnapshot({
-          collectionName: namespace.name, indexes: [],
+          collectionName: namespace.name, indexes: [], toleratedIndexNames: [],
         }, { namespace: namespace as unknown as Record<string, unknown>, indexes });
         collections.push(Object.freeze({
           collectionName: namespace.name, namespaceType, documentCount,

package/ts/nosqldb/classes.session.ts

@@ -45,7 +45,8 @@ interface ISmartdataSessionAcquireOptions {
 interface IOrdinarySessionOperationOptions {
   ordinaryWrite?: boolean;
   prepared?: boolean;
-  preparationMessage?: string;
+  /** Names the collection whose preparation a refusal must ask for. */
+  collectionName?: string;
 }
 
 const transactionContext = new plugins.nodeAsyncHooks.AsyncLocalStorage<
@@ -310,27 +311,65 @@ export const isOrdinarySessionInTransaction = (
   return sessionArg.inTransaction();
 };
 
-export const runWithOrdinarySmartdataSession = async <TResult>(
+/**
+ * A SmartData model initializes its collection lazily, and that initialization
+ * issues index DDL outside any session. Under an open transaction on the same
+ * collection the DDL waits for the transaction while the transaction waits for
+ * this operation, so the caller would only learn about it when the client
+ * deadline expires. Naming the missing preparation is the whole remedy.
+ */
+const refuseUnpreparedCollection = (
+  optionsArg: IOrdinarySessionOperationOptions,
+  reasonArg: 'with an owned SmartData session' | 'inside a transaction',
+): never => {
+  throw new SmartdataPersistenceError(
+    'unsupported_operation',
+    optionsArg.collectionName
+      ? `Initialize collection "${optionsArg.collectionName}" before using it ${reasonArg}.`
+      : `Initialize every participating SmartData model before using it ${reasonArg}.`,
+  );
+};
+
+/**
+ * Takes the same lease `runWithOrdinarySmartdataSession` takes, but hands it to
+ * the caller instead of releasing it at the end of one operation. Resources
+ * that outlive their creating call — a cursor the caller iterates itself — hold
+ * the owned session until they are closed, so a second operation on that
+ * session is refused while the cursor is open, exactly as the driver requires.
+ * A raw `ClientSession` or no session keeps its pass-through behavior and gets
+ * an inert release. `release()` is idempotent.
+ */
+export const leaseOrdinarySmartdataSession = (
   sessionArg: TSmartdataOrdinarySession | undefined,
   ownerArg: SmartdataDb,
   optionsArg: IOrdinarySessionOperationOptions,
-  operationArg: (
-    rawSessionArg: plugins.mongodb.ClientSession | undefined,
-  ) => Promise<TResult>,
-): Promise<TResult> => {
+): {
+  rawSession: plugins.mongodb.ClientSession | undefined;
+  release: () => void;
+} => {
   if (!isSmartdataSession(sessionArg)) {
-    return operationArg(sessionArg);
+    if (!optionsArg.prepared && sessionArg?.inTransaction()) {
+      refuseUnpreparedCollection(optionsArg, 'inside a transaction');
+    }
+    return { rawSession: sessionArg, release: () => {} };
   }
   if (!optionsArg.prepared) {
-    throw new SmartdataPersistenceError(
-      'unsupported_operation',
-      optionsArg.preparationMessage ||
-        'Initialize every participating SmartData model before using an owned session.',
-    );
+    refuseUnpreparedCollection(optionsArg, 'with an owned SmartData session');
   }
-  const lease = acquireSmartdataSession(sessionArg, ownerArg, {
+  return acquireSmartdataSession(sessionArg, ownerArg, {
     ordinaryWrite: optionsArg.ordinaryWrite,
   });
+};
+
+export const runWithOrdinarySmartdataSession = async <TResult>(
+  sessionArg: TSmartdataOrdinarySession | undefined,
+  ownerArg: SmartdataDb,
+  optionsArg: IOrdinarySessionOperationOptions,
+  operationArg: (
+    rawSessionArg: plugins.mongodb.ClientSession | undefined,
+  ) => Promise<TResult>,
+): Promise<TResult> => {
+  const lease = leaseOrdinarySmartdataSession(sessionArg, ownerArg, optionsArg);
   try {
     return await operationArg(lease.rawSession);
   } finally {

package/ts/objectstorage/classes.directory.ts

@@ -258,8 +258,11 @@ export class Directory {
       if (optionsArg.getEmptyDirectory || optionsArg.createWithInitializerFile) {
         returnDirectory = new Directory(this.bucketRef, directoryArg, dirNameToSearch);
       }
-      if (isFinalDirectory && optionsArg.createWithInitializerFile) {
-        returnDirectory?.createEmptyFile('00init.txt');
+      if (isFinalDirectory && optionsArg.createWithInitializerFile && returnDirectory) {
+        // The initializer file is what makes an empty directory exist in object storage, so the caller
+        // must not receive the directory before that write completed. An unawaited write is owned by
+        // nobody: closing the SmartBucket aborts it and its rejection reaches no caller.
+        await returnDirectory.createEmptyFile('00init.txt');
       }
       return returnDirectory || null;
     };

package/ts/sqldb/classes.sqlconnection.ts

@@ -5,7 +5,20 @@ 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, ISqlConnectionOptions, ISqlMutationResult, ISqlStatement, TSqlValue } from './interfaces.js';
+import type { IInsertOptions, IQueryOptions, ISqlMutationResult, ISqlStatement, TSqlValue } from './interfaces.js';
+
+/** Options of a MariaDB-protocol connection. `tls` is the driver's own TLS configuration. */
+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'];
+}
 
 interface ILease {
   connection: SqlPooledConnection;

package/ts/sqldb/clickhouse/index.ts

@@ -1,3 +1,8 @@
+// Connection
+export { ClickHouseConnection } from '../classes.clickhouseconnection.js';
+export { quoteClickHouseIdentifier } from '../interfaces.js';
+export type { IClickHouseConnectionOptions, IClickHouseStatement, IInsertOptions, IQueryOptions } from '../interfaces.js';
+
 // Core
 export * from './smartclickhouse.classes.smartclickhouse.js';
 export * from './smartclickhouse.classes.clickhousetable.js';

package/ts/sqldb/index.ts

@@ -1,6 +1,3 @@
-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 './mariadb/index.js';
 export * from './clickhouse/index.js';
+export { resultLimits, valueBytes } from './interfaces.js';

package/ts/sqldb/interfaces.ts

@@ -1,21 +1,9 @@
-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;

package/ts/sqldb/mariadb/index.ts

@@ -0,0 +1,7 @@
+// MariaDB-protocol entry point: SQLDB and MariaDB connections without the ClickHouse driver.
+export { SqlConnection, SqlTransaction } from '../classes.sqlconnection.js';
+export type { ISqlConnectionOptions } from '../classes.sqlconnection.js';
+export { SqlTable } from '../classes.sqltable.js';
+export type { ISqlSelectOptions, TSqlSelector } from '../classes.sqltable.js';
+export { quoteIdentifier } from '../interfaces.js';
+export type { IInsertOptions, IQueryOptions, ISqlMutationResult, ISqlStatement, TSqlValue } from '../interfaces.js';