@vulkano/core 0.1.0 → 0.5.0

package/.nvmrc

@@ -1 +1 @@
-v18
+v20

package/bootstrap/server.js

@@ -24,8 +24,10 @@ const AllControllers = require('include-all')({
   filter: /(.+Controller)\.js$/,
   optional: true
 });
+
 const responses = require('./responses');
-const JWT = require(`${CORE_PATH}/libs/Jwt`);
+
+const JWT = require('../libs/Jwt');
 
 module.exports = {
 

package/bootstrap/services.js

@@ -23,7 +23,6 @@ const appLibs = require('include-all')({
   optional: true
 });
 
-
 const allServices = {
   ...coreLibs,
   ...appServices,

package/database/models.js

@@ -79,7 +79,6 @@ module.exports = function loadModelsApplication() {
       ...Callbacks,
       ...scaffold,
       ...custom,
-      ...ActiveRecord,
       ...Current
     };
 

package/init.js

@@ -17,27 +17,27 @@ global._ = _;
 global.Promise = Promise;
 
 if (!global.ABS_PATH) {
-  global.ABS_PATH = path.resolve(__dirname, '');
+  global.ABS_PATH = path.resolve(__dirname, './');
 }
 
 if (!global.APP_PATH) {
-  global.APP_PATH = path.join(__dirname, '../app');
+  global.APP_PATH = path.join(__dirname, './');
 }
 
 if (!global.PUBLIC_PATH) {
-  global.PUBLIC_PATH = path.join(__dirname, '../public');
+  global.PUBLIC_PATH = path.join(__dirname, './');
 }
 
-global.CORE_PATH = path.join(__dirname, '');
+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, '');
+  console.log('the global var APP_PATH or directory not found', APP_PATH);
+  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, '');
+  console.log('the global var PUBLIC_PATH or directory not found', PUBLIC_PATH);
+  global.PUBLIC_PATH = path.resolve(__dirname, './');
 }
 
 // Read Dontenv config
@@ -201,10 +201,11 @@ function startVulkano() {
       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, ' ');
+      const redisText = (redis && redis.enabled ? 'YES' : 'NO').padEnd(5, ' ');
 
       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}`);
+      serverConfig.push(` ENV: ${app.PRODUCTION ? colors.fg.red : colors.fg.green}${NODE_ENV}${colors.reset}`);
 
       console.log(serverConfig.join(''));
 
@@ -218,20 +219,16 @@ function startVulkano() {
       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(' 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}`);
+        dbConfig.push(' REDIS: ', `${colors.fg.green}${redisText}${colors.reset}`);
       } else {
-        dbConfig.push(' REDIS: ', `${colors.fg.green}NO    ${colors.reset}`);
+        dbConfig.push(' REDIS: ', `${colors.fg.green}${redisText}${colors.reset}`);
       }
 
       dbConfig.push(' | ');

package/libs/ApiClient.js

@@ -0,0 +1,160 @@
+const http = require('http');
+const https = require('https');
+const axios = require('axios');
+
+module.exports = {
+
+  /**
+   * Method to make a GET request
+   *
+   * @param {String} url
+   * @param {Object} props { headers }
+   * @returns {Promise}
+   */
+  get(url, props) {
+
+    return this.send({
+      url,
+      ...props,
+      method: 'GET'
+    });
+
+  },
+
+  /**
+   * Method to make a POST request
+   *
+   * @param {String} url
+   * @param {Object} body
+   * @param {Object} props { headers }
+   * @returns {Promise}
+   */
+  post(url, body, props) {
+
+    return this.send({
+      url,
+      body,
+      ...props,
+      method: 'POST'
+    });
+
+  },
+
+  /**
+   * Method to make a PUT request
+   *
+   * @param {String} url
+   * @param {Object} body
+   * @param {Object} props { headers }
+   * @returns {Promise}
+   */
+  put(url, body, props) {
+
+    return this.send({
+      url,
+      body,
+      ...props,
+      method: 'PUT'
+    });
+
+  },
+
+  /**
+   * Method to make a DELETE request
+   *
+   * @param {String} url
+   * @param {Object} body
+   * @param {Object} props { headers }
+   * @returns {Promise}
+   */
+  delete(url, props) {
+
+    return this.send({
+      url,
+      ...props,
+      method: 'DELETE'
+    });
+
+  },
+
+  /**
+   * Method to send a request
+   *
+   * @param {Object} props
+   * @returns {Promise}
+   */
+  send(props) {
+
+    const {
+      url,
+      body,
+      method,
+      responseType,
+      headers
+    } = typeof props === 'string'
+      ? { path: props, method: 'get' }
+      : (props || {});
+
+    const optHeaders = {
+      'Content-Type': 'application/json',
+      Accept: 'application/json'
+    };
+
+    const options = {
+      url,
+      method: (method || 'GET').toLowerCase(),
+      headers: Object.assign(optHeaders, headers || {}),
+      httpAgent: new http.Agent({ keepAlive: true, rejectUnauthorized: false }),
+      httpsAgent: new https.Agent({ keepAlive: true, rejectUnauthorized: false }),
+      responseType: responseType || 'json'
+    };
+
+    if (body) {
+      // convert body into just one line of json.
+      options.data = JSON.parse(JSON.stringify(body || {}));
+    }
+
+    return axios(options)
+      .then( (response) => {
+
+        const {
+          data
+        } = response;
+
+        return data || {};
+
+      })
+      .catch( (err) => {
+
+        const {
+          response
+        } = err || {};
+
+        const {
+          data: errorData,
+          status: statusCode
+        } = response || {};
+
+        const target = options.baseURL ? `${options.method} ${options.baseURL}/${options.url}` : `${options.method} ${options.url}`;
+
+        console.log('');
+        console.log('');
+        console.log('---------------------');
+        console.log('ApiClient', target);
+        console.log('---------------------');
+
+        const {
+          msg,
+          message: errorMessage,
+          error: errorMessage2
+        } = errorData || {};
+
+        const message = msg || errorMessage || errorMessage2 || 'Unable to connect to the Request Service';
+
+        return VSError.reject(message, statusCode || 500);
+
+      });
+
+  }
+
+};

