@vulkano/core 0.1.0

package/init.js

@@ -0,0 +1,254 @@
+/**
+ * Bootstrap.js
+ *
+ */
+
+const dotenv = require('dotenv');
+const path = require('path');
+const moment = require('moment');
+const merge = require('deepmerge');
+const _ = require('underscore');
+const Promise = require('bluebird');
+const v8 = require('v8');
+const fs = require('fs');
+
+global.app = {};
+global._ = _;
+global.Promise = Promise;
+
+if (!global.ABS_PATH) {
+  global.ABS_PATH = path.resolve(__dirname, '');
+}
+
+if (!global.APP_PATH) {
+  global.APP_PATH = path.join(__dirname, '../app');
+}
+
+if (!global.PUBLIC_PATH) {
+  global.PUBLIC_PATH = path.join(__dirname, '../public');
+}
+
+global.CORE_PATH = path.join(__dirname, '');
+
+if (!fs.existsSync(APP_PATH)) {
+  console.log('the global var APP_PATH or directory not found');
+  global.APP_PATH = path.resolve(__dirname, '');
+}
+
+if (!fs.existsSync(PUBLIC_PATH)) {
+  console.log('the global var PUBLIC_PATH or directory not found');
+  global.PUBLIC_PATH = path.resolve(__dirname, '');
+}
+
+// Read Dontenv config
+dotenv.config();
+
+// Include all api config
+const config = require('include-all')({
+  dirname: `${APP_PATH}/config`,
+  filter: /(.+)\.js$/,
+  optional: true
+});
+
+// Get package.json information
+const pkg = require(`${CORE_PATH}/package.json`);
+const appPkg = require(`${ABS_PATH}/package.json`);
+
+// Environment
+const NODE_ENV = (process.env.NODE_ENV || 'development').toLowerCase();
+
+app.PRODUCTION = NODE_ENV === 'production' ? true : false;
+
+const {
+  views,
+  local,
+  env
+} = config || {};
+
+// NODE_ENV
+const environmentConfig = env ? env[NODE_ENV] || {} : {};
+
+// Merge Settings
+const settings = {
+  ...config.settings,
+  views: views?.config || ''
+};
+
+// All config merged (default, NODE_ENV (folder env), local.js file)
+const allConfig = merge.all([
+  // General Config
+  config || {},
+
+  // Settings Config
+  { settings },
+
+  // Environment Config
+  environmentConfig,
+
+  // Local Config
+  local || {}
+]);
+
+delete allConfig.env;
+delete allConfig.local;
+
+// General Settings
+app.config = allConfig;
+
+// Package Config
+app.pkg = pkg;
+
+// Include all components
+require('./bootstrap/services')();
+require('./database/mongodb')();
+
+const controllers = require('./controllers/controllers')();
+const server = require('./bootstrap/server');
+
+const colors = {
+  reset: '\x1b[0m',
+  bright: '\x1b[1m',
+  dim: '\x1b[2m',
+  underscore: '\x1b[4m',
+  blink: '\x1b[5m',
+  reverse: '\x1b[7m',
+  hidden: '\x1b[8m',
+  fg: {
+    black: '\x1b[30m',
+    red: '\x1b[31m',
+    green: '\x1b[32m',
+    yellow: '\x1b[33m',
+    blue: '\x1b[34m',
+    magenta: '\x1b[35m',
+    cyan: '\x1b[36m',
+    white: '\x1b[37m',
+    crimson: '\x1b[38m' // Scarlet
+  },
+  bg: {
+    black: '\x1b[40m',
+    red: '\x1b[41m',
+    green: '\x1b[42m',
+    yellow: '\x1b[43m',
+    blue: '\x1b[44m',
+    magenta: '\x1b[45m',
+    cyan: '\x1b[46m',
+    white: '\x1b[47m',
+    crimson: '\x1b[48m'
+  }
+};
+
+function startVulkano() {
+
+  console.log('');
+  console.log('');
+  console.log(`${colors.fg.magenta}------------------------------------------`, colors.reset);
+  console.log('');
+  console.log(colors.fg.cyan, '              🌋', colors.reset);
+  console.log(colors.fg.cyan, `       APP VERSION ${appPkg.version}`, colors.reset);
+  console.log(colors.fg.cyan, `         VULKANO ${pkg.version}`, colors.reset);
+  console.log('');
+  console.log(colors.fg.blue, '🔗 https://github.com/vulkanojs/vulkano', colors.reset);
+  console.log(colors.fg.cyan, '☕ https://buymeacoffee.com/argordmel', colors.reset);
+  console.log('');
+  console.log(`${colors.fg.magenta}------------------------------------------`, colors.reset);
+
+  // Routes
+  app.routes = controllers;
+
+  // Server Config
+  app.server = {
+    ...server,
+    ...app.config.settings
+  };
+
+  // Server Routes
+  app.server.routes = {
+    ...app.config.routes
+  };
+
+  const {
+    bootstrap
+  } = config;
+
+  if (!bootstrap || typeof bootstrap !== 'function') {
+    console.log('Missing the boostrap file to start app: app/config/bootstrap.js');
+    return;
+  }
+
+  bootstrap( (callbackAfterInitVulkano) => {
+
+    // Start Express
+    app.server.start( () => {
+
+      const {
+        sockets,
+        settings: configSettings,
+        redis
+      } = app.config || {};
+
+      const {
+        database
+      } = configSettings || {};
+
+      const {
+        connection
+      } = database || {};
+
+      const connectionToShow = connection && process.env.MONGO_URI ? 'MONGO_URI' : connection;
+
+      const serverConfig = [];
+
+      const nodeVersion = process.version.match(/^v(\d+\.\d+\.\d+)/)[1];
+      const portText = String(app.server.get('port') || 8000).padEnd(nodeVersion.length, ' ');
+      const socketText = (sockets.enabled ? 'YES' : 'NO').padEnd(nodeVersion.length - 3, ' ');
+
+      serverConfig.push(` PORT: ${colors.fg.green}${portText}${colors.reset}`);
+      serverConfig.push(' | ');
+      serverConfig.push(` ENV: ${app.PRODUCTION ? colors.fg.red : colors.fg.green}${env}${colors.reset}`);
+
+      console.log(serverConfig.join(''));
+
+      const totalHeapSize = v8.getHeapStatistics().total_available_size;
+      const totalHeapSizeGb = (totalHeapSize / 1024 / 1024 / 1024).toFixed(2);
+
+      const nodeConfig = [];
+      nodeConfig.push(` NODE: ${colors.fg.green}${nodeVersion}${colors.reset}`);
+      nodeConfig.push(' | ');
+      nodeConfig.push(' MAX MEM: ', `${colors.fg.green}${totalHeapSizeGb} GB${colors.reset}`);
+      console.log(nodeConfig.join(''));
+
+      const startUpConfig = [];
+      if (sockets.redis && redis && redis.enabled) {
+        startUpConfig.push(' SOCKETS: ', `${colors.fg.green}${socketText}${colors.reset}`);
+      } else {
+        startUpConfig.push(' SOCKETS: ', `${colors.fg.green}${socketText}${colors.reset}`);
+      }
+      startUpConfig.push(' | ');
+      startUpConfig.push(` STARTUP: ${colors.fg.green}${moment(moment().diff(global.START_TIME)).format('ss.SSS')} sec${colors.reset}`);
+      console.log(startUpConfig.join(''));
+
+      const dbConfig = [];
+      if (redis && redis.enabled) {
+        dbConfig.push(' REDIS: ', `${colors.fg.green}YES   ${colors.reset}`);
+      } else {
+        dbConfig.push(' REDIS: ', `${colors.fg.green}NO    ${colors.reset}`);
+      }
+
+      dbConfig.push(' | ');
+      dbConfig.push(' DB: ', connection ? `${colors.fg.green}${connectionToShow}${colors.reset}` : `${colors.fg.blue}The connection is empty${colors.reset}`);
+      console.log(dbConfig.join(''));
+
+      console.log(`${colors.fg.magenta}--------------------------------------`, colors.reset);
+
+      // Run custom callback after init vulkano
+      if (callbackAfterInitVulkano && typeof callbackAfterInitVulkano === 'function') {
+        callbackAfterInitVulkano();
+      }
+
+    });
+
+  });
+
+};
+
+module.exports = startVulkano;

