miolo 0.1.0 → 0.2.0

package/dist/miolo.cjs

@@ -1,5 +1,5 @@
 /**
- * miolo v0.1.0
+ * miolo v0.2.0
  *
  * Copyright (c) Donato Lorenzo <donato@afialapis.com>
  *

package/dist/miolo.min.mjs

@@ -1,5 +1,5 @@
 /**
- * miolo v0.1.0
+ * miolo v0.2.0
  *
  * Copyright (c) Donato Lorenzo <donato@afialapis.com>
  *

package/dist/miolo.mjs

@@ -1,5 +1,5 @@
 /**
- * miolo v0.1.0
+ * miolo v0.2.0
  *
  * Copyright (c) Donato Lorenzo <donato@afialapis.com>
  *

package/dist/miolo.node.mjs

@@ -1,5 +1,5 @@
 /**
- * miolo v0.1.0
+ * miolo v0.2.0
  *
  * Copyright (c) Donato Lorenzo <donato@afialapis.com>
  *

package/lib/cacher/index.cjs

@@ -0,0 +1,76 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.init_cacher = init_cacher;
+var _redis = _interopRequireDefault(require("redis"));
+var _util = require("util");
+var _tinguir = require("tinguir");
+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, _tinguir.magenta)('REDIS'), " Connection established!"));
+  }).on('error', function (err) {
+    var msg;
+    try {
+      if (err instanceof _redis.default.ReplyError) msg = "".concat((0, _tinguir.magenta)('REDIS'), " ").concat((0, _tinguir.red)('Error ' + err.code), " Command: ").concat(err.command, " ").concat(err.toString());else msg = "".concat((0, _tinguir.magenta)('REDIS'), " ").concat((0, _tinguir.red)('Error ' + err.code), " ").concat(err.toString());
+    } catch (e) {
+      msg = "".concat((0, _tinguir.magenta)('REDIS'), " ").concat((0, _tinguir.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.cjs

@@ -0,0 +1,27 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.verify_cacher = verify_cacher;
+var _index = require("./index.cjs");
+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.cjs

@@ -0,0 +1,287 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _path = _interopRequireDefault(require("path"));
+var _url = require("url");
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+var __my_filename = (0, _url.fileURLToPath)(require('url').pathToFileURL(__filename).toString());
+var __my_dirname = _path.default.dirname(__my_filename);
+var favicon = _path.default.resolve(__my_dirname, '../server/static/ig/favicon.ico');
+var _default = {
+  name: 'miolo',
+  http: {
+    port: 8001,
+    hostname: 'localhost',
+    static: {
+      favicon: favicon,
+      folders: {}
+    },
+    // cors can be:
+    //   - false
+    //   - simple    (just assign Access-Control-Allow-Origin='*' and Access-Control-Expose-Headers='SourceMap,X-SourceMap'
+    //   - true      enable @koa/cors
+    //   - {options} enable @koa/cors and use the custom options
+    //
+    cors: false,
+    // proxy can be:
+    //   - false
+    //   - true      enable koa-proxies and use default options
+    //   - {options} enable koa-proxies and use the custom options
+    proxy: false
+  },
+  session: {
+    salt: 'SUPER_SALTY_YES?',
+    secret: 'SUPER_SECRET_KEY_KERE',
+    options: {
+      /** (number || 'session') maxAge in ms (default is 1 days) */
+      /** 'session' will result in a cookie that expires when session/browser is closed */
+      /** Warning: If a session cookie is stolen, this cookie will never expire */
+      maxAge: 86400000,
+      /** (boolean) automatically commit headers (default true) */
+      //autoCommit: true, 
+
+      /** (boolean) can overwrite or not (default true) */
+      //overwrite: true, 
+
+      /** (boolean) httpOnly or not (default true) */
+      //httpOnly: true, 
+
+      /** (boolean) signed or not (default true) */
+      //signed: true, 
+
+      /** (boolean) Force a session identifier cookie to be set on every response. The expiration is reset to the original maxAge, resetting the expiration countdown. (default is false) */
+      //rolling: false, 
+
+      /** (boolean) renew session when session is nearly expired, so we can always keep user logged in. (default is false)*/
+      //renew: false, 
+
+      /** (boolean) secure cookie*/
+      secure: true,
+      /** (string) session cookie sameSite options (default null, don't set it) */
+      sameSite: null // 'strict', 
+    }
+  },
+
+  db: {
+    connection: {
+      database: {
+        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: 'silly' //  will be updated on the fly with miolo logger
+      }
+    },
+
+    tables: []
+  },
+  routes: {
+    bodyField: undefined,
+    getUserId: ctx => {
+      try {
+        var from_pport = ctx.state.user.id;
+        if (from_pport != undefined) {
+          return from_pport;
+        }
+      } catch (e) {}
+      try {
+        var from_basic_auth = ctx.user.id;
+        if (from_basic_auth != undefined) {
+          return from_basic_auth;
+        }
+      } catch (e) {}
+      try {
+        if (ctx.user.name == 'guest') {
+          var from_guest_auth = ctx.user.token;
+          if (from_guest_auth != undefined) {
+            return from_guest_auth;
+          }
+        }
+      } catch (e) {}
+      var uid = ctx.headers['user-id'];
+      if (uid != undefined) {
+        return uid;
+      }
+      return undefined;
+    },
+    // authUser: {
+    //   require: false,     // true / false / 'read-only'
+    //   action: 'redirect', // 'error'
+    //   redirect_url: '/',
+    //   error_code: 401
+    // }, 
+
+    crud: {
+      prefix: '',
+      routes: [] // miolo will not support '*' by now
+    },
+
+    queries: undefined
+  },
+  catcher: '/sys/jserror',
+  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: false,
+      level: 'warn',
+      name: 'miolo',
+      from: 'miolo@afialapis.com',
+      to: 'devel@afialapis.com'
+    }
+  },
+  mail: {
+    silent: true,
+    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, miolo) => done(null, user.id), // default
+    //  find_user_by_id: (id, done, miolo) => done(null, {id: 1}),  // ok=> done(null, user)  err=> done(error, null)
+    //  local_auth_user: (username, password, done, miolo) => done(null, {id: 1})
+    //                   // auth=> done(null, user) noauth=> done(null, false, {message: ''}) err=> done(error, null)
+    //  url_login : '/login',
+    //  url_logout: '/logout',
+    //  url_login_redirect: undefined
+    //  url_logout_redirect: '/'
+    //}
+    //guest: {
+    //  make_guest_token: undefined // (session) => ''
+    //}
+  },
+  middlewares: [
+    // async (ctx) => {}
+  ]
+};
+exports.default = _default;

