了解mongoose的插件机制

Schemas是可以插拔的，也就是说，它们提供在应用预先打包能力来扩展它们的功能。这是非常强大的特性。

插件写法

基本结构

  1. module.exports = exports = function (schema, options) {
  3. }

参数说明

  • schema是schema定义
  • options为配置项

用法

  1. var some_plugin = require('./some_plugin');
  2. var Game = new Schema({ ... });
  3. Game.plugin(some_plugin, { index: true });

说明

  • Game是用户自己定义的Schema
  • Game.plugin是给Game增加plugin
  • plugin方法有2个参数
    • 插件对象：some_plugin
    • 配置项： { index: true }

比如在数据库里想给所有的collection增加last-modified功能。这时候使用插件是非常简单。仅仅需要创建一个插件，在每个Schema里应用它即可：

示例

给所有的collection增加last-modified功能

定义

  1. // lastMod.js
  2. module.exports = exports = function lastModifiedPlugin (schema, options) {
  3.   schema.add({ lastMod: Date })
  5.   schema.pre('save', function (next) {
  6.     this.lastMod = new Date
  7.     next()
  8.   })
  10.   if (options && options.index) {
  11.     schema.path('lastMod').index(options.index)
  12.   }
  13. }

调用

  1. // game-schema.js
  2. var lastMod = require('./lastMod');
  3. var Game = new Schema({ ... });
  4. Game.plugin(lastMod, { index: true });

我们可以看出，整体来说，mongoose的插件机制比较简单，就是通过约定参数(schema, options)，然后在函数内部来对schema进行扩展。简单点说，就是在Game.plugin(lastMod, { index: true });时，把schema里的变化应用到Game的Schema里。

schema操作

这不是mongoose里对schema变动的唯一方式。其实都是schema.add的功劳。

  1. var ToySchema = new Schema;
  2. ToySchema.add({ name: 'string', color: 'string', price: 'number' });

我们获得某个Schema，然后自己手动add也是可以的，但要保证的是在定义model之前即可。

配置项

配置项也非常有意思，可以结合配置项给schema里的字段增加一些特性，比如增加索引，做一些更复杂的判断等。

  1. if (options && options.index) {
  2.   schema.path('lastMod').index(options.index)
  3. }

base-user-plugin

我们再举个例子，用户登录和注册的功能在hook一节已经讲过了，对密码的加密和解密可以说是最常见的需求，那么我们能不能够里有plugin机制完善一下呢？

答案是可以，首先我们观察一下它们的共同点，然后给出可行性分析。

可行性分析

hook的核心

  1. UserSchema.statics.login = function(username, password, cb) {
  2.   this.findOne({
  3.     username: username
  4.   }, function (err, user) {
  5.     if (err || !user) {
  6.       if (err)
  7.         console.log(err);
  9.       return cb(err, {
  10.         code: -1,
  11.         msg : username + ' is not exist!'
  12.       });
  13.     }
  15.     bcrypt.compare(password, user.password, function(error, res) {
  16.       if (error) {
  17.         console.log(error);
  18.         return cb(err, {
  19.           code: -2,
  20.           msg : 'password is incorrect, please check it again!'
  21.         });
  22.       }
  24.       return cb(null, user);
  25.     });
  26.   });
  27. };
  29. UserSchema.pre('save', function (next) {
  30.   var that = this;
  32.   bcrypt.genSalt(this._salt_bounds, function(err, salt) {
  33.     if (err) {
  34.       console.log(err);
  35.       return next();
  36.     }
  38.     bcrypt.hash(that.password, salt, function(error, hash) {
  39.       if (error) {
  40.         console.log(error);
  41.       }
  43.       // console.log(this.password + ' \n ' + hash);
  44.       //生成密文
  45.       that.password = hash;
  47.       return next();
  48.     });
  49.   });
  50. })

它们的共同点，无论是pre还是statics都是对UserSchema进行操作。

插件定义

而插件定义

  1. // lastMod.js
  2. module.exports = exports = function  (schema, options) {
  3.   ...
  4. }

可以看出，插件的第一个参数就是schema，很明显，它们都是对schema操作，基于这个思考，我们可以确定这种改造是可行的。

mongoose-base-user-plugin核心代码

  1. const mongoose = require('mongoose');
  2. const bcrypt = require('bcrypt');
  4. module.exports = exports = function baseUserPlugin (schema, options) {
  5.   schema.add({
  6.     username      : {// 真实姓名
  7.       type: String,
  8.       required: true
  9.     },
  10.     password      : { // 密码
  11.       type: String,
  12.       required: true
  13.     },
  14.     _salt_bounds: {
  15.       type: Number,
  16.       required: false,
  17.       default : 10
  18.     },
  19.     created_at    : {
  20.       type: Date,
  21.       "default": Date.now
  22.     }
  23.   });
  25.   schema.statics.login = function(username, password, cb) {
  26.     this.findOne({
  27.       username: username
  28.     }, function (err, user) {
  29.       if (err || !user) {
  30.         if (err)
  31.           console.log(err);
  33.         return cb(err, {
  34.           code: -1,
  35.           msg : username + ' is not exist!'
  36.         });
  37.       }
  39.       bcrypt.compare(password, user.password, function(error, res) {
  40.         if (error) {
  41.           console.log(error);
  42.           return cb(err, {
  43.             code: -2,
  44.             msg : 'password is incorrect, please check it again!'
  45.           });
  46.         }
  48.         return cb(null, user);
  49.       });
  50.     });
  51.   };
  53.   schema.pre('save', function (next) {
  54.     var that = this;
  56.     bcrypt.genSalt(this._salt_bounds, function(err, salt) {
  57.       if (err) {
  58.         console.log(err);
  59.         return next();
  60.       }
  62.       bcrypt.hash(that.password, salt, function(error, hash) {
  63.         if (error) {
  64.           console.log(error);
  65.         }
  67.         // console.log(this.password + ' \n ' + hash);
  68.         //生成密文
  69.         that.password = hash;
  71.         return next();
  72.       });
  73.     });
  74.   });
  76. }

