@jwn-js/common 2.0.9 → 2.0.14

package/Jwt.js

@@ -2,9 +2,43 @@
 
 Object.defineProperty(exports, '__esModule', { value: true });
 
-require('crypto');
-var Jwt = require('./Jwt-e49753f6.js');
+var crypto = require('crypto');
+var decoders = require('./decoders-ee9f4396.js');
 
+function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; }
 
+var crypto__default = /*#__PURE__*/_interopDefaultLegacy(crypto);
 
-exports.Jwt = Jwt.Jwt;
+class Jwt {
+  constructor(secret, opt) {
+    this.algorithm = "SHA256";
+    this.secret = secret;
+    this.algorithm = opt?.algorithm || this.algorithm;
+    this.algorithm = this.algorithm.replace("-", "");
+  }
+  verify(jwt) {
+    if (!jwt) {
+      return false;
+    }
+    const parts = jwt.split(".");
+    const signature = decoders.urlEncode(crypto__default["default"].createHmac(this.algorithm, this.secret).update(`${parts[0]}.${parts[1]}`).digest("base64"));
+    return signature === parts[2];
+  }
+  sign(data) {
+    const head = decoders.toBase64url({
+      alg: this.algorithm.replace("SHA", "HS"),
+      typ: "JWT"
+    });
+    const body = decoders.toBase64url(data);
+    const signature = decoders.urlEncode(crypto__default["default"].createHmac(this.algorithm, this.secret).update(`${head}.${body}`).digest("base64"));
+    return `${head}.${body}.${signature}`;
+  }
+  decode(jwt) {
+    const parts = (jwt || "").split(".");
+    const head = decoders.fromBase64url(parts[0]);
+    const body = decoders.fromBase64url(parts[1]);
+    return { head, body };
+  }
+}
+
+exports.Jwt = Jwt;

package/Memcached.d.ts