package/lib/config/index.cjs

@@ -0,0 +1,12 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.init_config = init_config;
+var _assignDeep = _interopRequireDefault(require("assign-deep"));
+var _defaults = _interopRequireDefault(require("./defaults.cjs"));
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+function init_config(config) {
+  return (0, _assignDeep.default)(_defaults.default, config);
+}

package/lib/emailer/index.cjs

@@ -0,0 +1,56 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.init_emailer = init_emailer;
+var _nodemailer = _interopRequireDefault(require("nodemailer"));
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+function init_emailer(options, defaults) {
+  var silent = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : false;
+  var nmailer = _nodemailer.default.createTransport(options, defaults);
+  function send_email(mail, cb) {
+    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,
+    options,
+    defaults,
+    silent
+  };
+  return emailer;
+}

package/lib/emailer/verify.cjs

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

package/lib/index.cjs

@@ -0,0 +1,40 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+Object.defineProperty(exports, "getCacher", {
+  enumerable: true,
+  get: function get() {
+    return _cacher.init_cacher;
+  }
+});
+Object.defineProperty(exports, "getConnection", {
+  enumerable: true,
+  get: function get() {
+    return _calustraRouter.getConnection;
+  }
+});
+Object.defineProperty(exports, "getEmailer", {
+  enumerable: true,
+  get: function get() {
+    return _emailer.init_emailer;
+  }
+});
+Object.defineProperty(exports, "getLogger", {
+  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 _calustraRouter = require("calustra-router");

package/lib/logger/index.cjs

@@ -0,0 +1,91 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.init_logger = void 0;
+var _tinguir = require("tinguir");
+var _logger_mail = require("./logger_mail.cjs");
+var _winston = require("winston");
+/* https://github.com/winstonjs/winston/issues/925 */
+/* https://github.com/winstonjs/winston/issues/287 */
+
+var {
+  combine,
+  timestamp,
+  _label,
+  printf,
+  errors
+} = _winston.format;
+var init_logger = (config, emailer) => {
+  var LEVEL_COLORS = {
+    silly: _tinguir.gray,
+    debug: _tinguir.magenta,
+    verbose: _tinguir.cyan,
+    info: _tinguir.yellow,
+    warn: _tinguir.red_light,
+    error: _tinguir.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)
+    var log = "[miolo] ".concat(lc(ts), " ").concat(lc(info.level), " ").concat(info.message);
+    return info.stack ? "".concat(log, "\n").concat(info.stack) : log;
+  });
+  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) {
+    var _config$console;
+    _log_transports.push(new _winston.transports.Console({
+      humanReadableUnhandledException: true,
+      level: (config === null || config === void 0 ? void 0 : (_config$console = config.console) === null || _config$console === void 0 ? void 0 : _config$console.level) || (config === null || config === void 0 ? void 0 : config.level) || 'silly',
+      handleExceptions: true
+    }));
+  }
+
+  //
+  // File transport
+  //
+  if (config.file.enabled) {
+    var _config$file;
+    _log_transports.push(new _winston.transports.File({
+      filename: config.file.filename,
+      level: (config === null || config === void 0 ? void 0 : (_config$file = config.file) === null || _config$file === void 0 ? void 0 : _config$file.level) || (config === null || config === void 0 ? void 0 : config.level) || 'info',
+      humanReadableUnhandledException: true,
+      handleExceptions: true
+    }));
+  }
+
+  //
+  // Mail transport
+  //
+  if (config.mail.enabled) {
+    var MailerLogger = (0, _logger_mail.init_logger_to_mail)(config.mail, emailer);
+    _winston.transports.MailerLogger = MailerLogger;
+    _log_transports.push(new _winston.transports.MailerLogger({
+      humanReadableUnhandledException: true,
+      handleExceptions: true
+    }));
+  }
+
+  //
+  // Logger
+  //
+  var logger = (0, _winston.createLogger)({
+    level: (config === null || config === void 0 ? void 0 : config.level) || 'silly',
+    format: combine(errors({
+      stack: true
+    }), timestamp(), myFormat),
+    transports: _log_transports
+  });
+  return logger;
+};
+exports.init_logger = init_logger;