wapplr 1.0.44 → 1.0.45

package/dist/server/middlewares.js

@@ -0,0 +1,354 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault")["default"];
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.createRenderMiddleware = createRenderMiddleware;
+exports.createNotModifiedMiddleware = createNotModifiedMiddleware;
+exports["default"] = createMiddlewares;
+exports.mimeType = void 0;
+
+var _objectWithoutProperties2 = _interopRequireDefault(require("@babel/runtime/helpers/objectWithoutProperties"));
+
+var _objectSpread2 = _interopRequireDefault(require("@babel/runtime/helpers/objectSpread2"));
+
+var _utils = require("../common/utils");
+
+var _middlewares = _interopRequireDefault(require("../common/middlewares"));
+
+var _html2 = _interopRequireDefault(require("./html"));
+
+var _excluded = ["log"];
+var mimeType = {
+  ".ico": "image/x-icon",
+  ".html": "text/html",
+  ".js": "application/javascript",
+  ".json": "application/json",
+  ".css": "text/css",
+  ".png": "image/png",
+  ".jpg": "image/jpeg",
+  ".webp": "image/webp",
+  ".svg": "image/svg+xml",
+  ".wav": "audio/wav",
+  ".mp3": "audio/mpeg",
+  ".mpg": "video/mpeg",
+  ".mp4": "video/mp4",
+  ".webm": "video/webm",
+  ".pdf": "application/pdf",
+  ".zip": "application/zip",
+  ".doc": "application/msword",
+  ".eot": "application/vnd.ms-fontobject",
+  ".ttf": "application/x-font-ttf"
+};
+exports.mimeType = mimeType;
+
+function createRenderMiddleware() {
+  var p = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
+  var wapp = p.wapp;
+
+  function defaultRenderHandle(req, res, next) {
+    var wappResponse = res.wappResponse;
+
+    if (wappResponse.content && !wappResponse.content.renderType) {
+      res.wappResponse.status(wappResponse.statusCode || 200);
+      var render = wapp.contents.getComponent("html");
+      res.wappResponse.send(render({
+        wapp: wapp,
+        req: req,
+        res: res
+      }).replace(/>\s+</g, "><"));
+      next();
+    } else {
+      next();
+    }
+  }
+
+  function defaultHandle(req, res, out) {
+    if (!wapp.contents.getComponent("html")) {
+      wapp.contents.addComponent({
+        html: defaultRender
+      });
+    }
+
+    var renderMiddlewares = Object.keys(renderMiddleware.handles).map(function (key) {
+      return renderMiddleware.handles[key];
+    });
+    renderMiddlewares.sort();
+    var index = 0;
+
+    function next(err) {
+      if (renderMiddlewares[index]) {
+        var func = renderMiddlewares[index];
+        index = index + 1;
+        return func(req, res, err ? function () {
+          next(err);
+        } : next);
+      } else if (typeof out === "function") {
+        index = 0;
+        return out(err);
+      }
+
+      return null;
+    }
+
+    return next();
+  }
+
+  var defaultRender = _html2["default"];
+
+  function defaultAddHandle(obj) {
+    if (typeof obj === "object" && !obj.length) {
+      Object.keys(obj).forEach(function (handleName) {
+        var handle = obj[handleName];
+
+        if (typeof handle == "function") {
+          renderMiddleware.handles[handleName] = handle;
+        }
+      });
+    }
+  }
+
+  var renderMiddlewareProperties = Object.create(Object.prototype, {
+    handle: (0, _objectSpread2["default"])((0, _objectSpread2["default"])({}, _utils.defaultDescriptor), {}, {
+      value: defaultHandle
+    }),
+    handles: (0, _objectSpread2["default"])((0, _objectSpread2["default"])({}, _utils.defaultDescriptor), {}, {
+      value: {
+        render: defaultRenderHandle
+      }
+    }),
+    render: (0, _objectSpread2["default"])((0, _objectSpread2["default"])({}, _utils.defaultDescriptor), {}, {
+      value: defaultRender
+    }),
+    addHandle: (0, _objectSpread2["default"])((0, _objectSpread2["default"])({}, _utils.defaultDescriptor), {}, {
+      value: defaultAddHandle
+    })
+  });
+
+  function renderMiddleware(req, res, next) {
+    if (typeof renderMiddleware.handle === "function") {
+      renderMiddleware.handle(req, res, next);
+    }
+
+    return renderMiddleware;
+  }
+
+  (0, _utils.mergeProperties)(renderMiddleware, renderMiddlewareProperties);
+  Object.defineProperty(renderMiddleware, "wapp", (0, _objectSpread2["default"])((0, _objectSpread2["default"])({}, _utils.defaultDescriptor), {}, {
+    writable: false,
+    enumerable: false,
+    value: wapp
+  }));
+  return renderMiddleware;
+}
+
+function createNotModifiedMiddleware() {
+  var p = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
+  var wapp = p.wapp;
+
+  function defaultIsFromCache(req, res) {
+    var ifMatch = req.headers["if-match"];
+    var ifUnmodifiedSince = req.headers["if-unmodified-since"];
+    var ifNoneMatch = req.headers["if-none-match"];
+    var ifModifiedSince = req.headers["if-modified-since"];
+    var cacheControl = req.headers["cache-control"];
+    var etag = res.getHeader("etag");
+    var lastModified = res.getHeader("last-modified");
+    var conditionalGet = ifMatch || ifUnmodifiedSince || ifNoneMatch || ifModifiedSince;
+    var isCacheable = res.wappResponse.statusCode >= 200 && res.wappResponse.statusCode < 300 || res.wappResponse.statusCode === 304;
+    var noCache = cacheControl && /(?:^|,)\s*?no-cache\s*?(?:,|$)/.test(cacheControl);
+    var unconditional = !ifUnmodifiedSince && !ifNoneMatch;
+
+    if (unconditional || noCache || !isCacheable || !conditionalGet) {
+      return false;
+    }
+
+    var fromCache = false;
+
+    if (ifNoneMatch && ifNoneMatch !== "*" && etag) {
+      var parseTokenList = function parseTokenList(str) {
+        var end = 0;
+        var list = [];
+        var start = 0;
+
+        for (var i = 0, len = str.length; i < len; i++) {
+          switch (str.charCodeAt(i)) {
+            case 0x20:
+              /*   */
+              if (start === end) {
+                start = end = i + 1;
+              }
+
+              break;
+
+            case 0x2c:
+              /* , */
+              list.push(str.substring(start, end));
+              start = end = i + 1;
+              break;
+
+            default:
+              end = i + 1;
+              break;
+          }
+        }
+
+        list.push(str.substring(start, end));
+        return list;
+      };
+
+      var matches = parseTokenList(ifNoneMatch);
+
+      for (var i = 0; i < matches.length; i++) {
+        var match = matches[i];
+
+        if (match === etag || match === "W/" + etag || "W/" + match === etag) {
+          fromCache = true;
+          break;
+        }
+      }
+    }
+
+    if (ifModifiedSince && lastModified) {
+      var parseHttpDate = function parseHttpDate(date) {
+        var timestamp = date && Date.parse(date);
+        return typeof timestamp === 'number' ? timestamp : NaN;
+      };
+
+      if (parseHttpDate(lastModified) <= parseHttpDate(ifModifiedSince)) {
+        fromCache = true;
+      }
+    }
+
+    return fromCache;
+  }
+
+  function defaultHandle(req, res, next) {
+    var fromCache = notModifiedMiddleware.isFromCache(req, res);
+
+    if (fromCache) {
+      res.wappResponse.status(304);
+      res.wapp.log(req, res);
+      res.end();
+    } else {
+      return next();
+    }
+  }
+
+  var notModifiedMiddlewareProperties = Object.create(Object.prototype, {
+    handle: (0, _objectSpread2["default"])((0, _objectSpread2["default"])({}, _utils.defaultDescriptor), {}, {
+      value: defaultHandle
+    }),
+    isFromCache: (0, _objectSpread2["default"])((0, _objectSpread2["default"])({}, _utils.defaultDescriptor), {}, {
+      value: defaultIsFromCache
+    })
+  });
+
+  function notModifiedMiddleware(req, res, next) {
+    if (typeof notModifiedMiddleware.handle === "function") {
+      notModifiedMiddleware.handle(req, res, next);
+    }
+
+    return notModifiedMiddleware;
+  }
+
+  (0, _utils.mergeProperties)(notModifiedMiddleware, notModifiedMiddlewareProperties);
+  Object.defineProperty(notModifiedMiddleware, "wapp", (0, _objectSpread2["default"])((0, _objectSpread2["default"])({}, _utils.defaultDescriptor), {}, {
+    writable: false,
+    enumerable: false,
+    value: wapp
+  }));
+  return notModifiedMiddleware;
+}
+
+function createMiddlewares(p) {
+  var _commonMiddlewares = (0, _middlewares["default"])(p),
+      log = _commonMiddlewares.log,
+      rest = (0, _objectWithoutProperties2["default"])(_commonMiddlewares, _excluded);
+
+  var wapp = p.wapp;
+  var wappMiddleware = wapp.middleware;
+  var notModifiedMiddleware = createNotModifiedMiddleware(p);
+  wappMiddleware.addSendMiddleware({
+    headers: function headers(req, res, next) {
+      var _res$wappResponse$sen = res.wappResponse.sendData,
+          sendData = _res$wappResponse$sen === void 0 ? {} : _res$wappResponse$sen;
+
+      if (res.setHeader) {
+        var data = sendData.data,
+            _sendData$stats = sendData.stats,
+            stats = _sendData$stats === void 0 ? {} : _sendData$stats,
+            _sendData$parsedPath = sendData.parsedPath,
+            parsedPath = _sendData$parsedPath === void 0 ? {} : _sendData$parsedPath;
+        var _html = data;
+        var _parsedPath$ext = parsedPath.ext,
+            ext = _parsedPath$ext === void 0 ? ".html" : _parsedPath$ext;
+        var mtime = stats.mtime;
+
+        if (!res.getHeader("Accept-Ranges")) {
+          res.setHeader("Accept-Ranges", "bytes");
+        }
+
+        if (!res.getHeader("Content-Type")) {
+          res.setHeader("Content-Type", mimeType[ext] || "text/plain");
+        }
+
+        if (!res.getHeader("Content-Length")) {
+          res.setHeader("Content-Length", Buffer.byteLength(_html));
+        }
+
+        if (!res.getHeader("Last-Modified") && mtime) {
+          res.setHeader("Last-Modified", mtime.toUTCString());
+        }
+
+        if (!res.getHeader("Cache-Control")) {
+          res.setHeader("Cache-Control", "public, max-age=0");
+        }
+
+        if (!res.getHeader("X-Powered-By")) {
+          res.setHeader("X-Powered-By", "Wapplr");
+        }
+      }
+
+      return next();
+    },
+    etag: function etag(req, res, next) {
+      var _res$wappResponse$sen2 = res.wappResponse.sendData,
+          sendData = _res$wappResponse$sen2 === void 0 ? {} : _res$wappResponse$sen2;
+
+      if (res.setHeader) {
+        var _sendData$stats2 = sendData.stats,
+            stats = _sendData$stats2 === void 0 ? {} : _sendData$stats2;
+        var mtime = stats.mtime,
+            size = stats.size;
+
+        if (!res.getHeader("ETag") && mtime && size) {
+          var etag = "W/\"".concat(size.toString(16), "-").concat(mtime.getTime().toString(16), "\"");
+          res.setHeader("ETag", etag);
+        }
+      }
+
+      return next();
+    },
+    notModified: function notModified(req, res, next) {
+      if (res.setHeader) {
+        var fromCache = notModifiedMiddleware.isFromCache(req, res);
+
+        if (fromCache) {
+          res.wappResponse.status(304);
+          res.wapp.log(req, res);
+          res.end();
+          return;
+        }
+      }
+
+      return next();
+    }
+  });
+  return (0, _objectSpread2["default"])((0, _objectSpread2["default"])({}, rest), {}, {
+    render: createRenderMiddleware(p),
+    log: log
+  });
+}