这其实和之前讲的的没啥区别，简单封装而已。

定义MyUser模型

  1. var mongoose = require('mongoose');
  2. var base_user = require('.')
  4. var MyUserSchema = new mongoose.Schema({ 
  5.   invite_code   : String, // 邀请码
  6.   phone_number  : Number, // 电话号码
  7.   address       : String, // 地址
  8.   unionid       : String,
  9.   nickname      : String,// from weixin 昵称
  10.   sex           : String,// from weixin 性别 0->女 1->男
  11.   language      : String,// from weixin 语言
  12.   city          : String,// from weixin 城市
  13.   province      : String,// from weixin 
  14.   country       : String,// from weixin
  15.   headimgurl    : String,// from weixin 头像路径
  16.   privilege     : [],    // from weixin
  17.   created_at    : {
  18.     type: Date,
  19.     "default": Date.now
  20.   }
  22. });
  24. MyUserSchema.plugin(base_user);
  26. // 定义Model
  27. var MyUserModel = mongoose.model('MyUser', MyUserSchema);
  29. // 暴露接口
  30. module.exports = MyUserModel;

测试代码

剩下和之前的测试一样了，我们简单的看一下测试代码

  1. import test from 'ava';
  3. // 1、引入`mongoose connect`
  4. require('../connect');
  6. // 2、引入`User` Model
  7. const User = require('../user');
  9. // 3、定义`user` Entity
  10. const user = new User({
  11.   username: 'i5ting',
  12.   password: '0123456789'
  13. });
  15. test.before.cb( t => {
  16.   User.remove({}, (err, u) => {
  17.     t.end()
  18.   })
  19. });
  22. test.cb('#register()', t => {
  23.   user.save((err, u) => {
  24.     t.true(u.password.length > 50)
  25.     t.end()
  26.   })
  27. });
  29. test.cb('#User.login(username, password) sucess', t => {
  30.   let _user = new User({
  31.     username: 'i5ting for is_login_valid',
  32.     password: '0123456789'
  33.   });
  34.   _user.save((err, u) => {
  35.     User.login('i5ting for is_login_valid', '0123456789', function (err, result) {
  36.       if (!err) {
  37.         t.pass()
  38.         t.end()
  39.       }
  40.     })
  41.   })
  42. });
  44. test.cb('#User.login(username, password) fail with username is not exist', t => {
  45.   let _user = new User({
  46.     username: 'i5ting for is_login_valid2',
  47.     password: '0123456789'
  48.   });
  49.   _user.save((err, u) => {
  50.     User.login('i5ting for is_login_valid not exist', '0123456789', function (err, result) {
  51.       if (err) {
  52.         // console.log(err)
  53.         t.pass()
  54.         t.end()
  55.       }
  57.       if (result.code === -1) {
  58.         t.pass()
  59.         t.end()
  60.       }
  61.     })
  62.   })
  63. });
  65. test.cb('#User.login(username, password) fail with password is incorrect', t => {
  66.   let _user = new User({
  67.     username: 'i5ting 2',
  68.     password: '0123456789'
  69.   });
  70.   _user.save((err, u) => {
  71.     // console.log(err)
  72.     User.login('i5ting 2', '0123456', function (err, result) {
  73.       if (err) {
  74.         console.log(err)
  75.         t.fail()
  76.         t.end()
  77.       }
  78.       if (result) {
  79.         t.is(result.username, _user.username)
  80.         t.end()
  81.       }
  82.     })
  83.   })
  84. });

执行

  1. $ npm test
  3. > mongoose-base-user-plugin@1.0.0 test /Users/sang/workspace/github/mongoose-base-user-plugin
  4. > ava -v
  7. 数据库连接成功
  8.   ✔ #register() (261ms)
  9.   ✔ #User.login(username, password) fail with username is not exist (269ms)
  10.   ✔ #User.login(username, password) sucess (359ms)
  11.   ✔ #User.login(username, password) fail with password is incorrect (356ms)
  13.   4 tests passed

集成travis-ci

在根目录创建.travis.yml文件

  1. sudo: false
  2. addons:
  3.   apt:
  4.     sources:
  5.     - ubuntu-toolchain-r-test
  6.     packages:
  7.     - g++-4.8
  8. env:
  9.   - CXX=g++-4.8
  10. language: node_js
  11. node_js:
  12.   - 6
  13.   - 5
  14.   - 4
  15. script: 
  16.   - npm test
  17. services:
  18.   - mongodb
  19. before_script:
  20.   - mongo mongoose-base-user-plugin --eval 'db.addUser("travis", "test");

说明

  • services指定mongodb连接
  • before_script 创建数据库和用户西你想
  • addons 使用apt安装g++依赖
  • env 定义CXX环境变量

这是因为bcrypt是Node.js的c/c++ addons，需要g++来编译，所以需要g++依赖。如果mac也需要先安装Xcode。

所以如果我们在项目代码里是bcrypt，部署的时候也需要安装g++的。

源码

https://github.com/i5ting/mongoose-base-user-plugin

总结

mongoose插件机制功能非常强大，又非常简单，对于我们优化代码，复用等有非常明显的帮助，在真实项目里，可以更好的组织代码，可以说是必会的一个特性。