@vulkano/core 0.1.0

package/controllers/ScaffoldController.js

@@ -0,0 +1,108 @@
+module.exports = (modelName) => {
+
+  const {
+    config
+  } = app;
+
+  const {
+    settings
+  } = config;
+
+  const {
+    database
+  } = settings;
+
+  const {
+    connection
+  } = database || {};
+
+  if (!connection && !process.env.MONGO_URI) {
+    return {};
+  }
+
+  if (!modelName) {
+    console.log(`Invalid Model name ${modelName} to the Scaffold Controller`);
+    return {};
+  }
+
+  const {
+    create,
+    update
+  } = global[modelName] || {};
+
+  const getAllModelName = `getAll${modelName}`;
+  const getModelName = `get${modelName}`;
+
+  if (!create || !update) {
+
+    const invalid = [];
+
+    if (!create) {
+      invalid.push('create');
+    }
+
+    if (!update) {
+      invalid.push('update');
+    }
+
+    console.log(`Invalid Model method(s) ${invalid.join(', ')} to the model ${modelName} to the Scaffold Controller. Please verify the connection and try again.`);
+
+    return {};
+
+  }
+
+  return {
+
+    get(req, res) {
+
+      res.vsr(global[modelName][getAllModelName](req.query || {}));
+
+    },
+
+    'get :id': function onGetRecord(req, res) {
+
+      const {
+        id
+      } = req.params || {};
+
+      res.vsr(global[modelName][getModelName](id) );
+
+    },
+
+    post: function onCreateRecord(req, res) {
+
+      const {
+        body
+      } = req || {};
+
+      res.vsr(global[modelName].create(body), 201);
+
+    },
+
+    'put :id': function onPutRecord(req, res) {
+
+      const {
+        id
+      } = req.params || {};
+
+      const {
+        body
+      } = req || {};
+
+      res.vsr(global[modelName].update(id, body), 202);
+
+    },
+
+    'delete :id': function onDeleteRecord(req, res) {
+
+      const {
+        id
+      } = req.params || {};
+
+      res.vsr(global[modelName].delete(id), 204);
+
+    }
+
+  };
+
+};

package/controllers/controllers.js

