@depup/mongoose 9.1.3-depup.0

package/lib/schema/map.js

@@ -0,0 +1,201 @@
+'use strict';
+
+/*!
+ * ignore
+ */
+
+const MongooseMap = require('../types/map');
+const SchemaMapOptions = require('../options/schemaMapOptions');
+const SchemaType = require('../schemaType');
+const createJSONSchemaTypeDefinition = require('../helpers/createJSONSchemaTypeDefinition');
+const MongooseError = require('../error/mongooseError');
+const Schema = require('../schema');
+const utils = require('../utils');
+
+class SchemaMap extends SchemaType {
+  /**
+   * Map SchemaType constructor.
+   *
+   * @param {String} path
+   * @param {Object} options
+   * @param {Object} schemaOptions
+   * @param {Schema} parentSchema
+   * @inherits SchemaType
+   * @api public
+   */
+
+  constructor(key, options, schemaOptions, parentSchema) {
+    super(key, options, 'Map', parentSchema);
+    this.$isSchemaMap = true;
+    // Create the nested schema type for the map values
+    this._createNestedSchemaType(parentSchema, key, options, schemaOptions);
+  }
+
+  /**
+   * Sets a default option for all Map instances.
+   *
+   * @param {String} option The option you'd like to set the value for
+   * @param {Any} value value for option
+   * @return {undefined}
+   * @function set
+   * @api public
+   */
+
+  set(option, value) {
+    return SchemaType.set(option, value);
+  }
+
+  /**
+   * Casts to Map
+   *
+   * @param {Object} value
+   * @param {Object} model this value is optional
+   * @api private
+   */
+
+  cast(val, doc, init, prev, options) {
+    if (val instanceof MongooseMap) {
+      return val;
+    }
+
+    const path = this.path;
+
+    if (init) {
+      const map = new MongooseMap({}, path, doc, this.$__schemaType, options);
+
+      // Use the map's path for passing to nested casts.
+      // If map's parent is a subdocument, use the relative path so nested casts get relative paths.
+      const mapPath = map.$__pathRelativeToParent != null ? map.$__pathRelativeToParent : map.$__path;
+
+      if (val instanceof global.Map) {
+        for (const key of val.keys()) {
+          let _val = val.get(key);
+          if (_val == null) {
+            _val = map.$__schemaType._castNullish(_val);
+          } else {
+            _val = map.$__schemaType.cast(_val, doc, true, null, { ...options, path: mapPath + '.' + key });
+          }
+          map.$init(key, _val);
+        }
+      } else {
+        for (const key of Object.keys(val)) {
+          let _val = val[key];
+          if (_val == null) {
+            _val = map.$__schemaType._castNullish(_val);
+          } else {
+            _val = map.$__schemaType.cast(_val, doc, true, null, { ...options, path: mapPath + '.' + key });
+          }
+          map.$init(key, _val);
+        }
+      }
+
+      return map;
+    }
+
+    return new MongooseMap(val, path, doc, this.$__schemaType, options);
+  }
+
+  /**
+   * Creates a copy of this map schema type.
+   *
+   * @api private
+   */
+
+  clone() {
+    const schematype = super.clone();
+
+    if (this.$__schemaType != null) {
+      schematype.$__schemaType = this.$__schemaType.clone();
+    }
+    return schematype;
+  }
+
+  /**
+   * Returns the embedded schema type (i.e. the `.$*` path)
+   *
+   * @api public
+   */
+
+  getEmbeddedSchemaType() {
+    return this.$__schemaType;
+  }
+
+  /**
+   * 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
+   */
+
+  toJSONSchema(options) {
+    const useBsonType = options?.useBsonType;
+    const embeddedSchemaType = this.getEmbeddedSchemaType();
+
+    const isRequired = this.options.required && typeof this.options.required !== 'function';
+    const result = createJSONSchemaTypeDefinition('object', 'object', useBsonType, isRequired);
+    result.additionalProperties = embeddedSchemaType.toJSONSchema(options);
+
+    return result;
+  }
+
+  /**
+   * Returns the auto encryption type for this schema type.
+   *
+   * @api public
+   */
+
+  autoEncryptionType() {
+    return 'object';
+  }
+}
+
+/**
+ * This schema type's name, to defend against minifiers that mangle
+ * function names.
+ *
+ * @api public
+ */
+
+SchemaMap.schemaName = 'Map';
+
+SchemaMap.prototype.OptionsConstructor = SchemaMapOptions;
+
+SchemaMap.defaultOptions = {};
+
+/*!
+ * ignore
+ */
+
+SchemaMap.prototype._createNestedSchemaType = function _createNestedSchemaType(schema, path, obj, options) {
+  const mapPath = path + '.$*';
+  let _mapType = { type: {} };
+  if (utils.hasUserDefinedProperty(obj, 'of')) {
+    const isInlineSchema = utils.isPOJO(obj.of) &&
+      utils.hasOwnKeys(obj.of) &&
+      !utils.hasUserDefinedProperty(obj.of, schema.options.typeKey);
+    if (isInlineSchema) {
+      _mapType = { [schema.options.typeKey]: new Schema(obj.of) };
+    } else if (utils.isPOJO(obj.of)) {
+      _mapType = Object.assign({}, obj.of);
+    } else {
+      _mapType = { [schema.options.typeKey]: obj.of };
+    }
+
+    if (_mapType[schema.options.typeKey] && _mapType[schema.options.typeKey].instanceOfSchema) {
+      const subdocumentSchema = _mapType[schema.options.typeKey];
+      subdocumentSchema.eachPath((subpath, type) => {
+        if (type.options.select === true || type.options.select === false) {
+          throw new MongooseError('Cannot use schema-level projections (`select: true` or `select: false`) within maps at path "' + path + '.' + subpath + '"');
+        }
+      });
+    }
+
+    if (utils.hasUserDefinedProperty(obj, 'ref')) {
+      _mapType.ref = obj.ref;
+    }
+  }
+  this.$__schemaType = schema.interpretAsType(mapPath, _mapType, options);
+};
+
+module.exports = SchemaMap;

