small refactor to aid testing

Author: baileympearson

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

@@ -12,7 +12,6 @@ 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');
 
 /**
  * A [node-mongodb-native](https://github.com/mongodb/node-mongodb-native) connection implementation.
@@ -305,8 +304,7 @@ NativeConnection.prototype.createClient = async function createClient(uri, optio
     };
   }
 
-
-  const { schemaMap, encryptedFieldsMap } = this._buildEncryptionSchemas(options);
+  const { schemaMap, encryptedFieldsMap } = this._buildEncryptionSchemas();
 
   if (Object.keys(schemaMap).length > 0) {
     options.autoEncryption.schemaMap = schemaMap;
@@ -349,91 +347,28 @@ NativeConnection.prototype.createClient = async function createClient(uri, optio
   */
 NativeConnection.prototype._buildEncryptionSchemas = function() {
   const schemaMap = Object.values(this.models).filter(model => model.schema.encryptionType() === 'csfle').reduce(
-    schemaMapReducer.bind(this),
+    (schemaMap, model) => {
+      const { schema, collection: { collectionName } } = model;
+      const namespace = `${this.$dbName}.${collectionName}`;
+      schemaMap[namespace] = schema._buildSchemaMap();
+      return schemaMap;
+    },
     {}
   );
+
   const encryptedFieldsMap = Object.values(this.models).filter(model => model.schema.encryptionType() === 'qe').reduce(
-    encryptedFieldsMapReducer.bind(this),
+    (encryptedFieldsMap, model) => {
+      const { schema, collection: { collectionName } } = model;
+      const namespace = `${this.$dbName}.${collectionName}`;
+      encryptedFieldsMap[namespace] = schema._buildEncryptedFields();
+      return encryptedFieldsMap;
+    },
     {}
   );
 
   return {
     schemaMap, encryptedFieldsMap
   };
-
-  /**
-   * `schemaMap`s are JSON schemas, which use the following structure to represent objects:
-   *    { field: { bsonType: 'object', properties: { ... } } }
-   *
-   * for example, a schema that looks like this `{ a: { b: int32 } }` would be encoded as
-   * `{ a: { bsonType: 'object', properties: { b: < encryption configuration > } } }`
-   *
-   * This function takes an array of path segments, an output object (that gets mutated) and
-   * a value to associated with the full path, and constructs a valid CSFLE JSON schema path for
-   * the object.  This works for deeply nested properties as well.
-   *
-   * @param {string[]} path array of path components
-   * @param {object} object the object in which to build a JSON schema of `path`'s properties
-   * @param {object} value the value to associate with the path in object
-   */
-  function buildNestedPath(path, object, value) {
-    let i = 0, component = path[i];
-    for (; i < path.length - 1; ++i, component = path[i]) {
-      object[component] = object[component] == null ? {
-        bsonType: 'object',
-        properties: {}
-      } : object[component];
-      object = object[component].properties;
-    }
-    object[component] = value;
-  }
-
-  /**
-   * @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);
-      const pathComponents = path.split('.');
-      const configuration = { encrypt: { ...propertyConfig, bsonType } };
-      buildNestedPath(pathComponents, accum, configuration);
-      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;
-  }
 };
 
 /*!

lib/schema.js

@@ -917,6 +917,63 @@ Schema.prototype._hasEncryptedFields = function _hasEncryptedFields() {
   return Object.keys(this.encryptedFields).length > 0;
 };
 
+Schema.prototype._buildEncryptedFields = function() {
+  const fields = Object.entries(this.encryptedFields).map(
+    ([path, config]) => {
+      const bsonType = inferBSONType(this, path);
+      // { path, bsonType, keyId, queries? }
+      return { path, bsonType, ...config };
+    });
+
+  return { fields };
+};
+
+Schema.prototype._buildSchemaMap = function() {
+  /**
+   * `schemaMap`s are JSON schemas, which use the following structure to represent objects:
+   *    { field: { bsonType: 'object', properties: { ... } } }
+   *
+   * for example, a schema that looks like this `{ a: { b: int32 } }` would be encoded as
+   * `{ a: { bsonType: 'object', properties: { b: < encryption configuration > } } }`
+   *
+   * This function takes an array of path segments, an output object (that gets mutated) and
+   * a value to associated with the full path, and constructs a valid CSFLE JSON schema path for
+   * the object.  This works for deeply nested properties as well.
+   *
+   * @param {string[]} path array of path components
+   * @param {object} object the object in which to build a JSON schema of `path`'s properties
+   * @param {object} value the value to associate with the path in object
+   */
+  function buildNestedPath(path, object, value) {
+    let i = 0, component = path[i];
+    for (; i < path.length - 1; ++i, component = path[i]) {
+      object[component] = object[component] == null ? {
+        bsonType: 'object',
+        properties: {}
+      } : object[component];
+      object = object[component].properties;
+    }
+    object[component] = value;
+  }
+
+  const schemaMapPropertyReducer = (accum, [path, propertyConfig]) => {
+    const bsonType = inferBSONType(this, path);
+    const pathComponents = path.split('.');
+    const configuration = { encrypt: { ...propertyConfig, bsonType } };
+    buildNestedPath(pathComponents, accum, configuration);
+    return accum;
+  };
+
+  const properties = Object.entries(this.encryptedFields).reduce(
+    schemaMapPropertyReducer,
+    {});
+
+  return {
+    bsonType: 'object',
+    properties
+  };
+};
+
 /**
  * Add an alias for `path`. This means getting or setting the `alias`
  * is equivalent to getting or setting the `path`.

test/encryption/encryption.test.js

@@ -80,7 +80,6 @@ describe('ci', () => {
           assert.ok(doc.field.equals(input));
         } else {
           assert.deepEqual(doc.field, expected ?? input);
-
         }
       }