miolo 0.0.1

package/.babelrc.js

@@ -0,0 +1,12 @@
+const path = require('path')
+
+module.exports = {
+  presets: [
+    ["@babel/preset-env", {"targets": {"esmodules": true}}]
+  ],
+  plugins: [
+    [require.resolve('babel-plugin-module-resolver'), {
+      "root": [path.resolve('./')]
+    }]
+  ]
+}

package/.eslintignore

@@ -0,0 +1,3 @@
+**/build
+**/dist
+**/lib

package/.eslintrc.js

@@ -0,0 +1,50 @@
+module.exports = {
+  "root": true,
+  "parser": "@babel/eslint-parser",
+  "extends": ["eslint:recommended"],
+  "parserOptions": {
+    "ecmaVersion": 7,
+    "sourceType": "module",
+    "ecmaFeatures": {
+      "globalReturn ": true,
+      "impliedStrict": true,
+      "experimentalObjectRestSpread": true
+    }
+  },
+  "env": {
+    "browser": true,
+    "mocha": true,
+    "node": true,
+    "es6": true
+  },
+  "rules": {
+	"semi": 0,
+	"vars-on-top": 0,
+	"spaced-comment": 0,
+	"prefer-template": 0,
+	"consistent-return": 0,
+	"comma-dangle": 0,
+	"no-use-before-define": 0,
+	"no-return-assign": 0,
+	"no-case-declarations": 0,
+	"no-cond-assign": 0,
+	"no-console": 0,
+	"max-len": 0,
+	"arrow-body-style": 0,
+	"new-cap": 0,
+	"quotes": 0,
+	"quote-props": 0,
+	"prefer-arrow-callback": 0,
+	"func-names": 0,
+	"padded-blocks": 0,
+	"keyword-spacing": 0,
+	"no-var": 1,
+	"no-trailing-spaces": 0,
+	"no-unused-expressions": 0,
+	"no-unused-vars": [1, {"argsIgnorePattern": "^_", "varsIgnorePattern": "^_"}],
+	"no-inner-declarations": 0,
+	"space-before-function-paren": 0,
+	"global-require": 0,
+	"no-empty": 0
+  }
+}

package/lib/cacher/index.js

@@ -0,0 +1,98 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.init_cacher = init_cacher;
+
+var _redis = _interopRequireDefault(require("redis"));
+
+var _util = require("util");
+
+var _farrapaColors = require("farrapa-colors");
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+function asyncGeneratorStep(gen, resolve, reject, _next, _throw, key, arg) { try { var info = gen[key](arg); var value = info.value; } catch (error) { reject(error); return; } if (info.done) { resolve(value); } else { Promise.resolve(value).then(_next, _throw); } }
+
+function _asyncToGenerator(fn) { return function () { var self = this, args = arguments; return new Promise(function (resolve, reject) { var gen = fn.apply(self, args); function _next(value) { asyncGeneratorStep(gen, resolve, reject, _next, _throw, "next", value); } function _throw(err) { asyncGeneratorStep(gen, resolve, reject, _next, _throw, "throw", err); } _next(undefined); }); }; }
+
+function init_cacher(config) {
+  var client = _redis.default.createClient(config.redis.port, config.redis.host).on('connect', function () {
+    console.info("".concat((0, _farrapaColors.PURPLE)('REDIS'), " Connection established!"));
+  }).on('error', function (err) {
+    var msg;
+
+    try {
+      if (err instanceof _redis.default.ReplyError) msg = "".concat((0, _farrapaColors.PURPLE)('REDIS'), " ").concat((0, _farrapaColors.RED)('Error ' + err.code), " Command: ").concat(err.command, " ").concat(err.toString());else msg = "".concat((0, _farrapaColors.PURPLE)('REDIS'), " ").concat((0, _farrapaColors.RED)('Error ' + err.code), " ").concat(err.toString());
+    } catch (e) {
+      msg = "".concat((0, _farrapaColors.PURPLE)('REDIS'), " ").concat((0, _farrapaColors.RED)('Error '), " ").concat(e);
+    }
+
+    console.error(msg);
+  });
+
+  var _getKey = (0, _util.promisify)(client.get).bind(client);
+
+  var _existsKey = (0, _util.promisify)(client.exists).bind(client);
+
+  var _setKey = (0, _util.promisify)(client.set).bind(client);
+
+  var _delKey = (0, _util.promisify)(client.del).bind(client);
+
+  function redisGet(_x) {
+    return _redisGet.apply(this, arguments);
+  }
+
+  function _redisGet() {
+    _redisGet = _asyncToGenerator(function* (key) {
+      return yield _getKey(key);
+    });
+    return _redisGet.apply(this, arguments);
+  }
+
+  function redisExists(_x2) {
+    return _redisExists.apply(this, arguments);
+  }
+
+  function _redisExists() {
+    _redisExists = _asyncToGenerator(function* (key) {
+      var r = yield _existsKey(key);
+      return r == 1 ? true : false;
+    });
+    return _redisExists.apply(this, arguments);
+  }
+
+  function redisSet(_x3, _x4) {
+    return _redisSet.apply(this, arguments);
+  }
+
+  function _redisSet() {
+    _redisSet = _asyncToGenerator(function* (key, value) {
+      var expiration = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : 86400;
+      var r = yield _setKey(key, value, 'EX', expiration);
+      return r == 'OK' ? true : false;
+    });
+    return _redisSet.apply(this, arguments);
+  }
+
+  function redisDel(_x5) {
+    return _redisDel.apply(this, arguments);
+  }
+
+  function _redisDel() {
+    _redisDel = _asyncToGenerator(function* (key) {
+      var r = yield _delKey(key);
+      return r >= 1 ? true : false;
+    });
+    return _redisDel.apply(this, arguments);
+  }
+
+  var cacher = {
+    get: redisGet,
+    exists: redisExists,
+    set: redisSet,
+    del: redisDel
+  };
+  return cacher;
+}

