@faasjs/http 0.0.2-beta.43 → 0.0.2-beta.430

package/lib/index.js

@@ -1,524 +0,0 @@
-'use strict';
-
-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 crypto = require('crypto');
-
-class Session {
-    constructor(cookie, config) {
-        this.cookie = cookie;
-        this.config = Object.assign({
-            key: 'key',
-            secret: crypto.randomBytes(128).toString('hex'),
-            salt: 'salt',
-            signedSalt: 'signedSalt',
-            keylen: 64,
-            iterations: 100,
-            digest: 'sha256',
-            cipherName: 'aes-256-cbc'
-        }, config);
-        this.secret = crypto.pbkdf2Sync(this.config.secret, this.config.salt, this.config.iterations, this.config.keylen / 2, this.config.digest);
-        this.signedSecret = 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 = crypto.randomBytes(16);
-        const cipher = 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 = 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 = 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 (part) {
-            return Buffer.from(part, 'base64');
-        });
-        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);
-    }
-    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;
-    }
-}
-
-class Cookie {
-    constructor(config) {
-        this.config = deepMerge({
-            path: '/',
-            expires: 31536000,
-            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);
-        // 解析 cookie
-        if (cookie) {
-            cookie.split(';').map((x) => {
-                x = x.trim();
-                const k = x.match(/([^=]+)/);
-                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));
-        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) {
-            return {};
-        }
-        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) {
-        this.paramsConfig = config.params;
-        this.cookieConfig = config.cookie;
-        this.sessionConfig = config.session;
-        this.logger = new Logger('Http.Validator');
-    }
-    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) {
-                throw Error('Not found Cookie');
-            }
-            this.validContent('cookie', cookie.content, '', this.cookieConfig);
-        }
-        if (this.sessionConfig) {
-            this.logger.debug('Valid Session');
-            if (!session) {
-                throw Error('Not found Session');
-            }
-            this.validContent('session', 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) {
-                if (config.whitelist === 'error') {
-                    const diffKeys = diff.map(k => `${baseKey}${k}`);
-                    const error = Error(`[${type}] Unpermitted keys: ${diffKeys.join(', ')}`);
-                    if (config.onError) {
-                        const res = config.onError(`${type}.whitelist`, baseKey, diffKeys);
-                        if (res) {
-                            throw new ValidError(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];
-            let value = params[key];
-            // default
-            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 (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);
-                        }
-                    }
-                    throw error;
-                }
-            }
-            if (typeof value !== 'undefined' && value !== null) {
-                // type
-                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 ValidError(res);
-                                }
-                            }
-                            throw error;
-                        }
-                    }
-                }
-                // in
-                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);
-                        }
-                    }
-                    throw error;
-                }
-                // nest config
-                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);
-                        }
-                    }
-                }
-            }
-        }
-    }
-}
-
-const 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'
-};
-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} 白名单配置
-     * @param config.validator.params.onError {function} 自定义报错
-     * @param config.validator.params.rules {object} 参数校验规则
-     * @param config.validator.cookie {object} cookie 校验配置
-     * @param config.validator.cookie.whitelist {string} 白名单配置
-     * @param config.validator.cookie.onError {function} 自定义报错
-     * @param config.validator.cookie.rules {object} 参数校验规则
-     * @param config.validator.session {object} session 校验配置
-     * @param config.validator.session.whitelist {string} 白名单配置
-     * @param config.validator.session.onError {function} 自定义报错
-     * @param config.validator.session.rules {object} 参数校验规则
-     */
-    constructor(config = Object.create(null)) {
-        this.type = 'http';
-        this.name = config.name || this.type;
-        this.config = config.config || Object.create(null);
-        if (config.validator)
-            this.validatorOptions = config.validator;
-        this.logger = new Logger(this.name);
-        this.headers = Object.create(null);
-        this.cookie = new Cookie(this.config.cookie || {});
-        this.session = this.cookie.session;
-    }
-    async onDeploy(data, next) {
-        await next();
-        this.logger.debug('组装网关配置');
-        this.logger.debug('%o', data);
-        const config = deepMerge(data.config.plugins[this.name || this.type], { config: this.config });
-        // 根据文件及文件夹名生成路径
-        if (!config.config.path) {
-            config.config.path = '=/' + data.name.replace(/_/g, '/').replace(/\/index$/, '');
-            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('组装完成 %o', config);
-        // 引用服务商部署插件
-        // eslint-disable-next-line @typescript-eslint/no-var-requires, @typescript-eslint/no-require-imports
-        const Provider = require(config.provider.type);
-        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);
-        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);
-        }
-        await next();
-    }
-    async onInvoke(data, next) {
-        this.headers = data.event.headers || Object.create(null);
-        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;
-            }
-        else if (data.event.queryString) {
-            this.logger.debug('[onInvoke] Parse params from queryString');
-            this.params = data.event.queryString;
-        }
-        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({
-                    params: this.params,
-                    cookie: this.cookie,
-                    session: this.session
-                });
-            }
-            catch (error) {
-                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 } })
-                };
-                return;
-            }
-        }
-        try {
-            await next();
-        }
-        catch (error) {
-            data.response = error;
-        }
-        // update seesion
-        this.session.update();
-        // 处理 body
-        if (data.response)
-            if (data.response instanceof Error || (data.response.constructor && data.response.constructor.name === 'Error')) {
-                // 当结果是错误类型时
-                this.logger.error(data.response);
-                this.response.body = JSON.stringify({ error: { message: data.response.message } });
-                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 });
-            }
-        // 处理 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()
-        }, this.cookie.headers(), this.response.headers);
-        data.response = this.response;
-    }
-    /**
-     * 设置 header
-     * @param key {string} key
-     * @param value {*} value
-     */
-    setHeader(key, value) {
-        this.response.headers[key] = value;
-        return this;
-    }
-    /**
-     * 设置 Content-Type
-     * @param type {string} 类型
-     * @param charset {string} 编码
-     */
-    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;
-    }
-    /**
-     * 设置状态码
-     * @param code {number} 状态码
-     */
-    setStatusCode(code) {
-        this.response.statusCode = code;
-        return this;
-    }
-    /**
-     * 设置 body
-     * @param body {*} 内容
-     */
-    setBody(body) {
-        this.response.body = body;
-        return this;
-    }
-}
-
-exports.ContentType = ContentType;
-exports.Cookie = Cookie;
-exports.Http = Http;
-exports.Session = Session;
-exports.Validator = Validator;