package/lib/schema/mixed.js

@@ -0,0 +1,146 @@
+/*!
+ * Module dependencies.
+ */
+
+'use strict';
+
+const SchemaType = require('../schemaType');
+const symbols = require('./symbols');
+const isObject = require('../helpers/isObject');
+const utils = require('../utils');
+
+/**
+ * Mixed SchemaType constructor.
+ *
+ * @param {String} path
+ * @param {Object} options
+ * @param {Object} _schemaOptions
+ * @param {Schema} parentSchema
+ * @inherits SchemaType
+ * @api public
+ */
+
+function SchemaMixed(path, options, _schemaOptions, parentSchema) {
+  if (options?.default) {
+    const def = options.default;
+    if (Array.isArray(def) && def.length === 0) {
+      // make sure empty array defaults are handled
+      options.default = Array;
+    } else if (!options.shared && isObject(def) && utils.hasOwnKeys(def) === false) {
+      // prevent odd "shared" objects between documents
+      options.default = function() {
+        return {};
+      };
+    }
+  }
+
+  SchemaType.call(this, path, options, 'Mixed', parentSchema);
+
+  this[symbols.schemaMixedSymbol] = true;
+}
+
+/**
+ * This schema type's name, to defend against minifiers that mangle
+ * function names.
+ *
+ * @api public
+ */
+SchemaMixed.schemaName = 'Mixed';
+
+SchemaMixed.defaultOptions = {};
+
+/*!
+ * Inherits from SchemaType.
+ */
+SchemaMixed.prototype = Object.create(SchemaType.prototype);
+SchemaMixed.prototype.constructor = SchemaMixed;
+
+/**
+ * Attaches a getter for all Mixed paths.
+ *
+ * #### Example:
+ *
+ *     // Hide the 'hidden' path
+ *     mongoose.Schema.Types.Mixed.get(v => Object.assign({}, v, { hidden: null }));
+ *
+ *     const Model = mongoose.model('Test', new Schema({ test: {} }));
+ *     new Model({ test: { hidden: 'Secret!' } }).test.hidden; // null
+ *
+ * @param {Function} getter
+ * @return {this}
+ * @function get
+ * @static
+ * @api public
+ */
+
+SchemaMixed.get = SchemaType.get;
+
+/**
+ * Sets a default option for all Mixed instances.
+ *
+ * #### Example:
+ *
+ *     // Make all mixed instances have `required` of true by default.
+ *     mongoose.Schema.Types.Mixed.set('required', true);
+ *
+ *     const User = mongoose.model('User', new Schema({ test: mongoose.Mixed }));
+ *     new User({ }).validateSync().errors.test.message; // Path `test` is required.
+ *
+ * @param {String} option The option you'd like to set the value for
+ * @param {Any} value value for option
+ * @return {undefined}
+ * @function set
+ * @static
+ * @api public
+ */
+
+SchemaMixed.set = SchemaType.set;
+
+SchemaMixed.setters = [];
+
+/**
+ * Casts `val` for Mixed.
+ *
+ * _this is a no-op_
+ *
+ * @param {Object} value to cast
+ * @api private
+ */
+
+SchemaMixed.prototype.cast = function(val) {
+  if (val instanceof Error) {
+    return utils.errorToPOJO(val);
+  }
+  return val;
+};
+
+/**
+ * Casts contents for queries.
+ *
+ * @param {String} $cond
+ * @param {any} [val]
+ * @api private
+ */
+
+SchemaMixed.prototype.castForQuery = function($cond, val) {
+  return val;
+};
+
+/**
+ * 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
+ */
+
+// eslint-disable-next-line no-unused-vars
+SchemaMixed.prototype.toJSONSchema = function toJSONSchema(_options) {
+  return {};
+};
+
+/*!
+ * Module exports.
+ */
+
+module.exports = SchemaMixed;