@@ -0,0 +1,149 @@
+/**
+ * Controllers
+ */
+
+// Include all api controllers
+const AllControllers = require('include-all')({
+  dirname: `${APP_PATH}/controllers`,
+  filter: /(.+Controller)\.js$/,
+  optional: true
+});
+
+const scaffoldController = require('./ScaffoldController');
+
+module.exports = function loadControllersApplication() {
+
+  const routes = {};
+
+  Object.keys(AllControllers).forEach( (controller) => {
+
+    const methods = ['get', 'post', 'put', 'delete'];
+    const current = AllControllers[controller];
+
+    const {
+      scaffold,
+      model
+    } = current;
+
+    if (scaffold && model) {
+
+      const scaffoldingCurrent = scaffoldController(model);
+
+      Object.keys(scaffoldingCurrent).forEach( (m) => {
+
+        if (!current[m]) {
+          current[m] = scaffoldingCurrent[m];
+        }
+
+      });
+
+    }
+
+    let controllerName = controller.replace('Controller', '').toLowerCase();
+
+    let parts = [];
+    let method = 'get';
+    let pathToRun = '';
+    let moduleName = '';
+
+    Object.keys(current || []).forEach( (route) => {
+
+      // Is a submodule (like api/TestController)
+      if (route.split('Controller').length > 1) {
+
+        moduleName = controllerName;
+        const submodules = AllControllers[moduleName];
+
+        Object.keys(submodules || []).forEach( (subcontroller) => {
+
+          controllerName = subcontroller.replace('Controller', '').toLowerCase();
+          const subcurrent = submodules[subcontroller];
+
+          const {
+            scaffold: subcurrentScaffold,
+            model: subcurrentModel
+          } = subcurrent || {};
+
+          if (subcurrentScaffold && subcurrentModel) {
+
+            const scaffoldingSubcurrent = scaffoldController(subcurrentModel);
+
+            Object.keys(scaffoldingSubcurrent).forEach( (m) => {
+
+              if (!subcurrent[m]) {
+                subcurrent[m] = scaffoldingSubcurrent[m];
+              }
+
+            });
+
+          }
+
+          Object.keys(subcurrent || []).forEach( (subroute) => {
+
+            parts = subroute.split(' ');
+
+            const [tmpMethod, tmpPath] = parts;
+
+            if (tmpPath) {
+              method = tmpMethod.toLowerCase();
+              pathToRun = tmpPath;
+            } else {
+              pathToRun = tmpMethod;
+            }
+
+            const isAbsolute = (pathToRun.substring(0, 1) === '/') ? true : false;
+
+            if (!isAbsolute) {
+
+              if (methods.indexOf(pathToRun.toLowerCase()) >= 0) {
+                method = pathToRun.toLowerCase();
+                pathToRun = `/${moduleName}/${controllerName}/`;
+              } else {
+                pathToRun = `/${moduleName}/${controllerName}/${pathToRun.replace(/GET|POST|DELETE|PUT/i, '')}`;
+              }
+
+            }
+
+            if (typeof subcurrent[subroute] === 'function') {
+              routes[`${method} ${pathToRun}`] = subcurrent[subroute];
+            }
+
+          });
+        });
+
+      } else {
+
+        parts = route.split(' ');
+        const [tmpMethod, tmpPath] = parts;
+
+        if (tmpPath) {
+          method = tmpMethod.toLowerCase();
+          pathToRun = tmpPath;
+        } else {
+          pathToRun = tmpMethod;
+        }
+
+        const isAbsolute = (pathToRun.substring(0, 1) === '/') ? true : false;
+
+        if (!isAbsolute) {
+          if (methods.indexOf(pathToRun.toLowerCase()) >= 0) {
+            method = pathToRun.toLowerCase();
+            pathToRun = `/${controllerName}/`;
+          } else {
+            pathToRun = `/${controllerName}/${pathToRun.replace(/GET|POST|DELETE|PUT/i, '')}`;
+          }
+        }
+
+        if (typeof current[route] === 'function') {
+          routes[`${method} ${pathToRun}`] = current[route];
+        }
+
+      }
+
+    });
+
+  });
+
+  return routes;
+
+};

package/database/models.js

@@ -0,0 +1,90 @@
+/**
+ * Models
+ */
+
+// Include all app models
+const AllModels = require('include-all')({
+  dirname: `${APP_PATH}/models`,
+  filter: /(.+)\.js$/,
+  excludeDirs: /^\.(git|svn)$/,
+  optional: true
+});
+
+const scaffold = require('./scaffold');
+
+const Callbacks = {
+
+  beforeSave: (next) => {
+    next();
+  },
+
+  beforeUpdate: (next) => {
+    next();
+  },
+
+  beforeRemove: (next) => {
+    next();
+  },
+
+  beforeValidate: (next) => {
+    next();
+  },
+
+  afterSave: () => {
+
+  },
+
+  afterUpdate: () => {
+
+  },
+
+  afterRemove: () => {
+
+  },
+
+  afterValidate: () => {
+
+  },
+
+  beforeFindOneAndUpdate: (next) => {
+    next();
+  }
+
+};
+
+module.exports = function loadModelsApplication() {
+
+  const models = {};
+
+  Object.keys(AllModels).forEach((i) => {
+
+    const Current = AllModels[i];
+
+    const getAll = `getAll${i}`;
+    const getModelName = `get${i}`;
+
+    const custom = {
+
+      [getAll](props) {
+        return global[i].getAll(props);
+      },
+
+      [getModelName](id) {
+        return global[i].getByField(id);
+      }
+
+    };
+
+    models[i] = {
+      ...Callbacks,
+      ...scaffold,
+      ...custom,
+      ...ActiveRecord,
+      ...Current
+    };
+
+  });
+
+  return models;
+
+};

package/database/mongodb.js

