@orion-js/mongodb 4.2.3 → 4.2.5

package/dist/index.cjs

@@ -43,6 +43,7 @@ __export(index_exports, {
   createIndexesPromises: () => createIndexesPromises,
   deleteAllUnusedIndexes: () => deleteAllUnusedIndexes,
   getDBName: () => getDBName,
+  getMergedIndexes: () => getMergedIndexes,
   getMongoConnection: () => getMongoConnection,
   getOrCreateEncryptionKey: () => getOrCreateEncryptionKey,
   getRegisteredCollections: () => getRegisteredCollections,
@@ -127,9 +128,6 @@ var OrionMongoDatabaseWrapper = class {
   configTimeout;
   constructor(connectionName) {
     this.connectionName = connectionName;
-    import_logger.logger.info("New connection requested", {
-      connectionName
-    });
     this.connectionEvent.setMaxListeners(Number.POSITIVE_INFINITY);
     this.connectionPromise = new Promise((resolve, reject) => {
       if (this.state === "connected") {
@@ -175,11 +173,8 @@ var OrionMongoDatabaseWrapper = class {
       return this;
     }
     this.state = "connecting";
-    const censoredURI = this.uri.replace(/\/\/.*:.*@/, "//");
-    import_logger.logger.info("Connecting to mongo", {
-      uri: censoredURI,
-      connectionName: this.connectionName
-    });
+    const censoredURI = this.uri.replace(/\/\/.*:.*@/, "//").replace(/^mongodb(\+srv)?:\/\//, "");
+    import_logger.logger.info(`Starting MongoDB connection "${this.connectionName}" [${censoredURI}]`);
     if (this.encrypted.client) {
       await this.connectWithRetry(this.encrypted.client);
       import_logger.logger.info("Successfully connected to encrypted mongo", {
@@ -190,10 +185,6 @@ var OrionMongoDatabaseWrapper = class {
     await this.connectWithRetry(this.client);
     this.state = "connected";
     this.connectionEvent.emit("connected", this.client);
-    import_logger.logger.info("Successfully connected to mongo", {
-      uri: censoredURI,
-      connectionName: this.connectionName
-    });
     (0, import_node_process.nextTick)(() => {
       this.connectionEvent.removeAllListeners();
       this.connectionEvent = null;
@@ -1197,7 +1188,7 @@ var generateId_default = getIdGenerator;
 
 // src/createCollection/createIndexes.ts
 var import_mongodb2 = require("mongodb");
-var import_logger3 = require("@orion-js/logger");
+var import_logger4 = require("@orion-js/logger");
 
 // src/createCollection/deleteUnusedIndexes.ts
 var import_logger2 = require("@orion-js/logger");
@@ -1219,6 +1210,15 @@ function getIndexName(indexDef) {
 }
 
 // src/createCollection/deleteUnusedIndexes.ts
+function isTextIndexDefinition(keys) {
+  return Object.values(keys).some((value) => value === "text");
+}
+function isMongoDBTextIndex(key) {
+  return "_fts" in key && "_ftsx" in key;
+}
+function generateIndexName(keys) {
+  return Object.entries(keys).map(([field, value]) => `${field}_${value}`).join("_");
+}
 function keysMatch(definitionKeys, currentIndexKey) {
   const defEntries = Object.entries(definitionKeys);
   const curEntries = Object.entries(currentIndexKey);
@@ -1234,7 +1234,12 @@ function isIndexDefined(definedIndexes, currentIndex) {
   return definedIndexes.some((defIndex) => {
     const customName = getIndexName(defIndex);
     if (customName && customName === currentIndex.name) return true;
-    return keysMatch(defIndex.keys, currentIndex.key);
+    const defKeys = defIndex.keys;
+    if (isTextIndexDefinition(defKeys) && isMongoDBTextIndex(currentIndex.key)) {
+      const expectedName = generateIndexName(defKeys);
+      return currentIndex.name === expectedName;
+    }
+    return keysMatch(defKeys, currentIndex.key);
   });
 }
 async function deleteUnusedIndexes(collection) {
@@ -1272,67 +1277,8 @@ async function deleteUnusedIndexes(collection) {
   return result;
 }
 
-// src/createCollection/createIndexes.ts
-async function checkIndexes(collection) {
-  await collection.connectionPromise;
-  let currentIndexes = [];
-  try {
-    currentIndexes = await collection.rawCollection.indexes();
-  } catch (error) {
-    if (error.codeName !== "NamespaceNotFound") throw error;
-    return;
-  }
-  if (!collection.indexes || collection.indexes.length === 0) {
-    return;
-  }
-  const unexpectedIndexes = currentIndexes.filter(
-    (index) => index.name !== "_id_" && !isIndexDefined(collection.indexes, index)
-  );
-  if (unexpectedIndexes.length > 0) {
-    import_logger3.logger.warn(
-      `${unexpectedIndexes.length} unexpected indexes found in collection "${collection.name}": ${unexpectedIndexes.map((i) => i.name).join(", ")} | Delete the index or fix the collection definition`
-    );
-  }
-}
-async function loadIndexes(collection) {
-  if (!collection.indexes) return;
-  if (!collection.indexes.length) return;
-  await collection.connectionPromise;
-  const results = Promise.all(
-    collection.indexes.map(async (indexDef) => {
-      const { keys } = indexDef;
-      const options = getIndexOptions(indexDef);
-      try {
-        return await collection.rawCollection.createIndex(keys, options);
-      } catch (error) {
-        if (error.code === 85 || error.code === 86) {
-          console.info("Will delete index to create the new version");
-          const indexName = (() => {
-            const message = error.errorResponse.errmsg;
-            const indexName2 = message.split('name: "')[1].split('"')[0];
-            return indexName2;
-          })();
-          await collection.rawCollection.dropIndex(indexName);
-          console.info("Index was deleted, creating new index");
-          const result = await collection.rawCollection.createIndex(keys, options);
-          console.info("Index updated correctly");
-          return result;
-        }
-        if (error instanceof import_mongodb2.MongoExpiredSessionError || error instanceof import_mongodb2.MongoNotConnectedError) {
-        } else {
-          console.error(`Error creating index for collection ${collection.name}: ${error.message}`);
-          console.error(error);
-          return error.message;
-        }
-      }
-    })
-  );
-  await checkIndexes(collection);
-  return results;
-}
-
 // src/createCollection/collectionsRegistry.ts
-var import_logger4 = require("@orion-js/logger");
+var import_logger3 = require("@orion-js/logger");
 var collectionsRegistry = /* @__PURE__ */ new Map();
 function indexesAreEqual(indexA, indexB) {
   const nameA = getIndexName(indexA);
@@ -1374,17 +1320,28 @@ function getRegisteredCollections(connectionName = "main") {
   }
   return Array.from(connectionCollections.values());
 }
+function getMergedIndexes(connectionName, collectionName) {
+  const connectionCollections = collectionsRegistry.get(connectionName);
+  if (!connectionCollections) {
+    return [];
+  }
+  const collection = connectionCollections.get(collectionName);
+  if (!collection) {
+    return [];
+  }
+  return collection.indexes || [];
+}
 async function deleteAllUnusedIndexes(connectionName = "main") {
   const collections = getRegisteredCollections(connectionName);
   if (collections.length === 0) {
-    import_logger4.logger.warn(`No collections registered for connection "${connectionName}"`);
+    import_logger3.logger.warn(`No collections registered for connection "${connectionName}"`);
     return [];
   }
   if (createIndexesPromises.length > 0) {
-    import_logger4.logger.info("Waiting for pending index creation to complete before deleting unused indexes...");
+    import_logger3.logger.info("Waiting for pending index creation to complete before deleting unused indexes...");
     await Promise.all(createIndexesPromises);
   }
-  import_logger4.logger.info(
+  import_logger3.logger.info(
     `Deleting unused indexes from ${collections.length} collections on connection "${connectionName}"`
   );
   const results = [];
@@ -1395,7 +1352,67 @@ async function deleteAllUnusedIndexes(connectionName = "main") {
     }
   }
   const totalDeleted = results.reduce((sum, r) => sum + r.deletedIndexes.length, 0);
-  import_logger4.logger.info(`Deleted ${totalDeleted} unused indexes from ${results.length} collections`);
+  import_logger3.logger.info(`Deleted ${totalDeleted} unused indexes from ${results.length} collections`);
+  return results;
+}
+
+// src/createCollection/createIndexes.ts
+async function checkIndexes(collection) {
+  await collection.connectionPromise;
+  let currentIndexes = [];
+  try {
+    currentIndexes = await collection.rawCollection.indexes();
+  } catch (error) {
+    if (error.codeName !== "NamespaceNotFound") throw error;
+    return;
+  }
+  const mergedIndexes = getMergedIndexes(collection.connectionName, collection.name);
+  if (mergedIndexes.length === 0) {
+    return;
+  }
+  const unexpectedIndexes = currentIndexes.filter(
+    (index) => index.name !== "_id_" && !isIndexDefined(mergedIndexes, index)
+  );
+  if (unexpectedIndexes.length > 0) {
+    import_logger4.logger.warn(
+      `${unexpectedIndexes.length} unexpected indexes found in collection "${collection.name}": ${unexpectedIndexes.map((i) => i.name).join(", ")} | Delete the index or fix the collection definition`
+    );
+  }
+}
+async function loadIndexes(collection) {
+  if (!collection.indexes) return;
+  if (!collection.indexes.length) return;
+  await collection.connectionPromise;
+  const results = Promise.all(
+    collection.indexes.map(async (indexDef) => {
+      const { keys } = indexDef;
+      const options = getIndexOptions(indexDef);
+      try {
+        return await collection.rawCollection.createIndex(keys, options);
+      } catch (error) {
+        if (error.code === 85 || error.code === 86) {
+          console.info("Will delete index to create the new version");
+          const indexName = (() => {
+            const message = error.errorResponse.errmsg;
+            const indexName2 = message.split('name: "')[1].split('"')[0];
+            return indexName2;
+          })();
+          await collection.rawCollection.dropIndex(indexName);
+          console.info("Index was deleted, creating new index");
+          const result = await collection.rawCollection.createIndex(keys, options);
+          console.info("Index updated correctly");
+          return result;
+        }
+        if (error instanceof import_mongodb2.MongoExpiredSessionError || error instanceof import_mongodb2.MongoNotConnectedError) {
+        } else {
+          console.error(`Error creating index for collection ${collection.name}: ${error.message}`);
+          console.error(error);
+          return error.message;
+        }
+      }
+    })
+  );
+  await checkIndexes(collection);
   return results;
 }
 
@@ -1680,6 +1697,7 @@ var ENCRYPTION_ALGORITHMS = {
   createIndexesPromises,
   deleteAllUnusedIndexes,
   getDBName,
+  getMergedIndexes,
   getMongoConnection,
   getOrCreateEncryptionKey,
   getRegisteredCollections,