@orion-js/mongodb 4.1.10 → 4.2.0

package/dist/index.cjs

@@ -295,6 +295,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 +1193,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 +1276,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 +1295,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) {
@@ -1277,7 +1359,7 @@ function getSchema(options) {
 }
 
 // src/createCollection/wrapMethods.ts
-var import_logger3 = require("@orion-js/logger");
+var import_logger4 = require("@orion-js/logger");
 function wrapMethods(collection) {
   const methodsWithPromises = [
     "findOne",
@@ -1313,7 +1395,7 @@ function wrapMethods(collection) {
         collection[methodName2] = (...args) => {
           collection.startConnection();
           if (!collection.rawCollection) {
-            import_logger3.logger.error("Method called before connection was initialized", {
+            import_logger4.logger.error("Method called before connection was initialized", {
               collectionName: collection.name,
               connectionName: collection.connectionName,
               methodName: methodName2
@@ -1414,6 +1496,10 @@ 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();
   }
@@ -1449,7 +1535,7 @@ function MongoCollection(options) {
 }
 
 // src/encrypted/getOrCreateEncryptionKey.ts
-var import_logger4 = require("@orion-js/logger");
+var import_logger5 = require("@orion-js/logger");
 var import_mongodb3 = require("mongodb");
 async function getOrCreateEncryptionKey({
   keyAltName,
@@ -1461,7 +1547,7 @@ async function getOrCreateEncryptionKey({
   kmsProviders
 }) {
   const keyVaultNamespace = `${keyVaultDatabase}.${keyVaultCollection}`;
-  import_logger4.logger.info("Connecting to database to get or create the encryption key", {
+  import_logger5.logger.info("Connecting to database to get or create the encryption key", {
     keyVaultNamespace,
     keyAltName
   });
@@ -1479,14 +1565,14 @@ async function getOrCreateEncryptionKey({
   });
   const key = await clientEncryption.getKeyByAltName(keyAltName);
   if (key) {
-    import_logger4.logger.info("Key found on the key vault", {
+    import_logger5.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_logger5.logger.info("Key not found on the key vault, creating a new one", {
     keyVaultNamespace,
     keyAltName
   });
@@ -1494,7 +1580,7 @@ async function getOrCreateEncryptionKey({
     keyAltNames: [keyAltName],
     ...masterKey ? { masterKey } : {}
   });
-  import_logger4.logger.info("New encryption key created", {
+  import_logger5.logger.info("New encryption key created", {
     keyVaultNamespace,
     keyAltName,
     UUID: newKey