@@ -0,0 +1,232 @@
+/**
+ * Database connection
+ */
+
+const Promise = require('bluebird');
+const paginate = require('mongoose-paginate');
+const merge = require('deepmerge');
+
+const mongoose = require('mongoose');
+
+mongoose.Promise = Promise;
+
+global.mongoose = mongoose;
+global.Virtual = 'Virtual';
+global.Mixed = mongoose.Schema.Types.Mixed;
+
+const AllModels = require('./models')();
+
+module.exports = function loadDatabaseApplication() {
+
+  const {
+    config
+  } = app;
+
+  const {
+    connections,
+    settings
+  } = config || {};
+
+  const {
+    database
+  } = settings || {};
+
+  const {
+    connection,
+    settings: dbSettings
+  } = database || {};
+
+  if (!connection) {
+    return;
+  }
+
+  const toConnect = connection in connections
+    ? connections[connection]
+    : (connection || null);
+
+  if (!toConnect) {
+    throw `Invalid conection to user MongoDB with source ${connection}`;
+  }
+
+  const defaultProps = {
+    useNewUrlParser: true,
+    useUnifiedTopology: true,
+    family: 4
+  };
+
+  const connectionProps = merge.all([
+    defaultProps,
+    (database ? database.config || {} : {})
+  ]);
+
+  if (dbSettings) {
+    Object.keys(dbSettings).forEach( (s) => {
+      mongoose.set(s, dbSettings[s]);
+    });
+  }
+
+  if (!mongoose.connection.readyState) {
+    mongoose.connect(toConnect, connectionProps);
+  }
+
+  const db = mongoose.connection;
+
+  // Each Model
+  Object.keys(AllModels).forEach((model) => {
+
+    const current = AllModels[model];
+    if (!current.attributes) {
+      global[model] = current;
+    } else {
+
+      // Allow trim all attributes
+      const attributes = {};
+      const virtuals = {};
+
+      Object.keys(current.attributes).forEach( (attr) => {
+
+        const currentAttr = current.attributes[attr];
+        const type = currentAttr.type || '';
+
+        if ( type !== Boolean) {
+          if (currentAttr.trim !== false) {
+            currentAttr.trim = true;
+          }
+        }
+
+        if ( String(type).toLowerCase() === 'virtual' ) {
+          virtuals[attr] = currentAttr;
+          delete attributes[attr];
+        } else {
+          attributes[attr] = currentAttr;
+        }
+
+      });
+
+      if (!attributes.active) {
+        attributes.active = {
+          type: Boolean,
+          default: true
+        };
+      }
+
+      if (!attributes.createdAt) {
+        attributes.createdAt = {
+          type: Date,
+          default: Date.now
+        };
+      }
+
+      if (!attributes.updatedAt) {
+        attributes.updatedAt = {
+          type: Date
+        };
+      }
+
+      const schema = mongoose.Schema(attributes);
+
+      Object.keys(virtuals).forEach( (v) => {
+
+        const currentVirtual = virtuals[v];
+
+        const {
+          get: getVirtual
+        } = currentVirtual || {};
+
+        if (getVirtual) {
+          schema.virtual(v, currentVirtual).get(getVirtual);
+        } else {
+          schema.virtual(v, currentVirtual);
+        }
+
+      });
+
+      schema.set('toObject', { virtuals: true, getters: true, setters: true });
+      schema.set('toJSON', { virtuals: true, getters: true, setters: true });
+
+      delete current.attributes;
+      schema.statics = { ...current };
+      schema.plugin(paginate);
+
+      // Indexes
+      if (current.indexes !== undefined) {
+        if (Array.isArray(current.indexes)) {
+          const tmp = current.indexes;
+          Object.keys(tmp).forEach( (index) => schema.index(tmp[index]));
+        } else if (typeof current.indexes === 'object') {
+          schema.index(current.indexes);
+        }
+      }
+
+      // Plugins
+      if (current.plugins !== undefined) {
+        if (Array.isArray(current.plugins)) {
+          const tmp = current.plugins;
+          Object.keys(tmp).forEach( (plugin) => schema.plugin(tmp[plugin]));
+        } else if (typeof current.plugins === 'object') {
+          schema.plugin(current.plugins);
+        }
+      }
+
+      //
+      // Callbacks
+      //
+
+      // Save
+      if (current.beforeSave) {
+        schema.pre('save', current.beforeSave);
+        delete schema.statics.beforeSave;
+      }
+      if (current.afterSave) {
+        schema.post('save', current.afterSave);
+        delete schema.statics.afterSave;
+      }
+
+      // Update
+      if (current.beforeUpdate) {
+        schema.pre('update', current.beforeUpdate);
+        delete schema.statics.beforeUpdate;
+      }
+      if (current.afterUpdate) {
+        schema.post('update', current.afterUpdate);
+        delete schema.statics.afterUpdate;
+      }
+
+      // findOneAndUpdate
+      if (current.beforeFindOneAndUpdate) {
+        schema.pre('findOneAndUpdate', current.beforeFindOneAndUpdate);
+        delete schema.statics.beforeFindOneAndUpdate;
+      }
+      if (current.afterFindOneAndUpdate) {
+        schema.post('findOneAndUpdate', current.afterFindOneAndUpdate);
+        delete schema.statics.afterFindOneAndUpdate;
+      }
+
+      // Remove
+      if (current.beforeRemove) {
+        schema.pre('remove', current.beforeRemove);
+        delete schema.statics.beforeRemove;
+      }
+      if (current.afterRemove) {
+        schema.post('remove', current.afterRemove);
+        delete schema.statics.afterRemove;
+      }
+
+      // Validation
+      if (current.beforeValidate) {
+        schema.pre('validate', current.beforeValidate);
+        delete schema.statics.beforeValidate;
+      }
+      if (current.afterValidate) {
+        schema.post('validate', current.afterValidate);
+        delete schema.statics.afterValidate;
+      }
+
+      global[model] = db.model(model, schema, model.toLowerCase());
+      global[model].attributes = attributes;
+
+    }
+
+  });
+
+};

