@orion-js/mongodb 4.0.18 → 4.0.20

package/dist/index.d.ts

@@ -1,5 +1,5 @@
 import * as MongoDB from 'mongodb';
-import { MongoClient, Db, EnhancedOmit } from 'mongodb';
+import { MongoClient, Db, MongoClientOptions, EnhancedOmit, KMSProviders, AWSEncryptionKeyOptions, UUID } from 'mongodb';
 export { MongoDB };
 import { SchemaInAnyOrionForm, Schema, StrictInferSchemaType, TypedSchemaOnSchema, InferSchemaType, FieldType } from '@orion-js/schema';
 
@@ -8,14 +8,51 @@ interface OrionMongoClient {
     db: Db;
     uri: string;
     dbName: 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.
+     * Kept for backwards compatibility. startConnection does not re-start the connection if it is already started, so it is safe to use.
+     */
     connectionPromise: Promise<MongoClient>;
     connectionName: string;
+    encrypted: {
+        client: MongoClient;
+        db: Db;
+    };
+    /**
+     * Starts the connection if it is not already started.
+     * If the connection is already started, it resolves immediately.
+     */
     startConnection: () => Promise<MongoClient>;
+    closeConnection: () => Promise<void>;
 }
-interface OrionMongoConnectionsMap {
-    [key: string]: OrionMongoClient;
+declare class OrionMongoDatabaseWrapper implements OrionMongoClient {
+    uri: string;
+    dbName: string;
+    connectionName: string;
+    connectionPromise: Promise<MongoClient>;
+    private mongoOptions;
+    private connectionEvent;
+    private state;
+    client: MongoClient;
+    db: Db;
+    configured: boolean;
+    readonly encrypted: {
+        client: MongoClient;
+        db: Db;
+    };
+    readonly configTimeout: NodeJS.Timeout;
+    constructor(connectionName: string);
+    config(mongoURL: string, mongoOptions: MongoClientOptions): void;
+    awaitConnection(): Promise<this>;
+    connectWithRetry(client: MongoClient): any;
+    startConnection(): Promise<MongoClient>;
+    closeConnection(): Promise<void>;
 }
-declare const connections: OrionMongoConnectionsMap;
+declare function configureConnection(connectionName: string, mongoOptions: MongoClientOptions): Promise<OrionMongoDatabaseWrapper>;
+declare const connections: {
+    [key: string]: OrionMongoDatabaseWrapper;
+};
 
 declare const allConnectionPromises: any[];
 interface MongoConnectOptions {
@@ -141,16 +178,19 @@ type CreateCollectionOptionsWithTypedSchema<T extends TypedSchemaOnSchema & {
 }> = {
     schema: T;
 } & Omit<CreateCollectionOptions<InferSchemaType<T>>, 'schema'>;
-declare class Collection<ModelClass extends ModelClassBase = ModelClassBase> {
+declare class BaseCollection<ModelClass extends ModelClassBase = ModelClassBase> {
     name: string;
     connectionName?: string;
     schema?: Schema;
-    indexes: Array<CollectionIndex>;
     generateId: () => ModelClass['_id'];
     getSchema: () => Schema;
     db: MongoDB.Db;
     client: OrionMongoClient;
+    /**
+     * @deprecated Use getRawCollection() instead. This property is not guaranteed to be defined if the connection has not been started.
+     */
     rawCollection: MongoDB.Collection<ModelClass>;
+    getRawCollection: () => Promise<MongoDB.Collection<ModelClass>>;
     findOne: FindOne<ModelClass>;
     find: Find<ModelClass>;
     insertOne: InsertOne<ModelClass>;
@@ -182,9 +222,18 @@ declare class Collection<ModelClass extends ModelClassBase = ModelClassBase> {
      */
     createIndexes: () => Promise<string[]>;
     createIndexesPromise: Promise<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.
+     * Kept for backwards compatibility. startConnection does not re-start the connection if it is already started, so it is safe to use.
+     */
     connectionPromise: Promise<MongoDB.MongoClient>;
     startConnection: () => Promise<MongoDB.MongoClient>;
 }
+declare class Collection<ModelClass extends ModelClassBase = ModelClassBase> extends BaseCollection<ModelClass> {
+    indexes: Array<CollectionIndex>;
+    encrypted?: BaseCollection<ModelClass>;
+}
 type DistinctDocumentId<DistinctId extends string> = string & {
     __TYPE__: `DistinctDocumentId<${DistinctId}>`;
 };
@@ -219,4 +268,21 @@ declare function createCollection<T extends TypedSchemaOnSchema & {
 }>(options: CreateCollectionOptionsWithTypedSchema<T>): Collection<InferSchemaType<T>>;
 declare function createCollection<T extends ModelClassBase>(options: CreateCollectionOptions<T>): Collection<T>;
 
-export { Collection, type CollectionIndex, type CountDocuments, type CreateCollectionOptions, type CreateCollectionOptionsWithSchemaType, type CreateCollectionOptionsWithTypedSchema, DataLoader, type DeleteMany, type DeleteOne, type DistinctDocumentId, type DocumentWithId, type EstimatedDocumentCount, type Find, type FindCursor, type FindOne, type FindOneAndUpdate, type FindOneAndUpdateUpdateOptions, type InferIdType, type InferSchemaTypeWithId, type InitItem, type InsertAndFind, type InsertMany, type InsertOne, type InsertOptions, type ModelClassBase, type ModelToMongoSelector, MongoCollection, type MongoFilter, type MongoSelector, type OptionalId, Repository, type SchemaWithRequiredId, type TypedId, type UpdateAndFind, type UpdateItem, type UpdateMany, type UpdateOne, type UpdateOptions, type Upsert, allConnectionPromises, connections, createCollection, createIndexesPromises, getMongoConnection, typedId };
+declare function getOrCreateEncryptionKey({ keyAltName, kmsProvider, masterKey, connectionName, keyVaultDatabase, keyVaultCollection, kmsProviders, }: {
+    keyAltName: string;
+    kmsProvider: keyof KMSProviders;
+    masterKey?: AWSEncryptionKeyOptions;
+    connectionName?: string;
+    keyVaultDatabase?: string;
+    keyVaultCollection?: string;
+    kmsProviders: KMSProviders;
+}): Promise<{
+    key: UUID;
+    keyVaultNamespace: string;
+}>;
+declare const ENCRYPTION_ALGORITHMS: {
+    DETERMINISTIC: string;
+    RANDOM: string;
+};
+
+export { BaseCollection, Collection, type CollectionIndex, type CountDocuments, type CreateCollectionOptions, type CreateCollectionOptionsWithSchemaType, type CreateCollectionOptionsWithTypedSchema, DataLoader, type DeleteMany, type DeleteOne, type DistinctDocumentId, type DocumentWithId, ENCRYPTION_ALGORITHMS, type EstimatedDocumentCount, type Find, type FindCursor, type FindOne, type FindOneAndUpdate, type FindOneAndUpdateUpdateOptions, type InferIdType, type InferSchemaTypeWithId, type InitItem, type InsertAndFind, type InsertMany, type InsertOne, type InsertOptions, type ModelClassBase, type ModelToMongoSelector, MongoCollection, type MongoFilter, type MongoSelector, type OptionalId, Repository, type SchemaWithRequiredId, type TypedId, type UpdateAndFind, type UpdateItem, type UpdateMany, type UpdateOne, type UpdateOptions, type Upsert, allConnectionPromises, configureConnection, connections, createCollection, createIndexesPromises, getMongoConnection, getOrCreateEncryptionKey, typedId };

package/dist/index.js

@@ -1,7 +1,5 @@
 // src/connect/connections.ts
-var connections = {};
-
-// src/connect/getMongoConnection.ts
+import { EventEmitter } from "events";
 import { MongoClient } from "mongodb";
 
 // src/connect/getDBName.ts
@@ -24,10 +22,14 @@ function getDBName(url) {
   return dbName;
 }
 
+// src/connect/connections.ts
+import { nextTick } from "process";
+import { logger } from "@orion-js/logger";
+import { sleep } from "@orion-js/helpers";
+
 // src/connect/getMongoURLFromEnv.ts
 import { internalGetEnv } from "@orion-js/env";
 var getMongoURLFromEnv = (connectionName) => {
-  var _a;
   if (connectionName === "main") {
     if (!internalGetEnv("mongo_url", "MONGO_URL")) {
       throw new Error("MONGO_URL is required");
@@ -36,7 +38,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) ?? internalGetEnv(envName, processEnvName);
+  const uri = 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}.`
@@ -44,56 +46,156 @@ var getMongoURLFromEnv = (connectionName) => {
   }
   return uri;
 };
+var requiresExplicitSetup = (connectionName) => {
+  if (connectionName === "main") {
+    const value2 = 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 = internalGetEnv(envName, processEnvName);
+  return typeof value === "boolean" ? value : value === "true";
+};
 
-// src/connect/getMongoConnection.ts
-import { logger } from "@orion-js/logger";
-import { sleep } from "@orion-js/helpers";
-var allConnectionPromises = [];
-async function connect(client) {
-  try {
-    const result = await client.connect();
-    return result;
-  } catch (error) {
-    logger.error(`Error connecting to mongo: ${error.message}. Will retry in 5s`, error);
-    await sleep(5e3);
-    return connect(client);
+// src/connect/connections.ts
+var connectionWrappers = {};
+var OrionMongoDatabaseWrapper = class {
+  uri;
+  dbName;
+  connectionName;
+  connectionPromise;
+  mongoOptions;
+  connectionEvent = new EventEmitter();
+  state = "disconnected";
+  client;
+  db;
+  configured = false;
+  encrypted = { client: null, db: null };
+  configTimeout;
+  constructor(connectionName) {
+    this.connectionName = connectionName;
+    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(() => {
+      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 MongoClient(mongoURL, {
+        retryReads: true,
+        ...this.mongoOptions
+      });
+      this.encrypted.db = this.encrypted.client.db(getDBName(this.uri));
+    }
+    this.client = new 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(/\/\/.*:.*@/, "//");
+    logger.info("Connecting to mongo", {
+      uri: censoredURI,
+      connectionName: this.connectionName
+    });
+    if (this.encrypted.client) {
+      await this.connectWithRetry(this.encrypted.client);
+      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);
+    logger.info("Successfully connected to mongo", {
+      uri: censoredURI,
+      connectionName: this.connectionName
+    });
+    nextTick(() => {
+      this.connectionEvent.removeAllListeners();
+      this.connectionEvent = null;
+    });
+    return this;
+  }
+  async connectWithRetry(client) {
+    try {
+      return await client.connect();
+    } catch (error) {
+      logger.error("Error connecting to mongo. Will retry in 5s", {
+        error,
+        connectionName: this.connectionName
+      });
+      await 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 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
@@ -101,16 +203,19 @@ import * as MongoDB from "mongodb";
 import {
   fieldTypes
 } from "@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;
@@ -142,9 +247,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 {
     ...fieldTypes.string,
@@ -1115,6 +1229,7 @@ function getSchema(options) {
 }
 
 // src/createCollection/wrapMethods.ts
+import { logger as logger2 } from "@orion-js/logger";
 function wrapMethods(collection) {
   const methodsWithPromises = [
     "findOne",
@@ -1149,6 +1264,14 @@ function wrapMethods(collection) {
       if (typeof collection[methodName2] === "function") {
         collection[methodName2] = (...args) => {
           collection.startConnection();
+          if (!collection.rawCollection) {
+            logger2.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);
         };
       }
@@ -1164,56 +1287,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
@@ -1241,16 +1399,78 @@ function MongoCollection(options) {
     });
   };
 }
+
+// src/encrypted/getOrCreateEncryptionKey.ts
+import { logger as logger3 } from "@orion-js/logger";
+import { ClientEncryption, MongoClient as MongoClient2 } from "mongodb";
+async function getOrCreateEncryptionKey({
+  keyAltName,
+  kmsProvider,
+  masterKey,
+  connectionName = "main",
+  keyVaultDatabase = "encryption",
+  keyVaultCollection = "__keyVault",
+  kmsProviders
+}) {
+  const keyVaultNamespace = `${keyVaultDatabase}.${keyVaultCollection}`;
+  logger3.info("Connecting to database to get or create the encryption key", {
+    keyVaultNamespace,
+    keyAltName
+  });
+  const client = new MongoClient2(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 ClientEncryption(client, {
+    keyVaultNamespace,
+    kmsProviders
+  });
+  const key = await clientEncryption.getKeyByAltName(keyAltName);
+  if (key) {
+    logger3.info("Key found on the key vault", {
+      keyVaultNamespace,
+      keyAltName,
+      UUID: key._id
+    });
+    return { key: key._id, keyVaultNamespace };
+  }
+  logger3.info("Key not found on the key vault, creating a new one", {
+    keyVaultNamespace,
+    keyAltName
+  });
+  const newKey = await clientEncryption.createDataKey(kmsProvider, {
+    keyAltNames: [keyAltName],
+    ...masterKey ? { masterKey } : {}
+  });
+  logger3.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"
+};
 export {
+  BaseCollection,
   Collection,
+  ENCRYPTION_ALGORITHMS,
   MongoCollection,
   MongoDB,
   Repository,
   allConnectionPromises,
+  configureConnection,
   connections,
   createCollection,
   createIndexesPromises,
   getMongoConnection,
+  getOrCreateEncryptionKey,
   typedId
 };
 //# sourceMappingURL=index.js.map