miolo 0.0.1

package/lib/logger/logger_mail.js

@@ -0,0 +1,59 @@
+"use strict";
+
+var _farrapaColors = require("farrapa-colors");
+
+var util = require("util");
+
+var winston = require("winston");
+
+function init_logger_to_mail(config, emailer) {
+  var MailerLogger = function MailerLogger(options) {
+    winston.Transport.call(this, options);
+    options = options || {};
+    this.silent = options.silent || false;
+    this.level = options.level || 'info';
+    this.to = options.to || config.to, this.from = config.from;
+    this.humanReadableUnhandledException = options.humanReadableUnhandledException || true;
+    this.handleExceptions = options.handleExceptions || true;
+    this.json = options.json || false;
+    this.colorize = options.colorize || false;
+  };
+  /** @extends winston.Transport */
+
+
+  util.inherits(MailerLogger, winston.Transport); //
+  // Expose the name of this Transport on the prototype
+  //
+
+  MailerLogger.prototype.name = 'MailerLogger';
+
+  MailerLogger.prototype.log = function (info, callback) {
+    var self = this;
+    if (this.silent) return callback(null, true);
+    var tit = '';
+
+    try {
+      tit = info.message.split("\n")[0];
+    } catch (e) {
+      tit = info.message.toString();
+    }
+
+    tit = (0, _farrapaColors.uncolor)(tit);
+    var subject = config.name + ': [' + info.level.toUpperCase() + '] ' + tit;
+    var mail = {
+      to: this.to,
+      subject: subject,
+      text: (0, _farrapaColors.uncolor)(info.message)
+    };
+    emailer.send(mail, function () {
+      self.emit("logged");
+      callback(null, true);
+    });
+  };
+
+  return MailerLogger;
+}
+
+module.exports = {
+  init_logger_to_mail
+};

package/lib/logger/verify.js

@@ -0,0 +1,25 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.verify_logger = verify_logger;
+
+var _index = require("./index");
+
+function verify_logger(config) {
+  var logger = (0, _index.make_logger)(config);
+
+  try {
+    console.info('[miolo][Verify][LOGGER] Verifying...');
+    logger.error('Error message');
+    logger.warn('Warn message');
+    logger.info('Info message');
+    logger.verbose('Verbose message');
+    logger.debug('Debug message');
+    logger.silly('Silly message');
+  } catch (e) {
+    console.error('[miolo][Verify][LOGGER] ERROR: ');
+    console.error(e);
+  }
+}

package/lib/server/engines/cron/index.js

@@ -0,0 +1,16 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.init_cron = init_cron;
+
+var _syscheck = require("./syscheck");
+
+var CronJob = require('cron').CronJob;
+
+function init_cron(logger) {
+  var sys_check_and_log = (0, _syscheck.init_sys_check_and_log)(logger);
+
+  var _sCheck = new CronJob('30 * * * *', sys_check_and_log, null, true, 'Europe/Madrid');
+}

package/lib/server/engines/cron/syscheck.js