package/lib/cacher/verify.js

@@ -0,0 +1,32 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.verify_cacher = verify_cacher;
+
+var _index = require("./index");
+
+function asyncGeneratorStep(gen, resolve, reject, _next, _throw, key, arg) { try { var info = gen[key](arg); var value = info.value; } catch (error) { reject(error); return; } if (info.done) { resolve(value); } else { Promise.resolve(value).then(_next, _throw); } }
+
+function _asyncToGenerator(fn) { return function () { var self = this, args = arguments; return new Promise(function (resolve, reject) { var gen = fn.apply(self, args); function _next(value) { asyncGeneratorStep(gen, resolve, reject, _next, _throw, "next", value); } function _throw(err) { asyncGeneratorStep(gen, resolve, reject, _next, _throw, "throw", err); } _next(undefined); }); }; }
+
+function verify_cacher(_x) {
+  return _verify_cacher.apply(this, arguments);
+}
+
+function _verify_cacher() {
+  _verify_cacher = _asyncToGenerator(function* (config) {
+    var cacher = (0, _index.make_cacher)(config);
+    var rs = yield cacher.set('test', 'I will be expired in 10 seconds', 10);
+    if (!rs) console.warning('[miolo][Verify][REDIS] Verifying error: Redis could not be tested (S)!');else {
+      var rd = yield cacher.del('test');
+      if (!rd) console.warning('[miolo][Verify][REDIS] Verifying error: Redis could not be tested (D)!');else {
+        console.info('[miolo][Verify][REDIS] Verifying: Redis Tested OK');
+        return true;
+      }
+    }
+    return false;
+  });
+  return _verify_cacher.apply(this, arguments);
+}

package/lib/config/defaults.js

@@ -0,0 +1,204 @@
+"use strict";
+
+var path = require('path');
+
+var favicon = path.resolve(__dirname, '../server/static/ig/favicon.ico');
+module.exports = {
+  name: 'miolo',
+  http: {
+    port: 8001,
+    hostname: 'localhost',
+    static: {
+      favicon: favicon,
+      folders: {}
+    }
+  },
+  session: {
+    salt: 'SUPER_SALTY_YES?',
+    secret: 'SUPER_SECRET_KEY_KERE',
+    expires: 9 * 3600 * 1000 // 9 hours
+
+  },
+  database: {
+    connection: {
+      dialect: 'postgres',
+      host: 'localhost',
+      port: 5432,
+      database: 'miolo',
+      user: 'postgres',
+      password: 'postgres',
+      max: 5,
+      // Maximum number of connection in pool
+      min: 0,
+      // Minimum number of connection in pool
+      idleTimeoutMillis: 10000 // The maximum time, in milliseconds, that a connection can be idle before being released. Use with combination of evict for proper working, for more details read https://github.com/coopernurse/node-pool/issues/178#issuecomment-327110870,
+
+    },
+    options: {
+      log: 'debug'
+    }
+  },
+  routes: {//  crud: {
+    //    path: '/crud',
+    //    routes: [
+    //      {
+    //        name: 'todos',
+    //        options: {
+    //          useDates: true,
+    //          checkBeforeDelete: ["edition.agent_id"],
+    //          customHooks: {
+    //            beforeInsert: beforeInsertTest,
+    //            beforeUpdate: beforeUpdateTest
+    //          }
+    //        }
+    //      }
+    //    ],  
+    //  },
+    //  queries: [
+    //    {
+    //      path: '/crud/fo/bar',
+    //      method: 'GET',
+    //      callback: method_receiving_params_ctx_conn
+    //    }
+    //  ]
+  },
+  cacher: {
+    redis: {
+      host: '127.0.0.1',
+      port: 6379
+    }
+  },
+  log: {
+    level: 'debug',
+    format: {
+      locale: 'en-GB'
+    },
+    console: {
+      enabled: true,
+      level: 'silly'
+    },
+    file: {
+      enabled: true,
+      level: 'silly',
+      filename: '/var/log/afialapis/miolo.log'
+    },
+    mail: {
+      enabled: process.env.NODE_ENV === 'production',
+      level: 'warn'
+    }
+  },
+  mail: {
+    silent: process.env.NODE_ENV !== 'production',
+    options: {
+      //
+      // General options
+      //
+      // port – is the port to connect to (defaults to 587 is secure is false or 465 if true)
+      port: 25,
+      // host – is the hostname or IP address to connect to (defaults to ‘localhost’)
+      host: 'mail.afialapis.com',
+      // auth – defines authentication data 
+      //        If authentication data is not present, the connection is considered authenticated from the start. 
+      //        Otherwise you would need to provide the authentication options object.
+      //   - type indicates the authetication type, defaults to ‘login’, other option is ‘oauth2’
+      //   - user is the username
+      //   - pass is the password for the user if normal login is used
+      // authMethod – defines preferred authentication method, defaults to ‘PLAIN’
+      authMethod: 'PLAIN',
+      //
+      // TLS options
+      //
+      // secure – if true the connection will use TLS when connecting to server.
+      //          If false (the default) then TLS is used if server supports the STARTTLS extension.
+      //          In most cases set this value to true if you are connecting to port 465. For port 587 or 25 keep it false
+      //    ** Setting secure to false does not mean that you would not use an encrypted connection. Most SMTP servers allow 
+      //       connection upgrade via STARTTLS command but to use this you have to connect using plaintext first
+      secure: false,
+      // tls – defines additional node.js TLSSocket options to be passed to the socket constructor, eg. {rejectUnauthorized: true}.
+      tls: {
+        // do not fail on invalid certs
+        rejectUnauthorized: false
+      },
+      // ignoreTLS – if this is true and secure is false then TLS is not used even if the server supports STARTTLS extension
+      // ** ignoreTLS: false,
+      // requireTLS – if this is true and secure is false then Nodemailer tries to use STARTTLS even 
+      //              if the server does not advertise support for it. If the connection can not be encrypted then message is not sent
+      // ** requireTLS: true,
+      //
+      // Connection options
+      //
+      // name – optional hostname of the client, used for identifying to the server, defaults to hostname of the machine
+      // ** name: ,
+      // localAddress – is the local interface to bind to for network connections
+      // ** localAddress: ,
+      // connectionTimeout – how many milliseconds to wait for the connection to establish
+      // ** connectionTimeout: ,
+      // greetingTimeout – how many milliseconds to wait for the greeting after connection is established
+      // ** greetingTimeout: ,
+      // socketTimeout – how many milliseconds of inactivity to allow
+      // ** socketTimeout: ,
+      //
+      // Debug options
+      //
+      // logger – optional bunyan compatible logger instance. If set to true then logs to console. 
+      //          If value is not set or is false then nothing is logged
+      logger: false,
+      // debug – if set to true, then logs SMTP traffic, otherwise logs only transaction events
+      debug: false //
+      // Security options
+      //
+      // disableFileAccess – if true, then does not allow to use files as content. 
+      //                     Use it when you want to use JSON data from untrusted source as the email.
+      //                    If an attachment or message node tries to fetch something from a file the sending returns an error
+      ////disableFileAccess: ,
+      // disableUrlAccess – if true, then does not allow to use Urls as content
+      // ** disableUrlAccess: ,
+      //
+      // Pooling options
+      //
+      // pool – see Pooled SMTP for details about connection pooling : https://nodemailer.com/smtp/pooled/
+      //
+      // Proxy options
+      //
+      // proxy – all SMTP based transports allow to use proxies for making TCP connections to servers.
+      //         Read about proxy support in Nodemailer from here: https://nodemailer.com/smtp/proxies/
+
+      /* TESTED */
+
+      /*
+      port: 465,
+      host: 'mail.afialapis.com',
+      auth: {
+        user: 'devel@afialapis.com',
+        pass: '***',
+        type: 'login',
+      },      
+      secure: true,
+      tls: {
+        rejectUnauthorized: false
+      } ,
+      */
+
+    },
+    defaults: {
+      name: 'miolo',
+      from: 'miolo@afialapis.com',
+      to: 'devel@afialapis.com'
+    }
+  },
+  auth: {//basic: {
+    //  auth_user: async (username, password) => { return {id: 1} },
+    //  realm: '',
+    //  paths: [],
+    //},
+    //passport: {
+    //  get_user_id:  (user, done) => done(null, user.id), // default
+    //  find_user_by_id: (id, done) => done(null, {id: 1}),  // ok=> done(null, user)  err=> done(error, null)
+    //  local_auth_user: (username, password, done) => done(null, {id: 1})
+    //                   // auth=> done(null, user) noauth=> done(null, false, {message: ''}) err=> done(error, null)
+    //  url_login: '/login',
+    //  url_login: '/login',
+    //  url_login: '/login',
+    //}
+  }
+};

package/lib/config/index.js

@@ -0,0 +1,14 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.init_config = init_config;
+
+var merge = require('assign-deep');
+
+var base_config = require("./defaults.js");
+
+function init_config(config) {
+  return merge(base_config, config);
+}

package/lib/db/conn.js

@@ -0,0 +1,15 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.init_db_connection = init_db_connection;
+
+var {
+  getConnection
+} = require('calustra-conn');
+
+function init_db_connection(config) {
+  var conn = getConnection(config.connection, config.options);
+  return conn;
+}

package/lib/emailer/index.js

@@ -0,0 +1,62 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.init_emailer = init_emailer;
+
+var nodemailer = require('nodemailer');
+
+function init_emailer(options, defaults) {
+  var silent = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : false;
+  var nmailer = nodemailer.createTransport(options, defaults);
+
+  function send_email(mail, cb) {
+    if (process.env.NODE_ENV != 'production') {
+      console.info('*********************************');
+      console.info('This mail would be sent if you were in production:');
+      console.info(mail);
+      console.info('*********************************');
+    } else if (silent) {
+      console.info('*********************************');
+      console.info('This mail will not be send (emailing is disabled):');
+      console.info(mail);
+      console.info('*********************************');
+    } else {
+      if (!cb) {
+        cb = function cb(err, info) {
+          if (err) {
+            console.error('NodeMailer error:');
+            console.error(err);
+          }
+
+          if (info) {
+            console.log('NodeMailer sent mail:');
+            console.log(info);
+          }
+        };
+      }
+
+      nmailer.sendMail(mail, cb);
+    }
+  }
+
+  function verify_emailer() {
+    console.info('[miolo][Verify][MAILER] Verifying...'); // verify connection configuration
+
+    nmailer.verify(function (error, _success) {
+      if (error) {
+        console.error('[miolo][Verify][MAILER] Verifying ERROR');
+        console.error(error);
+      } else {
+        console.info('[miolo][Verify][MAILER] Verifyed OK: Server is ready to take our messages'); //test_eail()
+      }
+    });
+  }
+
+  var emailer = {
+    send: send_email,
+    verify: verify_emailer
+  };
+  return emailer;
+}

package/lib/emailer/verify.js

@@ -0,0 +1,13 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.veryfy_emailer = veryfy_emailer;
+
+var _index = require("./index");
+
+function veryfy_emailer(config) {
+  var emailer = (0, _index.make_emailer)(config);
+  return emailer.verify();
+}