package/lib/session.d.ts

@@ -1,37 +0,0 @@
-import { Cookie } from './cookie';
-export interface SessionOptions {
-    key: string;
-    secret: string;
-    salt?: string;
-    signedSalt?: string;
-    keylen?: number;
-    iterations?: number;
-    digest?: string;
-    cipherName?: string;
-}
-export declare class Session {
-    content: {
-        [key: string]: any;
-    };
-    readonly config: {
-        key: string;
-        secret: string;
-        salt: string;
-        signedSalt: string;
-        keylen: number;
-        iterations: number;
-        digest: string;
-        cipherName: string;
-    };
-    private secret;
-    private signedSecret;
-    private cookie;
-    private changed?;
-    constructor(cookie: Cookie, 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;
-}

package/lib/validator.d.ts

@@ -1,42 +0,0 @@
-import { Cookie } from './cookie';
-import { Session } from './session';
-export interface ValidatorRuleOptions {
-    type?: 'string' | 'number' | 'boolean' | 'object' | 'array';
-    required?: boolean;
-    in?: any[];
-    default?: any;
-    config?: Partial<ValidatorOptions>;
-}
-export interface ValidatorOptions {
-    whitelist?: 'error' | 'ignore';
-    rules: {
-        [key: string]: ValidatorRuleOptions;
-    };
-    onError?: (type: string, key: string | string[], value?: any) => {
-        statusCode?: number;
-        headers?: {
-            [key: string]: any;
-        };
-        message: any;
-    } | void;
-}
-export declare class Validator {
-    paramsConfig?: ValidatorOptions;
-    cookieConfig?: ValidatorOptions;
-    sessionConfig?: ValidatorOptions;
-    private request?;
-    private logger;
-    constructor(config: {
-        params?: ValidatorOptions;
-        cookie?: ValidatorOptions;
-        session?: ValidatorOptions;
-    });
-    valid({ params, cookie, session }: {
-        params?: any;
-        cookie?: Cookie;
-        session?: Session;
-    }): void;
-    validContent(type: string, params: {
-        [key: string]: any;
-    }, baseKey: string, config: ValidatorOptions): void;
-}