@@ -0,0 +1,50 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.init_sys_check_and_log = init_sys_check_and_log;
+
+var _farrapaColors = require("farrapa-colors");
+
+var os = require('os');
+
+var diskspace = require('diskspace');
+
+function init_sys_check_and_log(logger) {
+  function toMB(bytes) {
+    if (!bytes) return 0;
+    return bytes / 1000000;
+  }
+
+  function toGB(kbytes) {
+    if (!kbytes) return 0;
+    return kbytes / 1000000;
+  }
+
+  function sys_check_and_log() {
+    var used = Math.round(toMB(os.freemem()), 2);
+    var total = Math.round(toMB(os.totalmem()), 2);
+    var perc = Math.round(used * 100 / total, 2);
+
+    if (perc > 80) {
+      logger.error("[SERVER][".concat((0, _farrapaColors.CYAN)('SysCheck'), "] RAM ").concat((0, _farrapaColors.YELLOW)(used), " MB used of ").concat((0, _farrapaColors.GREEN)(total), " MB (").concat((0, _farrapaColors.YELLOW)(perc), " %)"));
+    } else {
+      logger.info("[SERVER][".concat((0, _farrapaColors.CYAN)('SysCheck'), "] RAM ").concat((0, _farrapaColors.YELLOW)(used), " MB used of ").concat((0, _farrapaColors.GREEN)(total), " MB (").concat((0, _farrapaColors.YELLOW)(perc), " %)"));
+    }
+
+    diskspace.check('/', function (err, result) {
+      var used = Math.round(toGB(result.used), 2);
+      var total = Math.round(toGB(result.total), 2);
+      var free = Math.round(toGB(result.free), 2);
+
+      if (free < 1) {
+        logger.error("[SERVER][".concat((0, _farrapaColors.CYAN)('SysCheck'), "] DISK ").concat((0, _farrapaColors.YELLOW)(used), " GB used of ").concat((0, _farrapaColors.GREEN)(total), " MB (").concat((0, _farrapaColors.YELLOW)(free), " GB free)"));
+      } else {
+        logger.info("[SERVER][".concat((0, _farrapaColors.CYAN)('SysCheck'), "] DISK ").concat((0, _farrapaColors.YELLOW)(used), " GB used of ").concat((0, _farrapaColors.GREEN)(total), " MB (").concat((0, _farrapaColors.YELLOW)(free), " GB free)"));
+      }
+    });
+  }
+
+  return sys_check_and_log;
+}

package/lib/server/engines/socket/index.js

@@ -0,0 +1,48 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.init_socket = init_socket;
+
+var _koaSocket = _interopRequireDefault(require("koa-socket-2"));
+
+var _farrapaColors = require("farrapa-colors");
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+function init_socket(logger) {
+  var getInfo = ctx => {
+    var i = {
+      id: '',
+      ip: ''
+    };
+
+    try {
+      i.id = ctx.socket.id;
+    } catch (e) {}
+
+    try {
+      i.ip = ctx.socket.handshake.address;
+    } catch (e) {}
+
+    return i;
+  };
+
+  var io = new _koaSocket.default({
+    origins: '*:*'
+  });
+  io.on('connection', function (ctx, _data) {
+    var i = getInfo(ctx);
+    logger.debug("".concat((0, _farrapaColors.BLUE)('SOCKET'), " Connection from ").concat(i.ip, " ").concat(i.id));
+  });
+  io.on('disconnect', function (ctx, data) {
+    var i = getInfo(ctx);
+    logger.debug("".concat((0, _farrapaColors.BLUE)('SOCKET'), " Disconnected ").concat(i.ip, " ").concat(i.id, " => ").concat(data));
+  });
+  io.on('error', function (ctx, data) {
+    var i = getInfo(ctx);
+    logger.error("".concat((0, _farrapaColors.BLUE)('SOCKET'), " Error on ").concat(i.ip, " ").concat(i.id, " => ").concat(data));
+  });
+  return io;
+}

package/lib/server/index.js