package/database/scaffold.js

@@ -0,0 +1,118 @@
+module.exports = {
+
+  /**
+   * Method to get all records by page
+   *
+   * @param {Object} props (page, perPage, search, sort)
+   * @returns {Promise}
+   */
+  getAll(props) {
+
+    // Props to Query
+    const defaultProps = {
+      sort: 'createdAt|DESC',
+      searchBy: [],
+      filter: {
+        active: true
+      },
+    };
+
+    // Query to Run
+    const query = Paginate.serializeQuery(defaultProps, props);
+
+    // Pagination
+    return Paginate.get(this, query);
+
+  },
+
+  /**
+   * Method to get a record by id
+   *
+   * @param {ObjectID} id
+   * @returns {Promise}
+   */
+  getByField(value, field) {
+
+    // This is to prevent error while run the findOne
+    if (!(/^[a-fA-F0-9]{24}$/).test(value) && !field) {
+      return VSError.reject('Invalid ID. Record not found.', 404);
+    }
+
+    const toSearch = { active: true };
+    toSearch[field || '_id'] = value;
+
+    return this.findOne(toSearch)
+      .then( (r) => {
+
+        if (!r) {
+          return VSError.notFound();
+        }
+
+        return r.toObject({ transform: true });
+
+      });
+
+  },
+
+  /**
+   * Method to create a new record
+   * @param {Promise} data
+   */
+  create(data) {
+
+    const obj = new this(data);
+
+    if (obj._id) {
+      delete obj._id;
+    }
+
+    return obj.save();
+
+  },
+
+  /**
+   * Method to update a record
+   * @param {ObjectID} id
+   * @param {Object} data
+   * @returns {Promise}
+   */
+  update(_id, data) {
+
+    return this.getByField(_id)
+      .then( (record) => {
+
+        // Merge current info with incoming values
+        const merged = {
+          ...record,
+          ...data,
+          updatedAt: Date.now()
+        };
+
+        return this.findOneAndUpdate({ _id }, merged, { new: true })
+          .then( (r) => {
+
+            const tmp = r.toObject({ transform: true });
+            return tmp;
+
+          });
+
+      });
+
+  },
+
+  /**
+   * Method to delete a record
+   * @param {ObjectID} id
+   * @returns {Promise}
+   */
+  delete(id) {
+
+    // Scaffold Model
+    // const Model = global[modelName];
+
+    // Soft delete
+    return this.update(id, { active: false });
+
+  }
+
+};