@orion-js/mongodb 4.1.10 → 4.2.0

package/dist/index.d.ts

@@ -73,8 +73,26 @@ type DocumentWithId<TSchema> = EnhancedOmit<TSchema, '_id'> & {
     _id: InferIdType<TSchema>;
 };
 type ModelClassBase = DocumentWithId<MongoDB.Document>;
-interface CollectionIndex {
+/**
+ * Index definition for a MongoDB collection.
+ * Supports flat options (recommended) or nested options object (deprecated).
+ *
+ * @example New format (recommended):
+ * ```ts
+ * { keys: { email: 1 }, unique: true, sparse: true }
+ * ```
+ *
+ * @example Old format (deprecated):
+ * ```ts
+ * { keys: { email: 1 }, options: { unique: true, sparse: true } }
+ * ```
+ */
+interface CollectionIndex extends Partial<MongoDB.CreateIndexesOptions> {
     keys: MongoDB.IndexSpecification;
+    /**
+     * @deprecated Use flat options instead. Example: `{ keys: { email: 1 }, unique: true }`
+     * instead of `{ keys: { email: 1 }, options: { unique: true } }`
+     */
     options?: MongoDB.CreateIndexesOptions;
 }
 declare namespace DataLoader {
@@ -229,6 +247,15 @@ declare class BaseCollection<ModelClass extends ModelClassBase = ModelClassBase>
      */
     createIndexes: () => Promise<string[]>;
     createIndexesPromise: Promise<string[]>;
+    /**
+     * 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: () => Promise<{
+        deletedIndexes: string[];
+        collectionName: string;
+    }>;
     /**
      * @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.

package/dist/index.js

@@ -248,6 +248,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.
@@ -1140,12 +1146,82 @@ var generateId_default = getIdGenerator;
 
 // src/createCollection/createIndexes.ts
 import { MongoExpiredSessionError, MongoNotConnectedError } from "mongodb";
+import { logger as logger3 } from "@orion-js/logger";
+
+// src/createCollection/deleteUnusedIndexes.ts
 import { logger as logger2 } from "@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);
+      logger2.info(`Deleted unused index "${index.name}" from collection "${collection.name}"`);
+    } catch (error) {
+      logger2.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 = [];
@@ -1153,13 +1229,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) {
-    logger2.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) {
+    logger3.warn(
+      `${unexpectedIndexes.length} unexpected indexes found in collection "${collection.name}": ${unexpectedIndexes.map((i) => i.name).join(", ")} | Delete the index or fix the collection definition`
     );
   }
 }
@@ -1168,7 +1248,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) {
@@ -1230,7 +1312,7 @@ function getSchema(options) {
 }
 
 // src/createCollection/wrapMethods.ts
-import { logger as logger3 } from "@orion-js/logger";
+import { logger as logger4 } from "@orion-js/logger";
 function wrapMethods(collection) {
   const methodsWithPromises = [
     "findOne",
@@ -1266,7 +1348,7 @@ function wrapMethods(collection) {
         collection[methodName2] = (...args) => {
           collection.startConnection();
           if (!collection.rawCollection) {
-            logger3.error("Method called before connection was initialized", {
+            logger4.error("Method called before connection was initialized", {
               collectionName: collection.name,
               connectionName: collection.connectionName,
               methodName: methodName2
@@ -1367,6 +1449,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();
   }
@@ -1402,7 +1488,7 @@ function MongoCollection(options) {
 }
 
 // src/encrypted/getOrCreateEncryptionKey.ts
-import { logger as logger4 } from "@orion-js/logger";
+import { logger as logger5 } from "@orion-js/logger";
 import { ClientEncryption, MongoClient as MongoClient2 } from "mongodb";
 async function getOrCreateEncryptionKey({
   keyAltName,
@@ -1414,7 +1500,7 @@ async function getOrCreateEncryptionKey({
   kmsProviders
 }) {
   const keyVaultNamespace = `${keyVaultDatabase}.${keyVaultCollection}`;
-  logger4.info("Connecting to database to get or create the encryption key", {
+  logger5.info("Connecting to database to get or create the encryption key", {
     keyVaultNamespace,
     keyAltName
   });
@@ -1432,14 +1518,14 @@ async function getOrCreateEncryptionKey({
   });
   const key = await clientEncryption.getKeyByAltName(keyAltName);
   if (key) {
-    logger4.info("Key found on the key vault", {
+    logger5.info("Key found on the key vault", {
       keyVaultNamespace,
       keyAltName,
       UUID: key._id
     });
     return { key: key._id, keyVaultNamespace };
   }
-  logger4.info("Key not found on the key vault, creating a new one", {
+  logger5.info("Key not found on the key vault, creating a new one", {
     keyVaultNamespace,
     keyAltName
   });
@@ -1447,7 +1533,7 @@ async function getOrCreateEncryptionKey({
     keyAltNames: [keyAltName],
     ...masterKey ? { masterKey } : {}
   });
-  logger4.info("New encryption key created", {
+  logger5.info("New encryption key created", {
     keyVaultNamespace,
     keyAltName,
     UUID: newKey