node-easywechat 2.9.3 → 3.0.0-alpha.1

package/dist/Core/Http/Contracts/ServerRequestInterface.d.ts

@@ -0,0 +1,78 @@
+import RequestInterface from "./RequestInterface";
+declare abstract class ServerRequestInterface extends RequestInterface {
+    /**
+     * 获取所有服务端参数
+     * @returns
+     */
+    getServerParams(): Record<string, any>;
+    /**
+     * 获取所有cookie参数
+     * @returns
+     */
+    getCookieParams(): Record<string, any>;
+    /**
+     * 设置cookie参数
+     * @param cookies
+     * @returns
+     */
+    withCookieParams(cookies: Record<string, any>): this;
+    /**
+     * 获取所有get参数
+     * @returns
+     */
+    getQueryParams(): Record<string, any>;
+    /**
+     * 设置get参数
+     * @param query
+     * @returns
+     */
+    withQueryParams(query: Record<string, any>): this;
+    /**
+     * 获取所有上传文件
+     * @returns
+     */
+    getUploadedFiles(): Record<string, any>;
+    /**
+     * 设置上传文件
+     * @param files
+     * @returns
+     */
+    withUploadedFiles(files: Record<string, any>): this;
+    /**
+     * 获取所有post参数
+     * @returns
+     */
+    getParsedBody(): Record<string, any>;
+    /**
+     * 设置post参数
+     * @param data
+     * @returns
+     */
+    withParsedBody(data: Record<string, any>): this;
+    /**
+     * 获取所有属性
+     * @returns
+     */
+    getAttributes(): Record<string, any>;
+    /**
+     * 获取单个属性
+     * @param name
+     * @param defaultValue
+     * @returns
+     */
+    getAttribute(name: string, defaultValue?: any): any;
+    /**
+     * 设置属性值
+     * @param name
+     * @param value
+     * @returns
+     */
+    withAttribute(name: string, value: any): this;
+    /**
+     * 删除属性
+     * @param name
+     * @returns
+     */
+    withoutAttribute(name: string): this;
+}
+export = ServerRequestInterface;

package/dist/Core/Http/Contracts/ServerRequestInterface.js

@@ -0,0 +1,83 @@
+'use strict';
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+const RequestInterface_1 = __importDefault(require("./RequestInterface"));
+class ServerRequestInterface extends RequestInterface_1.default {
+    /**
+     * 获取所有服务端参数
+     * @returns
+     */
+    getServerParams() { return null; }
+    /**
+     * 获取所有cookie参数
+     * @returns
+     */
+    getCookieParams() { return null; }
+    /**
+     * 设置cookie参数
+     * @param cookies
+     * @returns
+     */
+    withCookieParams(cookies) { return this; }
+    /**
+     * 获取所有get参数
+     * @returns
+     */
+    getQueryParams() { return null; }
+    /**
+     * 设置get参数
+     * @param query
+     * @returns
+     */
+    withQueryParams(query) { return this; }
+    /**
+     * 获取所有上传文件
+     * @returns
+     */
+    getUploadedFiles() { return null; }
+    /**
+     * 设置上传文件
+     * @param files
+     * @returns
+     */
+    withUploadedFiles(files) { return this; }
+    /**
+     * 获取所有post参数
+     * @returns
+     */
+    getParsedBody() { return null; }
+    /**
+     * 设置post参数
+     * @param data
+     * @returns
+     */
+    withParsedBody(data) { return this; }
+    /**
+     * 获取所有属性
+     * @returns
+     */
+    getAttributes() { return null; }
+    /**
+     * 获取单个属性
+     * @param name
+     * @param defaultValue
+     * @returns
+     */
+    getAttribute(name, defaultValue = null) { return null; }
+    /**
+     * 设置属性值
+     * @param name
+     * @param value
+     * @returns
+     */
+    withAttribute(name, value) { return this; }
+    /**
+     * 删除属性
+     * @param name
+     * @returns
+     */
+    withoutAttribute(name) { return this; }
+}
+;
+module.exports = ServerRequestInterface;

package/dist/Core/Http/Minxins/MessageMixin.d.ts

