node.js - 作为具有继承链的 ES6 类的 Mongoose 模型

Question

我试图创建一个 ES6 类层次结构来实现 mongoose 和 mongodb 查询之间的缓存层。我看到了这个 PR https://github.com/Automattic/mongoose/pull/4668并以此为基础编写了以下代码。

'use strict'

const mongoose = require('mongoose');
mongoose.connect("mongodb://host:port/db", {});
mongoose.connection.on('error', console.error.bind(console, 'DB connection failed', arguments));
mongoose.connection.once('open', console.log.bind(console, 'Connected to DB'));

class Base extends mongoose.Model {
    save() {
        console.log('Base class save()')
        return super.save();
    }

    findOne(query){
        console.log('Base class find...');
        return super.findOne(query);
    }
}

class Derived extends Base{
    save(){
        console.log('Derived class save()');
        super.save();
    }

    static getOne(){
        console.log('Derived class Get one');
        return this.findOne({});
    }
}

let usersSchema = new mongoose.Schema({ name: String })

usersSchema.loadClass(Derived);

let User = mongoose.model(Derived, usersSchema, 'users');

setTimeout(function(){
    User.getOne()
            .then(user => console.log('Found user...', user));

    let newUser = new User();
    console.log('newUser instance of Derived ? ', (newUser instanceof Derived));
    console.log('newUser instance of Base ? ', (newUser instanceof Base));
    newUser.name = 'Tony';
    newUser.save()
                .then(result => console.log('Saved', result));
}, 2000);

由于方法在派生类中被重写，我期望对派生类中的方法的调用将依次调用基类，然后我可以在查询之前/之后在基类中添加额外的逻辑。

下面是我得到的输出，它表明方法调用没有命中 Derived/Base 类。

输出

Connected to DB
Derived class Get one
newUser instance of Derived ?  true
newUser instance of Base ?  true
Base class save()
Found user... { _id: 58ec765f9dd99f049c2a833b, name: 'Tony', __v: 0 }

当我调用 save 方法时，它没有命中 Derived 类，当我调用 Derived 类中的 getOne 静态方法时，调用没有命中 findOne Base 类中的方法。我不确定我哪里出错了。任何人都可以对此有所了解。

Answer 1

我昨天确实遇到了这个问题。

这是我开始工作的代码:

class User extends mongoose.Model {
    constructor(user) {
        super(user);
        this.settings = new UserSettings({userId: this._id});
    }

    async save(callback) {
        try {
            await this.settings.save();
            return super.save(callback);
        }
        catch (error) {
            throw error;
        }
    }

    //implement only if you want to use create...
    static async create(obj, callback) {
        let user = new User(obj);
        return user.save(callback);
    }
}

我认为您缺少 async 关键字，因此会产生竞争效应。

我创建此代码是为了在您创建父文档时自动创建子文档(具有默认值)，而不是执行let prt = new Parent({}).save() 然后(按照文档):Parent.find({id: prt.id}).populate('child').

这有点糟糕，或者我错过了正确的文档...