@orion-js/mongodb 4.2.0 → 4.2.3

package/dist/index.cjs

@@ -36,13 +36,17 @@ __export(index_exports, {
   MongoDB: () => MongoDB,
   Repository: () => Repository,
   allConnectionPromises: () => allConnectionPromises,
+  collectionsRegistry: () => collectionsRegistry,
   configureConnection: () => configureConnection,
   connections: () => connections,
   createCollection: () => createCollection,
   createIndexesPromises: () => createIndexesPromises,
+  deleteAllUnusedIndexes: () => deleteAllUnusedIndexes,
   getDBName: () => getDBName,
   getMongoConnection: () => getMongoConnection,
   getOrCreateEncryptionKey: () => getOrCreateEncryptionKey,
+  getRegisteredCollections: () => getRegisteredCollections,
+  registerCollection: () => registerCollection,
   typedId: () => typedId
 });
 module.exports = __toCommonJS(index_exports);
@@ -1327,6 +1331,74 @@ async function loadIndexes(collection) {
   return results;
 }
 
+// src/createCollection/collectionsRegistry.ts
+var import_logger4 = require("@orion-js/logger");
+var collectionsRegistry = /* @__PURE__ */ new Map();
+function indexesAreEqual(indexA, indexB) {
+  const nameA = getIndexName(indexA);
+  const nameB = getIndexName(indexB);
+  if (nameA && nameB) {
+    return nameA === nameB;
+  }
+  return keysMatch(
+    indexA.keys,
+    indexB.keys
+  );
+}
+function mergeIndexes(existingIndexes, newIndexes) {
+  const merged = [...existingIndexes];
+  for (const newIndex of newIndexes) {
+    const isDuplicate = existingIndexes.some((existing) => indexesAreEqual(existing, newIndex));
+    if (!isDuplicate) {
+      merged.push(newIndex);
+    }
+  }
+  return merged;
+}
+function registerCollection(connectionName, collection) {
+  if (!collectionsRegistry.has(connectionName)) {
+    collectionsRegistry.set(connectionName, /* @__PURE__ */ new Map());
+  }
+  const connectionMap = collectionsRegistry.get(connectionName);
+  const existingCollection = connectionMap.get(collection.name);
+  if (existingCollection) {
+    existingCollection.indexes = mergeIndexes(existingCollection.indexes, collection.indexes);
+  } else {
+    connectionMap.set(collection.name, collection);
+  }
+}
+function getRegisteredCollections(connectionName = "main") {
+  const connectionCollections = collectionsRegistry.get(connectionName);
+  if (!connectionCollections) {
+    return [];
+  }
+  return Array.from(connectionCollections.values());
+}
+async function deleteAllUnusedIndexes(connectionName = "main") {
+  const collections = getRegisteredCollections(connectionName);
+  if (collections.length === 0) {
+    import_logger4.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...");
+    await Promise.all(createIndexesPromises);
+  }
+  import_logger4.logger.info(
+    `Deleting unused indexes from ${collections.length} collections on connection "${connectionName}"`
+  );
+  const results = [];
+  for (const collection of collections) {
+    const result = await collection.deleteUnusedIndexes();
+    if (result.deletedIndexes.length > 0) {
+      results.push(result);
+    }
+  }
+  const totalDeleted = results.reduce((sum, r) => sum + r.deletedIndexes.length, 0);
+  import_logger4.logger.info(`Deleted ${totalDeleted} unused indexes from ${results.length} collections`);
+  return results;
+}
+
 // src/createCollection/getSchemaAndModel.ts
 var import_helpers7 = require("@orion-js/helpers");
 Symbol.metadata ?? (Symbol.metadata = Symbol("Symbol.metadata"));
@@ -1359,7 +1431,7 @@ function getSchema(options) {
 }
 
 // src/createCollection/wrapMethods.ts
-var import_logger4 = require("@orion-js/logger");
+var import_logger5 = require("@orion-js/logger");
 function wrapMethods(collection) {
   const methodsWithPromises = [
     "findOne",
@@ -1395,7 +1467,7 @@ function wrapMethods(collection) {
         collection[methodName2] = (...args) => {
           collection.startConnection();
           if (!collection.rawCollection) {
-            import_logger4.logger.error("Method called before connection was initialized", {
+            import_logger5.logger.error("Method called before connection was initialized", {
               collectionName: collection.name,
               connectionName: collection.connectionName,
               methodName: methodName2
@@ -1505,6 +1577,7 @@ function createCollection(options) {
   }
   wrapMethods(mainCollection);
   wrapMethods(encryptedCollection);
+  registerCollection(connectionName, mainCollection);
   return mainCollection;
 }
 
@@ -1535,7 +1608,7 @@ function MongoCollection(options) {
 }
 
 // src/encrypted/getOrCreateEncryptionKey.ts
-var import_logger5 = require("@orion-js/logger");
+var import_logger6 = require("@orion-js/logger");
 var import_mongodb3 = require("mongodb");
 async function getOrCreateEncryptionKey({
   keyAltName,
@@ -1547,7 +1620,7 @@ async function getOrCreateEncryptionKey({
   kmsProviders
 }) {
   const keyVaultNamespace = `${keyVaultDatabase}.${keyVaultCollection}`;
-  import_logger5.logger.info("Connecting to database to get or create the encryption key", {
+  import_logger6.logger.info("Connecting to database to get or create the encryption key", {
     keyVaultNamespace,
     keyAltName
   });
@@ -1565,14 +1638,14 @@ async function getOrCreateEncryptionKey({
   });
   const key = await clientEncryption.getKeyByAltName(keyAltName);
   if (key) {
-    import_logger5.logger.info("Key found on the key vault", {
+    import_logger6.logger.info("Key found on the key vault", {
       keyVaultNamespace,
       keyAltName,
       UUID: key._id
     });
     return { key: key._id, keyVaultNamespace };
   }
-  import_logger5.logger.info("Key not found on the key vault, creating a new one", {
+  import_logger6.logger.info("Key not found on the key vault, creating a new one", {
     keyVaultNamespace,
     keyAltName
   });
@@ -1580,7 +1653,7 @@ async function getOrCreateEncryptionKey({
     keyAltNames: [keyAltName],
     ...masterKey ? { masterKey } : {}
   });
-  import_logger5.logger.info("New encryption key created", {
+  import_logger6.logger.info("New encryption key created", {
     keyVaultNamespace,
     keyAltName,
     UUID: newKey
@@ -1600,13 +1673,17 @@ var ENCRYPTION_ALGORITHMS = {
   MongoDB,
   Repository,
   allConnectionPromises,
+  collectionsRegistry,
   configureConnection,
   connections,
   createCollection,
   createIndexesPromises,
+  deleteAllUnusedIndexes,
   getDBName,
   getMongoConnection,
   getOrCreateEncryptionKey,
+  getRegisteredCollections,
+  registerCollection,
   typedId
 });
 //# sourceMappingURL=index.cjs.map