@faasjs/http 0.0.2-beta.3 → 0.0.2-beta.319

package/dist/index.js

@@ -0,0 +1,513 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __markAsModule = (target) => __defProp(target, "__esModule", { value: true });
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __reExport = (target, module2, copyDefault, desc) => {
+  if (module2 && typeof module2 === "object" || typeof module2 === "function") {
+    for (let key of __getOwnPropNames(module2))
+      if (!__hasOwnProp.call(target, key) && (copyDefault || key !== "default"))
+        __defProp(target, key, { get: () => module2[key], enumerable: !(desc = __getOwnPropDesc(module2, key)) || desc.enumerable });
+  }
+  return target;
+};
+var __toCommonJS = /* @__PURE__ */ ((cache) => {
+  return (module2, temp) => {
+    return cache && cache.get(module2) || (temp = __reExport(__markAsModule({}), module2, 1), cache && cache.set(module2, temp), temp);
+  };
+})(typeof WeakMap !== "undefined" ? /* @__PURE__ */ new WeakMap() : 0);
+
+// src/index.ts
+var src_exports = {};
+__export(src_exports, {
+  ContentType: () => ContentType,
+  Cookie: () => Cookie,
+  Http: () => Http,
+  HttpError: () => HttpError,
+  Session: () => Session,
+  Validator: () => Validator,
+  useHttp: () => useHttp
+});
+var import_func = require("@faasjs/func");
+var import_deep_merge2 = require("@faasjs/deep_merge");
+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 = Object.create(null);
+  }
+  invoke(cookie) {
+    try {
+      this.content = cookie ? this.decode(cookie) : Object.create(null);
+    } catch (error) {
+      console.error(error);
+      this.content = 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 import_deep_merge = require("@faasjs/deep_merge");
+var Cookie = class {
+  constructor(config) {
+    this.config = (0, import_deep_merge.deepMerge)({
+      path: "/",
+      expires: 31536e3,
+      secure: true,
+      httpOnly: true,
+      session: {}
+    }, config);
+    this.session = new Session(this, this.config.session);
+    this.content = Object.create(null);
+    this.setCookie = Object.create(null);
+  }
+  invoke(cookie) {
+    this.content = 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 = 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, logger) {
+    this.paramsConfig = config.params;
+    this.cookieConfig = config.cookie;
+    this.sessionConfig = config.session;
+    this.before = config.before;
+    this.logger = logger;
+  }
+  async valid(request) {
+    if (this.before) {
+      const result = await this.before(request);
+      if (result)
+        throw new HttpError(result);
+    }
+    this.request = request;
+    if (this.paramsConfig && request.params) {
+      this.logger.debug("Valid Params");
+      this.validContent("params", request.params, "", this.paramsConfig);
+    }
+    if (this.cookieConfig && request.cookie) {
+      this.logger.debug("Valid Cookie");
+      if (request.cookie == null)
+        throw Error("Not found Cookie");
+      this.validContent("cookie", request.cookie.content, "", this.cookieConfig);
+    }
+    if (this.sessionConfig && request.session) {
+      this.logger.debug("Valid Session");
+      if (request.session == null)
+        throw Error("Not found Session");
+      this.validContent("session", request.session.content, "", this.sessionConfig);
+    }
+  }
+  validContent(type, params, baseKey, config) {
+    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")
+          this.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")
+            this.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.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")
+            this.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);
+          else if (typeof value === "object")
+            this.validContent(type, value, baseKey ? `${baseKey}.${key}.` : `${key}.`, rule.config);
+        }
+      }
+    }
+  }
+};
+
+// 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) || Object.create(null);
+    if (config == null ? void 0 : config.validator)
+      this.validatorOptions = config.validator;
+    this.logger = new import_logger.Logger(this.name);
+    this.headers = Object.create(null);
+    this.cookie = new Cookie(this.config.cookie || {});
+    this.session = this.cookie.session;
+  }
+  async onDeploy(data, next) {
+    var _a;
+    await next();
+    this.logger.debug("\u7EC4\u88C5\u7F51\u5173\u914D\u7F6E");
+    this.logger.debug("%j", data);
+    const config = data.config.plugins ? (0, import_deep_merge2.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 = "/";
+      }
+    }
+    this.logger.debug("\u7EC4\u88C5\u5B8C\u6210 %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) {
+    this.logger.debug("[onMount] merge config");
+    if (data.config.plugins && data.config.plugins[this.name || this.type])
+      this.config = (0, import_deep_merge2.deepMerge)(this.config, data.config.plugins[this.name || this.type].config);
+    this.logger.debug("[onMount] prepare cookie & session");
+    this.cookie = new Cookie(this.config.cookie || {});
+    this.session = this.cookie.session;
+    if (this.validatorOptions) {
+      this.logger.debug("[onMount] prepare validator");
+      this.validator = new Validator(this.validatorOptions, this.logger);
+    }
+    await next();
+  }
+  async onInvoke(data, next) {
+    var _a, _b;
+    this.headers = data.event.headers || Object.create(null);
+    this.body = data.event.body;
+    this.params = Object.create(null);
+    this.response = { headers: Object.create(null) };
+    if (data.event.body) {
+      if (data.event.headers && data.event.headers["content-type"] && data.event.headers["content-type"].includes("application/json")) {
+        this.logger.debug("[onInvoke] Parse params from json body");
+        this.params = JSON.parse(data.event.body);
+      } else {
+        this.logger.debug("[onInvoke] Parse params from raw body");
+        this.params = data.event.body;
+      }
+      this.logger.debug("[onInvoke] Params: %j", this.params);
+    } else if (data.event.queryString) {
+      this.logger.debug("[onInvoke] Parse params from queryString");
+      this.params = data.event.queryString;
+      this.logger.debug("[onInvoke] Params: %j", this.params);
+    }
+    this.cookie.invoke(this.headers.cookie);
+    if (this.headers.cookie) {
+      this.logger.debug("[onInvoke] Cookie: %j", this.cookie.content);
+      this.logger.debug("[onInvoke] Session: %j", this.session.content);
+    }
+    if (this.validator) {
+      this.logger.debug("[onInvoke] Valid request");
+      try {
+        await this.validator.valid({
+          headers: this.headers,
+          params: this.params,
+          cookie: this.cookie,
+          session: this.session
+        });
+      } catch (error) {
+        this.logger.error(error);
+        data.response = {
+          statusCode: error.statusCode || 500,
+          headers: { "Content-Type": "application/json; charset=utf-8" },
+          body: JSON.stringify({ error: { message: error.message } })
+        };
+        return;
+      }
+    }
+    try {
+      await next();
+    } catch (error) {
+      data.response = error;
+    }
+    this.session.update();
+    if (data.response)
+      if (data.response instanceof Error || ((_a = data.response.constructor) == null ? void 0 : _a.name) === "Error") {
+        this.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 = this.response;
+    if (process.env.FaasMode === "local") {
+      this.logger.debug("[onInvoke] Response: %j", data.response);
+      return;
+    }
+    if (data.response.isBase64Encoded || typeof data.response.body !== "string" || !((_b = data.response.headers["Content-Type"]) == null ? void 0 : _b.includes("json")) || data.response.body.length < 100)
+      return;
+    const acceptEncoding = this.headers["accept-encoding"] || this.headers["Accept-Encoding"];
+    if (!acceptEncoding || !/(br|gzip|deflate)/.test(acceptEncoding))
+      return;
+    const originBody = data.response.body;
+    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;
+      data.response.originBody = originBody;
+    } 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));
+}
+module.exports = __toCommonJS(src_exports);
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ContentType,
+  Cookie,
+  Http,
+  HttpError,
+  Session,
+  Validator,
+  useHttp
+});