@@ -0,0 +1,126 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.miolo = miolo;
+
+var _koa = _interopRequireDefault(require("koa"));
+
+var _config = require("../config");
+
+var _emailer = require("../emailer");
+
+var _logger = require("../logger");
+
+var _cron = require("./engines/cron");
+
+var _catcher = require("./middleware/catcher");
+
+var _static = require("./middleware/static");
+
+var _body = require("./middleware/body");
+
+var _conn = require("../db/conn");
+
+var _request = require("./middleware/request");
+
+var _session = require("./middleware/session");
+
+var _robots = require("./routes/robots");
+
+var _catch_js_error = require("./routes/catch_js_error");
+
+var _html_render = require("./routes/html_render");
+
+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 miolo(_x, _x2) {
+  return _miolo.apply(this, arguments);
+}
+
+function _miolo() {
+  _miolo = _asyncToGenerator(function* (sconfig, render) {
+    var _config$http, _config$auth, _config$auth2, _config$routes, _config$routes2;
+
+    // Init some pieces
+    var config = (0, _config.init_config)(sconfig);
+    var emailer = (0, _emailer.init_emailer)(config.mail.options, config.mail.defaults);
+    var logger = (0, _logger.init_logger)(config.log, emailer);
+    var app = new _koa.default(); // Compress and body parser
+
+    (0, _body.init_body_middleware)(app); // override koa's undocumented error handler
+
+    (0, _catcher.init_catcher_middleware)(app, logger); // Serve static files
+
+    (0, _static.init_static_middleware)(app, (_config$http = config.http) === null || _config$http === void 0 ? void 0 : _config$http.static); // Feed and log request
+
+    (0, _request.init_request_middleware)(app, logger); // Create context/session
+
+    (0, _session.init_session_middleware)(app, config === null || config === void 0 ? void 0 : config.session, logger); // attach the default robots.txt
+
+    (0, _robots.init_route_robots)(app); // Middleware for caching JS errors
+
+    (0, _catch_js_error.init_route_catch_js_error)(app, '/sys/jserror', logger); // auth middleware
+
+    if (config !== null && config !== void 0 && (_config$auth = config.auth) !== null && _config$auth !== void 0 && _config$auth.basic) {
+      var {
+        init_basic_auth_middleware
+      } = require("./middleware/auth/basic");
+
+      init_basic_auth_middleware(app, config.auth.basic);
+    }
+
+    if (config !== null && config !== void 0 && (_config$auth2 = config.auth) !== null && _config$auth2 !== void 0 && _config$auth2.passport) {
+      var {
+        init_passport_auth_middleware
+      } = require("./middleware/auth/passport");
+
+      init_passport_auth_middleware(app, config.auth.passport);
+    } // Routes to /crud
+
+
+    var conn;
+
+    if (config.database) {
+      conn = (0, _conn.init_db_connection)(config.database);
+    }
+
+    if (config !== null && config !== void 0 && (_config$routes = config.routes) !== null && _config$routes !== void 0 && _config$routes.crud) {
+      var {
+        init_crud_router
+      } = require("./routes/crud");
+
+      yield init_crud_router(app, conn, config.routes.crud);
+    } // Queries routes
+
+
+    if (config !== null && config !== void 0 && (_config$routes2 = config.routes) !== null && _config$routes2 !== void 0 && _config$routes2.queries) {
+      var {
+        init_queries_router
+      } = require("./routes/queries");
+
+      yield init_queries_router(app, conn, config.routes.queries);
+    } // Socket.io
+    // const io= init_socket(logger)
+    // io.attach(app)
+    // Middleware for html render
+
+
+    if (render == undefined || render.html != undefined) {
+      (0, _html_render.init_route_html_render)(app, render === null || render === void 0 ? void 0 : render.html, logger);
+    } else if (render.middleware != undefined) {
+      app.use(render.middleware);
+    }
+
+    app.listen(config.http.port, function () {
+      logger.info('miolo is listening on port ' + config.http.port);
+      (0, _cron.init_cron)(logger);
+    });
+  });
+  return _miolo.apply(this, arguments);
+}

package/lib/server/middleware/_cors.js