@@ -0,0 +1,24 @@
+/// <reference types="node" />
+declare class MessageMixin {
+    protected headers: Record<string, any>;
+    protected protocal: string;
+    protected content: Buffer;
+    getProtocolVersion(): string;
+    withProtocolVersion(protocal: string): this;
+    getHeaders(): Record<string, any>;
+    hasHeader(name: string): boolean;
+    getHeader(name: string): any;
+    getHeaderLine(name: string): any;
+    withHeader(name: string, value: string | string[]): this;
+    withAddedHeader(name: string, value: string | string[]): this;
+    withoutHeader(name: string): this;
+    getBody(): Buffer;
+    withBody(body: any): this;
+    /**
+     * 设置headers
+     * @param headers
+     * @returns
+     */
+    protected setHeaders(headers: Record<string, any>): this;
+}
+export = MessageMixin;

package/dist/Core/Http/Minxins/MessageMixin.js

@@ -0,0 +1,93 @@
+'use strict';
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+const merge_1 = __importDefault(require("merge"));
+class MessageMixin {
+    constructor() {
+        this.headers = {};
+        this.protocal = '1.1';
+    }
+    getProtocolVersion() {
+        return this.protocal;
+    }
+    withProtocolVersion(protocal) {
+        this.protocal = protocal;
+        return this;
+    }
+    getHeaders() {
+        return this.headers;
+    }
+    hasHeader(name) {
+        return this.headers[name.toLowerCase()] !== undefined;
+    }
+    getHeader(name) {
+        return this.headers[name.toLowerCase()];
+    }
+    getHeaderLine(name) {
+        let values = this.getHeader(name);
+        if (values && Object.prototype.toString.call(values) == '[object Array]') {
+            return values.join(',');
+        }
+        return values;
+    }
+    withHeader(name, value) {
+        this.headers[name.toLowerCase()] = value;
+        return this;
+    }
+    withAddedHeader(name, value) {
+        let oldValue = this.getHeader(name);
+        if (oldValue === undefined || oldValue === null) {
+            return this.withHeader(name, value);
+        }
+        name = name.toLowerCase();
+        if (Object.prototype.toString.call(oldValue) != '[object Array]') {
+            this.headers[name] = [oldValue];
+        }
+        if (Object.prototype.toString.call(value) == '[object Array]') {
+            this.headers[name] = oldValue.concat(value);
+        }
+        else {
+            this.headers[name].push(value);
+        }
+        return this;
+    }
+    withoutHeader(name) {
+        name = name.toLowerCase();
+        this.headers[name] = undefined;
+        delete this.headers[name];
+        return this;
+    }
+    getBody() {
+        return this.content;
+    }
+    withBody(body) {
+        if (Buffer.isBuffer(body)) {
+            this.content = Buffer.from('');
+            this.content.copy(body);
+        }
+        else if (typeof body === 'string') {
+            this.content = Buffer.from(body);
+        }
+        else {
+            this.content = Buffer.from(JSON.stringify(body));
+        }
+        return this;
+    }
+    /**
+     * 设置headers
+     * @param headers
+     * @returns
+     */
+    setHeaders(headers) {
+        this.headers = merge_1.default.recursive(true, headers);
+        for (let key in this.headers) {
+            if (key !== key.toLowerCase()) {
+                this.headers[key.toLowerCase()] = this.headers[key];
+            }
+        }
+        return this;
+    }
+}
+;
+module.exports = MessageMixin;

package/dist/Core/Http/Minxins/RequestMixin.d.ts

@@ -0,0 +1,12 @@
+declare class RequestMixin {
+    protected requestTarget: string;
+    protected method: string;
+    protected uri: string;
+    getRequestTarget(): string;
+    withRequestTarget(requestTarget: string): this;
+    getMethod(): string;
+    withMethod(method: string): this;
+    getUri(): string;
+    withUri(uri: string): this;
+}
+export = RequestMixin;

package/dist/Core/Http/Minxins/RequestMixin.js

@@ -0,0 +1,30 @@
+'use strict';
+class RequestMixin {
+    constructor() {
+        this.requestTarget = '';
+        this.method = '';
+    }
+    getRequestTarget() {
+        return this.requestTarget;
+    }
+    withRequestTarget(requestTarget) {
+        this.requestTarget = requestTarget;
+        return this;
+    }
+    getMethod() {
+        return this.method;
+    }
+    withMethod(method) {
+        this.method = method.toUpperCase();
+        return this;
+    }
+    getUri() {
+        return this.uri;
+    }
+    withUri(uri) {
+        this.uri = uri;
+        return this;
+    }
+}
+;
+module.exports = RequestMixin;

