@orion-js/mongodb 4.1.10 → 4.2.1

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);
@@ -295,6 +299,12 @@ var BaseCollection = class {
    */
   createIndexes;
   createIndexesPromise;
+  /**
+   * Deletes indexes that exist in MongoDB but are not defined in the collection configuration.
+   * This helps clean up stale indexes that are no longer needed.
+   * Always preserves the _id_ index.
+   */
+  deleteUnusedIndexes;
   /**
    * @deprecated Use startConnection() instead. This property is not guaranteed to be resolved if the connection is not started.
    * When using async calls startConnection or connectionPromise is no longer needed. Orion will automatically start the connection if it is not already started.
@@ -1187,12 +1197,82 @@ var generateId_default = getIdGenerator;
 
 // src/createCollection/createIndexes.ts
 var import_mongodb2 = require("mongodb");
+var import_logger3 = require("@orion-js/logger");
+
+// src/createCollection/deleteUnusedIndexes.ts
 var import_logger2 = require("@orion-js/logger");
-function matchingDefinition(defIndex, curIndex) {
-  if (defIndex.options && defIndex.options.name === curIndex.name) return true;
-  const defIndexName = Object.keys(defIndex.keys).map((key) => `${key}_${defIndex.keys[key]}`).join("_");
-  return defIndexName === curIndex.name;
+
+// src/createCollection/getIndexOptions.ts
+function getIndexOptions(indexDef) {
+  const { keys: _keys, options: deprecatedOptions, ...flatOptions } = indexDef;
+  if (deprecatedOptions) {
+    return { ...deprecatedOptions, ...flatOptions };
+  }
+  return Object.keys(flatOptions).length > 0 ? flatOptions : void 0;
+}
+function getIndexName(indexDef) {
+  var _a;
+  if (indexDef.name) {
+    return indexDef.name;
+  }
+  return (_a = indexDef.options) == null ? void 0 : _a.name;
+}
+
+// src/createCollection/deleteUnusedIndexes.ts
+function keysMatch(definitionKeys, currentIndexKey) {
+  const defEntries = Object.entries(definitionKeys);
+  const curEntries = Object.entries(currentIndexKey);
+  if (defEntries.length !== curEntries.length) return false;
+  for (let i = 0; i < defEntries.length; i++) {
+    const [defKey, defValue] = defEntries[i];
+    const [curKey, curValue] = curEntries[i];
+    if (defKey !== curKey || defValue !== curValue) return false;
+  }
+  return true;
+}
+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);
+  });
 }
+async function deleteUnusedIndexes(collection) {
+  await collection.connectionPromise;
+  const result = {
+    deletedIndexes: [],
+    collectionName: collection.name
+  };
+  let currentIndexes = [];
+  try {
+    currentIndexes = await collection.rawCollection.indexes();
+  } catch (error) {
+    if (error.codeName === "NamespaceNotFound") {
+      return result;
+    }
+    throw error;
+  }
+  if (!collection.indexes || collection.indexes.length === 0) {
+    return result;
+  }
+  const unusedIndexes = currentIndexes.filter(
+    (index) => index.name !== "_id_" && !isIndexDefined(collection.indexes, index)
+  );
+  for (const index of unusedIndexes) {
+    try {
+      await collection.rawCollection.dropIndex(index.name);
+      result.deletedIndexes.push(index.name);
+      import_logger2.logger.info(`Deleted unused index "${index.name}" from collection "${collection.name}"`);
+    } catch (error) {
+      import_logger2.logger.error(`Failed to delete index "${index.name}" from collection "${collection.name}"`, {
+        error
+      });
+    }
+  }
+  return result;
+}
+
+// src/createCollection/createIndexes.ts
 async function checkIndexes(collection) {
   await collection.connectionPromise;
   let currentIndexes = [];
@@ -1200,13 +1280,17 @@ async function checkIndexes(collection) {
     currentIndexes = await collection.rawCollection.indexes();
   } catch (error) {
     if (error.codeName !== "NamespaceNotFound") throw error;
+    return;
   }
-  const indexesToDelete = collection.indexes ? currentIndexes.filter(
-    (index) => index.name !== "_id_" && !collection.indexes.find((definitionIndex) => matchingDefinition(definitionIndex, index))
-  ) : currentIndexes;
-  if (indexesToDelete.length > 0) {
-    import_logger2.logger.warn(
-      `${indexesToDelete.length} unexpected indexes found in collection "${collection.name}": ${indexesToDelete.map((i) => i.name).join(", ")} | Delete the index or fix the collection definition`
+  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`
     );
   }
 }
@@ -1215,7 +1299,9 @@ async function loadIndexes(collection) {
   if (!collection.indexes.length) return;
   await collection.connectionPromise;
   const results = Promise.all(
-    collection.indexes.map(async ({ keys, options }) => {
+    collection.indexes.map(async (indexDef) => {
+      const { keys } = indexDef;
+      const options = getIndexOptions(indexDef);
       try {
         return await collection.rawCollection.createIndex(keys, options);
       } catch (error) {
@@ -1245,6 +1331,43 @@ async function loadIndexes(collection) {
   return results;
 }
 
+// src/createCollection/collectionsRegistry.ts
+var import_logger4 = require("@orion-js/logger");
+var collectionsRegistry = /* @__PURE__ */ new Map();
+function registerCollection(connectionName, collection) {
+  if (!collectionsRegistry.has(connectionName)) {
+    collectionsRegistry.set(connectionName, /* @__PURE__ */ new Map());
+  }
+  collectionsRegistry.get(connectionName).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 [];
+  }
+  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"));
@@ -1277,7 +1400,7 @@ function getSchema(options) {
 }
 
 // src/createCollection/wrapMethods.ts
-var import_logger3 = require("@orion-js/logger");
+var import_logger5 = require("@orion-js/logger");
 function wrapMethods(collection) {
   const methodsWithPromises = [
     "findOne",
@@ -1313,7 +1436,7 @@ function wrapMethods(collection) {
         collection[methodName2] = (...args) => {
           collection.startConnection();
           if (!collection.rawCollection) {
-            import_logger3.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
@@ -1414,11 +1537,16 @@ function createCollection(options) {
     return createIndexPromise;
   };
   mainCollection.createIndexes = createIndexes;
+  mainCollection.deleteUnusedIndexes = async () => {
+    await orionConnection.startConnection();
+    return deleteUnusedIndexes(mainCollection);
+  };
   if (!process.env.DONT_CREATE_INDEXES_AUTOMATICALLY) {
     createIndexes();
   }
   wrapMethods(mainCollection);
   wrapMethods(encryptedCollection);
+  registerCollection(connectionName, mainCollection);
   return mainCollection;
 }
 
@@ -1449,7 +1577,7 @@ function MongoCollection(options) {
 }
 
 // src/encrypted/getOrCreateEncryptionKey.ts
-var import_logger4 = require("@orion-js/logger");
+var import_logger6 = require("@orion-js/logger");
 var import_mongodb3 = require("mongodb");
 async function getOrCreateEncryptionKey({
   keyAltName,
@@ -1461,7 +1589,7 @@ async function getOrCreateEncryptionKey({
   kmsProviders
 }) {
   const keyVaultNamespace = `${keyVaultDatabase}.${keyVaultCollection}`;
-  import_logger4.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
   });
@@ -1479,14 +1607,14 @@ async function getOrCreateEncryptionKey({
   });
   const key = await clientEncryption.getKeyByAltName(keyAltName);
   if (key) {
-    import_logger4.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_logger4.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
   });
@@ -1494,7 +1622,7 @@ async function getOrCreateEncryptionKey({
     keyAltNames: [keyAltName],
     ...masterKey ? { masterKey } : {}
   });
-  import_logger4.logger.info("New encryption key created", {
+  import_logger6.logger.info("New encryption key created", {
     keyVaultNamespace,
     keyAltName,
     UUID: newKey
@@ -1514,13 +1642,17 @@ var ENCRYPTION_ALGORITHMS = {
   MongoDB,
   Repository,
   allConnectionPromises,
+  collectionsRegistry,
   configureConnection,
   connections,
   createCollection,
   createIndexesPromises,
+  deleteAllUnusedIndexes,
   getDBName,
   getMongoConnection,
   getOrCreateEncryptionKey,
+  getRegisteredCollections,
+  registerCollection,
   typedId
 });
 //# sourceMappingURL=index.cjs.map