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

package/dist/index.mjs

@@ -0,0 +1,578 @@
+var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
+  get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
+}) : x)(function(x) {
+  if (typeof require !== "undefined")
+    return require.apply(this, arguments);
+  throw new Error('Dynamic require of "' + x + '" is not supported');
+});
+
+// src/index.ts
+import {
+  usePlugin
+} from "@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
+import { Logger } from "@faasjs/logger";
+
+// src/session.ts
+import {
+  randomBytes,
+  pbkdf2Sync,
+  createCipheriv,
+  createHmac,
+  createDecipheriv
+} from "crypto";
+var Session = class {
+  constructor(cookie, config) {
+    this.cookie = cookie;
+    this.config = Object.assign({
+      key: "key",
+      secret: randomBytes(128).toString("hex"),
+      salt: "salt",
+      signedSalt: "signedSalt",
+      keylen: 64,
+      iterations: 100,
+      digest: "sha256",
+      cipherName: "aes-256-cbc"
+    }, config);
+    this.secret = pbkdf2Sync(
+      this.config.secret,
+      this.config.salt,
+      this.config.iterations,
+      this.config.keylen / 2,
+      this.config.digest
+    );
+    this.signedSecret = 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 = randomBytes(16);
+    const cipher = 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 = 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 = 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 = 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
+import {
+  gzipSync,
+  deflateSync,
+  brotliCompressSync
+} from "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 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 = brotliCompressSync(originBody).toString("base64");
+      } else if (acceptEncoding.includes("gzip")) {
+        data.response.headers["Content-Encoding"] = "gzip";
+        data.response.body = gzipSync(originBody).toString("base64");
+      } else if (acceptEncoding.includes("deflate")) {
+        data.response.headers["Content-Encoding"] = "deflate";
+        data.response.body = 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 usePlugin(new Http(config));
+}
+export {
+  ContentType,
+  Cookie,
+  Http,
+  HttpError,
+  Session,
+  Validator,
+  useHttp
+};

package/package.json

@@ -1,24 +1,33 @@
 {
   "name": "@faasjs/http",
-  "version": "0.0.2-beta.99",
+  "version": "0.0.3-beta.2",
   "license": "MIT",
-  "main": "lib/index.js",
-  "module": "lib/index.es.js",
-  "types": "lib/index.d.ts",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "module": "dist/index.cjs",
+  "homepage": "https://faasjs.com/docs/http",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/faasjs/faasjs.git",
+    "directory": "packages/http"
+  },
+  "bugs": {
+    "url": "https://github.com/faasjs/faasjs/issues"
+  },
+  "funding": "https://github.com/sponsors/faasjs",
   "scripts": {
-    "prepack": "rm -rf ./lib && rollup -c && mv lib/*/src/* lib/"
+    "build": "tsup-node src/index.ts --format esm,cjs",
+    "build:types": "tsup-node src/index.ts --dts-only"
   },
   "files": [
-    "lib"
+    "dist"
   ],
-  "devDependencies": {
-    "@faasjs/func": "^0.0.2-beta.99",
-    "@types/debug": "*",
-    "@types/jest": "*",
-    "@types/node": "*",
-    "rollup": "*",
-    "rollup-plugin-typescript2": "*",
-    "typescript": "*"
+  "dependencies": {
+    "@faasjs/func": "^0.0.3-beta.2",
+    "@faasjs/logger": "^0.0.3-beta.2"
   },
-  "gitHead": "8c2bc1591c90b91123b6295845f43e09fac3e53b"
+  "engines": {
+    "npm": ">=8.0.0",
+    "node": ">=16.0.0"
+  }
 }

package/lib/cookie.d.ts

@@ -1,41 +0,0 @@
-import { Session, SessionOptions } from './session';
-export interface CookieOptions {
-    domain?: string;
-    path?: string;
-    expires?: number;
-    secure?: boolean;
-    httpOnly?: boolean;
-    sameSite?: 'Strict' | 'Lax' | 'None';
-    session?: SessionOptions;
-    [key: string]: any;
-}
-export declare class Cookie<C, S> {
-    session: Session<S, C>;
-    content: C;
-    readonly config: {
-        domain?: string;
-        path: string;
-        expires: number;
-        secure: boolean;
-        httpOnly: boolean;
-        sameSite?: 'Strict' | 'Lax' | 'None';
-        session: SessionOptions;
-    };
-    private setCookie;
-    constructor(config: CookieOptions);
-    invoke(cookie: string | undefined): this;
-    read(key: string): any;
-    write(key: string, value: any, opts?: {
-        domain?: string;
-        path?: string;
-        expires?: number | string;
-        secure?: boolean;
-        httpOnly?: boolean;
-        sameSite?: 'Strict' | 'Lax' | 'None';
-    }): this;
-    headers(): {
-        'Set-Cookie'?: undefined;
-    } | {
-        'Set-Cookie': string[];
-    };
-}