package/dist/Core/Http/Request.d.ts

@@ -1,26 +1,9 @@
-/// <reference types="node" />
-import { IncomingMessage } from 'http';
-import RequestInterface from '../Contracts/RequestInterface';
-export default class Request implements RequestInterface {
-    protected _req: IncomingMessage;
-    protected _uri: string;
-    protected _method: string;
-    protected _headers: object;
-    protected _get: object;
-    protected _post: object;
-    protected _content: Buffer;
-    protected _contentType: string;
-    protected _ip: string;
-    constructor(req?: IncomingMessage, content?: Buffer | object | string);
-    isValid(): Boolean;
-    getMethod(): string;
-    get(key: string): Promise<any>;
-    post(key: string): Promise<any>;
-    getAllGet(): object;
-    getAllPost(): object;
-    getContent(): Promise<Buffer>;
-    getUri(): string;
-    getContentType(): string;
-    getHeaders(): object;
-    getClientIp(): string;
+import RequestInterface from "./Contracts/RequestInterface";
+import MessageMixin from "./Minxins/MessageMixin";
+import RequestMixin from "./Minxins/RequestMixin";
+declare class Request implements RequestInterface {
+    constructor(method: string, uri: string, headers?: Record<string, any>, content?: any, version?: string);
 }
+interface Request extends MessageMixin, RequestMixin {
+}
+export = Request;

package/dist/Core/Http/Request.js

@@ -1,185 +1,20 @@
 'use strict';
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
 var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
-Object.defineProperty(exports, "__esModule", { value: true });
-const url_1 = __importDefault(require("url"));
-const Utils_1 = require("../Utils");
-const raw_body_1 = __importDefault(require("raw-body"));
+const Utils_1 = require("../Support/Utils");
+const MessageMixin_1 = __importDefault(require("./Minxins/MessageMixin"));
+const RequestMixin_1 = __importDefault(require("./Minxins/RequestMixin"));
 class Request {
-    constructor(req = null, content = null) {
-        this._req = null;
-        this._uri = '';
-        this._method = '';
-        this._headers = null;
-        this._get = null;
-        this._post = null;
-        this._content = null;
-        this._contentType = '';
-        this._ip = '';
-        if (req) {
-            this._req = req;
-            this._uri = req.url;
-            this._method = req.method.toUpperCase();
-            this._headers = req.headers || {};
-            this._contentType = this._headers['content-type'] || '';
-            if (content) {
-                if (Buffer.isBuffer(content)) {
-                    this._content = content;
-                }
-                else if ((0, Utils_1.isObject)(content)) {
-                    this._post = content;
-                    this._content = Buffer.from(JSON.stringify(content));
-                    this._contentType = 'application/json';
-                }
-                else if (typeof content === 'string') {
-                    try {
-                        this._post = JSON.parse(content);
-                        this._contentType = 'application/json';
-                    }
-                    catch (e) {
-                        if (content.substr(0, 1) === '<') {
-                            (0, Utils_1.parseXml)(content).then(res => {
-                                this._post = res;
-                                this._contentType = 'text/xml';
-                            });
-                        }
-                        else {
-                            this._post = (0, Utils_1.parseQueryString)(content);
-                            this._contentType = 'application/x-www-form-urlencoded';
-                        }
-                    }
-                    this._content = Buffer.from(content);
-                }
-            }
-            this._get = url_1.default.parse(req.url, true).query || {};
-            // 提取请求ip
-            if ((0, Utils_1.isIp)(this._headers['x-client-ip'])) {
-                this._ip = this._headers['x-client-ip'];
-            }
-            else if (this._headers['x-forwarded-for']) {
-                let ip = '';
-                let items = this._headers['x-forwarded-for'].split(',');
-                for (let i = 0; i < items.length; i++) {
-                    if (!items[i])
-                        continue;
-                    ip = items[i].trim();
-                    if (items[i].indexOf(':') > -1) {
-                        let tmp = items[i].split(':');
-                        if (tmp.length == 2) {
-                            ip = tmp[0];
-                        }
-                    }
-                    if ((0, Utils_1.isIp)(ip)) {
-                        break;
-                    }
-                }
-                this._ip = ip;
-            }
-            else if ((0, Utils_1.isIp)(this._headers['x-real-ip'])) {
-                this._ip = this._headers['x-real-ip'];
-            }
-            else if ((0, Utils_1.isIp)(this._headers['x-forwarded'])) {
-                this._ip = this._headers['x-forwarded'];
-            }
-            else if ((0, Utils_1.isIp)(this._headers['forwarded-for'])) {
-                this._ip = this._headers['forwarded-for'];
-            }
-            else if ((0, Utils_1.isIp)(this._headers['client-ip'])) {
-                this._ip = this._headers['client-ip'];
-            }
-        }
-    }
-    isValid() {
-        return !!this._req;
-    }
-    getMethod() {
-        if (!this.isValid)
-            throw new Error('Please set request first. app.rebind(\'request\', new EasyWechat.Request(ctx.req));');
-        return this._method;
-    }
-    get(key) {
-        if (!this.isValid)
-            throw new Error('Please set request first. app.rebind(\'request\', new EasyWechat.Request(ctx.req));');
-        if (this._get[key] != undefined)
-            return this._get[key];
-        return this.post(key);
-    }
-    post(key) {
-        return __awaiter(this, void 0, void 0, function* () {
-            if (!this.isValid)
-                throw new Error('Please set request first. app.rebind(\'request\', new EasyWechat.Request(ctx.req));');
-            if (this._method !== 'POST')
-                return null;
-            if (!this._content) {
-                this._content = yield this.getContent();
-            }
-            if (!this._post && this._content) {
-                let contentType = this._contentType.toLowerCase();
-                if (contentType.indexOf('application/json') > -1) {
-                    try {
-                        this._post = JSON.parse(this._content.toString());
-                    }
-                    catch (e) { }
-                }
-                else if (contentType.indexOf('application/x-www-form-urlencoded') > -1) {
-                    this._post = (0, Utils_1.parseQueryString)(this._content.toString());
-                }
-            }
-            return this._post && this._post[key] != undefined ? this._post[key] : null;
-        });
-    }
-    getAllGet() {
-        if (!this.isValid)
-            throw new Error('Please set request first. app.rebind(\'request\', new EasyWechat.Request(ctx.req));');
-        return this._get;
-    }
-    getAllPost() {
-        if (!this.isValid)
-            throw new Error('Please set request first. app.rebind(\'request\', new EasyWechat.Request(ctx.req));');
-        return this._post;
-    }
-    getContent() {
-        return __awaiter(this, void 0, void 0, function* () {
-            if (!this.isValid)
-                throw new Error('Please set request first. app.rebind(\'request\', new EasyWechat.Request(ctx.req));');
-            if (this._method !== 'POST')
-                return null;
-            if (!this._content) {
-                this._content = yield (0, raw_body_1.default)(this._req);
-            }
-            return this._content;
-        });
-    }
-    getUri() {
-        if (!this.isValid)
-            throw new Error('Please set request first. app.rebind(\'request\', new EasyWechat.Request(ctx.req));');
-        return this._uri || '';
-    }
-    getContentType() {
-        if (!this.isValid)
-            throw new Error('Please set request first. app.rebind(\'request\', new EasyWechat.Request(ctx.req));');
-        return this._contentType || '';
-    }
-    getHeaders() {
-        if (!this.isValid)
-            throw new Error('Please set request first. app.rebind(\'request\', new EasyWechat.Request(ctx.req));');
-        return this._headers || {};
-    }
-    getClientIp() {
-        if (!this.isValid)
-            throw new Error('Please set request first. app.rebind(\'request\', new EasyWechat.Request(ctx.req));');
-        return this._ip;
+    constructor(method, uri, headers = {}, content = null, version = '1.1') {
+        this.withMethod(method)
+            .withUri(uri)
+            .setHeaders(headers)
+            .withBody(content)
+            .withProtocolVersion(version);
     }
 }
-exports.default = Request;
 ;
+;
+(0, Utils_1.applyMixins)(Request, [MessageMixin_1.default, RequestMixin_1.default]);
+module.exports = Request;

package/dist/Core/Http/Response.d.ts

@@ -1,15 +1,14 @@
-/// <reference types="node" />
-export default class Response {
-    protected content: Buffer;
+import ResponseInterface from "./Contracts/ResponseInterface";
+import MessageMixin from "./Minxins/MessageMixin";
+declare class Response implements ResponseInterface {
+    private PHRASES;
     protected statusCode: number;
-    protected headers: object;
-    constructor(content: Buffer, statusCode?: number, headers?: object);
-    setContent(content: Buffer): void;
-    getContent(): Buffer;
-    setStatusCode(statusCode: number): void;
+    protected reasonPhrase: string;
+    constructor(statusCode?: number, headers?: Record<string, any>, content?: any, version?: string, reason?: string);
     getStatusCode(): number;
-    addHeader(key: string, val: string): void;
-    setHeaders(headers: object): void;
-    getHeaders(): object;
-    getHeader(key: string): string;
+    withStatus(code: number, reasonPhrase?: string): this;
+    getReasonPhrase(): string;
 }
+interface Response extends MessageMixin {
+}
+export = Response;

package/dist/Core/Http/Response.js

@@ -1,38 +1,42 @@
 'use strict';
-Object.defineProperty(exports, "__esModule", { value: true });
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+const Utils_1 = require("../Support/Utils");
+const MessageMixin_1 = __importDefault(require("./Minxins/MessageMixin"));
 class Response {
-    constructor(content, statusCode = 200, headers = {}) {
-        this.content = null;
+    constructor(statusCode = 200, headers = {}, content = null, version = '1.1', reason = null) {
+        this.PHRASES = {
+            100: 'Continue', 101: 'Switching Protocols', 102: 'Processing',
+            200: 'OK', 201: 'Created', 202: 'Accepted', 203: 'Non-Authoritative Information', 204: 'No Content', 205: 'Reset Content', 206: 'Partial Content', 207: 'Multi-status', 208: 'Already Reported',
+            300: 'Multiple Choices', 301: 'Moved Permanently', 302: 'Found', 303: 'See Other', 304: 'Not Modified', 305: 'Use Proxy', 306: 'Switch Proxy', 307: 'Temporary Redirect',
+            400: 'Bad Request', 401: 'Unauthorized', 402: 'Payment Required', 403: 'Forbidden', 404: 'Not Found', 405: 'Method Not Allowed', 406: 'Not Acceptable', 407: 'Proxy Authentication Required', 408: 'Request Time-out', 409: 'Conflict', 410: 'Gone', 411: 'Length Required', 412: 'Precondition Failed', 413: 'Request Entity Too Large', 414: 'Request-URI Too Large', 415: 'Unsupported Media Type', 416: 'Requested range not satisfiable', 417: 'Expectation Failed', 418: 'I\'m a teapot', 422: 'Unprocessable Entity', 423: 'Locked', 424: 'Failed Dependency', 425: 'Unordered Collection', 426: 'Upgrade Required', 428: 'Precondition Required', 429: 'Too Many Requests', 431: 'Request Header Fields Too Large', 451: 'Unavailable For Legal Reasons',
+            500: 'Internal Server Error', 501: 'Not Implemented', 502: 'Bad Gateway', 503: 'Service Unavailable', 504: 'Gateway Time-out', 505: 'HTTP Version not supported', 506: 'Variant Also Negotiates', 507: 'Insufficient Storage', 508: 'Loop Detected', 511: 'Network Authentication Required',
+        };
         this.statusCode = 200;
-        this.headers = {};
-        this.content = content;
-        this.statusCode = statusCode;
-        this.headers = headers;
-    }
-    setContent(content) {
-        this.content = content;
-    }
-    getContent() {
-        return this.content;
-    }
-    setStatusCode(statusCode) {
+        this.reasonPhrase = '';
+        if (!reason && this.PHRASES[statusCode] !== undefined) {
+            reason = this.PHRASES[statusCode];
+        }
         this.statusCode = statusCode;
+        this.reasonPhrase = reason;
+        this.setHeaders(headers)
+            .withBody(content)
+            .withProtocolVersion(version);
     }
     getStatusCode() {
         return this.statusCode;
     }
-    addHeader(key, val) {
-        this.headers[key] = val;
+    withStatus(code, reasonPhrase) {
+        this.statusCode = code;
+        this.reasonPhrase = reasonPhrase;
+        return this;
     }
-    setHeaders(headers) {
-        this.headers = headers;
-    }
-    getHeaders() {
-        return this.headers;
-    }
-    getHeader(key) {
-        return this.headers[key] || '';
+    getReasonPhrase() {
+        return this.reasonPhrase;
     }
 }
-exports.default = Response;
 ;
+;
+(0, Utils_1.applyMixins)(Response, [MessageMixin_1.default]);
+module.exports = Response;