@lossless.org/client 1.2.0 → 1.3.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 {