@lossless.org/client 1.1.0 → 1.3.0

package/ts/nosqldb/classes.exactpersistence.ts

@@ -4,6 +4,7 @@ import { assertBsonWithoutMutation } from './classes.bsonassertion.js';
 import { getOrdinaryPersistencePolicy } from './classes.ordinarypersistence.js';
 
 import type { SmartdataCollection } from './classes.collection.js';
+import { getIdentityIndexName } from './classes.collectiontopology.js';
 import { registerCollectionReconnectHandler } from './classes.collectionlifecycle.js';
 import type { SmartdataSession } from './classes.session.js';
 import { acquireSmartdataSession } from './classes.session.js';
@@ -1024,10 +1025,17 @@ export class SmartdataExactCollection<
     const missingUniqueIndexes = this.uniqueIndexes.filter(
       (uniqueIndexArg) => !this.collection.uniqueIndexes.includes(uniqueIndexArg),
     );
+    const boundSchema = this.collection.getBoundModelSchema();
     for (const uniqueIndex of missingUniqueIndexes) {
       await targetCollectionArg.createIndex(
         { [uniqueIndex]: 1 },
-        { unique: true, name: `${uniqueIndex}_1` },
+        {
+          unique: true,
+          // A model may back its identity with a differently named index;
+          // creating `<field>_1` would duplicate that key.
+          name: getIdentityIndexName(boundSchema, uniqueIndex)
+            ?? `${uniqueIndex}_1`,
+        },
       );
     }
 

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.persistence.ts

@@ -43,6 +43,23 @@ export const isMongoDuplicateKeyError = (
   );
 };
 
+/**
+ * MongoDB refuses an index whose key or name collides with an existing one:
+ * `IndexOptionsConflict` when an equivalent index already carries another
+ * name, `IndexKeySpecsConflict` when the name is taken by another key.
+ */
+export const isMongoIndexConflictError = (
+  errorArg: unknown,
+): errorArg is plugins.mongodb.MongoServerError => {
+  return (
+    errorArg instanceof plugins.mongodb.MongoServerError &&
+    (errorArg.code === 85 ||
+      errorArg.code === 86 ||
+      errorArg.codeName === 'IndexOptionsConflict' ||
+      errorArg.codeName === 'IndexKeySpecsConflict')
+  );
+};
+
 export const normalizeOrdinaryPersistenceError = (
   errorArg: unknown,
   messageArg: string,

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 {