Accessing models about sequelize-singleton HOT 5 CLOSED

 var Model = sequelize.define("Model", {
    value:  DataTypes.INTEGER
  }, {
    underscored:  true,
    paranoid:     true,
    tableName:    'model',
    classMethods : {
      associate: function(models){
        Model.hasMany(models.OtherModel, { through: 'model_other_model'});
      }
    }
);

var User = models.User;

var UserSchema = mongoose.Schema({ /* ... */ });
var User = mongoose.model('User', UserSchema);
/* 
 * Here nothing is connected yet and 
 * this is fine as long as I don't use User methods that need a connection
 * mongoose.model only register the schema for when the connection will be opened
*/
mongoose.connect(/* ... */);
/* Now I'm able to call User.find(...) */

'use strict';

var Sequelize = require('sequelize');
var _ = require('lodash');
var Schema = function (name, core, association, options) {
    if (!(this instanceof Model)){
        return new Model(name, core, association, options);
    }
    options = options || { };
    this._name = name;
    this._core = core;
    this._options = _.defaults(options, {
        /* my default options here */
        timestamps: false,
        underscored: true,
        underscoredAll: true,
        freezeTableName: true,
        classMethods: { },
        instanceMethods: { },
        hooks: { }
    });
    this._association = association;
};

Object.defineProperty(Schema.prototype, 'statics', {
    get: function () { return this._options.classMethods; }
});

Object.defineProperty(Schema.prototype, 'methods', {
    get: function () { return this._options.instanceMethods; }
});

Object.defineProperty(Schema.prototype, 'hooks', {
    get: function () { return this._options.hooks; }
});

Schema.Type = Sequelize;

'use strict';

var Schema = require('./schema');
var T = Schema.Type;
var $ = require('./models');

var User = Schema('User', {
    emailAddress: { type: T.STRING(255),  allowNull: false, unique: true },
    password: { type: T.STRING(255), allowNull: false },
    username: { type: T.STRING(50), unique: true },
}, function ($) {
    /* this is executed after all models have been loaded */
    this.hasOne($.Avatar);
});

User.statics.register = function (email, password) {
/* this.create(...) or $.User.create(...) */
};

User.methods.getProfile = function () {
    return { this.username };
};

module.exports = User;

Db.prototype.load = function(schemaDir) {
    var self = this;
    var sequelize = this.sequelize;
    var schema;
    fs.readdirSync(schemaDir).forEach(function(name) {
        schema = require(path.join(schemaDir, name));
        if (schema instanceof Schema) {
            // Create the sequelize model and store it in $
            $[schema._name] = sequelize.define(schema._name,
                                              schema._core,
                                              schema._options);
            self.schemas.push(schema);
        }
    });
    // Add associations
    this.schemas.forEach(function (schema) {
        if (_.isFunction(schema._association)) {
            schema._association.apply($[schema._name], [ $ ]);
        }
    });
};

var $ = require('./models');
/* Here it may be empty */

router.get('/', function (req, res) {
   /* 
    * Here I'm sure $ contains all models
    * because I made it a requirement for the application to start 
   */
   $.User.find(/* ... *).then(/*... */);
});

Object.defineProperty(Schema.prototype, 'find', {
    get: function () {
     if (!this._seqmodel) { throw new Error('connection is not opened yet'); }
     return this._seqmodel.find;
});