Question

我希望能够为mongoose定义类，而不是使用普通的Schema，然后为其定义函数。我有一个这样的课：

var odd = function() {
    this.name = String;
    this.someprop = {
        type: String,
        required: true
    }
}

这个类有一些功能：

odd.prototype.cake = function() {
    return "This cake has the name \"" + this.name + "\".";
}

通常在mongoose中我必须在创建模式后定义最后一个函数，但是通过这样做（我已经比它已经更多）我放弃了我的intellisense。

是否有一种很好的方法可以让我的课程变成猫鼬模式而不会有太多麻烦？

Answer 1

我能找到的最好方法是创建一个这样的辅助函数，然后将其放入一个单独的文件中：

var mongoose = require("mongoose");
var Schema = mongoose.Schema;
var helpers = require("./helpers");

/**
 * Dark wizardry function that creates a mongoose schema from a normal JS class
 * Objects can also be passed along, and any properties that has methods will be turned into methods on the mongoose Schema.
 * @param c The class to creare the schema from
 * @param options The additional options to pass to the schema creation
 * @returns {Schema} A new mongoose schema for the describing the given class
 */
module.exports = function(c, options) {
    var f = null;
    // Figure out if f is an object or a function, and take appropriate action
    if(helpers.isFunction(c)) {
        f = new c();
    } else if(typeof f === "object") {
        f = c;
    } else {
        throw new TypeError("Class schema cannot work with that type. Whatever it was you supplied, probably a simple type. ");
    }

    var prop;
    var o = {};
    // Save all the properties of f into a new object
    for(prop in f) {
        var p = f[prop];
        switch (p) {
            case String:
            case Number:
            case Date:
            case Buffer:
            case Boolean:
            case mongoose.Types.Mixed:
            case mongoose.Types.ObjectId:
            case Array:
                o[prop] = p;
                break;
            default:
                if(!helpers.isFunction(p)) {
                    o[prop] = p;
                }
        }
    }
    // Create the schema
    var sch = new Schema(o, options);
    // Create the methods for the schema
    for(prop in f) {
        if (prop in f) {
            var func = f[prop];
            switch (func) {
                case String:
                case Number:
                case Date:
                case Buffer:
                case Boolean:
                case mongoose.Types.Mixed:
                case mongoose.Types.ObjectId:
                case Array:
                    continue
            }
            if (helpers.isFunction(func)) {
                sch.methods[prop] = func;
            }
        }
    }
    return sch;
};

我的helpers.js包含一个非常简单的isFunction函数：

function isFunction(f) {
    return typeof f === "function";
}

exports.isFunction = isFunction;

然后，只要我想要一个mongoose架构，我就会执行以下操作：

var mongoose = require("mongoose");
var classSchema = require("./class-schema");
var odd = function() {
   ...
}

odd.prototype.cake = function() {
   ...
}

var oddSchema = classSchema(odd, {timestamps: true});

module.exports = mongoose.model("Odd", oddSchema);

这将创建一个与原始odd类具有相同属性和相同功能的模型。

如何从类（函数）创建mongoose模式

1 个答案: