add support for CSFLE/QE for all primitive types

Author: baileympearson

lib/collection.js

@@ -81,7 +81,7 @@ Collection.prototype.onOpen = function() {
  * @api private
  */
 
-Collection.prototype.onClose = function() {};
+Collection.prototype.onClose = function() { };
 
 /**
  * Queues a method for later execution when its

lib/connection.js

@@ -607,7 +607,7 @@ Connection.prototype.bulkWrite = async function bulkWrite(ops, options) {
 
 Connection.prototype.createCollections = async function createCollections(options = {}) {
   const result = {};
-  const errorsMap = { };
+  const errorsMap = {};
 
   const { continueOnError } = options;
   delete options.continueOnError;
@@ -734,7 +734,7 @@ Connection.prototype.transaction = function transaction(fn, options) {
         throw err;
       }).
       finally(() => {
-        session.endSession().catch(() => {});
+        session.endSession().catch(() => { });
       });
   });
 };
@@ -1025,7 +1025,7 @@ Connection.prototype.openUri = async function openUri(uri, options) {
 
   for (const model of Object.values(this.models)) {
     // Errors handled internally, so safe to ignore error
-    model.init().catch(function $modelInitNoop() {});
+    model.init().catch(function $modelInitNoop() { });
   }
 
   // `createConnection()` calls this `openUri()` function without
@@ -1061,7 +1061,7 @@ Connection.prototype.openUri = async function openUri(uri, options) {
 // to avoid uncaught exceptions when using `on('error')`. See gh-14377.
 Connection.prototype.on = function on(event, callback) {
   if (event === 'error' && this.$initialConnection) {
-    this.$initialConnection.catch(() => {});
+    this.$initialConnection.catch(() => { });
   }
   return EventEmitter.prototype.on.call(this, event, callback);
 };
@@ -1083,7 +1083,7 @@ Connection.prototype.on = function on(event, callback) {
 // to avoid uncaught exceptions when using `on('error')`. See gh-14377.
 Connection.prototype.once = function on(event, callback) {
   if (event === 'error' && this.$initialConnection) {
-    this.$initialConnection.catch(() => {});
+    this.$initialConnection.catch(() => { });
   }
   return EventEmitter.prototype.once.call(this, event, callback);
 };
@@ -1412,7 +1412,7 @@ Connection.prototype.model = function model(name, schema, collection, options) {
     }
 
     // Errors handled internally, so safe to ignore error
-    model.init().catch(function $modelInitNoop() {});
+    model.init().catch(function $modelInitNoop() { });
 
     return model;
   }
@@ -1439,7 +1439,7 @@ Connection.prototype.model = function model(name, schema, collection, options) {
   }
 
   if (this === model.prototype.db
-      && (!collection || collection === model.collection.name)) {
+    && (!collection || collection === model.collection.name)) {
     // model already uses this connection.
 
     // only the first model with this name is cached to allow
@@ -1626,8 +1626,8 @@ Connection.prototype.authMechanismDoesNotRequirePassword = function authMechanis
  */
 Connection.prototype.optionsProvideAuthenticationData = function optionsProvideAuthenticationData(options) {
   return (options) &&
-      (options.user) &&
-      ((options.pass) || this.authMechanismDoesNotRequirePassword());
+    (options.user) &&
+    ((options.pass) || this.authMechanismDoesNotRequirePassword());
 };
 
 /**
@@ -1689,7 +1689,7 @@ Connection.prototype.createClient = function createClient() {
  */
 Connection.prototype.syncIndexes = async function syncIndexes(options = {}) {
   const result = {};
-  const errorsMap = { };
+  const errorsMap = {};
 
   const { continueOnError } = options;
   delete options.continueOnError;

lib/drivers/node-mongodb-native/connection.js

@@ -12,6 +12,8 @@ const pkg = require('../../../package.json');
 const processConnectionOptions = require('../../helpers/processConnectionOptions');
 const setTimeout = require('../../helpers/timers').setTimeout;
 const utils = require('../../utils');
+const { inferBSONType } = require('../../encryption_utils');
+const clone = require('../../helpers/clone');
 
 /**
  * A [node-mongodb-native](https://github.com/mongodb/node-mongodb-native) connection implementation.
@@ -304,6 +306,9 @@ NativeConnection.prototype.createClient = async function createClient(uri, optio
     };
   }
 
+
+  options = this._buildEncryptionSchemas(options);
+
   this.readyState = STATES.connecting;
   this._connectionString = uri;
 
@@ -327,6 +332,86 @@ NativeConnection.prototype.createClient = async function createClient(uri, optio
   return this;
 };
 
+/**
+ * Given a connection, which may or may not have encrypted models, build
+ * a schemaMap and/or an encryptedFieldsMap for the connection, combining all models
+ * into a single schemaMap and encryptedFields map.
+ *
+ * @param { object } options
+ * @param { object } [options.autoEncryption] the auto encryption options for the connection.  Technically
+ * marked optional, because it is optional in the MongoClient options interface, but auto encryption
+ * will fail without it so in practice it is always required if encryption is enabled.
+ *
+ * @returns a copy of the options object with a schemaMap and/or an encryptedFieldsMap added to the options' autoEncryption
+ * options.
+  */
+NativeConnection.prototype._buildEncryptionSchemas = function(options) {
+  const schemaMap = Object.values(this.models).filter(model => model.schema.encryptionType() === 'csfle').reduce(
+    schemaMapReducer.bind(this),
+    {}
+  );
+  const encryptedFieldsMap = Object.values(this.models).filter(model => model.schema.encryptionType() === 'qe').reduce(
+    encryptedFieldsMapReducer.bind(this),
+    {}
+  );
+
+  return Object.assign(
+    clone(options), {
+      autoEncryption: {
+        ...options.autoEncryption,
+        schemaMap,
+        encryptedFieldsMap
+      }
+    });
+
+  /**
+   * @param {object} schemaMap the accumulation schemaMap
+   * @param {Model} the model
+   * @returns
+   */
+  function schemaMapReducer(schemaMap, model) {
+    const { schema, collection: { collectionName } } = model;
+    const namespace = `${this.$dbName}.${collectionName}`;
+
+    function schemaMapPropertyReducer(accum, [path, propertyConfig]) {
+      const bsonType = inferBSONType(schema, path);
+      // `<db>.<collection>`: { encrypt: { keyId, bsonType, algorithm }}
+      accum[path] = { encrypt: { ...propertyConfig, bsonType } };
+      return accum;
+    }
+    const properties = Object.entries(schema.encryptedFields).reduce(
+      schemaMapPropertyReducer,
+      {});
+
+    schemaMap[namespace] = {
+      bsonType: 'object',
+      properties
+    };
+
+    return schemaMap;
+  }
+
+  /**
+   *
+   * @param {object} encryptedFieldsMap the accumulation encryptedFieldsMap
+   * @param {Model} the model
+   * @returns
+   */
+  function encryptedFieldsMapReducer(encryptedFieldsMap, { schema, collection: { collectionName } }) {
+    const namespace = `${this.$dbName}.${collectionName}`;
+    const fields = Object.entries(schema.encryptedFields).map(
+      ([path, config]) => {
+        const bsonType = inferBSONType(schema, path);
+        // { path, bsonType, keyId, queries? }
+        return { path, bsonType, ...config };
+      });
+
+    encryptedFieldsMap[namespace] = { fields };
+
+    return encryptedFieldsMap;
+  }
+};
+
 /*!
  * ignore
  */
@@ -347,7 +432,7 @@ NativeConnection.prototype.setClient = function setClient(client) {
 
   for (const model of Object.values(this.models)) {
     // Errors handled internally, so safe to ignore error
-    model.init().catch(function $modelInitNoop() {});
+    model.init().catch(function $modelInitNoop() { });
   }
 
   return this;
@@ -390,9 +475,9 @@ function _setClient(conn, client, options, dbName) {
   };
 
   const type = client &&
-  client.topology &&
-  client.topology.description &&
-  client.topology.description.type || '';
+    client.topology &&
+    client.topology.description &&
+    client.topology.description.type || '';
 
   if (type === 'Single') {
     client.on('serverDescriptionChanged', ev => {