@@ -0,0 +1,130 @@
+'use strict';
+/**
+ * CORS middleware
+ *
+ * @param {Object} [options]
+ *  - {String|Function(ctx)} origin `Access-Control-Allow-Origin`, default is request Origin header
+ *  - {String|Array} allowMethods `Access-Control-Allow-Methods`, default is 'GET,HEAD,PUT,POST,DELETE,PATCH'
+ *  - {String|Array} exposeHeaders `Access-Control-Expose-Headers`
+ *  - {String|Array} allowHeaders `Access-Control-Allow-Headers`
+ *  - {String|Number} maxAge `Access-Control-Max-Age` in seconds
+ *  - {Boolean} credentials `Access-Control-Allow-Credentials`
+ *  - {Boolean} keepHeadersOnError Add set headers to `err.header` if an error is thrown
+ * @return {Function} cors middleware
+ * @api public
+ */
+
+module.exports = function (options) {
+  var defaults = {
+    allowMethods: 'GET,HEAD,PUT,POST,DELETE,PATCH'
+  };
+  options = Object.assign({}, defaults, options);
+
+  if (Array.isArray(options.exposeHeaders)) {
+    options.exposeHeaders = options.exposeHeaders.join(',');
+  }
+
+  if (Array.isArray(options.allowMethods)) {
+    options.allowMethods = options.allowMethods.join(',');
+  }
+
+  if (Array.isArray(options.allowHeaders)) {
+    options.allowHeaders = options.allowHeaders.join(',');
+  }
+
+  if (options.maxAge) {
+    options.maxAge = String(options.maxAge);
+  }
+
+  options.credentials = !!options.credentials;
+  options.keepHeadersOnError = options.keepHeadersOnError === undefined || !!options.keepHeadersOnError;
+  return function cors(ctx, next) {
+    // If the Origin header is not present terminate this set of steps.
+    // The request is outside the scope of this specification.
+    var requestOrigin = ctx.get('Origin'); // Always set Vary header
+    // https://github.com/rs/cors/issues/10
+
+    ctx.vary('Origin');
+
+    if (!requestOrigin) {
+      return next();
+    }
+
+    var origin;
+
+    if (typeof options.origin === 'function') {
+      // FIXME: origin can be promise
+      origin = options.origin(ctx);
+
+      if (!origin) {
+        return next();
+      }
+    } else {
+      origin = options.origin || requestOrigin;
+    }
+
+    var headersSet = {};
+
+    function set(key, value) {
+      ctx.set(key, value);
+      headersSet[key] = value;
+    }
+
+    if (ctx.method !== 'OPTIONS') {
+      // Simple Cross-Origin Request, Actual Request, and Redirects
+      set('Access-Control-Allow-Origin', origin);
+
+      if (options.credentials === true) {
+        set('Access-Control-Allow-Credentials', 'true');
+      }
+
+      if (options.exposeHeaders) {
+        set('Access-Control-Expose-Headers', options.exposeHeaders);
+      }
+
+      if (!options.keepHeadersOnError) {
+        return next();
+      }
+
+      return next().catch(err => {
+        err.headers = Object.assign({}, err.headers, headersSet);
+        throw err;
+      });
+    } else {
+      // Preflight Request
+      // If there is no Access-Control-Request-Method header or if parsing failed,
+      // do not set any additional headers and terminate this set of steps.
+      // The request is outside the scope of this specification.
+      if (!ctx.get('Access-Control-Request-Method')) {
+        // this not preflight request, ignore it
+        return next();
+      }
+
+      ctx.set('Access-Control-Allow-Origin', origin);
+
+      if (options.credentials === true) {
+        ctx.set('Access-Control-Allow-Credentials', 'true');
+      }
+
+      if (options.maxAge) {
+        ctx.set('Access-Control-Max-Age', options.maxAge);
+      }
+
+      if (options.allowMethods) {
+        ctx.set('Access-Control-Allow-Methods', options.allowMethods);
+      }
+
+      var allowHeaders = options.allowHeaders;
+
+      if (!allowHeaders) {
+        allowHeaders = ctx.get('Access-Control-Request-Headers');
+      }
+
+      if (allowHeaders) {
+        ctx.set('Access-Control-Allow-Headers', allowHeaders);
+      }
+
+      ctx.status = 204;
+    }
+  };
+};

package/lib/server/middleware/auth/basic.js

