node-easywechat 2.10.2 → 3.0.0-beta.1

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

@@ -0,0 +1,70 @@
+'use strict';
+class MessageInterface {
+    /**
+     * 获取 HTTP 协议版本，如：'1.1', '1.0'
+     * @returns
+     */
+    getProtocolVersion() { return null; }
+    /**
+     * 设置 HTTP 协议版本
+     * @param version
+     * @returns
+     */
+    withProtocolVersion(version) { return this; }
+    /**
+     * 获取所有headers
+     * @returns
+     */
+    getHeaders() { return null; }
+    /**
+     * 判断header是否存在
+     * @param name
+     * @returns
+     */
+    hasHeader(name) { return false; }
+    /**
+     * 获取header
+     * @param name
+     * @returns
+     */
+    getHeader(name) { return null; }
+    /**
+     * 获取header，逗号分隔同名header
+     * @param name
+     * @returns
+     */
+    getHeaderLine(name) { return null; }
+    /**
+     * 设置header值
+     * @param name
+     * @param value
+     * @returns
+     */
+    withHeader(name, value) { return this; }
+    /**
+     * 附加header值
+     * @param name
+     * @param value
+     * @returns
+     */
+    withAddedHeader(name, value) { return this; }
+    /**
+     * 删除header
+     * @param name
+     * @returns
+     */
+    withoutHeader(name) { return this; }
+    /**
+     * 获取body内容
+     * @returns
+     */
+    getBody() { return null; }
+    /**
+     * 设置body内容
+     * @param body
+     * @returns
+     */
+    withBody(body) { return this; }
+}
+;
+module.exports = MessageInterface;

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

@@ -0,0 +1,37 @@
+import MessageInterface from "./MessageInterface";
+declare abstract class RequestInterface extends MessageInterface {
+    /**
+     * 获取请求路径，默认返回：'/'
+     * @returns
+     */
+    getRequestTarget(): string;
+    /**
+     * 设置请求路径
+     * @param requestTarget
+     * @returns
+     */
+    withRequestTarget(requestTarget: string): this;
+    /**
+     * 获取请求方式
+     * @returns
+     */
+    getMethod(): string;
+    /**
+     * 设置请求方式
+     * @param method
+     * @returns
+     */
+    withMethod(method: string): this;
+    /**
+     * 获取请求地址
+     * @returns
+     */
+    getUri(): string;
+    /**
+     * 设置请求地址
+     * @param uri
+     * @returns
+     */
+    withUri(uri: string): this;
+}
+export = RequestInterface;

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

@@ -0,0 +1,42 @@
+'use strict';
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+const MessageInterface_1 = __importDefault(require("./MessageInterface"));
+class RequestInterface extends MessageInterface_1.default {
+    /**
+     * 获取请求路径，默认返回：'/'
+     * @returns
+     */
+    getRequestTarget() { return null; }
+    /**
+     * 设置请求路径
+     * @param requestTarget
+     * @returns
+     */
+    withRequestTarget(requestTarget) { return this; }
+    /**
+     * 获取请求方式
+     * @returns
+     */
+    getMethod() { return null; }
+    /**
+     * 设置请求方式
+     * @param method
+     * @returns
+     */
+    withMethod(method) { return this; }
+    /**
+     * 获取请求地址
+     * @returns
+     */
+    getUri() { return null; }
+    /**
+     * 设置请求地址
+     * @param uri
+     * @returns
+     */
+    withUri(uri) { return this; }
+}
+;
+module.exports = RequestInterface;

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

@@ -0,0 +1,21 @@
+import MessageInterface from "./MessageInterface";
+declare abstract class ResponseInterface extends MessageInterface {
+    /**
+     * 获取响应状态码
+     * @returns
+     */
+    getStatusCode(): number;
+    /**
+     * 设置响应状态
+     * @param code 状态码
+     * @param reasonPhrase 状态码描述
+     * @returns
+     */
+    withStatus(code: number, reasonPhrase?: string): this;
+    /**
+     * 获取状态码描述
+     * @returns
+     */
+    getReasonPhrase(): string;
+}
+export = ResponseInterface;

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

@@ -0,0 +1,26 @@
+'use strict';
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+const MessageInterface_1 = __importDefault(require("./MessageInterface"));
+class ResponseInterface extends MessageInterface_1.default {
+    /**
+     * 获取响应状态码
+     * @returns
+     */
+    getStatusCode() { return null; }
+    /**
+     * 设置响应状态
+     * @param code 状态码
+     * @param reasonPhrase 状态码描述
+     * @returns
+     */
+    withStatus(code, reasonPhrase = '') { return this; }
+    /**
+     * 获取状态码描述
+     * @returns
+     */
+    getReasonPhrase() { return null; }
+}
+;
+module.exports = ResponseInterface;

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,27 +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(): Promise<object>;
-    private _parseContent;
-    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;