@nullix/zod-mongoose-studio 1.0.13 → 2.1.0

package/.output/server/node_modules/mongoose/lib/schema/documentArray.js

@@ -12,7 +12,6 @@ const SchemaDocumentArrayOptions =
   require('../options/schemaDocumentArrayOptions');
 const SchemaType = require('../schemaType');
 const cast = require('../cast');
-const createJSONSchemaTypeDefinition = require('../helpers/createJSONSchemaTypeDefinition');
 const discriminator = require('../helpers/model/discriminator');
 const handleIdOption = require('../helpers/schema/handleIdOption');
 const handleSpreadDoc = require('../helpers/document/handleSpreadDoc');
@@ -31,44 +30,51 @@ let Subdocument;
 /**
  * SubdocsArray SchemaType constructor
  *
- * @param {String} key
+ * @param {string} key
  * @param {Schema} schema
- * @param {Object} options
- * @param {Object} schemaOptions
+ * @param {object} options
+ * @param {object} schemaOptions
  * @param {Schema} parentSchema
  * @inherits SchemaArray
  * @api public
  */
 
 function SchemaDocumentArray(key, schema, options, schemaOptions, parentSchema) {
-  if (schema.options && schema.options.timeseries) {
+  if (schema.options?.timeseries) {
     throw new InvalidSchemaOptionError(key, 'timeseries');
   }
-  const schemaTypeIdOption = SchemaDocumentArray.defaultOptions &&
-    SchemaDocumentArray.defaultOptions._id;
+  const schemaTypeIdOption = SchemaDocumentArray.defaultOptions?._id;
   if (schemaTypeIdOption != null) {
     schemaOptions = schemaOptions || {};
     schemaOptions._id = schemaTypeIdOption;
   }
 
-  if (schemaOptions != null && schemaOptions._id != null) {
+  if (schemaOptions?._id != null) {
     schema = handleIdOption(schema, schemaOptions);
-  } else if (options != null && options._id != null) {
+  } else if (options?._id != null) {
     schema = handleIdOption(schema, options);
   }
 
-  const EmbeddedDocument = _createConstructor(schema, options);
-  EmbeddedDocument.prototype.$basePath = key;
+  const Constructor = _createConstructor(schema, options);
+  Constructor.prototype.$basePath = key;
+  Constructor.path = key;
 
-  SchemaArray.call(this, key, EmbeddedDocument, options, null, parentSchema);
+  const $parentSchemaType = this;
+  const embeddedSchemaType = new DocumentArrayElement(key + '.$', schema, {
+    ...(schemaOptions || {}),
+    $parentSchemaType,
+    Constructor
+  });
+
+  SchemaArray.call(this, key, embeddedSchemaType, options, null, parentSchema);
 
   this.schema = schema;
   // EmbeddedDocument schematype options
   this.schemaOptions = schemaOptions || {};
   this.$isMongooseDocumentArray = true;
-  this.Constructor = EmbeddedDocument;
+  this.Constructor = Constructor;
 
-  EmbeddedDocument.base = schema.base;
+  Constructor.base = schema.base;
 
   const fn = this.defaultValue;
 
@@ -82,20 +88,6 @@ function SchemaDocumentArray(key, schema, options, schemaOptions, parentSchema)
       return arr;
     });
   }
