[feat] Trails Stores

Author: scott-wyatt

api/services/FootprintService.js

@@ -1,7 +1,7 @@
 'use strict'
 
 const _ = require('lodash')
-const Service = require('trails/lib/service')
+const Service = require('trails/lib/Service')
 const ModelError = require('../../lib').ModelError
 
 const manageError = err => {

api/services/SchemaMigrationService.js

@@ -1,6 +1,6 @@
 'use strict'
 
-const Service = require('trails/lib/service')
+const Service = require('trails/lib/Service')
 
 /**
  * @module SchemaMigrationService

archetype/config/database.js

@@ -1,2 +1 @@
 exports.trailpack = require('./trailpack')
-exports.database = require('./database')

config/database.js

@@ -1,3 +1,4 @@
+/* eslint no-console: [0] */
 'use strict'
 
 const Trailpack = require('trailpack/datastore')
@@ -15,7 +16,7 @@ module.exports = class SequelizeTrailpack extends Trailpack {
       this.app.config.log.logger.warn('No store configured at config.database.stores, models will be ignored')
     }
     return Promise.all([
-      lib.Validator.validateDatabaseConfig(this.app.config.database)
+      lib.Validator.validateStoresConfig(stores)
     ])
   }
 
@@ -36,40 +37,55 @@ module.exports = class SequelizeTrailpack extends Trailpack {
 
     this.orm = this.orm || {}
     this.app.orm = {}
-    this.connections = lib.Transformer.transformStores(this.app)
-    this.models = lib.Transformer.transformModels(this.app)
-
-    _.each(this.models, (model, modelName) => {
-      _.each(this.connections, (connection, name) => {
-        if (model.connection === name) {
-          const Model = connection.define(modelName, model.schema, model.config)
-
-          if (model.config) {
-            if (model.config.classMethods) {
-              for (const methodName in model.config.classMethods) {
-                Model[methodName] = model.config.classMethods[methodName]
-              }
-            }
+    this.connections = lib.Transformer.transformStoreConnections(this.app)
+    this.app.models = lib.Transformer.transformModels(this.app)
+
+    this.stores = _.mapValues(this.app.config.get('stores'), (store, storeName) => {
+      return {
+        models: _.pickBy(this.app.models, { store: storeName }),
+        connection: this.connections[storeName],
+        migrate: store.migrate || this.app.config.get('models.migrate')
+      }
+    })
 
-            if (model.config.instanceMethods) {
-              for (const methodName in model.config.instanceMethods) {
-                Model.prototype[methodName] = model.config.instanceMethods[methodName]
-              }
+    // Loop through store models and define them in Sequelize
+    _.each(this.stores, (store, storeName) => {
+      _.each(store.models, (model, modelName) => {
+        const Model = store.connection.define(modelName, model.schema, model.options)
+
+        if (model.options) {
+          if (model.options.classMethods) {
+            for (const methodName in model.options.classMethods) {
+              Model[methodName] = model.options.classMethods[methodName]
             }
           }
 
-          this.app.orm[model.globalId] = Model
+          if (model.options.instanceMethods) {
+            for (const methodName in model.options.instanceMethods) {
+              Model.prototype[methodName] = model.options.instanceMethods[methodName]
+            }
+          }
         }
+        this.app.orm[model.globalId] = Model
       })
     })
 
-    _.each(this.models, (model, modelName) => {
-      if (!this.app.orm[model.globalId]) return //ignore model if not configured
-
-      if (this.app.orm[model.globalId].associate)
-        this.app.orm[model.globalId].associate(this.app.orm)
+    // Loop through store models and associate
+    _.each(this.stores, (store, storeName) => {
+      // Run Associate on the Models
+      _.each(store.models, (model, modelName) => {
+        // ignore model if not configured
+        if (!this.app.orm[model.globalId]) {
+          return
+        }
+        // Associate models if method defined
+        if (this.app.orm[model.globalId].associate) {
+          this.app.orm[model.globalId].associate(this.app.orm)
+        }
 
-      this.orm[model.globalId.toLowerCase()] = this.app.orm[model.globalId]
+        // Reset the orm Model
+        this.orm[model.globalId.toLowerCase()] = this.app.orm[model.globalId]
+      })
     })
 
     return this.migrate()
@@ -80,9 +96,9 @@ module.exports = class SequelizeTrailpack extends Trailpack {
    */
   async unload() {
     return Promise.all(
-      _.map(this.connections, connection => {
+      _.map(this.stores, store => {
         return new Promise((resolve, reject) => {
-          connection.close()
+          store.connection.close()
           resolve()
         })
       })
@@ -91,18 +107,20 @@ module.exports = class SequelizeTrailpack extends Trailpack {
 
   async migrate() {
     const SchemaMigrationService = this.app.services.SchemaMigrationService
-    const migrate = this.app.config.get('database.models.migrate')
-
-    if (migrate === 'none') return
 
     return Promise.all(
-      _.map(this.connections, connection => {
-
-        if (migrate === 'drop') {
-          return SchemaMigrationService.dropDB(connection)
+      _.map(this.stores, store => {
+        if (store.migrate === 'drop') {
+          return SchemaMigrationService.dropDB(store.connection)
+        }
+        else if (store.migrate === 'alter') {
+          return SchemaMigrationService.alterDB(store.connection)
+        }
+        else if (store.migrate === 'none') {
+          return
         }
-        else if (migrate === 'alter') {
-          return SchemaMigrationService.alterDB(connection)
+        else {
+          return
         }
       })
     )

config/index.js

@@ -2,14 +2,9 @@
 const joi = require('joi')
 
 module.exports = {
-  databaseConfig: joi.object().keys({
-    orm: joi.string(),
-    models: joi.object().keys({
-      defaultStore: joi.string().required(),
-      migrate: joi.string()
-    }),
-    stores: joi.object()
-  }),
+  storesConfig: joi.object().keys({
+    orm: joi.string()
+  }).unknown(),
 
   models: joi.object().keys({
     autoPK: joi.boolean(),

index.js

@@ -5,16 +5,14 @@ const _ = require('lodash')
 const Sequelize = require('sequelize')
 
 module.exports = {
-
   /**
    * Augment the model definition with some sequelize-required properties
    */
   transformModels (app) {
 
-    const models = app.models
-    const dbConfig = app.config.database
+    // const models = app.models
 
-    return _.mapValues(models, (model, modelName) => {
+    return _.mapValues(app.models, (model, modelName) => {
       const config = model.constructor.config(app, Sequelize) || {}
       const schema = model.constructor.schema(app, Sequelize) || {}
 
@@ -26,16 +24,41 @@ module.exports = {
         config.options.tableName = modelName.toLowerCase()
       }
 
-      return {
-        identity: modelName.toLowerCase(),
-        globalId: modelName,
-        tableName: config.tableName || modelName.toLowerCase(),
-        connection: config.store || app.config.get('database.models.defaultStore'),
-        migrate: config.migrate || app.config.get('database.models.migrate'),
-        config: config.options,
-        schema: schema
-      }
-
+      Object.defineProperties(model, {
+        identity: {
+          value: modelName.toLowerCase(),
+          writable: false
+        },
+        Sequelize: {
+          value: Sequelize,
+          writable: true
+        },
+        globalId: {
+          value: modelName,
+          writable: false
+        },
+        tableName: {
+          value: config.tableName || modelName.toLowerCase(),
+          writable: false
+        },
+        store: {
+          value: config.store || app.config.get('models.defaultStore'),
+          writable: false
+        },
+        migrate: {
+          value: config.migrate || app.config.get('models.migrate'),
+          writable: false
+        },
+        options: {
+          value: config.options,
+          writable: true
+        },
+        schema: {
+          value: schema,
+          writable: true
+        }
+      })
+      return model
     })
   },
 
@@ -58,7 +81,7 @@ module.exports = {
 	 * @param {Object} stores
 	 * @return {Object}
 	 */
-  pickStores (stores) {
+  pickStoreConnections (stores) {
     return _.pickBy(stores, (_store, name) => {
       return ((_store.dialect && _.isString(_store.dialect))
         || _.startsWith(_store.uri, 'mysql://')
@@ -71,8 +94,8 @@ module.exports = {
   /**
    * Transform the Trails.js "stores" config into a Sequelize object
    */
-  transformStores (app) {
-    const stores = this.pickStores(app.config.get('database.stores'))
+  transformStoreConnections (app) {
+    const stores = this.pickStoreConnections(app.config.get('stores'))
     const sequelize = {}
     Object.keys(stores).forEach(key => {
       sequelize[key] = this.createFromConfig(stores[key])

lib/schemas.js

@@ -2,9 +2,9 @@ const joi = require('joi')
 const lib = require('.')
 
 module.exports = {
-  validateDatabaseConfig (config) {
+  validateStoresConfig (config) {
     return new Promise((resolve, reject) => {
-      joi.validate(config, lib.Schemas.databaseConfig, (err, value) => {
+      joi.validate(config, lib.Schemas.storesConfig, (err, value) => {
         if (err) return reject(err)
 
         return resolve(value)