@orion-js/mongodb 4.1.8 → 4.2.0

package/dist/index.cjs

@@ -250,6 +250,7 @@ var getMongoConnection = ({ name, uri }) => {
 // src/types/index.ts
 var MongoDB = __toESM(require("mongodb"), 1);
 var import_schema = require("@orion-js/schema");
+var import_helpers2 = require("@orion-js/helpers");
 var BaseCollection = class {
   name;
   connectionName;
@@ -294,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.
@@ -310,7 +317,8 @@ function typedId(prefix) {
   return {
     ...import_schema.fieldTypes.string,
     name: `typedId:${prefix}`,
-    toSerializedType: async () => "string"
+    toSerializedType: async () => "string",
+    generateId: () => (0, import_helpers2.generateUUIDWithPrefix)(prefix)
   };
 }
 
@@ -947,13 +955,13 @@ var insertOne_default = (collection) => {
 };
 
 // src/createCollection/getMethods/insertMany.ts
-var import_helpers2 = require("@orion-js/helpers");
+var import_helpers3 = require("@orion-js/helpers");
 var import_schema10 = require("@orion-js/schema");
 var insertMany_default = (collection) => {
   const insertMany = async (docs, options = {}) => {
     await collection.connectionPromise;
     for (let index = 0; index < docs.length; index++) {
-      let doc = (0, import_helpers2.clone)(docs[index]);
+      let doc = (0, import_helpers3.clone)(docs[index]);
       if (!doc || type(doc) !== "Object") {
         throw new Error(`Item at index ${index} is not a document`);
       }
@@ -1070,7 +1078,7 @@ function loadOne_default(collection) {
 }
 
 // src/createCollection/getMethods/dataLoader/loadData.ts
-var import_helpers4 = require("@orion-js/helpers");
+var import_helpers5 = require("@orion-js/helpers");
 
 // src/createCollection/getMethods/dataLoader/dataLoad/getDataLoader.ts
 var import_dataloader = __toESM(require("dataloader"), 1);
@@ -1092,10 +1100,10 @@ var getDataLoader = (params) => {
 };
 
 // src/createCollection/getMethods/dataLoader/dataLoad/index.ts
-var import_helpers3 = require("@orion-js/helpers");
+var import_helpers4 = require("@orion-js/helpers");
 var dataLoad = async (options) => {
   const dataLoader = getDataLoader({
-    key: (0, import_helpers3.hashObject)(options.loaderKey),
+    key: (0, import_helpers4.hashObject)(options.loaderKey),
     func: options.load,
     timeout: options.timeout || 5
   });
@@ -1124,10 +1132,10 @@ function loadData_default(collection) {
       timeout: options.timeout,
       load: async (values) => {
         const query = {
-          ...(0, import_helpers4.clone)(options.match),
+          ...(0, import_helpers5.clone)(options.match),
           [options.key]: { $in: values }
         };
-        const cursor = collection.find(query);
+        const cursor = collection.find(query, { readPreference: "secondaryPreferred" });
         if (options.sort) {
           cursor.sort(options.sort);
         }
@@ -1138,7 +1146,7 @@ function loadData_default(collection) {
           console.info(`Will execute data loading query now on ${collection.name}: `, query);
         }
         const items = await cursor.toArray();
-        const itemsMap = (0, import_helpers4.createMapArray)(items, options.key);
+        const itemsMap = (0, import_helpers5.createMapArray)(items, options.key);
         return values.map((value) => {
           return itemsMap[value] || [];
         });
@@ -1150,7 +1158,7 @@ function loadData_default(collection) {
 }
 
 // src/createCollection/generateId.ts
-var import_helpers5 = require("@orion-js/helpers");
+var import_helpers6 = require("@orion-js/helpers");
 var import_bson = require("bson");
 var getIdGenerator = (options) => {
   var _a, _b;
@@ -1158,23 +1166,21 @@ var getIdGenerator = (options) => {
     const idField = options.schema._id.type;
     if ((_b = idField.name) == null ? void 0 : _b.startsWith("typedId:")) {
       return () => {
-        const prefix = idField.name.split(":")[1];
-        const random = (0, import_helpers5.generateUUID)();
-        return `${prefix}-${random}`;
+        return idField.generateId();
       };
     }
   }
   if (options.idPrefix || options.idGeneration === "uuid") {
     return () => {
       const prefix = options.idPrefix || "";
-      const random = (0, import_helpers5.generateUUID)();
+      const random = (0, import_helpers6.generateUUID)();
       return `${prefix}${random}`;
     };
   }
   if (options.idGeneration === "random") {
     return () => {
       const prefix = options.idPrefix || "";
-      const random = (0, import_helpers5.generateId)();
+      const random = (0, import_helpers6.generateId)();
       return `${prefix}${random}`;
     };
   }
@@ -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;
+  }
+  if (!collection.indexes || collection.indexes.length === 0) {
+    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`
+  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) {
@@ -1246,7 +1328,7 @@ async function loadIndexes(collection) {
 }
 
 // src/createCollection/getSchemaAndModel.ts
-var import_helpers6 = require("@orion-js/helpers");
+var import_helpers7 = require("@orion-js/helpers");
 Symbol.metadata ?? (Symbol.metadata = Symbol("Symbol.metadata"));
 function prepareShema(schema) {
   if (!schema._id) {
@@ -1268,7 +1350,7 @@ function getSchema(options) {
   }
   if (options.schema.getModel) {
     const model = options.schema.getModel();
-    const schema = model ? (0, import_helpers6.clone)(model.getSchema()) : {};
+    const schema = model ? (0, import_helpers7.clone)(model.getSchema()) : {};
     return prepareShema(schema);
   }
   if (type(options.schema) === "Object") {
@@ -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