@faasjs/http 0.0.2-beta.99 → 0.0.3-beta.2

package/dist/index.js

@@ -0,0 +1,589 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var src_exports = {};
+__export(src_exports, {
+  ContentType: () => ContentType,
+  Cookie: () => Cookie,
+  Http: () => Http,
+  HttpError: () => HttpError,
+  Session: () => Session,
+  Validator: () => Validator,
+  useHttp: () => useHttp
+});
+module.exports = __toCommonJS(src_exports);
+var import_func = require("@faasjs/func");
+
+// ../deep_merge/src/index.ts
+var shouldMerge = function(item) {
+  const type = Object.prototype.toString.call(item);
+  return type === "[object Object]" || type === "[object Array]";
+};
+function deepMerge(...sources) {
+  let acc = /* @__PURE__ */ Object.create(null);
+  for (const source of sources)
+    if (source instanceof Array) {
+      if (!(acc instanceof Array))
+        acc = [];
+      acc = [...new Set(source.concat(...acc))];
+    } else if (shouldMerge(source))
+      for (const [key, value] of Object.entries(source)) {
+        let val;
+        if (shouldMerge(value))
+          val = deepMerge(acc[key], value);
+        else
+          val = value;
+        acc = {
+          ...acc,
+          [key]: val
+        };
+      }
+  return acc;
+}
+
+// src/index.ts
+var import_logger = require("@faasjs/logger");
+
+// src/session.ts
+var import_crypto = require("crypto");
+var Session = class {
+  constructor(cookie, config) {
+    this.cookie = cookie;
+    this.config = Object.assign({
+      key: "key",
+      secret: (0, import_crypto.randomBytes)(128).toString("hex"),
+      salt: "salt",
+      signedSalt: "signedSalt",
+      keylen: 64,
+      iterations: 100,
+      digest: "sha256",
+      cipherName: "aes-256-cbc"
+    }, config);
+    this.secret = (0, import_crypto.pbkdf2Sync)(
+      this.config.secret,
+      this.config.salt,
+      this.config.iterations,
+      this.config.keylen / 2,
+      this.config.digest
+    );
+    this.signedSecret = (0, import_crypto.pbkdf2Sync)(
+      this.config.secret,
+      this.config.signedSalt,
+      this.config.iterations,
+      this.config.keylen,
+      this.config.digest
+    );
+    this.content = /* @__PURE__ */ Object.create(null);
+  }
+  invoke(cookie) {
+    try {
+      this.content = cookie ? this.decode(cookie) : /* @__PURE__ */ Object.create(null);
+    } catch (error) {
+      console.error(error);
+      this.content = /* @__PURE__ */ Object.create(null);
+    }
+    this.changed = false;
+  }
+  encode(text) {
+    if (typeof text !== "string")
+      text = JSON.stringify(text);
+    const iv = (0, import_crypto.randomBytes)(16);
+    const cipher = (0, import_crypto.createCipheriv)(this.config.cipherName, this.secret, iv);
+    const encrypted = Buffer.concat([cipher.update(text), cipher.final()]).toString("base64");
+    const main = Buffer.from([encrypted, iv.toString("base64")].join("--")).toString("base64");
+    const hmac = (0, import_crypto.createHmac)(this.config.digest, this.signedSecret);
+    hmac.update(main);
+    const digest = hmac.digest("hex");
+    return main + "--" + digest;
+  }
+  decode(text) {
+    text = decodeURIComponent(text);
+    const signedParts = text.split("--");
+    const hmac = (0, import_crypto.createHmac)(this.config.digest, this.signedSecret);
+    hmac.update(signedParts[0]);
+    const digest = hmac.digest("hex");
+    if (signedParts[1] !== digest)
+      throw Error("Not valid");
+    const message = Buffer.from(signedParts[0], "base64").toString();
+    const parts = message.split("--").map(function(part2) {
+      return Buffer.from(part2, "base64");
+    });
+    const cipher = (0, import_crypto.createDecipheriv)(this.config.cipherName, this.secret, parts[1]);
+    const part = Buffer.from(cipher.update(parts[0])).toString("utf8");
+    const final = cipher.final("utf8");
+    const decrypt = [part, final].join("");
+    return JSON.parse(decrypt);
+  }
+  read(key) {
+    return this.content[key];
+  }
+  write(key, value) {
+    if (value === null || typeof value === "undefined")
+      delete this.content[key];
+    else
+      this.content[key] = value;
+    this.changed = true;
+    return this;
+  }
+  update() {
+    if (this.changed)
+      this.cookie.write(this.config.key, this.encode(JSON.stringify(this.content)));
+    return this;
+  }
+};
+
+// src/cookie.ts
+var Cookie = class {
+  constructor(config) {
+    this.config = deepMerge({
+      path: "/",
+      expires: 31536e3,
+      secure: true,
+      httpOnly: true,
+      session: {}
+    }, config);
+    this.session = new Session(this, this.config.session);
+    this.content = /* @__PURE__ */ Object.create(null);
+    this.setCookie = /* @__PURE__ */ Object.create(null);
+  }
+  invoke(cookie) {
+    this.content = /* @__PURE__ */ Object.create(null);
+    if (cookie)
+      cookie.split(";").forEach((x) => {
+        x = x.trim();
+        const k = /([^=]+)/.exec(x);
+        if (k !== null)
+          this.content[k[0]] = decodeURIComponent(x.replace(`${k[0]}=`, "").replace(/;$/, ""));
+      });
+    this.setCookie = /* @__PURE__ */ Object.create(null);
+    this.session.invoke(this.read(this.session.config.key));
+    return this;
+  }
+  read(key) {
+    return this.content[key];
+  }
+  write(key, value, opts) {
+    opts = Object.assign(this.config, opts || {});
+    let cookie;
+    if (value === null || typeof value === "undefined") {
+      opts.expires = "Thu, 01 Jan 1970 00:00:01 GMT";
+      cookie = `${key}=;`;
+      delete this.content[key];
+    } else {
+      cookie = `${key}=${encodeURIComponent(value)};`;
+      this.content[key] = value;
+    }
+    if (typeof opts.expires === "number")
+      cookie += `max-age=${opts.expires};`;
+    else if (typeof opts.expires === "string")
+      cookie += `expires=${opts.expires};`;
+    cookie += `path=${opts.path || "/"};`;
+    if (opts.domain)
+      cookie += `domain=${opts.domain};`;
+    if (opts.secure)
+      cookie += "Secure;";
+    if (opts.httpOnly)
+      cookie += "HttpOnly;";
+    if (opts.sameSite)
+      cookie += `SameSite=${opts.sameSite};`;
+    this.setCookie[key] = cookie;
+    return this;
+  }
+  headers() {
+    if (Object.keys(this.setCookie).length === 0)
+      return {};
+    else
+      return { "Set-Cookie": Object.values(this.setCookie) };
+  }
+};
+
+// src/validator.ts
+var Validator = class {
+  constructor(config) {
+    this.paramsConfig = config.params;
+    this.cookieConfig = config.cookie;
+    this.sessionConfig = config.session;
+    this.before = config.before;
+  }
+  async valid(request, logger) {
+    if (this.before) {
+      const result = await this.before(request);
+      if (result)
+        throw new HttpError(result);
+    }
+    this.request = request;
+    if (this.paramsConfig && request.params) {
+      logger.debug("Valid Params");
+      this.validContent("params", request.params, "", this.paramsConfig, logger);
+    }
+    if (this.cookieConfig && request.cookie) {
+      logger.debug("Valid Cookie");
+      if (request.cookie == null)
+        throw Error("Not found Cookie");
+      this.validContent(
+        "cookie",
+        request.cookie.content,
+        "",
+        this.cookieConfig,
+        logger
+      );
+    }
+    if (this.sessionConfig && request.session) {
+      logger.debug("Valid Session");
+      if (request.session == null)
+        throw Error("Not found Session");
+      this.validContent(
+        "session",
+        request.session.content,
+        "",
+        this.sessionConfig,
+        logger
+      );
+    }
+  }
+  validContent(type, params, baseKey, config, logger) {
+    if (config.whitelist) {
+      const paramsKeys = Object.keys(params);
+      const rulesKeys = Object.keys(config.rules);
+      const diff = paramsKeys.filter((k) => !rulesKeys.includes(k));
+      if (diff.length > 0) {
+        if (config.whitelist === "error") {
+          const diffKeys = diff.map((k) => `${baseKey}${k}`);
+          const error = Error(
+            `[${type}] Not permitted keys: ${diffKeys.join(", ")}`
+          );
+          if (config.onError) {
+            const res = config.onError(`${type}.whitelist`, baseKey, diffKeys);
+            if (res)
+              throw new HttpError(res);
+          }
+          throw error;
+        } else if (config.whitelist === "ignore")
+          for (const key of diff)
+            delete params[key];
+      }
+    }
+    for (const key in config.rules) {
+      const rule = config.rules[key];
+      if (!rule)
+        continue;
+      let value = params[key];
+      if (rule.default) {
+        if (type === "cookie" || type === "session")
+          logger.warn("Cookie and Session not support default rule.");
+        else if (typeof value === "undefined" && rule.default) {
+          value = typeof rule.default === "function" ? rule.default(this.request) : rule.default;
+          params[key] = value;
+        }
+      }
+      if (rule.required) {
+        if (typeof value === "undefined" || value === null) {
+          const error = Error(`[${type}] ${baseKey}${key} is required.`);
+          if (config.onError) {
+            const res = config.onError(
+              `${type}.rule.required`,
+              `${baseKey}${key}`,
+              value
+            );
+            if (res)
+              throw new HttpError(res);
+          }
+          throw error;
+        }
+      }
+      if (typeof value !== "undefined" && value !== null) {
+        if (rule.type)
+          if (type === "cookie")
+            logger.warn("Cookie not support type rule");
+          else {
+            let typed = true;
+            switch (rule.type) {
+              case "array":
+                typed = Array.isArray(value);
+                break;
+              case "object":
+                typed = Object.prototype.toString.call(value) === "[object Object]";
+                break;
+              default:
+                typed = typeof value === rule.type;
+                break;
+            }
+            if (!typed) {
+              const error = Error(
+                `[${type}] ${baseKey}${key} must be a ${rule.type}.`
+              );
+              if (config.onError) {
+                const res = config.onError(
+                  `${type}.rule.type`,
+                  `${baseKey}${key}`,
+                  value
+                );
+                if (res)
+                  throw new HttpError(res);
+              }
+              throw error;
+            }
+          }
+        if (rule.regexp && (rule.type === "string" || !rule.type) && !rule.regexp.test(value)) {
+          const error = Error(
+            `[${type}] ${baseKey}${key} must match ${rule.regexp}.`
+          );
+          if (config.onError) {
+            const res = config.onError(
+              `${type}.rule.regexp`,
+              `${baseKey}${key}`,
+              value
+            );
+            if (res)
+              throw new HttpError(res);
+          }
+          throw error;
+        }
+        if (rule.in && !rule.in.includes(value)) {
+          const error = Error(
+            `[${type}] ${baseKey}${key} must be in ${rule.in.join(", ")}.`
+          );
+          if (config.onError) {
+            const res = config.onError(
+              `${type}.rule.in`,
+              `${baseKey}${key}`,
+              value
+            );
+            if (res)
+              throw new HttpError(res);
+          }
+          throw error;
+        }
+        if (rule.config) {
+          if (type === "cookie")
+            logger.warn("Cookie not support nest rule.");
+          else if (Array.isArray(value))
+            for (const val of value)
+              this.validContent(
+                type,
+                val,
+                baseKey ? `${baseKey}.${key}.` : `${key}.`,
+                rule.config,
+                logger
+              );
+          else if (typeof value === "object")
+            this.validContent(
+              type,
+              value,
+              baseKey ? `${baseKey}.${key}.` : `${key}.`,
+              rule.config,
+              logger
+            );
+        }
+      }
+    }
+  }
+};
+
+// src/index.ts
+var import_zlib = require("zlib");
+var ContentType = {
+  plain: "text/plain",
+  html: "text/html",
+  xml: "application/xml",
+  csv: "text/csv",
+  css: "text/css",
+  javascript: "application/javascript",
+  json: "application/json",
+  jsonp: "application/javascript"
+};
+var HttpError = class extends Error {
+  constructor({
+    statusCode,
+    message
+  }) {
+    super(message);
+    if (Error.captureStackTrace)
+      Error.captureStackTrace(this, HttpError);
+    this.statusCode = statusCode || 500;
+    this.message = message;
+  }
+};
+var Name = "http";
+var Http = class {
+  constructor(config) {
+    this.type = Name;
+    this.name = Name;
+    this.name = (config == null ? void 0 : config.name) || this.type;
+    this.config = (config == null ? void 0 : config.config) || /* @__PURE__ */ Object.create(null);
+    if (config == null ? void 0 : config.validator)
+      this.validatorOptions = config.validator;
+    this.headers = /* @__PURE__ */ Object.create(null);
+    this.cookie = new Cookie(this.config.cookie || {});
+    this.session = this.cookie.session;
+  }
+  async onDeploy(data, next) {
+    var _a;
+    data.dependencies["@faasjs/http"] = "*";
+    await next();
+    const logger = new import_logger.Logger(this.name);
+    logger.debug("Generate api gateway's config");
+    logger.debug("%j", data);
+    const config = data.config.plugins ? deepMerge(data.config.plugins[this.name || this.type], { config: this.config }) : { config: this.config };
+    if (!config.config.path) {
+      config.config.path = "/" + ((_a = data.name) == null ? void 0 : _a.replace(/_/g, "/").replace(/\/index$/, ""));
+      if (config.config.path === "/index")
+        config.config.path = "/";
+      if (config.config.ignorePathPrefix) {
+        config.config.path = config.config.path.replace(new RegExp("^" + config.config.ignorePathPrefix), "");
+        if (config.config.path === "")
+          config.config.path = "/";
+      }
+    }
+    logger.debug("Api gateway's config: %j", config);
+    const Provider = require(config.provider.type).Provider;
+    const provider = new Provider(config.provider.config);
+    await provider.deploy(this.type, data, config);
+  }
+  async onMount(data, next) {
+    data.logger.debug("[onMount] merge config");
+    if (data.config.plugins && data.config.plugins[this.name || this.type])
+      this.config = deepMerge(this.config, data.config.plugins[this.name || this.type].config);
+    data.logger.debug("[onMount] prepare cookie & session");
+    this.cookie = new Cookie(this.config.cookie || {});
+    this.session = this.cookie.session;
+    if (this.validatorOptions) {
+      data.logger.debug("[onMount] prepare validator");
+      this.validator = new Validator(this.validatorOptions);
+    }
+    await next();
+  }
+  async onInvoke(data, next) {
+    var _a, _b;
+    this.headers = data.event.headers || /* @__PURE__ */ Object.create(null);
+    this.body = data.event.body;
+    this.params = data.event.queryString || /* @__PURE__ */ Object.create(null);
+    this.response = { headers: /* @__PURE__ */ Object.create(null) };
+    if (data.event.body) {
+      if ((_a = this.headers["content-type"]) == null ? void 0 : _a.includes("application/json")) {
+        data.logger.debug("[onInvoke] Parse params from json body");
+        this.params = Object.assign(this.params, JSON.parse(data.event.body));
+      } else {
+        data.logger.debug("[onInvoke] Parse params from raw body");
+        this.params = data.event.body || /* @__PURE__ */ Object.create(null);
+      }
+      data.logger.debug("[onInvoke] Params: %j", this.params);
+    }
+    this.cookie.invoke(this.headers.cookie);
+    if (this.headers.cookie) {
+      data.logger.debug("[onInvoke] Cookie: %j", this.cookie.content);
+      data.logger.debug("[onInvoke] Session: %j", this.session.content);
+    }
+    try {
+      if (this.validator) {
+        data.logger.debug("[onInvoke] Valid request");
+        await this.validator.valid({
+          headers: this.headers,
+          params: this.params,
+          cookie: this.cookie,
+          session: this.session
+        }, data.logger);
+      }
+      await next();
+    } catch (error) {
+      data.response = error;
+    }
+    this.session.update();
+    if (data.response)
+      if (data.response instanceof Error || ((_b = data.response.constructor) == null ? void 0 : _b.name) === "Error") {
+        data.logger.error(data.response);
+        this.response.body = JSON.stringify({ error: { message: data.response.message } });
+        try {
+          this.response.statusCode = data.response.statusCode || 500;
+        } catch (error) {
+          this.response.statusCode = 500;
+        }
+      } else if (Object.prototype.toString.call(data.response) === "[object Object]" && data.response.statusCode && data.response.headers)
+        this.response = data.response;
+      else
+        this.response.body = JSON.stringify({ data: data.response });
+    if (!this.response.statusCode)
+      this.response.statusCode = this.response.body ? 200 : 201;
+    this.response.headers = Object.assign({
+      "Content-Type": "application/json; charset=utf-8",
+      "Cache-Control": "no-cache, no-store"
+    }, this.cookie.headers(), this.response.headers);
+    data.response = Object.assign({}, data.response, this.response);
+    const originBody = data.response.body;
+    data.response.originBody = originBody;
+    if (originBody && !data.response.isBase64Encoded && typeof originBody !== "string")
+      data.response.body = JSON.stringify(originBody);
+    if (!data.response.body || data.response.isBase64Encoded || typeof data.response.body !== "string" || data.response.body.length < 1024)
+      return;
+    const acceptEncoding = this.headers["accept-encoding"] || this.headers["Accept-Encoding"];
+    if (!acceptEncoding || !/(br|gzip|deflate)/.test(acceptEncoding))
+      return;
+    try {
+      if (acceptEncoding.includes("br")) {
+        data.response.headers["Content-Encoding"] = "br";
+        data.response.body = (0, import_zlib.brotliCompressSync)(originBody).toString("base64");
+      } else if (acceptEncoding.includes("gzip")) {
+        data.response.headers["Content-Encoding"] = "gzip";
+        data.response.body = (0, import_zlib.gzipSync)(originBody).toString("base64");
+      } else if (acceptEncoding.includes("deflate")) {
+        data.response.headers["Content-Encoding"] = "deflate";
+        data.response.body = (0, import_zlib.deflateSync)(originBody).toString("base64");
+      } else
+        throw Error("No matched compression.");
+      data.response.isBase64Encoded = true;
+    } catch (error) {
+      console.error(error);
+      data.response.body = originBody;
+      delete data.response.headers["Content-Encoding"];
+    }
+  }
+  setHeader(key, value) {
+    this.response.headers[key] = value;
+    return this;
+  }
+  setContentType(type, charset = "utf-8") {
+    if (ContentType[type])
+      this.setHeader("Content-Type", `${ContentType[type]}; charset=${charset}`);
+    else
+      this.setHeader("Content-Type", `${type}; charset=${charset}`);
+    return this;
+  }
+  setStatusCode(code) {
+    this.response.statusCode = code;
+    return this;
+  }
+  setBody(body) {
+    this.response.body = body;
+    return this;
+  }
+};
+function useHttp(config) {
+  return (0, import_func.usePlugin)(new Http(config));
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ContentType,
+  Cookie,
+  Http,
+  HttpError,
+  Session,
+  Validator,
+  useHttp
+});