startORM: function(cb, stack) {
var modelDefs = stack.modelDefs;
// -> Instantiate ORM in memory.
// -> Iterate through each model definition:
// -> Create a proper Waterline Collection for each model
// -> then register it w/ the ORM.
sails.log.verbose('Starting ORM...');
var waterline = new Waterline();
_.each(modelDefs, function loadModelsIntoWaterline (modelDef, modelID) {
sails.log.silly('Registering model `' + modelID + '` in Waterline (ORM)');
waterline.loadCollection( Waterline.Collection.extend(modelDef) );
});
// Find all the connections used
var connections = {};
_.each(sails.adapters, function pruneConnections (adapter, adapterKey) {
_.each(sails.config.connections, function(connection, connectionKey) {
if(adapterKey !== connection.adapter) return;
connections[connectionKey] = connection;
});
});
// -> "Initialize" ORM
// : This performs tasks like managing the schema across associations,
// : hooking up models to their connections, and auto-migrations.
waterline.initialize({
adapters: sails.adapters,
connections: connections
}, cb);
},
var init = function (cb) {
fs.readdirSync(__dirname + '/models').forEach(function (filename) {
if (/\.js$/.test(filename)) {
var model = depInj('orm', 'models/' + filename);
model = _.extend(defalutModel, model);
var collection = Waterline.Collection.extend(model);
orm.loadCollection(collection)
}
});
//['user', 'hero'].forEach(function (def) {
// var model = depInj('dao', 'models/' + def);
// model = _.extend(defalutModel, model);
// var collection = Waterline.Collection.extend(model);
// orm.loadCollection(collection)
//});
var connectionName = defalutModel.connection;
options.connections[connectionName] = connection;
orm.initialize(options, function (err, models) {
if (err) {
logger.warn('orm database init fails!', err, options);
}
cb(err, models);
logger.info('orm database init success!');
});
};
Adapter.teardown('autoIncConn', function adapterTeardown(){
waterline.initialize({ adapters: { wl_tests: Adapter }, connections: connections, defaults: defaults }, function(err, ontology) {
if(err) return done(err);
AutoIncModel = ontology.collections['autoinc'];
done();
});
});
Adapter.teardown('compositeUniqueConnection', function adapterTeardown(){
waterline.initialize({ adapters: { wl_tests: Adapter }, connections: connections, defaults: defaults }, function(err, ontology) {
if(err) return done(err);
Model = ontology.collections['compositeunique'];
done();
});
});
Migratable.Waterline.teardown(function(err) {
// Create a new ORM instance
var wl = new Waterline();
// Load the fixtures again
var fixtures = _.cloneDeep(Migratable.fixtures);
_.each(fixtures, function(val, key) {
wl.registerModel(Waterline.Collection.extend(_.merge({ archiveModelIdentity: false }, fixtures[key])));
});
// Initialize the ORM again
wl.initialize(Migratable.WaterlineOptions, function(err, orm) {
if (err) {
return done(err);
}
// Run migrations
waterlineUtils.autoMigrations('alter', orm, function(err) {
if (err) {
return done(err);
}
orm.collections.custom.count().exec(function(err, numOfPirates) {
if (err) {
return done(err);
}
assert.strictEqual(numOfPirates, 1);
return done();
});
});
});
});
module.exports = function bootstrap( options, cb ) {
"use strict";
var _ = require("underscore");
var Waterline = require('waterline');
var adapters = options.adapters || {};
var connections = options.connections || {};
var collections = options.collections || {};
_(adapters).each(function (def, identity) {
def.identity = def.identity || identity;
});
var waterline = new Waterline();
_(collections).each(function (collection) {
// Extend and load the Waterline collections.
waterline.loadCollection(Waterline.Collection.extend(collection));
});
// Initialize Waterline
// (and tell it about our adapters)
waterline.initialize({
adapters: adapters,
connections: connections
}, cb);
return waterline;
};
SailsTasksModels.prototype.init = function(callback) {
// initialize ORM
orm.initialize({
adapters: {
'sails-mysql': require('sails-mysql')
},
connections: require(path.join(CWD, 'config/connections')).connections,
defaults: require(path.join(CWD, 'config/models')).models
}, function (err, ontology) {
if (err) console.log(err);
else {
// Create global variables for each model (e.g User.findOne)
fs.readdirSync(modelsPath).forEach(function(file) {
var name = null;
if (name = file.match(/^(\w+)\.js$/i)) {
name = name[1];
var collection = name.toLowerCase();
global[name] = ontology.collections[collection];
}
});
}
callback(ontology);
});
};
before(function(done) {
waterline = new Waterline();
waterline.loadCollection(UniqueFixture);
var connections = { uniqueConn: _.clone(Connections.test) };
waterline.initialize({ adapters: { wl_tests: Adapter }, connections: connections, defaults: defaults }, function(err, ontology) {
if(err) return done(err);
UniqueModel = ontology.collections['unique'];
// Insert 3 Records
var records = [];
for(var i=0; i<3; i++) {
records.push({name: 'testUnique' + i, email: 'email' + i, type: 'unique'});
}
UniqueModel.createEach(records, function(err, records) {
if(err) return done(err);
id0 = records[0].id;
id1 = records[1].id;
email0 = records[0].email.toString();
done();
});
});
});
return new Promise((resolve, reject) => {
try {
orm.initialize(wlConfig, (err, models) => {
if(err) {
return reject(err);
}
var allModels = [];
_.forEach(models.collections, (model, identity) => {
Promise.promisifyAll(model);
allModels.push({
table: model.adapter.collection,
identity: identity,
model: model
});
});
reverseNext(allModels).then(() => {
resolve();
}).catch(err => {
reject(err);
});
});
} catch(err) {
reject(err);
}
});
exports.register = function (server, options, next) {
let waterlineConfig = Hoek.clone(config);
for (const key in options) {
waterlineConfig[key] = options[key];
}
try {
waterline.initialize(waterlineConfig, (err, ontology) => {
server.method('data.teardown', (opts, cb) => {
return Promise.resolve(waterline.teardown()).nodeify(cb);
});
server.methods.data.teardown = Promise.promisify(server.methods.data.teardown);
server.expose('models', ontology.collections);
return next();
});
} catch(err) {
waterline.teardown(() => {
next(err);
});
}
};
before(function(done) {
waterline = new Waterline();
waterline.registerModel(UniqueFixture);
var connections = { uniqueConn: _.clone(Connections.test) };
waterline.initialize({ adapters: { wl_tests: Adapter }, datastores: connections, defaults: defaults }, function(err, ontology) {
if(err) return done(err);
// Migrations Helper
WaterlineUtils.autoMigrations(defaults.migrate, ontology, function(err) {
if (err) {
return done(err);
}
UniqueModel = ontology.collections.unique;
// Insert 3 Records
var records = [];
for(var i=0; i<3; i++) {
records.push({name: 'testUnique' + i, email: 'email' + i, type: 'unique'});
}
UniqueModel.createEach(records, function(err, records) {
if(err) return done(err);
id0 = records[0].id;
id1 = records[1].id;
email0 = records[0].email.toString();
done();
}, {fetch: true});
});
});
});
async.each(dbConfList, function(eachConfig, callback) {
if(enableWaterline){
var orm = new Waterline();
var models_path = dirPaths.serverDir + 'models';
fs.readdirSync(models_path).forEach(function (file) {
var newPath = models_path + '/' + file
var stat = fs.statSync(newPath);
if (stat.isFile()) {
try {
orm.loadCollection(require(newPath));
}
catch(ex){
console.log(ex);
}
}
});
orm.initialize(eachConfig, function(err, models) {
try{
app.models = models.collections;
app.connections = models.connections;
}catch(e){
console.error("please start the monogdb before starting the aquajs server");
process.exit(1);
}
});
}
if(enablePersist){
//code for persist model initialization
}
callback('finished the model initialization');
}, function(err){
}, function (err) {
// Build Config for each adapter
util.each(sails.adapters, function(adapter, identity) {
ormUtil.buildAdapterConfig(identity);
});
var waterline = new Waterline();
Object.keys(sails.models).forEach(function(model) {
waterline.loadCollection(loadCollection(model));
});
waterline.initialize({ adapters: sails.adapters }, function(err, collections) {
if(err) return cb(err);
Object.keys(collections).forEach(function(key) {
// Set Model to instantiated Collection
sails.models[key] = collections[key];
// Globalize Model if Enabled
if (sails.config.globals.models) {
var globalName = sails.models[key].globalId || sails.models[key].identity;
global[globalName] = collections[key];
}
});
cb();
});
});
before(function(done) {
waterline = new Waterline();
Object.keys(fixtures).forEach(function(key) {
waterline.loadCollection(fixtures[key]);
});
var connections = { queryable: conn };
var defaults = { migrate: 'alter' };
waterline.initialize({ adapters: { wl_tests: Adapter }, connections: connections, defaults: defaults }, function(err, _ontology) {
if(err) return done(err);
ontology = _ontology;
Object.keys(_ontology.collections).forEach(function(key) {
var globalName = key.charAt(0).toUpperCase() + key.slice(1);
global.Queryable[globalName] = _ontology.collections[key];
});
done();
});
});
module.exports = new Promise(function(resolve) {
ORM.loadCollection(Todo);
ORM.initialize(config, (error, data) => {
if (error) {
console.error(error);
}
// Create a Waterline Feathers service with a default page size of 2 items
// and a maximum size of 4
app.use('/todos', waterline({
Model: data.collections.todo,
paginate: {
default: 2,
max: 4
}
}));
app.use(function(error, req, res, next){
res.json(error);
});
// Start the server
const server = app.listen(3030);
server.on('listening', function() {
console.log('Feathers Todo waterline service running on 127.0.0.1:3030');
resolve(server);
});
});
});
module.exports.initialize = function(app, PORT, callback) {
orm.initialize(connectConfig, function(err, models) {
if(err) throw err;
callback(models.collections, models.connections);
});
}
// initialize function
function initialize(app, PORT, callback) {
// Initialize the whole database and store models and connections to app
orm.initialize(connectionConfig, function(err, models) {
if(err) throw err;
// pass the collections (models) and connections created to app
callback(models.collections, models.connections);
});
}
exports.init = function(callback) {
orm.initialize(ormConfig, function(err, result) {
if(err) throw err;
models = result.collections;
callback();
});
};
return new Promise((resolve, reject) => {
this.wl.initialize(wlConfig, (err, orm) => {
if (err) return reject(err)
this.orm = orm
this.app.orm = lib.Transformer.transformWaterlineOrm(this.orm)
resolve()
})
})
setup(function (done) {
waterline.loadCollection(require('../models/users.js'));
waterline.loadCollection(require('../models/registrants.js'));
waterline.initialize(config, function (err, ontology) {
if (err) {
return done(err);
}
done();
});
});
before(function(done) {
waterline = new Waterline();
// Store the fixtures so they can be accessed globally
global.Migratable.fixtures = _.cloneDeep(fixtures);
_.each(fixtures, function(val, key) {
var modelFixture = _.merge({}, defaults, fixtures[key]);
waterline.registerModel(Waterline.Collection.extend(modelFixture));
});
var datastores = {
migratable: _.clone(Connections.test)
};
// Store access to the instantiated Waterline instance so tests can
// call teardown.
global.Migratable.Waterline = waterline;
// Store access to the options passed in to initialize so tests can re-initialize
// Waterline.
var wlOptions = {
adapters: {
wl_tests: Adapter
},
datastores: datastores,
defaults: defaults
};
global.Migratable.WaterlineOptions = wlOptions;
waterline.initialize(wlOptions, function(err, orm) {
if (err) {
return done(err);
}
// Save a reference to the ORM
ORM = orm;
// Globalize collections for normalization
_.each(ORM.collections, function(collection, identity) {
var globalName = identity.charAt(0).toUpperCase() + identity.slice(1);
global.Migratable[globalName] = collection;
});
// Run migrations
waterlineUtils.autoMigrations('alter', orm, function(err) {
if (err) {
return done(err);
}
return done();
});
});
});
before(done => {
waterline = new Waterline();
waterline.loadCollection(models.ArrayModel)
waterline.loadCollection(models.JsonModel)
waterline.initialize(wlconfig, (err, _orm) => {
if (err) return done(err)
orm = _orm.collections
done()
})
})
var init = function(app, done) {
orm.initialize(ormConfig, function(e, models){
if (e){
console.log('ORM error: ', e);
}
exports.db = models.collections;
done(e, models)
});
}
Adapter.teardown('autoIncConn', function adapterTeardown(){
waterline.initialize({ adapters: { wl_tests: Adapter }, datastores: connections, defaults: defaults }, function(err, ontology) {
if(err) return done(err);
WaterlineUtils.autoMigrations(defaults.migrate, ontology, function(err) {
if (err) {
return done(err);
}
AutoIncModel = ontology.collections.autoinc;
done();
});
});
});
before(function(done) {
var waterline = new Waterline();
waterline.loadCollection(Model);
Events.emit('fixture', Model);
waterline.initialize({ adapters: { test: Adapter }}, function(err, colls) {
if(err) return done(err);
User = colls.loadtest;
done();
});
});
function loadModels(asyncCb) {
orm.initialize({
adapters: sails.adapters,
connections: self.getConnections()
}, function(err, models) {
if (err) {
sails.log.debug('Error initializing models ', err);
return asyncCb(err);
} else {
self.globalizeModels(models, asyncCb);
}
});
}
function dbInitialize(app){
waterline.initialize(config, function(err, models) {
if(err)
throw err;
app.models = models.collections;
app.connections = models.connections;
app.models.framework.create({ name: 'vue.js', language: 'javascript' }).then(console.log).catch(console.error);
app.models.framework.create({ name: 'react', language: 'javascript' }).then(console.log).catch(console.error);
app.models.framework.create({ name: 'angular', language: 'javascript' }).then(console.log).catch(console.error);
app.models.framework.create({ name: 'boost', language: 'c++' }).then(console.log).catch(console.error);
});
}
var initialize = function(cb) {
if(initialized) {
return cb();
}
orm.initialize(config, function(err, models) {
if(err) {
return log.error(err);
}
collections = models.collections;
initialized = true;
cb();
});
};
module.exports = function(done) {
var waterline= new Waterline();
Conf.options.models.forEach(function(model){
waterline.loadCollection(Waterline.Collection.extend(model));
});
waterline.initialize({
connections: Conf.options.connections,
adapters: Conf.options.adapters,
defaults: Conf.options.defaults
},function waterlineReady (err, ontology) {
if (err) throw err;
done(waterline);
}
);
};
yield function(callback) {
// Initialize Waterline
this.waterline.initialize({
adapters: this.config.waterlineAdapters,
connections: this.config.connections
}, (err, models) => {
if (err) {
throw err
}
this.models = models.collections;
this.connections = models.connections;
callback();
});
}.bind(this);