@@ -0,0 +1,72 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.init_basic_auth_middleware = void 0;
+
+var _koaMount = _interopRequireDefault(require("koa-mount"));
+
+var _basicAuth = _interopRequireDefault(require("basic-auth"));
+
+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); }); }; }
+
+var init_basic_auth_middleware = (app, options) => {
+  var {
+    auth_user,
+    realm,
+    paths
+  } = options;
+
+  if (!realm) {
+    realm = 'Secure Area';
+  }
+
+  function basic_auth_middleware(_x, _x2) {
+    return _basic_auth_middleware.apply(this, arguments);
+  }
+
+  function _basic_auth_middleware() {
+    _basic_auth_middleware = _asyncToGenerator(function* (ctx, next) {
+      ctx.user = null;
+      var au_user = (0, _basicAuth.default)(ctx);
+
+      var unauth_err = () => {
+        return ctx.throw(401, null, {
+          headers: {
+            'WWW-Authenticate': 'Basic realm="' + realm.replace(/"/g, '\\"') + '"'
+          }
+        });
+      };
+
+      if (!au_user) {
+        return unauth_err();
+      }
+
+      console.log('authing........');
+      var user = yield auth_user(au_user.name, au_user.pass);
+      console.log('authed authed');
+      console.log(user);
+
+      if (user === false || user == undefined) {
+        return unauth_err();
+      }
+
+      ctx.user = user;
+      yield next();
+    });
+    return _basic_auth_middleware.apply(this, arguments);
+  }
+
+  if (paths == undefined || paths.length == 0) {
+    app.use(basic_auth_middleware);
+  } else {
+    paths.map(p => app.use((0, _koaMount.default)(p, basic_auth_middleware)));
+  }
+};
+
+exports.init_basic_auth_middleware = init_basic_auth_middleware;

package/lib/server/middleware/auth/passport.js

@@ -0,0 +1,119 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.init_passport_auth_middleware = void 0;
+
+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); }); }; }
+
+var passport = require('koa-passport');
+
+var LocalStrategy = require('passport-local').Strategy;
+
+var Router = require('@koa/router'); // 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)
+// }
+
+
+var def_get_user_id = (user, done) => done(null, user.id);
+
+var def_find_user_by_id = (id, done) => {
+  var err = Error('You need to define auth.passport.find_user_by_id');
+  done(err, null);
+};
+
+var def_local_auth_user = (username, password, done) => {
+  var err = Error('You need to define auth.passport.local_auth_user');
+  done(err, null);
+};
+
+var init_passport_auth_middleware = (app, options) => {
+  var {
+    get_user_id,
+    find_user_by_id,
+    local_auth_user
+  } = options; //const local_options = {}
+
+  var get_user_id_f = get_user_id || def_get_user_id;
+  var find_user_by_id_f = find_user_by_id || def_find_user_by_id;
+  var local_auth_user_f = local_auth_user || def_local_auth_user;
+
+  var serialize_user = (user, done) => {
+    process.nextTick(function () {
+      get_user_id_f(user, done);
+    });
+  };
+
+  var deserialize_user = (id, done) => {
+    process.nextTick(function () {
+      find_user_by_id_f(id, done);
+    });
+  };
+
+  var local_strategy = new LocalStrategy((username, password, done) => {
+    local_auth_user_f(username, password, done);
+  });
+  passport.serializeUser(serialize_user);
+  passport.deserializeUser(deserialize_user);
+  passport.use(local_strategy);
+  app.use(passport.initialize());
+  app.use(passport.session());
+  var login_router = new Router();
+  /*login_router.post('/login', passport.authenticate('local', {
+    successRedirect: '/',
+    failureRedirect: '/', // /login
+    //failureMessage: true
+  }))*/
+
+  login_router.post('/login', function (ctx, next) {
+    return passport.authenticate('local', function (err, user, info, status) {
+      // console.log('[PASS AUTH] Error', err)
+      // console.log('[PASS AUTH] User', user)
+      // console.log('[PASS AUTH] Info', info)
+      // console.log('[PASS AUTH] Status', status)
+      if (user === false) {
+        ctx.body = {
+          success: false,
+          user: undefined,
+          authenticated: false,
+          info: info,
+          error: err
+        };
+        ctx.throw(401);
+      } else {
+        ctx.body = {
+          success: true,
+          user: user,
+          authenticated: true
+        };
+        return ctx.login(user);
+      }
+    })(ctx);
+  });
+  login_router.post('/logout', /*#__PURE__*/function () {
+    var _ref = _asyncToGenerator(function* (ctx) {
+      if (ctx.isAuthenticated()) {
+        ctx.logout();
+        ctx.redirect('/');
+      } else {
+        ctx.body = {
+          success: false
+        };
+        ctx.throw(401);
+      }
+    });
+
+    return function (_x) {
+      return _ref.apply(this, arguments);
+    };
+  }());
+  app.use(login_router.routes());
+};
+
+exports.init_passport_auth_middleware = init_passport_auth_middleware;