package/libs/Crontab.js

@@ -0,0 +1,19 @@
+const Cron = require('cron').CronJob;
+
+module.exports = {
+
+  schedule(start, task, end, timeZone) {
+
+    const config = {
+      cronTime: start,
+      onTick: task || ( () => {} ),
+      onComplete: end || ( () => {} ),
+      timeZone: timeZone || 'America/New_York',
+      start: true
+    };
+
+    return new Cron(config);
+
+  }
+
+};

package/libs/Encrypter.js

@@ -0,0 +1,45 @@
+const crypto = require('crypto');
+
+class Encrypter {
+
+  constructor(encryptionKey) {
+
+    this.algorithm = 'aes-256-cbc';
+    this.key = crypto.scryptSync(encryptionKey, 'salt', 32);
+
+  }
+
+  encrypt(clearText) {
+
+    const iv = crypto.randomBytes(16);
+    const cipher = crypto.createCipheriv(this.algorithm, this.key, iv);
+    const encrypted = cipher.update(clearText, 'utf8', 'hex');
+
+    return [
+      encrypted + cipher.final('hex'),
+      Buffer.from(iv).toString('hex'),
+    ].join('|');
+
+  }
+
+  dencrypt(encryptedText) {
+
+    const [encrypted, iv] = encryptedText.split('|');
+
+    if (!iv) {
+      throw new VSError('IV not found', 500);
+    }
+
+    const decipher = crypto.createDecipheriv(
+      this.algorithm,
+      this.key,
+      Buffer.from(iv, 'hex')
+    );
+
+    return decipher.update(encrypted, 'hex', 'utf8') + decipher.final('utf8');
+
+  }
+
+}
+
+module.exports = Encrypter;