package/dist/server/static.js

@@ -0,0 +1,58 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports["default"] = serveStatic;
+
+var fs = require("fs");
+
+var path = require("path");
+
+function serveStatic(publicPath) {
+  return function staticMiddleware(req, res, next) {
+    var parsedUrl = {
+      pathname: req.wappRequest.path
+    };
+
+    try {
+      parsedUrl = new URL(req.wappRequest.url);
+    } catch (e) {}
+
+    var sanitizePath = path.normalize(parsedUrl.pathname).replace(/^(\.\.[\/\\])+/, "");
+    var pathname = path.join(publicPath, sanitizePath);
+    var paredSanitizePath = path.parse(pathname);
+    var ext = paredSanitizePath.ext;
+
+    if (!fs.existsSync(pathname) || !ext) {
+      return next();
+    }
+
+    try {
+      var data = fs.readFileSync(pathname);
+      var stats = fs.statSync(pathname);
+      res.wappResponse.status(200);
+      res.wappResponse.sendData = {
+        data: data,
+        stats: stats,
+        parsedPath: paredSanitizePath
+      };
+      var stream = fs.createReadStream(pathname);
+      stream.on("error", function onerror(err) {
+        res.wappResponse.status(err.statusCode || 500, err);
+        res.wapp.log(err, req, res);
+        next(err);
+      });
+      stream.on("open", function onopen() {
+        res.wapp.middleware.runSendMiddlewares(req, res, function next() {
+          res.wapp.log(req, res);
+          stream.pipe(res);
+        });
+      });
+    } catch (err) {
+      res.wappResponse.status(err.statusCode || 500, err);
+      res.wapp.log(err, req, res);
+      next(err);
+    }
+  };
+}

package/package.json

@@ -22,11 +22,11 @@
     "files": [
         "dist/*"
     ],
-    "version": "1.0.44",
+    "version": "1.0.45",
     "main": "dist/server",
     "browser": "dist/client",
     "repository": {
         "type": "git",
         "url": "https://github.com/wapplr/wapplr.git"
     }
-}
+}