你可以这样做：

var schema = {
  name: { type: String},
  value: { type: String}
};

var requiredAttrs = ['name', 'value'];

for (attr in requiredAttrs) { schema[attr].required = true; }

var Dimension = mongoose.schema(schema);

字符串
或者对于所有属性（使用下划线，这很棒）：

var schema = {
  name: { type: String},
  value: { type: String}
};

_.each(_.keys(schema), function (attr) { schema[attr].required = true; });

var Dimension = mongoose.schema(schema);

型

我最终做到了这一点：

r_string = 
  type: String
  required: true 

r_number = 
  type: Number
  required: true

字符串
而对于其他数据类型则为ON。

所有字段属性的格式为schema.paths[attribute]或schema.path(attribute);
一个正确的方法：定义何时不需要字段，

Schema = mongoose.Schema;
var Myschema = new Schema({
    name : { type:String },
    type : { type:String, required:false }
})

字符串
并将它们设置为默认必填项：

function AllFieldsRequiredByDefautlt(schema) {
    for (var i in schema.paths) {
        var attribute = schema.paths[i]
        if (attribute.isRequired == undefined) {
            attribute.required(true);
        }
    }
}

AllFieldsRequiredByDefautlt(Myschema)

型
下划线方式：

_=require('underscore')
_.each(_.keys(schema.paths), function (attr) {
    if (schema.path(attr).isRequired == undefined) {
        schema.path(attr).required(true);
    }
})

型
测试一下：

MyTable = mongoose.model('Myschema', Myschema);
t = new MyTable()
t.save()

型

你可以写一个mongoose模式插件函数，遍历模式对象并调整它，使每个字段都是必需的。然后你只需要每个模式一行：Dimension.plugin(allRequired)的。

Mongoose没有提供设置所有字段的方法，但是您可以递归地完成它。
就像Peter提到的，你可以将它插件化，以便重用代码。

递归设置：

// game.model.js
var fields = require('./fields');
var Game = new Schema({ ... });

for(var p in Game.paths){
  Game.path(p).required(true);
}

字符串

插件化：

// fields.js
module.exports = function (schema, options) {
  if (options && options.required) {
    for(var p in schema.paths){
      schema.path(p).required(true);
    }
  }
}

// game.model.js
var fields = require('./fields');
var Game = new Schema({ ... });
Game.plugin(fields, { required: true });

型

我不确定在Mongoose中是否有更简单的方法，但我会在您的IDE/编辑器中执行以下操作：
像往常一样列出您的字段：

Dimension = mongoose.Schema(
  name: String
  value: String
)

字符串
然后在String上执行查找和替换，并将其替换为{type: String, required: true},。

Dimension = mongoose.Schema(
  name: {type: String, required: true},
  value:  {type: String, required: true},
)

型
然后对Number和其他类型执行相同的操作。

在前面的答案的基础上，下面的模块将默认为必填字段。前面的答案没有递归嵌套对象/数组。
使用方法：

const rSchema = require("rschema");

var mySchema = new rSchema({
    request:{
        key:String,
        value:String
    },
    responses:[{
        key:String,
        value:String
    }]
});

字符串
节点模块：

const Schema = require("mongoose").Schema;

//Extends Mongoose Schema to require all fields by default
module.exports = function(data){
    //Recursive
    var makeRequired = function(schema){
        for (var i in schema.paths) {
            var attribute = schema.paths[i];
            if (attribute.isRequired == undefined) {
                attribute.required(true);
            }
            if (attribute.schema){
                makeRequired(attribute.schema);
            }
        }
    };

    var schema = new Schema(data);
    makeRequired(schema);
    return schema;
};

型

我为你可能拥有的复杂类型创建了这个函数，这样你就不必为你拥有的每个类型声明一个新变量。

function require<T>(type: T): { type: T; required: true } {
  return {
    type,
    required: true,
  };
}

字符串
要使用它，您只需执行以下操作：

const mySchema = new mongoose.Schema({
  someRequiredField: require(String),
  someCustomTypedField: require(MyType),
});

型
这样更简洁，也更容易解释。