package/libs/Filter.js

@@ -0,0 +1,55 @@
+/**
+ * Filter
+ *
+ * Filter.get(' custom string', 'trim');
+ * return 'custom
+ *
+ */
+const path = require('path');
+
+// Include all api controllers
+const coreFilters = require('include-all')({
+  dirname: path.join(CORE_PATH, '/libs/filters'),
+  filter: /(.+)\.js$/,
+  optional: true
+});
+
+const appFilters = require('include-all')({
+  dirname: path.join(APP_PATH, '/services/filters'),
+  filter: /(.+)\.js$/,
+  optional: true
+});
+
+const allFilters = { ...coreFilters, ...appFilters };
+
+module.exports = {
+
+  get(str, filters, opts) {
+
+    let result = null;
+
+    if (Array.isArray(filters)) {
+      filters.forEach((filter) => {
+        const f = Filter.load(filter);
+        result = (!f) ? '' : f.exec(str, opts);
+      });
+      return result;
+    }
+
+    const f = Filter.load(filters);
+    return (!f) ? '' : f.exec(str, opts);
+
+  },
+
+  load(filter) {
+
+    if (!allFilters[filter]) {
+      console.error('FILTER', filter, 'NOT FOUND INTO /app/services/filters');
+      return false;
+    }
+
+    return allFilters[filter];
+
+  }
+
+};

package/libs/Jwt.js

@@ -0,0 +1,220 @@
+const { expressjwt: JWT } = require('express-jwt');
+const jwtSimple = require('jwt-simple');
+const moment = require('moment');
+
+module.exports = {
+
+  /**
+   * Get JWT config
+   *
+   * @returns {Object}
+   */
+  getConfig() {
+
+    const {
+      jwt,
+      // Express config folder in app/confg/express
+      express
+    } = app.config || {};
+
+    const {
+      jwt: expressJwt,
+    } = express || {};
+
+    return jwt || expressJwt || {};
+
+  },
+
+  /**
+   * Init JWT for Express
+   *
+   * @param {Object} opts
+   * @returns
+   */
+  init(opts) {
+
+    const {
+      key,
+      algorithms
+    } = this.getConfig();
+
+    const config = {
+
+      algorithms: algorithms || ['HS256'],
+
+      secret: key,
+
+      getToken: (req) => this.getToken(req)
+
+    };
+
+    return JWT({ ...config, ...opts });
+
+  },
+
+  /**
+   * Get token from request
+   *
+   * @param {Express} req
+   * @returns {String}
+   */
+  getToken(req) {
+
+    const {
+      header,
+      queryParameter,
+      cookieName
+    } = this.getConfig();
+
+    // Get Token via HTTP header
+    const headerToken = req.headers[header] || req.headers[header.toUpperCase()] || null;
+
+    // Get Token via Cookie
+    const cookieToken = req.cookies && req.cookies[cookieName]
+      ? req.cookies[cookieName]
+      : null;
+
+    // Get Token via Query Parameter
+    const queryToken = req.query && req.query[queryParameter]
+      ? req.query[queryParameter]
+      : null;
+
+    // Current Token
+    const token = headerToken || cookieToken || queryToken || null;
+
+    // Decode Token
+    const hasData = this.decode(token);
+
+    // Return only if token is valid
+    return hasData ? token : null;
+
+  },
+
+  /**
+   * Encode token
+   *
+   * @param {String} data
+   * @returns {Object}
+   */
+  encode(data) {
+
+    const {
+      key
+    } = this.getConfig();
+
+    const Encrypt = new Encrypter(`${key}-JWT`);
+    const payload = Encrypt.encrypt(JSON.stringify({ data }));
+
+    return jwtSimple.encode(payload, key);
+
+  },
+
+  /**
+   * Decode token
+   *
+   * @param {String} token
+   * @param {String} customKey Optional Key
+   * @returns {Object}
+   */
+  decode(token, customKey) {
+
+    const {
+      key
+    } = this.getConfig();
+
+    let data = {};
+    try {
+
+      const payload = jwtSimple.decode(token, customKey || key);
+      data = this.decrypt(payload);
+
+    } catch (e) {
+      console.log('Invalid Token');
+    }
+
+    const {
+      expiration
+    } = data || {};
+
+    const now = moment().format('x');
+
+    // Token expired
+    if (expiration && ( Number(now) > Number(expiration) )) {
+      return null;
+    }
+
+    // Expiration must be required
+    if (!expiration) {
+      console.log('JWT Without expiration date');
+      return null;
+    }
+
+    return data;
+
+  },
+
+  /**
+   * Decryp Token
+   *
+   * @param {String} str
+   * @returns {String}
+   */
+  decrypt(str) {
+
+    const {
+      key
+    } = this.getConfig();
+
+    const Encrypt = new Encrypter(`${key}-JWT`);
+
+    let data = null;
+
+    try {
+
+      const r = JSON.parse(Encrypt.dencrypt(str));
+
+      const {
+        data: result
+      } = r || {};
+
+      data = result;
+
+    } catch (e) {
+      data = null;
+    }
+
+    return data;
+
+  },
+
+  /**
+   * Decode token from SocketIO
+   *
+   * @param {Socket} socket
+   * @returns {Object}
+   */
+  socket(socket) {
+
+    const {
+      token
+    } = socket.handshake.auth || {};
+
+    if (token === null || typeof token === 'undefined' || !token) {
+      return false;
+    }
+
+    const data = this.decode(token);
+
+    const {
+      _id
+    } = data || {};
+
+    if (!_id) {
+      return false;
+    }
+
+    return data;
+
+  }
+
+};