package/libs/Paginate.js

@@ -0,0 +1,276 @@
+const _ = require('underscore');
+
+module.exports = {
+
+  serializeQuery(_props, _query) {
+
+    const props = typeof _props === 'object'
+      ? _props
+      : { sort: null, search: [] };
+
+    const query = _query || {};
+
+    const page = query.page || 1;
+    const perPage = Number(query.per_page) || Number(query.perPage) || 30;
+    const fields = query.fields || props.fields || [];
+    const sort = query.sort || props.sort || null;
+    const search = query.search || props.search || null;
+    const searchType = (query.searchType || '').toLowerCase().replace('-', '');
+
+    const result = _.omit({
+      page,
+      perPage,
+      fields,
+      sort,
+      search
+    }, (value) => !value );
+
+    // Filter by search
+    const searchBy = props.searchBy || [];
+
+    const itemsToSearch = [];
+
+    if (search && Array.isArray(searchBy) && searchBy.length > 0 ) {
+
+      searchBy.forEach( (item) => {
+
+        let type = String;
+
+        if (typeof item === 'object') {
+          type = item?.type || String;
+        }
+
+        const row = {};
+
+        if (type === String) {
+
+          if (searchType === 'startwith' || searchType === 'start') {
+            row[item] = new RegExp(['^', Utils.accentToRegex(search), '*.'].join(''), 'i');
+          } else if (searchType === 'endwith' || searchType === 'end') {
+            row[item] = new RegExp(['.*', Utils.accentToRegex(search)].join(''), 'i');
+          } else {
+            row[item] = new RegExp(['.*', Utils.accentToRegex(search), '*.'].join(''), 'i');
+          }
+
+        } else if (type === Number) {
+
+          row[item] = search;
+
+        }
+
+        itemsToSearch.push(row);
+
+      });
+
+    }
+
+    if (props.filterByOr) {
+      if (Array.isArray(props.filterByOr)) {
+        props.filterByOr.forEach( (i) => {
+          itemsToSearch.push(i);
+        });
+      } else {
+        itemsToSearch.push(props.filterByOr);
+      }
+    }
+
+    let newSearch = {};
+
+    const currentFilters = {
+      ...(props.filter || {})
+    };
+
+    const hasFilters = Object.keys( props.filter || {} ).length > 0 ? true : false;
+    const hasItems = itemsToSearch.length > 0 ? true : false;
+
+    if (hasItems && hasFilters) {
+
+      newSearch.$and = [];
+
+      // AND
+      newSearch.$and.push(currentFilters);
+
+      // OR
+      newSearch.$and.push({ $or: itemsToSearch });
+
+    } else if (hasItems && !hasFilters) {
+
+      newSearch.$or = itemsToSearch;
+
+    } else if (!hasItems && hasFilters) {
+
+      newSearch = { ...currentFilters };
+
+    }
+
+    return {
+      ...result,
+      search: newSearch
+    };
+
+  },
+
+  getPopulatedCollections(populate) {
+
+    const optPopulate = [];
+
+    if (populate.length > 0) {
+
+      populate.forEach( (item) => {
+
+        const {
+          virtual,
+          collection,
+          path,
+          model
+        } = item;
+
+        let populateProps = null;
+
+        if (virtual) {
+          populateProps = virtual;
+        } else {
+
+          populateProps = {
+            path: collection || path || model
+          };
+
+          if (item.fields) {
+            populateProps.select = item.fields;
+          } else if (item.select) {
+            populateProps.select = item.select;
+          }
+
+          if (item.match) {
+            populateProps.match = item.match;
+          }
+
+          if (item.populate) {
+            populateProps.populate = item.populate;
+          }
+
+        }
+
+        optPopulate.push(populateProps);
+
+      });
+
+    }
+
+    return optPopulate;
+
+  },
+
+  // Convert records to paginate
+  get(Model, query, hasPopulate) {
+
+    const populate = hasPopulate || [];
+
+    let criteria = query || {};
+
+    // Setup
+    const page = criteria.page === 'all' ? 'all' : ( parseInt(criteria.page, 10) || 1);
+    const perPage = +criteria.per_page || +criteria.perPage || 50;
+
+    delete criteria.page;
+    delete criteria.per_page;
+    delete criteria.perPage; // Fallback
+
+    const fields = [];
+    if (Array.isArray(criteria.fields)) {
+      criteria.fields.forEach( (f) => {
+        fields.push(f);
+      });
+    } else if (typeof criteria.fields === 'string') {
+      const tmpFields = (criteria.fields) ? criteria.fields.split(',') : [];
+      tmpFields.forEach( (f) => {
+        fields.push(f);
+      });
+    }
+    delete criteria.fields;
+
+    const tmpSort = (criteria.sort || '').split(',');
+    const sort = { sort: {} };
+    tmpSort.forEach( (_part) => {
+      const part = (_part || '').split('|');
+      if (part.length > 1) {
+        const desc = part[1].trim().toLowerCase() === 'descending' ? 'desc' : '';
+        const asc = part[1].trim().toLowerCase() === 'ascending' ? 'asc' : '';
+        sort.sort[part[0].trim()] = asc || desc || part[1].trim().toLowerCase();
+      }
+    });
+
+    delete criteria.sort;
+
+    if (criteria.search) {
+      criteria = _.extend(criteria, criteria.search);
+      delete criteria.search;
+    }
+
+    const optPopulate = this.getPopulatedCollections(populate || []);
+    const queryModel = _.extend(criteria, {});
+
+    if (page === 'all') {
+
+      const optsModel = _.extend(sort, { populate: optPopulate });
+      return Model.find(queryModel, fields.join(' '), optsModel);
+
+    }
+
+    return Model
+      .countDocuments(criteria)
+      .then( (total) => {
+
+        const opts = {
+          page,
+          limit: perPage
+        };
+
+        if (fields.length > 0) {
+          opts.select = fields.join(' ');
+        }
+
+        opts.populate = optPopulate;
+
+        const optsModel = _.extend(opts, sort);
+
+        return Model
+          .paginate(queryModel, optsModel)
+          .then( (data) => this._set(total, data.docs, page, perPage) );
+
+      });
+
+  },
+
+  _set(total, items, _page, _perPage) {
+
+    const page = _page || 1;
+    const perPage = _perPage || 30;
+
+    let cursor = (page > 1) ? ((page * perPage) - (perPage - 1)) : 1;
+
+    const tmpNext = (((perPage * (page - 1)) + perPage) <= total);
+    const next = tmpNext ? (page + 1) : false;
+    let prev = (page > 1) ? (page - 1) : false;
+    const totalPages = Math.ceil(total / perPage);
+
+    if ( (totalPages < page) && (total > 0) ) {
+      prev = false;
+    }
+
+    cursor = (total >= cursor) ? cursor : 1;
+
+    return {
+      items,
+      cursor,
+      page,
+      perPage,
+      next,
+      prev,
+      totalPages,
+      totalItems: total
+    };
+
+  }
+
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vulkano/core",
-  "version": "0.1.0",
+  "version": "0.5.0",
   "description": "A MVC framework using Express 4",
   "license": "MIT",
   "author": "Vulkano Team",
@@ -15,7 +15,7 @@
   "homepage": "https://github.com/vulkanojs/vulkano-core",
   "repository": {
     "type": "git",
-    "url": "git+https://github.com/vulkanojs/vulkano-core"
+    "url": "git+https://github.com/vulkanojs/vulkano-core.git"
   },
   "keywords": [
     "vulkano",
@@ -29,6 +29,7 @@
   },
   "dependencies": {
     "@socket.io/redis-adapter": "^8.3.0",
+    "axios": "^1.6.8",
     "bluebird": "^3.7.2",
     "body-parser": "^1.20.2",
     "compression": "^1.7.4",
@@ -49,7 +50,7 @@
     "jwt-simple": "^0.5.6",
     "moment": "^2.30.1",
     "moment-timezone": "^0.5.45",
-    "mongoose": "^8.2.4",
+    "mongoose": "^7.4.0",
     "mongoose-paginate": "^5.0.3",
     "morgan": "^1.10.0",
     "multer": "^1.4.5-lts.1",
@@ -63,5 +64,20 @@
     "underscore": "^1.13.6",
     "webp-middleware": "^0.4.0",
     "yargs": "^17.7.2"
+  },
+  "devDependencies": {
+    "@babel/core": "^7.24.3",
+    "@babel/eslint-parser": "^7.24.1",
+    "@babel/plugin-syntax-dynamic-import": "^7.8.3",
+    "@babel/plugin-syntax-jsx": "^7.24.1",
+    "@babel/preset-env": "^7.24.3",
+    "@babel/preset-react": "^7.24.1",
+    "@babel/preset-stage-1": "^7.8.3",
+    "eslint": "^8.57.0",
+    "eslint-config-airbnb": "^19.0.4",
+    "eslint-plugin-import": "^2.29.1",
+    "eslint-plugin-jsx-a11y": "^6.8.0",
+    "eslint-plugin-react": "^7.34.1",
+    "eslint-plugin-react-hooks": "^4.6.0"
   }
 }