-
-  const $parentSchemaType = this;
-  this.$embeddedSchemaType = new DocumentArrayElement(
-    key + '.$',
-    {
-      ...(schemaOptions || {}),
-      $parentSchemaType
-    },
-    schemaOptions,
-    parentSchema
-  );
-
-  this.$embeddedSchemaType.caster = this.Constructor;
-  this.$embeddedSchemaType.schema = this.schema;
 }
 
 /**
@@ -156,7 +148,7 @@ function _createConstructor(schema, options, baseClass) {
 
   schema._preCompile();
 
-  const proto = baseClass != null ? baseClass.prototype : Subdocument.prototype;
+  const proto = baseClass?.prototype ?? Subdocument.prototype;
   EmbeddedDocument.prototype = Object.create(proto);
   EmbeddedDocument.prototype.$__setSchema(schema);
   EmbeddedDocument.schema = schema;
@@ -195,11 +187,11 @@ function _createConstructor(schema, options, baseClass) {
  *     const docArrayPath = parentSchema.path('shapes');
  *     docArrayPath.discriminator('Circle', Schema({ radius: Number }));
  *
- * @param {String} name
+ * @param {string} name
  * @param {Schema} schema fields to add to the schema for instances of this sub-class
- * @param {Object|string} [options] If string, same as `options.value`.
- * @param {String} [options.value] the string stored in the `discriminatorKey` property. If not specified, Mongoose uses the `name` parameter.
- * @param {Boolean} [options.clone=true] By default, `discriminator()` clones the given `schema`. Set to `false` to skip cloning.
+ * @param {object|string} [options] If string, same as `options.value`.
+ * @param {string} [options.value] the string stored in the `discriminatorKey` property. If not specified, Mongoose uses the `name` parameter.
+ * @param {boolean} [options.clone=true] By default, `discriminator()` clones the given `schema`. Set to `false` to skip cloning.
  * @see discriminators https://mongoosejs.com/docs/discriminators.html
  * @return {Function} the constructor Mongoose will use for creating instances of this discriminator model
  * @api public
@@ -218,93 +210,62 @@ SchemaDocumentArray.prototype.discriminator = function(name, schema, options) {
     schema = schema.clone();
   }
 
-  schema = discriminator(this.casterConstructor, name, schema, tiedValue, null, null, options?.overwriteExisting);
+  schema = discriminator(this.Constructor, name, schema, tiedValue, null, null, options?.overwriteExisting);
 
-  const EmbeddedDocument = _createConstructor(schema, null, this.casterConstructor);
-  EmbeddedDocument.baseCasterConstructor = this.casterConstructor;
+  const EmbeddedDocument = _createConstructor(schema, null, this.Constructor);
+  EmbeddedDocument.baseCasterConstructor = this.Constructor;
 
-  try {
-    Object.defineProperty(EmbeddedDocument, 'name', {
-      value: name
-    });
-  } catch (error) {
-    // Ignore error, only happens on old versions of node
-  }
+  Object.defineProperty(EmbeddedDocument, 'name', {
+    value: name
+  });
 
-  this.casterConstructor.discriminators[name] = EmbeddedDocument;
+  this.Constructor.discriminators[name] = EmbeddedDocument;
 
-  return this.casterConstructor.discriminators[name];
+  return this.Constructor.discriminators[name];
 };
 
 /**
  * Performs local validations first, then validations on each embedded doc
  *
- * @api private
+ * @api public
  */
 
