@orion-js/mongodb 4.0.19 → 4.0.21

package/dist/index.cjs

@@ -29,23 +29,25 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 // src/index.ts
 var index_exports = {};
 __export(index_exports, {
+  BaseCollection: () => BaseCollection,
   Collection: () => Collection,
+  ENCRYPTION_ALGORITHMS: () => ENCRYPTION_ALGORITHMS,
   MongoCollection: () => MongoCollection,
   MongoDB: () => MongoDB,
   Repository: () => Repository,
   allConnectionPromises: () => allConnectionPromises,
+  configureConnection: () => configureConnection,
   connections: () => connections,
   createCollection: () => createCollection,
   createIndexesPromises: () => createIndexesPromises,
   getMongoConnection: () => getMongoConnection,
+  getOrCreateEncryptionKey: () => getOrCreateEncryptionKey,
   typedId: () => typedId
 });
 module.exports = __toCommonJS(index_exports);
 
 // src/connect/connections.ts
-var connections = {};
-
-// src/connect/getMongoConnection.ts
+var import_node_events = require("events");
 var import_mongodb = require("mongodb");
 
 // src/connect/getDBName.ts
@@ -68,10 +70,14 @@ function getDBName(url) {
   return dbName;
 }
 
+// src/connect/connections.ts
+var import_node_process = require("process");
+var import_logger = require("@orion-js/logger");
+var import_helpers = require("@orion-js/helpers");
+
 // src/connect/getMongoURLFromEnv.ts
 var import_env = require("@orion-js/env");
 var getMongoURLFromEnv = (connectionName) => {
-  var _a;
   if (connectionName === "main") {
     if (!(0, import_env.internalGetEnv)("mongo_url", "MONGO_URL")) {
       throw new Error("MONGO_URL is required");
@@ -80,7 +86,7 @@ var getMongoURLFromEnv = (connectionName) => {
   }
   const envName = `mongo_url_${connectionName.toLowerCase()}`;
   const processEnvName = `MONGO_URL_${connectionName.toUpperCase()}`;
-  const uri = ((_a = connections[connectionName]) == null ? void 0 : _a.uri) ?? (0, import_env.internalGetEnv)(envName, processEnvName);
+  const uri = (0, import_env.internalGetEnv)(envName, processEnvName);
   if (!uri) {
     throw new Error(
       `To use the connection "${connectionName}" you must initialize it first calling getMongoConnection({name: "${connectionName}", uri: "MONGOURI"}) or setting the environment variable ${processEnvName}.`
@@ -88,71 +94,174 @@ var getMongoURLFromEnv = (connectionName) => {
   }
   return uri;
 };
+var requiresExplicitSetup = (connectionName) => {
+  if (connectionName === "main") {
+    const value2 = (0, import_env.internalGetEnv)("mongo_explicit_setup", "MONGO_EXPLICIT_SETUP");
+    return typeof value2 === "boolean" ? value2 : value2 === "true";
+  }
+  const envName = `mongo_explicit_setup_${connectionName.toLowerCase()}`;
+  const processEnvName = `MONGO_EXPLICIT_SETUP_${connectionName.toUpperCase()}`;
+  const value = (0, import_env.internalGetEnv)(envName, processEnvName);
+  return typeof value === "boolean" ? value : value === "true";
+};
 
-// src/connect/getMongoConnection.ts
-var import_logger = require("@orion-js/logger");
-var import_helpers = require("@orion-js/helpers");
-var allConnectionPromises = [];
-async function connect(client) {
-  try {
-    const result = await client.connect();
-    return result;
-  } catch (error) {
-    import_logger.logger.error(`Error connecting to mongo: ${error.message}. Will retry in 5s`, error);
-    await (0, import_helpers.sleep)(5e3);
-    return connect(client);
+// src/connect/connections.ts
+var connectionWrappers = {};
+var OrionMongoDatabaseWrapper = class {
+  uri;
+  dbName;
+  connectionName;
+  connectionPromise;
+  mongoOptions;
+  connectionEvent = new import_node_events.EventEmitter();
+  state = "disconnected";
+  client;
+  db;
+  configured = false;
+  encrypted = { client: null, db: null };
+  configTimeout;
+  constructor(connectionName) {
+    this.connectionName = connectionName;
+    import_logger.logger.info("New connection requested", {
+      connectionName
+    });
+    this.connectionEvent.setMaxListeners(Number.POSITIVE_INFINITY);
+    this.connectionPromise = new Promise((resolve, reject) => {
+      if (this.state === "connected") {
+        resolve(this.client);
+      }
+      this.connectionEvent.once("connected", resolve);
+      this.connectionEvent.once("error", reject);
+    });
+    this.configTimeout = setTimeout(() => {
+      import_logger.logger.error(
+        "Connection was required but never configured, call configureConnection() or unset the env variable MONGO_EXPLICIT_SETUP",
+        {
+          connectionName
+        }
+      );
+      this.connectionEvent.emit("error", new Error("Connection was required but never configured"));
+    }, 30 * 1e3);
+  }
+  config(mongoURL, mongoOptions) {
+    var _a;
+    this.uri = mongoURL;
+    this.mongoOptions = mongoOptions;
+    this.configured = true;
+    if ((_a = this.mongoOptions) == null ? void 0 : _a.autoEncryption) {
+      this.encrypted.client = new import_mongodb.MongoClient(mongoURL, {
+        retryReads: true,
+        ...this.mongoOptions
+      });
+      this.encrypted.db = this.encrypted.client.db(getDBName(this.uri));
+    }
+    this.client = new import_mongodb.MongoClient(mongoURL, {
+      retryReads: true,
+      ...this.mongoOptions,
+      autoEncryption: null
+    });
+    this.db = this.client.db(getDBName(this.uri));
+    clearTimeout(this.configTimeout);
+  }
+  async awaitConnection() {
+    if (this.state === "connected") return this;
+    if (this.state === "connecting" || !this.configured) {
+      await this.connectionPromise;
+      return this;
+    }
+    this.state = "connecting";
+    const censoredURI = this.uri.replace(/\/\/.*:.*@/, "//");
+    import_logger.logger.info("Connecting to mongo", {
+      uri: censoredURI,
+      connectionName: this.connectionName
+    });
+    if (this.encrypted.client) {
+      await this.connectWithRetry(this.encrypted.client);
+      import_logger.logger.info("Successfully connected to encrypted mongo", {
+        uri: censoredURI,
+        connectionName: this.connectionName
+      });
+    }
+    await this.connectWithRetry(this.client);
+    this.state = "connected";
+    this.connectionEvent.emit("connected", this.client);
+    import_logger.logger.info("Successfully connected to mongo", {
+      uri: censoredURI,
+      connectionName: this.connectionName
+    });
+    (0, import_node_process.nextTick)(() => {
+      this.connectionEvent.removeAllListeners();
+      this.connectionEvent = null;
+    });
+    return this;
+  }
+  async connectWithRetry(client) {
+    try {
+      return await client.connect();
+    } catch (error) {
+      import_logger.logger.error("Error connecting to mongo. Will retry in 5s", {
+        error,
+        connectionName: this.connectionName
+      });
+      await (0, import_helpers.sleep)(5e3);
+      return this.connectWithRetry(client);
+    }
+  }
+  async startConnection() {
+    return this.awaitConnection().then(() => this.client);
   }
+  async closeConnection() {
+    var _a, _b, _c;
+    if (this.state === "disconnected" || this.state === "disconnecting") return;
+    this.state = "disconnecting";
+    await ((_a = this.client) == null ? void 0 : _a.close());
+    await ((_c = (_b = this.encrypted) == null ? void 0 : _b.client) == null ? void 0 : _c.close());
+    this.state = "disconnected";
+  }
+};
+function configureConnection(connectionName, mongoOptions) {
+  connectionWrappers[connectionName] = connectionWrappers[connectionName] || new OrionMongoDatabaseWrapper(connectionName);
+  const connectionWrapper = connectionWrappers[connectionName];
+  if (connectionWrapper.configured) {
+    throw new Error("Connection already configured");
+  }
+  connectionWrapper.config(getMongoURLFromEnv(connectionName), mongoOptions);
+  return connectionWrapper.awaitConnection();
 }
+function getExistingConnection(connectionName) {
+  connectionWrappers[connectionName] = connectionWrappers[connectionName] || new OrionMongoDatabaseWrapper(connectionName);
+  return connectionWrappers[connectionName];
+}
+var connections = connectionWrappers;
+
+// src/connect/getMongoConnection.ts
+var allConnectionPromises = [];
 var getMongoConnection = ({ name, uri }) => {
   uri = uri || getMongoURLFromEnv(name);
-  if (connections[name]) return connections[name];
-  const client = new import_mongodb.MongoClient(uri, {
-    retryReads: true
-  });
-  let resolveConnected;
-  const connectionPromise = new Promise((resolve) => {
-    resolveConnected = resolve;
-  });
-  let internalConnectionPromise;
-  const startConnection = async () => {
-    if (internalConnectionPromise) {
-      return await internalConnectionPromise;
-    }
-    internalConnectionPromise = connect(client);
-    allConnectionPromises.push(internalConnectionPromise);
-    internalConnectionPromise.then((client2) => {
-      resolveConnected(client2);
-    });
-    return await internalConnectionPromise;
-  };
-  const dbName = getDBName(uri);
-  const db = client.db(dbName);
-  const mongoClient = {
-    uri,
-    client,
-    connectionPromise,
-    startConnection,
-    dbName,
-    db,
-    connectionName: name
-  };
-  connections[name] = mongoClient;
-  return mongoClient;
+  const connection = getExistingConnection(name);
+  if (!connection.configured && !requiresExplicitSetup(name)) {
+    connection.config(uri, {});
+  }
+  allConnectionPromises.push(connection.connectionPromise);
+  return connection;
 };
 
 // src/types/index.ts
 var MongoDB = __toESM(require("mongodb"), 1);
 var import_schema = require("@orion-js/schema");
-var Collection = class {
+var BaseCollection = class {
   name;
   connectionName;
   schema;
-  indexes;
   generateId;
   getSchema;
   db;
   client;
+  /**
+   * @deprecated Use getRawCollection() instead. This property is not guaranteed to be defined if the connection has not been started.
+   */
   rawCollection;
+  getRawCollection;
   findOne;
   find;
   insertOne;
@@ -184,9 +293,18 @@ var Collection = class {
    */
   createIndexes;
   createIndexesPromise;
+  /**
+   * @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.
+   * Kept for backwards compatibility. startConnection does not re-start the connection if it is already started, so it is safe to use.
+   */
   connectionPromise;
   startConnection;
 };
+var Collection = class extends BaseCollection {
+  indexes;
+  encrypted;
+};
 function typedId(prefix) {
   return {
     ...import_schema.fieldTypes.string,
@@ -1157,6 +1275,7 @@ function getSchema(options) {
 }
 
 // src/createCollection/wrapMethods.ts
+var import_logger2 = require("@orion-js/logger");
 function wrapMethods(collection) {
   const methodsWithPromises = [
     "findOne",
@@ -1191,6 +1310,14 @@ function wrapMethods(collection) {
       if (typeof collection[methodName2] === "function") {
         collection[methodName2] = (...args) => {
           collection.startConnection();
+          if (!collection.rawCollection) {
+            import_logger2.logger.error("Method called before connection was initialized", {
+              collectionName: collection.name,
+              connectionName: collection.connectionName,
+              methodName: methodName2
+            });
+            throw new Error("Method called before connection was initialized");
+          }
           return originalMethods[methodName2](...args);
         };
       }
@@ -1206,56 +1333,91 @@ function createCollection(options) {
   if (!orionConnection) {
     throw new Error(`The connection to MongoDB "${connectionName}" was not found`);
   }
-  const db = orionConnection.db;
-  const rawCollection = db.collection(options.name);
   const schema = getSchema(options);
-  const collection = {
+  let resolveCollectionPromise;
+  const collectionPromise = new Promise((resolve) => {
+    resolveCollectionPromise = resolve;
+  });
+  const baseCollection = {
     name: options.name,
     connectionName,
     schema,
     indexes: options.indexes || [],
-    db,
     client: orionConnection,
-    connectionPromise: orionConnection.connectionPromise,
-    startConnection: orionConnection.startConnection,
-    rawCollection,
+    connectionPromise: collectionPromise,
+    startConnection: () => orionConnection.startConnection(),
     generateId: generateId_default(options),
+    getRawCollection: async () => {
+      await orionConnection.startConnection();
+      return orionConnection.db.collection(options.name);
+    },
     getSchema: () => schema
   };
-  collection.findOne = findOne_default(collection);
-  collection.find = find_default(collection);
-  collection.findOneAndUpdate = findOneAndUpdate_default(collection);
-  collection.insertOne = insertOne_default(collection);
-  collection.insertMany = insertMany_default(collection);
-  collection.insertAndFind = insertAndFind_default(collection);
-  collection.updateOne = updateOne_default(collection);
-  collection.updateMany = updateMany_default(collection);
-  collection.deleteMany = deleteMany_default(collection);
-  collection.deleteOne = deleteOne_default(collection);
-  collection.upsert = upsert_default(collection);
-  collection.estimatedDocumentCount = estimatedDocumentCount_default(collection);
-  collection.countDocuments = countDocuments_default(collection);
-  collection.updateAndFind = updateAndFind_default(collection);
-  collection.updateItem = updateItem_default(collection);
-  collection.aggregate = (pipeline, options2) => collection.rawCollection.aggregate(pipeline, options2);
-  collection.watch = (pipeline, options2) => collection.rawCollection.watch(pipeline, options2);
-  collection.loadData = loadData_default(collection);
-  collection.loadById = loadById_default(collection);
-  collection.loadOne = loadOne_default(collection);
-  collection.loadMany = loadMany_default(collection);
+  const encryptedCollection = {
+    ...baseCollection,
+    getRawCollection: async () => {
+      await orionConnection.startConnection();
+      return orionConnection.encrypted.db.collection(options.name);
+    }
+  };
+  const mainCollection = {
+    ...baseCollection,
+    encrypted: encryptedCollection
+  };
+  const defineCollectionProperties = () => {
+    if (orionConnection.db) {
+      mainCollection.db = orionConnection.db;
+      mainCollection.rawCollection = orionConnection.db.collection(options.name);
+    }
+    if (orionConnection.encrypted.db) {
+      encryptedCollection.db = orionConnection.encrypted.db;
+      encryptedCollection.rawCollection = orionConnection.encrypted.db.collection(options.name);
+    }
+  };
+  defineCollectionProperties();
+  orionConnection.connectionPromise.then(() => {
+    defineCollectionProperties();
+    resolveCollectionPromise(orionConnection.client);
+  });
+  const collections = [mainCollection, encryptedCollection];
+  for (const collection of collections) {
+    collection.findOne = findOne_default(collection);
+    collection.find = find_default(collection);
+    collection.findOneAndUpdate = findOneAndUpdate_default(collection);
+    collection.insertOne = insertOne_default(collection);
+    collection.insertMany = insertMany_default(collection);
+    collection.insertAndFind = insertAndFind_default(collection);
+    collection.updateOne = updateOne_default(collection);
+    collection.updateMany = updateMany_default(collection);
+    collection.deleteMany = deleteMany_default(collection);
+    collection.deleteOne = deleteOne_default(collection);
+    collection.upsert = upsert_default(collection);
+    collection.estimatedDocumentCount = estimatedDocumentCount_default(collection);
+    collection.countDocuments = countDocuments_default(collection);
+    collection.updateAndFind = updateAndFind_default(collection);
+    collection.updateItem = updateItem_default(collection);
+    collection.aggregate = (pipeline, options2) => collection.rawCollection.aggregate(pipeline, options2);
+    collection.watch = (pipeline, options2) => collection.rawCollection.watch(pipeline, options2);
+    collection.loadData = loadData_default(collection);
+    collection.loadById = loadById_default(collection);
+    collection.loadOne = loadOne_default(collection);
+    collection.loadMany = loadMany_default(collection);
+    collection.createIndexes = async () => [];
+  }
   const createIndexes = async () => {
-    await orionConnection.connectionPromise;
-    const createIndexPromise = loadIndexes(collection);
+    await orionConnection.startConnection();
+    const createIndexPromise = loadIndexes(mainCollection);
     createIndexesPromises.push(createIndexPromise);
-    collection.createIndexesPromise = createIndexPromise;
+    mainCollection.createIndexesPromise = createIndexPromise;
     return createIndexPromise;
   };
-  collection.createIndexes = createIndexes;
+  mainCollection.createIndexes = createIndexes;
   if (!process.env.DONT_CREATE_INDEXES_AUTOMATICALLY) {
     createIndexes();
   }
-  wrapMethods(collection);
-  return collection;
+  wrapMethods(mainCollection);
+  wrapMethods(encryptedCollection);
+  return mainCollection;
 }
 
 // src/service/index.ts
@@ -1283,17 +1445,79 @@ function MongoCollection(options) {
     });
   };
 }
+
+// src/encrypted/getOrCreateEncryptionKey.ts
+var import_logger3 = require("@orion-js/logger");
+var import_mongodb3 = require("mongodb");
+async function getOrCreateEncryptionKey({
+  keyAltName,
+  kmsProvider,
+  masterKey,
+  connectionName = "main",
+  keyVaultDatabase = "encryption",
+  keyVaultCollection = "__keyVault",
+  kmsProviders
+}) {
+  const keyVaultNamespace = `${keyVaultDatabase}.${keyVaultCollection}`;
+  import_logger3.logger.info("Connecting to database to get or create the encryption key", {
+    keyVaultNamespace,
+    keyAltName
+  });
+  const client = new import_mongodb3.MongoClient(getMongoURLFromEnv(connectionName));
+  await client.connect();
+  const db = client.db(keyVaultDatabase);
+  const collection = db.collection(keyVaultCollection);
+  await collection.createIndex(
+    { keyAltName: 1 },
+    { unique: true, partialFilterExpression: { keyAltName: { $exists: true } } }
+  );
+  const clientEncryption = new import_mongodb3.ClientEncryption(client, {
+    keyVaultNamespace,
+    kmsProviders
+  });
+  const key = await clientEncryption.getKeyByAltName(keyAltName);
+  if (key) {
+    import_logger3.logger.info("Key found on the key vault", {
+      keyVaultNamespace,
+      keyAltName,
+      UUID: key._id
+    });
+    return { key: key._id, keyVaultNamespace };
+  }
+  import_logger3.logger.info("Key not found on the key vault, creating a new one", {
+    keyVaultNamespace,
+    keyAltName
+  });
+  const newKey = await clientEncryption.createDataKey(kmsProvider, {
+    keyAltNames: [keyAltName],
+    ...masterKey ? { masterKey } : {}
+  });
+  import_logger3.logger.info("New encryption key created", {
+    keyVaultNamespace,
+    keyAltName,
+    UUID: newKey
+  });
+  return { key: newKey, keyVaultNamespace };
+}
+var ENCRYPTION_ALGORITHMS = {
+  DETERMINISTIC: "AEAD_AES_256_CBC_HMAC_SHA_512-Deterministic",
+  RANDOM: "AEAD_AES_256_CBC_HMAC_SHA_512-Random"
+};
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
+  BaseCollection,
   Collection,
+  ENCRYPTION_ALGORITHMS,
   MongoCollection,
   MongoDB,
   Repository,
   allConnectionPromises,
+  configureConnection,
   connections,
   createCollection,
   createIndexesPromises,
   getMongoConnection,
+  getOrCreateEncryptionKey,
   typedId
 });
 //# sourceMappingURL=index.cjs.map