package/libs/VSError.js

@@ -0,0 +1,33 @@
+const Promise = require('bluebird');
+
+function VSError(msg, code, props) {
+
+  Error.captureStackTrace(this, this.constructor);
+
+  const {
+    stack
+  } = props || {};
+
+  this.message = msg;
+  this.statusCode = code || 500;
+  this.customProps = props || {};
+
+  if (app.PRODUCTION || stack === false ) {
+    delete this.stack;
+  }
+
+}
+
+// Not Found Object
+VSError.notFound = (n) => {
+  const name = n || 'Object';
+  return Promise.reject(new VSError(`${name} Not Found`, 404));
+};
+
+// Reject request
+VSError.reject = (text, status, props) => Promise.reject(new VSError(text, status, props));
+
+// Extending of native error object
+require('util').inherits(VSError, Error);
+
+module.exports = VSError;

package/libs/filters/ltrim.js

@@ -0,0 +1,24 @@
+/**
+ * Filter ltrim
+ *
+ * Filter.get('custom string', 'ltrim', 'cus');
+ * return 'tom string'
+ *
+ */
+module.exports = {
+
+  exec: (_str, opt) => {
+    let str = _str || '';
+    if (opt) {
+      while (str.charAt(0) === opt) {
+        str = str.substr(1, str.length - 1);
+      }
+    } else {
+      while (str.charAt(0) === ' ') {
+        str = str.substr(1, str.length - 1);
+      }
+    }
+    return str;
+  }
+
+};

package/libs/filters/number.js

@@ -0,0 +1,14 @@
+/**
+ * Filter number
+ *
+ * Filter.get('cu570m 5tr1ng', 'number');
+ * return '57051'
+ *
+ */
+module.exports = {
+
+  exec: (_str) => {
+    return String(_str || '').replace( /\D+/g, '');
+  }
+
+};

package/libs/filters/objectId.js

@@ -0,0 +1,14 @@
+/**
+ * Filter Object ID
+ *
+ * Filter.get('new ObjectId("aiuijdñjñ8987987")', 'objectId');
+ * return 'aiuijdñjñ8987987'
+ *
+ */
+module.exports = {
+
+  exec: (_id) => {
+    return String(_id || '').replace(/ObjectId\("(.*)"\)/, '$1');
+  }
+
+};

package/libs/filters/prefix.js

@@ -0,0 +1,22 @@
+/**
+ * Filter prefix
+ *
+ * Filter.get('custom string', 'prefix', '/');
+ * return '/custom string'
+ *
+ */
+module.exports = {
+
+  exec: (_str, opt) => {
+
+    const str = _str || '';
+
+    if (str.indexOf(opt) === 0) {
+      return str;
+    }
+
+    return opt + str;
+
+  }
+
+};