package/lib/index.js

@@ -0,0 +1,59 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+Object.defineProperty(exports, "getDb", {
+  enumerable: true,
+  get: function get() {
+    return _calustraRouter.getDb;
+  }
+});
+Object.defineProperty(exports, "getModel", {
+  enumerable: true,
+  get: function get() {
+    return _calustraRouter.getModel;
+  }
+});
+Object.defineProperty(exports, "init_cacher", {
+  enumerable: true,
+  get: function get() {
+    return _cacher.init_cacher;
+  }
+});
+Object.defineProperty(exports, "init_db_connection", {
+  enumerable: true,
+  get: function get() {
+    return _conn.init_db_connection;
+  }
+});
+Object.defineProperty(exports, "init_emailer", {
+  enumerable: true,
+  get: function get() {
+    return _emailer.init_emailer;
+  }
+});
+Object.defineProperty(exports, "init_logger", {
+  enumerable: true,
+  get: function get() {
+    return _logger.init_logger;
+  }
+});
+Object.defineProperty(exports, "miolo", {
+  enumerable: true,
+  get: function get() {
+    return _server.miolo;
+  }
+});
+
+var _server = require("./server");
+
+var _emailer = require("./emailer");
+
+var _cacher = require("./cacher");
+
+var _logger = require("./logger");
+
+var _conn = require("./db/conn");
+
+var _calustraRouter = require("calustra-router");

package/lib/logger/index.js

@@ -0,0 +1,98 @@
+"use strict";
+
+var _farrapaColors = require("farrapa-colors");
+
+/* https://github.com/winstonjs/winston/issues/925 */
+
+/* https://github.com/winstonjs/winston/issues/287 */
+var {
+  createLogger,
+  format,
+  transports
+} = require('winston');
+
+var {
+  combine,
+  timestamp,
+  _label,
+  printf
+} = format;
+
+var init_logger = (config, emailer) => {
+  var LEVEL_COLORS = {
+    silly: _farrapaColors.LIGHT_CYAN,
+    debug: _farrapaColors.LIGHT_BLUE,
+    verbose: _farrapaColors.LIGHT_GREEN,
+    info: _farrapaColors.YELLOW,
+    warn: _farrapaColors.LIGHT_RED,
+    error: _farrapaColors.RED
+  };
+  var myFormat = printf(info => {
+    var _config$format;
+
+    var lc = LEVEL_COLORS[info.level];
+    var tm = new Date(info.timestamp);
+    var ts = tm.toLocaleString((config === null || config === void 0 ? void 0 : (_config$format = config.format) === null || _config$format === void 0 ? void 0 : _config$format.locale) || 'en'); //const ts= tm.toString().substr(4, 20)
+
+    return "[miolo] ".concat(lc(ts), " ").concat(lc(info.level), " ").concat(info.message);
+  });
+  var _log_transports = []; //
+  // Console transport
+  // If we're not in production then log to the `console` with the format:
+  // `${info.level}: ${info.message} JSON.stringify({ ...rest }) `
+  // 
+
+  if (config.console.enabled) {
+    _log_transports.push(new transports.Console({
+      humanReadableUnhandledException: true,
+      level: config.console.level,
+      handleExceptions: true
+    }));
+  } //
+  // File transport
+  //
+
+
+  if (config.file.enabled) {
+    _log_transports.push(new transports.File({
+      filename: config.file.filename,
+      level: config.file.level,
+      humanReadableUnhandledException: true,
+      handleExceptions: true
+    }));
+  } //
+  // Mail transport
+  //
+
+
+  if (config.mail.enabled) {
+    var winston = require("winston");
+
+    var {
+      init_logger_to_mail
+    } = require("./logger_mail");
+
+    var MailerLogger = init_logger_to_mail(config.mail, emailer);
+    winston.transports.MailerLogger = MailerLogger;
+
+    _log_transports.push(new transports.MailerLogger({
+      level: config.mail.level,
+      humanReadableUnhandledException: true,
+      handleExceptions: true
+    }));
+  } //
+  // Logger
+  //
+
+
+  var logger = createLogger({
+    level: (config === null || config === void 0 ? void 0 : config.level) || 'silly',
+    format: combine(timestamp(), myFormat),
+    transports: _log_transports
+  });
+  return logger;
+};
+
+module.exports = {
+  init_logger
+};