-SchemaDocumentArray.prototype.doValidate = function(array, fn, scope, options) {
+SchemaDocumentArray.prototype.doValidate = async function doValidate(array, scope, options) {
   // lazy load
   MongooseDocumentArray || (MongooseDocumentArray = require('../types/documentArray'));
 
-  const _this = this;
-  try {
-    SchemaType.prototype.doValidate.call(this, array, cb, scope);
-  } catch (err) {
-    return fn(err);
+  await SchemaType.prototype.doValidate.call(this, array, scope);
+  if (options?.updateValidator) {
+    return;
+  }
+  if (!utils.isMongooseDocumentArray(array)) {
+    array = new MongooseDocumentArray(array, this.path, scope);
   }
 
-  function cb(err) {
-    if (err) {
-      return fn(err);
-    }
-
-    let count = array && array.length;
-    let error;
-
-    if (!count) {
-      return fn();
-    }
-    if (options && options.updateValidator) {
-      return fn();
-    }
-    if (!utils.isMongooseDocumentArray(array)) {
-      array = new MongooseDocumentArray(array, _this.path, scope);
-    }
-
+  const promises = [];
+  for (let i = 0; i < array.length; ++i) {
     // handle sparse arrays, do not use array.forEach which does not
     // iterate over sparse elements yet reports array.length including
     // them :(
-
-    function callback(err) {
-      if (err != null) {
-        error = err;
-      }
-      --count || fn(error);
+    let doc = array[i];
+    if (doc == null) {
+      continue;
+    }
+    // If you set the array index directly, the doc might not yet be
+    // a full fledged mongoose subdoc, so make it into one.
+    if (!(doc instanceof Subdocument)) {
+      const Constructor = getConstructor(this.Constructor, array[i]);
+      doc = array[i] = new Constructor(doc, array, undefined, undefined, i);
     }
 
-    for (let i = 0, len = count; i < len; ++i) {
-      // sidestep sparse entries
-      let doc = array[i];
-      if (doc == null) {
-        --count || fn(error);
-        continue;
-      }
-
-      // If you set the array index directly, the doc might not yet be
-      // a full fledged mongoose subdoc, so make it into one.
-      if (!(doc instanceof Subdocument)) {
-        const Constructor = getConstructor(_this.casterConstructor, array[i]);
-        doc = array[i] = new Constructor(doc, array, undefined, undefined, i);
-      }
-
-      if (options != null && options.validateModifiedOnly && !doc.$isModified()) {
-        --count || fn(error);
-        continue;
-      }
-
-      doc.$__validate(null, options, callback);
+    if (options?.validateModifiedOnly && !doc.$isModified()) {
+      continue;
     }
+
+    promises.push(doc.validate(null, options));
   }
+
+  await Promise.all(promises);
 };
 
 /**
@@ -324,7 +285,7 @@ SchemaDocumentArray.prototype.doValidateSync = function(array, scope, options) {
     return schemaTypeError;
   }
 
-  const count = array && array.length;
+  const count = array?.length;
   let resultError = null;
 
   if (!count) {
@@ -345,11 +306,11 @@ SchemaDocumentArray.prototype.doValidateSync = function(array, scope, options) {
     // If you set the array index directly, the doc might not yet be
     // a full fledged mongoose subdoc, so make it into one.
     if (!(doc instanceof Subdocument)) {
-      const Constructor = getConstructor(this.casterConstructor, array[i]);
+      const Constructor = getConstructor(this.Constructor, array[i]);
       doc = array[i] = new Constructor(doc, array, undefined, undefined, i);
     }
 
-    if (options != null && options.validateModifiedOnly && !doc.$isModified()) {
+    if (options?.validateModifiedOnly && !doc.$isModified()) {
       continue;
     }
 
@@ -376,7 +337,7 @@ SchemaDocumentArray.prototype.getDefault = function(scope, init, options) {
     return ret;
   }
 
-  if (options && options.skipCast) {
+  if (options?.skipCast) {
     return ret;
   }
 
@@ -390,7 +351,7 @@ SchemaDocumentArray.prototype.getDefault = function(scope, init, options) {
   ret = new MongooseDocumentArray(ret, this.path, scope);
 
   for (let i = 0; i < ret.length; ++i) {
-    const Constructor = getConstructor(this.casterConstructor, ret[i]);
+    const Constructor = getConstructor(this.Constructor, ret[i]);
     const _subdoc = new Constructor({}, ret, undefined,
       undefined, i);
     _subdoc.$init(ret[i]);
@@ -413,7 +374,7 @@ const initDocumentOptions = Object.freeze({ skipId: false, willInit: true });
 /**
  * Casts contents
  *
- * @param {Object} value
+ * @param {object} value
  * @param {Document} document that triggers the casting
  * @api private
  */
@@ -423,7 +384,7 @@ SchemaDocumentArray.prototype.cast = function(value, doc, init, prev, options) {
   MongooseDocumentArray || (MongooseDocumentArray = require('../types/documentArray'));
 
   // Skip casting if `value` is the same as the previous value, no need to cast. See gh-9266
-  if (value != null && value[arrayPathSymbol] != null && value === prev) {
+  if (value?.[arrayPathSymbol] != null && value === prev) {
     return value;
   }
 
@@ -468,7 +429,7 @@ SchemaDocumentArray.prototype.cast = function(value, doc, init, prev, options) {
       continue;
     }
 
-    const Constructor = getConstructor(this.casterConstructor, rawArray[i]);
+    const Constructor = getConstructor(this.Constructor, rawArray[i]);
 
     const spreadDoc = handleSpreadDoc(rawArray[i], true);
     if (rawArray[i] !== spreadDoc) {
@@ -476,7 +437,11 @@ SchemaDocumentArray.prototype.cast = function(value, doc, init, prev, options) {
     }
 
     if (rawArray[i] instanceof Subdocument) {
-      if (rawArray[i][documentArrayParent] !== doc) {
+      // gh-15973: Clone if subdocument has a different parent, or if it already has a
+      // different __index (e.g. reordered or duplicated in the array). If __index is null,
+      // we can safely set it without cloning.
+      if (rawArray[i][documentArrayParent] !== doc ||
+          (rawArray[i].__index != null && rawArray[i].__index !== i)) {
         if (init) {
           const subdoc = new Constructor(null, value, initDocumentOptions, selected, i);
           rawArray[i] = subdoc.$init(rawArray[i]);
@@ -498,9 +463,15 @@ SchemaDocumentArray.prototype.cast = function(value, doc, init, prev, options) {
         }
 
         subdoc = new Constructor(null, value, initDocumentOptions, selected, i);
+        // Don't pass `path` to $init - it's only for this DocumentArray itself, not its element fields.
+        // Element subdocuments use relative paths internally for change tracking.
+        if (options.path != null) {
+          options = { ...options };
+          delete options.path;
+        }
         rawArray[i] = subdoc.$init(rawArray[i], options);
       } else {
-        if (prev && typeof prev.id === 'function') {
+        if (typeof prev?.id === 'function') {
           subdoc = prev.id(rawArray[i]._id);
         }
 
@@ -565,8 +536,8 @@ SchemaDocumentArray.prototype.applyGetters = function(value, scope) {
  * Necessary for proper default application of subdocument values.
  *
  * @param {DocumentArrayPath} array the array to scope `fields` paths
- * @param {Object|undefined} fields the root fields selected in the query
- * @param {Boolean|undefined} init if we are being created part of a query result
+ * @param {object|undefined} fields the root fields selected in the query
+ * @param {boolean|undefined} init if we are being created part of a query result
  * @api private
  */
 
@@ -612,11 +583,11 @@ SchemaDocumentArray.defaultOptions = {};
  *
  * #### Example:
  *
- *     // Make all numbers have option `min` equal to 0.
- *     mongoose.Schema.DocumentArray.set('_id', false);
+ *     // Make all document arrays not have `_id` by default.
+ *     mongoose.Schema.Types.DocumentArray.set('_id', false);
  *
- * @param {String} option The name of the option you'd like to set (e.g. trim, lowercase, etc...)
- * @param {Any} value The value of the option you'd like to set.
+ * @param {string} option The name of the option you'd like to set (e.g. trim, lowercase, etc...)
+ * @param {any} value The value of the option you'd like to set.
  * @return {void}
  * @function set
  * @static
@@ -658,38 +629,30 @@ function cast$elemMatch(val, context) {
 
   // Is this an embedded discriminator and is the discriminator key set?
   // If so, use the discriminator schema. See gh-7449
-  const discriminatorKey = this &&
-    this.casterConstructor &&
-    this.casterConstructor.schema &&
-    this.casterConstructor.schema.options &&
-    this.casterConstructor.schema.options.discriminatorKey;
-  const discriminators = this &&
-  this.casterConstructor &&
-  this.casterConstructor.schema &&
-  this.casterConstructor.schema.discriminators || {};
+  const discriminatorKey = this?.Constructor?.schema?.options?.discriminatorKey;
+  const discriminators = this?.Constructor?.schema?.discriminators || {};
   if (discriminatorKey != null &&
       val[discriminatorKey] != null &&
       discriminators[val[discriminatorKey]] != null) {
-    return cast(discriminators[val[discriminatorKey]], val, null, this && this.$$context);
+    return cast(discriminators[val[discriminatorKey]], val, null, this?.$$context);
   }
 
-  const schema = this.casterConstructor.schema ?? context.schema;
-  return cast(schema, val, null, this && this.$$context);
+  const schema = this.Constructor.schema ?? context.schema;
+  return cast(schema, val, null, this?.$$context);
 }
 
 /**
  * Returns this schema type's representation in a JSON schema.
  *
- * @param [options]
- * @param [options.useBsonType=false] If true, return a representation with `bsonType` for use with MongoDB's `$jsonSchema`.
- * @returns {Object} JSON schema properties
+ * @param {object} [options]
+ * @param {boolean} [options.useBsonType=false] If true, return a representation with `bsonType` for use with MongoDB's `$jsonSchema`.
+ * @returns {object} JSON schema properties
  */
 
 SchemaDocumentArray.prototype.toJSONSchema = function toJSONSchema(options) {
-  const itemsTypeDefinition = createJSONSchemaTypeDefinition('object', 'object', options?.useBsonType, false);
-  const isRequired = this.options.required && typeof this.options.required !== 'function';
+  const itemsTypeDefinition = this._createJSONSchemaTypeDefinition('object', 'object', { ...options, _overrideRequired: false });
   return {
-    ...createJSONSchemaTypeDefinition('array', 'array', options?.useBsonType, isRequired),
+    ...this._createJSONSchemaTypeDefinition('array', 'array', options),
     items: { ...itemsTypeDefinition, ...this.schema.toJSONSchema(options) }
   };
 };

package/.output/server/node_modules/mongoose/lib/schema/documentArrayElement.js

@@ -10,18 +10,22 @@ const SchemaSubdocument = require('./subdocument');
 const getConstructor = require('../helpers/discriminator/getConstructor');
 
 /**
- * DocumentArrayElement SchemaType constructor.
+ * DocumentArrayElement SchemaType constructor. Mongoose calls this internally when you define a new document array in your schema.
  *
- * @param {String} path
- * @param {Object} options
- * @param {Object} schemaOptions
+ * #### Example:
+ *     const schema = new Schema({ users: [{ name: String }] });
+ *     schema.path('users.$'); // SchemaDocumentArrayElement with schema `new Schema({ name: String })`
+ *
+ * @param {string} path
+ * @param {Schema} schema
+ * @param {object} options
  * @param {Schema} parentSchema
  * @inherits SchemaType
  * @api public
  */
 
-function SchemaDocumentArrayElement(path, options, _schemaOptions, parentSchema) {
-  this.$parentSchemaType = options && options.$parentSchemaType;
+function SchemaDocumentArrayElement(path, schema, options, parentSchema) {
+  this.$parentSchemaType = options?.$parentSchemaType;
   if (!this.$parentSchemaType) {
     throw new MongooseError('Cannot create DocumentArrayElement schematype without a parent');
   }
@@ -30,6 +34,8 @@ function SchemaDocumentArrayElement(path, options, _schemaOptions, parentSchema)
   SchemaType.call(this, path, options, 'DocumentArrayElement', parentSchema);
 
   this.$isMongooseDocumentArrayElement = true;
+  this.Constructor = options?.Constructor;
+  this.schema = schema;
 }
 
 /**
@@ -42,6 +48,36 @@ SchemaDocumentArrayElement.schemaName = 'DocumentArrayElement';
 
 SchemaDocumentArrayElement.defaultOptions = {};
 
+/**
+ * Sets a default option for all SchemaDocumentArrayElement instances.
+ *
+ * #### Example:
+ *
+ *     // Make all document array elements have option `_id` equal to false.
+ *     mongoose.Schema.Types.DocumentArrayElement.set('_id', false);
+ *
+ * @param {string} option The name of the option you'd like to set
+ * @param {any} value The value of the option you'd like to set.
+ * @return {void}
+ * @function set
+ * @static
+ * @api public
+ */
+
+SchemaDocumentArrayElement.set = SchemaType.set;
+
+/**
+ * Attaches a getter for all DocumentArrayElement instances
+ *
+ * @param {Function} getter
+ * @return {this}
+ * @function get
+ * @static
+ * @api public
+ */
+
+SchemaDocumentArrayElement.get = SchemaType.get;
+
 /*!
  * Inherits from SchemaType.
  */
@@ -51,7 +87,7 @@ SchemaDocumentArrayElement.prototype.constructor = SchemaDocumentArrayElement;
 /**
  * Casts `val` for DocumentArrayElement.
  *
- * @param {Object} value to cast
+ * @param {object} value to cast
  * @api private
  */
 
@@ -60,21 +96,19 @@ SchemaDocumentArrayElement.prototype.cast = function(...args) {
 };
 
 /**
- * Casts contents for queries.
+ * Async validation on this individual array element
  *
- * @param {String} $cond
- * @param {any} [val]
- * @api private
+ * @api public
  */
 
-SchemaDocumentArrayElement.prototype.doValidate = function(value, fn, scope, options) {
-  const Constructor = getConstructor(this.caster, value);
+SchemaDocumentArrayElement.prototype.doValidate = async function doValidate(value, scope, options) {
+  const Constructor = getConstructor(this.Constructor, value);
 
   if (value && !(value instanceof Constructor)) {
-    value = new Constructor(value, scope, null, null, options && options.index != null ? options.index : null);
+    value = new Constructor(value, scope, null, null, options?.index ?? null);
   }
 
-  return SchemaSubdocument.prototype.doValidate.call(this, value, fn, scope, options);
+  return SchemaSubdocument.prototype.doValidate.call(this, value, scope, options);
 };
 
 /**
@@ -89,7 +123,7 @@ SchemaDocumentArrayElement.prototype.clone = function() {
   const ret = SchemaType.prototype.clone.apply(this, arguments);
   delete this.options.$parentSchemaType;
 
-  ret.caster = this.caster;
+  ret.Constructor = this.Constructor;
   ret.schema = this.schema;
 
   return ret;

package/.output/server/node_modules/mongoose/lib/schema/double.js

@@ -7,14 +7,13 @@
 const CastError = require('../error/cast');
 const SchemaType = require('../schemaType');
 const castDouble = require('../cast/double');
-const createJSONSchemaTypeDefinition = require('../helpers/createJSONSchemaTypeDefinition');
 
 /**
  * Double SchemaType constructor.
  *
- * @param {String} path
- * @param {Object} options
- * @param {Object} schemaOptions
+ * @param {string} path
+ * @param {object} options
+ * @param {object} schemaOptions
  * @param {Schema} parentSchema
  * @inherits SchemaType
  * @api public
@@ -52,10 +51,10 @@ SchemaDouble._cast = castDouble;
  * #### Example:
  *
  *     // Make all Double fields required by default
- *     mongoose.Schema.Double.set('required', true);
+ *     mongoose.Schema.Types.Double.set('required', true);
  *
- * @param {String} option The option you'd like to set the value for
- * @param {Any} value value for option
+ * @param {string} option The option you'd like to set the value for
+ * @param {any} value value for option
  * @return {undefined}
  * @function set
  * @static
@@ -72,7 +71,7 @@ SchemaDouble.setters = [];
  * #### Example:
  *
  *     // Converts Double to be a represent milliseconds upon access
- *     mongoose.Schema.Double.get(v => v == null ? '0.000 ms' : v.toString() + ' ms');
+ *     mongoose.Schema.Types.Double.get(v => v == null ? '0.000 ms' : v.toString() + ' ms');
  *
  * @param {Function} getter
  * @return {this}
@@ -112,7 +111,7 @@ SchemaDouble._defaultCaster = v => {
  *     });
  *
  *     // Or disable casting for Doubles entirely (only JS numbers are permitted)
- *     mongoose.Schema.Double.cast(false);
+ *     mongoose.Schema.Types.Double.cast(false);
  *
  *
  * @param {Function} caster
@@ -157,8 +156,8 @@ SchemaDouble.checkRequired = SchemaType.checkRequired;
 /**
  * Check if the given value satisfies a required validator.
  *
- * @param {Any} value
- * @return {Boolean}
+ * @param {any} value
+ * @return {boolean}
  * @api public
  */
 
@@ -169,8 +168,8 @@ SchemaDouble.prototype.checkRequired = function(value) {
 /**
  * Casts to Double
  *
- * @param {Object} value
- * @param {Object} model this value is optional
+ * @param {object} value
+ * @param {object} model this value is optional
  * @api private
  */
 
@@ -225,14 +224,13 @@ Object.defineProperty(SchemaDouble.prototype, '$conditionalHandlers', {
 /**
  * Returns this schema type's representation in a JSON schema.
  *
- * @param [options]
- * @param [options.useBsonType=false] If true, return a representation with `bsonType` for use with MongoDB's `$jsonSchema`.
- * @returns {Object} JSON schema properties
+ * @param {object} [options]
+ * @param {boolean} [options.useBsonType=false] If true, return a representation with `bsonType` for use with MongoDB's `$jsonSchema`.
+ * @returns {object} JSON schema properties
  */
 
 SchemaDouble.prototype.toJSONSchema = function toJSONSchema(options) {
-  const isRequired = this.options.required && typeof this.options.required !== 'function';
-  return createJSONSchemaTypeDefinition('number', 'double', options?.useBsonType, isRequired);
+  return this._createJSONSchemaTypeDefinition('number', 'double', options);
 };
 
 SchemaDouble.prototype.autoEncryptionType = function autoEncryptionType() {

package/.output/server/node_modules/mongoose/lib/schema/index.js

@@ -12,6 +12,7 @@ exports.Buffer = require('./buffer');
 exports.Date = require('./date');
 exports.Decimal128 = exports.Decimal = require('./decimal128');
 exports.DocumentArray = require('./documentArray');
+exports.DocumentArrayElement = require('./documentArrayElement');
 exports.Double = require('./double');
 exports.Int32 = require('./int32');
 exports.Map = require('./map');