@@ -16,6 +16,10 @@ declare class Memcached {
     constructor(memjs: Client | null, specialHeaders?: {
         'x-cache': string;
     }, maxKeyLength?: number, debug?: number);
+    /**
+     * Is Client exists
+     */
+    isClient(): boolean;
     /**
      * Set value to memcache
      * @param key string key

package/Memcached.js

@@ -11,6 +11,9 @@ class Memcached {
     this.debug = debug;
     this.prefix = process.env.NODE_ENV !== "production" ? "dev::" : "";
   }
+  isClient() {
+    return !!this.memjs;
+  }
   async setValue(key, value, expires) {
     if ((expires || expires === 0) && key.length <= this.maxKeyLength && this.memjs) {
       try {

package/Server.js

@@ -2,11 +2,235 @@
 
 Object.defineProperty(exports, '__esModule', { value: true });
 
-require('dns');
-require('uWebSockets.js');
-var Server = require('./Server-dadc1f87.js');
+var dns = require('dns');
+var uws = require('uWebSockets.js');
+var cookieParse = require('./cookieParse-49f1da46.js');
 
+function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; }
 
+var dns__default = /*#__PURE__*/_interopDefaultLegacy(dns);
+var uws__default = /*#__PURE__*/_interopDefaultLegacy(uws);
 
-exports.Server = Server.Server;
-exports.codeToStatus = Server.codeToStatus;
+const status = {
+  100: "100 Continue",
+  101: "101 Switching Protocols",
+  200: "200 OK",
+  201: "201 Created",
+  202: "202 Accepted",
+  203: "203 Non-Authoritative Information",
+  204: "No Content",
+  205: "205 Reset Content",
+  206: "206 Partial Content",
+  300: "300 Multiple Choices",
+  301: "301 Moved Permanently",
+  302: "302 Found",
+  303: "303 See Other",
+  304: "304 Not Modified",
+  305: "305 Use Proxy",
+  306: "306 (Unused)",
+  307: "307 Temporary Redirect",
+  400: "400 Bad Request",
+  401: "401 Unauthorized",
+  402: "402 Payment Required",
+  403: "403 Forbidden",
+  404: "404 Not Found",
+  405: "405 Method Not Allowed",
+  406: "406 Not Acceptable",
+  407: "407 Proxy Authentication Required",
+  408: "408 Request Timeout",
+  409: "409 Conflict",
+  410: "410 Gone",
+  411: "411 Length Required",
+  412: "412 Precondition Failed",
+  413: "413 Request Entity Too Large",
+  414: "414 Request-URI Too Long",
+  415: "415 Unsupported Media Type",
+  416: "416 Requested Range Not Satisfiable",
+  417: "417 Expectation Failed",
+  500: "500 Internal Server Error",
+  501: "501 Not Implemented",
+  502: "502 Bad Gateway",
+  503: "503 Service Unavailable",
+  504: "504 Gateway Timeout",
+  505: "505 HTTP Version Not Supported"
+};
+const codeToStatus = (code) => {
+  return status.hasOwnProperty(code) ? status[code] : `${code}`;
+};
+class Server {
+  constructor(options) {
+    this._socket = null;
+    this._timeout = 0;
+    this._routes = [];
+    this._host = "localhost";
+    this._port = 3e3;
+    this._mode = "production";
+    this._appOptions = {};
+    this._defaultRoute = {
+      method: "get",
+      pattern: "/*",
+      handler: (res, req, next) => next()
+    };
+    this._routes = options.routes || this._routes;
+    this._host = options.host || this._host;
+    this._port = options.port || this._port;
+    this._timeout = options.timeout || this._timeout;
+    this._mode = options.mode || this._mode;
+    this._appOptions = options.appOptions || this._appOptions;
+  }
+  getApp() {
+    return this._app;
+  }
+  app() {
+    this._protocol = "http";
+    this._app = uws__default["default"].App(this._appOptions);
+    return this;
+  }
+  sslApp() {
+    this._protocol = "https";
+    this._app = uws__default["default"].SSLApp(this._appOptions);
+    return this;
+  }
+  push(route) {
+    this._routes.push(route);
+    return this;
+  }
+  unshift(route) {
+    this._routes.unshift(route);
+    return this;
+  }
+  listen(host, port, fn = () => {
+  }) {
+    if (typeof port === "number") {
+      this._port = port;
+      this._host = host;
+    } else if (typeof host === "number") {
+      if (typeof port === "function") {
+        fn = port;
+      }
+      this._port = host;
+    } else if (typeof host === "function") {
+      fn = host;
+    }
+    if (!this._app) {
+      throw new Error("Create app or sslApp first");
+    }
+    this._lookup(this._host, (ip) => {
+      for (let route of this._routes) {
+        route = typeof route === "function" ? { handler: route } : route;
+        route = Object.assign({}, this._defaultRoute, route);
+        switch (route.method) {
+          case "ws":
+            this._app[route.method](route.pattern, route.behavior);
+            break;
+          default:
+            const routeHandler = route;
+            this._app[routeHandler.method](route.pattern, (res, req) => {
+              res.redirect = (url, code = 307) => this.constructor._redirect(res, req, url, code);
+              req.cookies = cookieParse.cookieParse(req.getHeader("cookie"));
+              Promise.race([
+                this._abortTimeout(res, req),
+                this._createHandler(res, req, routeHandler.handler)
+              ]);
+            });
+        }
+      }
+      this._app.listen(ip, this._port, (listenSocket) => {
+        fn(listenSocket);
+        if (listenSocket) {
+          this._socket = listenSocket;
+          if (this._mode === "development") {
+            console.log(`Listening ${this._protocol}://${this._host}:${this._port}`);
+          }
+        } else {
+          console.error(`Error start server on ${this._protocol}://${this._host}:${this._port}`);
+        }
+      });
+    });
+    return this;
+  }
+  async close() {
+    if (this._socket) {
+      await uws__default["default"].us_listen_socket_close(this._socket);
+      while (true) {
+        await new Promise((resolve) => setTimeout(resolve, 50));
+        if (await this.socketPort() < 0) {
+          break;
+        }
+      }
+      this._socket = null;
+    }
+    return this;
+  }
+  async socketPort() {
+    if (!this._socket) {
+      return -1;
+    }
+    return uws__default["default"].us_socket_local_port(this._socket);
+  }
+  _createHandler(res, req, fn) {
+    return new Promise(async (resolve) => {
+      const end = () => {
+        clearTimeout(this._timeoutId);
+        resolve();
+      };
+      try {
+        const next = (param, code = 307) => {
+          if (typeof param === "boolean") {
+            req.setYield(param);
+          }
+          if (param instanceof Error) {
+            throw param;
+          }
+          if (typeof param === "string") {
+            res.redirect(param, code);
+          }
+          end();
+        };
+        const result = fn(res, req, next);
+        if (result instanceof Promise) {
+          next(await result);
+        }
+      } catch (e) {
+        const body = this._mode === "development" ? e.message : "";
+        try {
+          res.writeStatus("404 Not Found").end(body);
+        } catch (e2) {
+        }
+        end();
+      }
+    });
+  }
+  static _redirect(res, req, url, code = 307) {
+    let status2 = "307 Temporary Redirect";
+    if (code === 301) {
+      status2 = "301 Moved Permanently";
+    }
+    res.writeStatus(status2).writeHeader("location", url).end();
+  }
+  _abortTimeout(res, req) {
+    return new Promise((resolve) => {
+      if (this._timeout && !req.getHeader("x-no-timeout")) {
+        this._timeoutId = setTimeout(() => {
+          try {
+            res.writeStatus("408 Request Timeout").end();
+            resolve();
+          } catch (e) {
+          }
+        }, this._timeout);
+      }
+    });
+  }
+  _lookup(host, resolve) {
+    dns__default["default"].lookup(this._host, (err, addresses) => {
+      if (err) {
+        console.log(`${this._host} error: ${err.message}`);
+      } else {
+        resolve(Buffer.from(addresses));
+      }
+    });
+  }
+}
+
+exports.Server = Server;
+exports.codeToStatus = codeToStatus;

package/cookieParse-49f1da46.js

@@ -0,0 +1,25 @@
+'use strict';
+
+const cookieParse = (str) => {
+  if (!str) {
+    return {};
+  }
+  return str.split(/; */).reduce((obj, str2) => {
+    if (str2 === "") {
+      return obj;
+    }
+    const eq = str2.indexOf("=");
+    const key = eq > 0 ? str2.slice(0, eq) : str2;
+    let val = eq > 0 ? str2.slice(eq + 1) : null;
+    if (val != null) {
+      try {
+        val = decodeURIComponent(val);
+      } catch (ex) {
+      }
+    }
+    obj[key] = val;
+    return obj;
+  }, {});
+};
+
+exports.cookieParse = cookieParse;

package/decoders-ee9f4396.js

@@ -0,0 +1,18 @@
+'use strict';
+
+const urlEncode = (str) => {
+  return str.replace(/\+/ig, "-").replace(/\//ig, "_").replace(/=+$/, "");
+};
+const urlDecode = (str) => {
+  return str.replace(/-/ig, "+").replace(/_/ig, "/");
+};
+const toBase64url = (params) => {
+  return urlEncode(Buffer.from(JSON.stringify(params)).toString("base64"));
+};
+const fromBase64url = (str) => {
+  return JSON.parse(Buffer.from(urlDecode(str), "base64").toString());
+};
+
+exports.fromBase64url = fromBase64url;
+exports.toBase64url = toBase64url;
+exports.urlEncode = urlEncode;