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

package/lib/index.js

@@ -2,11 +2,11 @@
 
 Object.defineProperty(exports, '__esModule', { value: true });
 
-function _interopDefault (ex) { return (ex && (typeof ex === 'object') && 'default' in ex) ? ex['default'] : ex; }
-
-var deepMerge = _interopDefault(require('@faasjs/deep_merge'));
-var Logger = _interopDefault(require('@faasjs/logger'));
+var func = require('@faasjs/func');
+var deep_merge = require('@faasjs/deep_merge');
+var logger = require('@faasjs/logger');
 var crypto = require('crypto');
+var zlib = require('zlib');
 
 class Session {
     constructor(cookie, config) {
@@ -36,9 +36,8 @@ class Session {
         this.changed = false;
     }
     encode(text) {
-        if (typeof text !== 'string') {
+        if (typeof text !== 'string')
             text = JSON.stringify(text);
-        }
         const iv = crypto.randomBytes(16);
         const cipher = crypto.createCipheriv(this.config.cipherName, this.secret, iv);
         const encrypted = Buffer.concat([cipher.update(text), cipher.final()]).toString('base64');
@@ -54,9 +53,8 @@ class Session {
         const hmac = crypto.createHmac(this.config.digest, this.signedSecret);
         hmac.update(signedParts[0]);
         const digest = hmac.digest('hex');
-        if (signedParts[1] !== digest) {
+        if (signedParts[1] !== digest)
             throw Error('Not valid');
-        }
         const message = Buffer.from(signedParts[0], 'base64').toString();
         const parts = message.split('--').map(function (part) {
             return Buffer.from(part, 'base64');
@@ -64,33 +62,30 @@ class Session {
         const cipher = 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 decryptor = [part, final].join('');
-        return JSON.parse(decryptor);
+        const decrypt = [part, final].join('');
+        return JSON.parse(decrypt);
     }
     read(key) {
         return this.content[key];
     }
     write(key, value) {
-        if (value === null || typeof value === 'undefined') {
+        if (value === null || typeof value === 'undefined')
             delete this.content[key];
-        }
-        else {
+        else
             this.content[key] = value;
-        }
         this.changed = true;
         return this;
     }
     update() {
-        if (this.changed) {
+        if (this.changed)
             this.cookie.write(this.config.key, this.encode(JSON.stringify(this.content)));
-        }
         return this;
     }
 }
 
 class Cookie {
     constructor(config) {
-        this.config = deepMerge({
+        this.config = deep_merge.deepMerge({
             path: '/',
             expires: 31536000,
             secure: true,
@@ -104,15 +99,13 @@ class Cookie {
     invoke(cookie) {
         this.content = Object.create(null);
         // 解析 cookie
-        if (cookie) {
-            cookie.split(';').map((x) => {
+        if (cookie)
+            cookie.split(';').forEach(x => {
                 x = x.trim();
-                const k = x.match(/([^=]+)/);
-                if (k !== null) {
+                const k = /([^=]+)/.exec(x);
+                if (k !== null)
                     this.content[k[0]] = decodeURIComponent(x.replace(`${k[0]}=`, '').replace(/;$/, ''));
-                }
             });
-        }
         this.setCookie = Object.create(null);
         // 预读取 session
         this.session.invoke(this.read(this.session.config.key));
@@ -133,78 +126,60 @@ class Cookie {
             cookie = `${key}=${encodeURIComponent(value)};`;
             this.content[key] = value;
         }
-        if (typeof opts.expires === 'number') {
+        if (typeof opts.expires === 'number')
             cookie += `max-age=${opts.expires};`;
-        }
-        else if (typeof opts.expires === 'string') {
+        else if (typeof opts.expires === 'string')
             cookie += `expires=${opts.expires};`;
-        }
         cookie += `path=${opts.path || '/'};`;
-        if (opts.domain) {
+        if (opts.domain)
             cookie += `domain=${opts.domain};`;
-        }
-        if (opts.secure) {
+        if (opts.secure)
             cookie += 'Secure;';
-        }
-        if (opts.httpOnly) {
+        if (opts.httpOnly)
             cookie += 'HttpOnly;';
-        }
-        if (opts.sameSite) {
+        if (opts.sameSite)
             cookie += `SameSite=${opts.sameSite};`;
-        }
         this.setCookie[key] = cookie;
         return this;
     }
     headers() {
-        if (!Object.keys(this.setCookie).length) {
+        if (Object.keys(this.setCookie).length === 0)
             return {};
-        }
-        else {
-            return {
-                'Set-Cookie': Object.values(this.setCookie)
-            };
-        }
+        else
+            return { 'Set-Cookie': Object.values(this.setCookie) };
     }
 }
 
-class ValidError extends Error {
-    constructor({ statusCode, headers, message }) {
-        super(message);
-        this.statusCode = statusCode || 500;
-        this.headers = headers || Object.create(null);
-    }
-}
 class Validator {
-    constructor(config) {
+    constructor(config, logger) {
         this.paramsConfig = config.params;
         this.cookieConfig = config.cookie;
         this.sessionConfig = config.session;
-        this.logger = new Logger('Http.Validator');
+        this.before = config.before;
+        this.logger = logger;
     }
-    valid({ params, cookie, session }) {
-        this.request = {
-            params,
-            cookie,
-            session
-        };
-        this.logger.debug('Begin');
-        if (this.paramsConfig) {
-            this.logger.debug('Valid params');
-            this.validContent('params', params, '', this.paramsConfig);
-        }
-        if (this.cookieConfig) {
-            this.logger.debug('Valid cookie');
-            if (!cookie) {
+    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', cookie.content, '', this.cookieConfig);
+            this.validContent('cookie', request.cookie.content, '', this.cookieConfig);
         }
-        if (this.sessionConfig) {
+        if (this.sessionConfig && request.session) {
             this.logger.debug('Valid Session');
-            if (!session) {
+            if (request.session == null)
                 throw Error('Not found Session');
-            }
-            this.validContent('session', session.content, '', this.sessionConfig);
+            this.validContent('session', request.session.content, '', this.sessionConfig);
         }
     }
     validContent(type, params, baseKey, config) {
@@ -212,57 +187,50 @@ class Validator {
             const paramsKeys = Object.keys(params);
             const rulesKeys = Object.keys(config.rules);
             const diff = paramsKeys.filter(k => !rulesKeys.includes(k));
-            if (diff.length) {
+            if (diff.length > 0)
                 if (config.whitelist === 'error') {
                     const diffKeys = diff.map(k => `${baseKey}${k}`);
-                    const error = Error(`[${type}] Unpermitted keys: ${diffKeys.join(', ')}`);
+                    const error = Error(`[${type}] Not permitted keys: ${diffKeys.join(', ')}`);
                     if (config.onError) {
                         const res = config.onError(`${type}.whitelist`, baseKey, diffKeys);
-                        if (res) {
-                            throw new ValidError(res);
-                        }
+                        if (res)
+                            throw new HttpError(res);
                     }
                     throw error;
                 }
-                else if (config.whitelist === 'ignore') {
-                    for (const key of diff) {
+                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];
             // default
-            if (rule.default) {
-                if (type === 'cookie' || type === 'session') {
+            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;
                 }
-            }
             // required
-            if (rule.required === true) {
+            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 ValidError(res);
-                        }
+                        if (res)
+                            throw new HttpError(res);
                     }
                     throw error;
                 }
-            }
             if (typeof value !== 'undefined' && value !== null) {
                 // type
-                if (rule.type) {
-                    if (type === 'cookie') {
+                if (rule.type)
+                    if (type === 'cookie')
                         this.logger.warn('Cookie not support type rule');
-                    }
                     else {
                         let typed = true;
                         switch (rule.type) {
@@ -280,43 +248,33 @@ class Validator {
                             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 ValidError(res);
-                                }
+                                if (res)
+                                    throw new HttpError(res);
                             }
                             throw error;
                         }
                     }
-                }
                 // in
-                if (rule.in && !rule.in.includes(value)) {
+                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 ValidError(res);
-                        }
+                        if (res)
+                            throw new HttpError(res);
                     }
                     throw error;
                 }
                 // nest config
-                if (rule.config) {
-                    if (type === 'cookie') {
+                if (rule.config)
+                    if (type === 'cookie')
                         this.logger.warn('Cookie not support nest rule.');
-                    }
-                    else {
-                        if (Array.isArray(value)) {
-                            // array
-                            for (const val of value) {
-                                this.validContent(type, val, (baseKey ? `${baseKey}.${key}.` : `${key}.`), rule.config);
-                            }
-                        }
-                        else if (typeof value === 'object') {
-                            // object
-                            this.validContent(type, value, (baseKey ? `${baseKey}.${key}.` : `${key}.`), rule.config);
-                        }
-                    }
-                }
+                    else if (Array.isArray(value))
+                        // array
+                        for (const val of value)
+                            this.validContent(type, val, (baseKey ? `${baseKey}.${key}.` : `${key}.`), rule.config);
+                    else if (typeof value === 'object')
+                        // object
+                        this.validContent(type, value, (baseKey ? `${baseKey}.${key}.` : `${key}.`), rule.config);
             }
         }
     }
@@ -332,12 +290,26 @@ const ContentType = {
     json: 'application/json',
     jsonp: 'application/javascript'
 };
+class HttpError extends Error {
+    constructor({ statusCode, message }) {
+        super(message);
+        if (Error.captureStackTrace)
+            Error.captureStackTrace(this, HttpError);
+        this.statusCode = statusCode || 500;
+        this.message = message;
+    }
+}
+const Name = 'http';
 class Http {
     /**
      * 创建 Http 插件实例
      * @param config {object} 配置项
      * @param config.name {string} 配置名
      * @param config.config {object} 网关配置
+     * @param config.config.method {string} 请求方法，默认为 POST
+     * @param config.config.path {string} 请求路径，默认为云函数文件路径
+     * @param config.config.ignorePathPrefix {string} 排除的路径前缀，当设置 path 时无效
+     * @param config.config.cookie {object} Cookie 配置
      * @param config.validator {object} 入参校验配置
      * @param config.validator.params {object} params 校验配置
      * @param config.validator.params.whitelist {string} 白名单配置
@@ -351,56 +323,66 @@ class Http {
      * @param config.validator.session.whitelist {string} 白名单配置
      * @param config.validator.session.onError {function} 自定义报错
      * @param config.validator.session.rules {object} 参数校验规则
+     * @param config.validator.before {function} 参数校验前自定义函数
      */
-    constructor(config = Object.create(null)) {
-        this.logger = new Logger('Http');
-        this.type = 'http';
-        this.name = config.name;
-        this.config = config.config || Object.create(null);
-        if (config.validator) {
+    constructor(config) {
+        this.type = Name;
+        this.name = Name;
+        this.name = (config === null || config === void 0 ? void 0 : config.name) || this.type;
+        this.config = ((config === null || config === void 0 ? void 0 : config.config)) || Object.create(null);
+        if ((config === null || config === void 0 ? void 0 : config.validator))
             this.validatorOptions = config.validator;
-        }
+        this.logger = new 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('[Http] 组装网关配置');
-        this.logger.debug('%o', data);
-        const config = deepMerge(data.config.plugins[this.name || this.type], { config: this.config });
+        this.logger.debug('组装网关配置');
+        this.logger.debug('%j', data);
+        const config = data.config.plugins ?
+            deep_merge.deepMerge(data.config.plugins[this.name || this.type], { config: this.config }) :
+            { config: this.config };
         // 根据文件及文件夹名生成路径
-        config.config.path = '=/' + data.name.replace(/_/g, '/').replace(/\/index$/, '');
-        this.logger.debug('[Http] 组装完成 %o', config);
+        if (!config.config.path) {
+            config.config.path = '/' + ((_a = data.name) === null || _a === void 0 ? 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('组装完成 %j', config);
         // 引用服务商部署插件
-        // eslint-disable-next-line security/detect-non-literal-require, @typescript-eslint/no-var-requires
-        const Provider = require(config.provider.type);
+        // eslint-disable-next-line @typescript-eslint/no-var-requires
+        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[this.name || this.type]) {
-            this.config = deepMerge(this.config, data.config.plugins[this.name || this.type].config);
-        }
+        if (data.config.plugins && data.config.plugins[this.name || this.type])
+            this.config = deep_merge.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.validator = new Validator(this.validatorOptions, this.logger);
         }
         await next();
     }
     async onInvoke(data, next) {
-        this.logger.debug('[onInvoke] Parse & valid');
-        this.logger.time('http');
+        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)
-        };
+        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');
@@ -410,19 +392,23 @@ class Http {
                 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);
         }
-        this.logger.debug('[onInvoke] Parse cookie');
-        this.cookie.invoke(this.headers['cookie']);
-        this.logger.debug('[onInvoke] Cookie: %o', this.cookie.content);
-        this.logger.debug('[onInvoke] Session: %o', this.session.content);
         if (this.validator) {
             this.logger.debug('[onInvoke] Valid request');
             try {
-                this.validator.valid({
+                await this.validator.valid({
+                    headers: this.headers,
                     params: this.params,
                     cookie: this.cookie,
                     session: this.session
@@ -432,53 +418,85 @@ class Http {
                 this.logger.error(error);
                 data.response = {
                     statusCode: error.statusCode || 500,
-                    headers: Object.assign({
-                        'Content-Type': 'application/json; charset=utf-8',
-                        'X-Request-Id': data.context.request_id
-                    }, error.headers || {}),
-                    body: JSON.stringify({
-                        error: {
-                            message: error.message
-                        }
-                    })
+                    headers: { 'Content-Type': 'application/json; charset=utf-8' },
+                    body: JSON.stringify({ error: { message: error.message } })
                 };
                 return;
             }
         }
-        this.logger.timeEnd('http', '[onInvoke] Parse & valid done');
-        await next();
-        this.logger.debug('[onInvoke] Generate response');
-        this.logger.time('http');
-        // update seesion
+        try {
+            await next();
+        }
+        catch (error) {
+            data.response = error;
+        }
+        // update session
         this.session.update();
         // 处理 body
-        if (data.response) {
-            if (data.response instanceof Error || (data.response.constructor && data.response.constructor.name === 'Error')) {
+        if (data.response)
+            if (data.response instanceof Error || ((_a = data.response.constructor) === null || _a === void 0 ? void 0 : _a.name) === 'Error') {
                 // 当结果是错误类型时
                 this.logger.error(data.response);
                 this.response.body = JSON.stringify({ error: { message: data.response.message } });
-                this.response.statusCode = 500;
+                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) {
+            else if (Object.prototype.toString.call(data.response) === '[object Object]' && data.response.statusCode && data.response.headers)
                 // 当返回结果是响应结构体时
                 this.response = data.response;
-            }
-            else {
+            else
                 this.response.body = JSON.stringify({ data: data.response });
-            }
-        }
         // 处理 statusCode
-        if (!this.response.statusCode) {
+        if (!this.response.statusCode)
             this.response.statusCode = this.response.body ? 200 : 201;
-        }
         // 处理 headers
         this.response.headers = Object.assign({
             'Content-Type': 'application/json; charset=utf-8',
-            'X-Request-Id': new Date().getTime().toString()
+            'Cache-Control': 'no-cache, no-store'
         }, this.cookie.headers(), this.response.headers);
-        /* eslint-disable-next-line require-atomic-updates */
         data.response = this.response;
-        this.logger.timeEnd('http', '[onInvoke] done');
+        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 || _b === void 0 ? 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 = zlib.brotliCompressSync(originBody).toString('base64');
+            }
+            else if (acceptEncoding.includes('gzip')) {
+                data.response.headers['Content-Encoding'] = 'gzip';
+                data.response.body = zlib.gzipSync(originBody).toString('base64');
+            }
+            else if (acceptEncoding.includes('deflate')) {
+                data.response.headers['Content-Encoding'] = 'deflate';
+                data.response.body = 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'];
+        }
     }
     /**
      * 设置 header
@@ -495,12 +513,10 @@ class Http {
      * @param charset {string} 编码
      */
     setContentType(type, charset = 'utf-8') {
-        if (ContentType[type]) {
+        if (ContentType[type])
             this.setHeader('Content-Type', `${ContentType[type]}; charset=${charset}`);
-        }
-        else {
+        else
             this.setHeader('Content-Type', `${type}; charset=${charset}`);
-        }
         return this;
     }
     /**
@@ -519,10 +535,15 @@ class Http {
         this.response.body = body;
         return this;
     }
+}
+function useHttp(config) {
+    return func.usePlugin(new Http(config));
 }
 
 exports.ContentType = ContentType;
 exports.Cookie = Cookie;
 exports.Http = Http;
+exports.HttpError = HttpError;
 exports.Session = Session;
 exports.Validator = Validator;
+exports.useHttp = useHttp;

package/lib/session.d.ts

@@ -1,5 +1,5 @@
 import { Cookie } from './cookie';
-export interface SessionOptions {
+export declare type SessionOptions = {
     key: string;
     secret: string;
     salt?: string;
@@ -8,11 +8,12 @@ export interface SessionOptions {
     iterations?: number;
     digest?: string;
     cipherName?: string;
-}
-export declare class Session {
-    content: {
-        [key: string]: any;
-    };
+};
+export declare type SessionContent = string | number | {
+    [key: string]: any;
+} | null | undefined;
+export declare class Session<S extends Record<string, string> = any, C extends Record<string, string> = any> {
+    content: Record<string, string>;
     readonly config: {
         key: string;
         secret: string;
@@ -23,15 +24,15 @@ export declare class Session {
         digest: string;
         cipherName: string;
     };
-    private secret;
-    private signedSecret;
-    private cookie;
+    private readonly secret;
+    private readonly signedSecret;
+    private readonly cookie;
     private changed?;
-    constructor(cookie: Cookie, config: SessionOptions);
+    constructor(cookie: Cookie<C, S>, config: SessionOptions);
     invoke(cookie?: string): void;
-    encode(text: any): string;
-    decode(text: string): any;
-    read(key: string): any;
-    write(key: string, value?: any): this;
-    update(): this;
+    encode(text: SessionContent): string;
+    decode(text: string): SessionContent;
+    read(key: string): string;
+    write(key: string, value?: string): Session<S, C>;
+    update(): Session<S, C>;
 }