node-easywechat 2.10.1 → 3.0.0-alpha.2

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;

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

@@ -0,0 +1,47 @@
+/// <reference types="node" />
+import { IncomingMessage } from "http";
+import ServerRequestInterface from "./Contracts/ServerRequestInterface";
+import MessageMixin from "./Minxins/MessageMixin";
+import RequestMixin from "./Minxins/RequestMixin";
+declare class ServerRequest implements ServerRequestInterface {
+    protected attributes: Record<string, any>;
+    protected cookieParams: Record<string, any>;
+    protected parsedBody: Record<string, any>;
+    protected queryParams: Record<string, any>;
+    protected serverParams: Record<string, any>;
+    protected uploadedFiles: Record<string, any>;
+    constructor(method: string, url: string, headers?: Record<string, any>, body?: Buffer | Record<string, any> | string, version?: string, serverParams?: Record<string, any>);
+    /**
+     * 解析 body 内容
+     * @param body 支持 Buffer、object对象、JSON字符串、XML字符串、QueryString等格式
+     */
+    protected parseBody(body: Buffer | Record<string, any> | string): void;
+    getServerParams(): Record<string, any>;
+    getCookieParams(): Record<string, any>;
+    withCookieParams(cookies: Record<string, any>): this;
+    getQueryParams(): Record<string, any>;
+    withQueryParams(query: Record<string, any>): this;
+    getUploadedFiles(): Record<string, any>;
+    withUploadedFiles(files: Record<string, any>): this;
+    getParsedBody(): Record<string, any>;
+    withParsedBody(data: Record<string, any>): this;
+    getAttributes(): Record<string, any>;
+    getAttribute(name: string, defaultValue?: any): any;
+    withAttribute(name: string, value: any): this;
+    withoutAttribute(name: string): this;
+    /**
+     * 通过 IncomingMessage 创建实例
+     *
+     * 由于 IncomingMessage 的 body 流的特殊性，某些框架（目前已知：fastify）
+     * 可能会自动读取后挂载到上下文中，从而导致 node-easywechat 去尝试读取时报错。
+     * 这时可以选择传入第二个参数，即 body 的内容
+     *
+     * @param req
+     * @param body 支持 Buffer、object对象、JSON字符串、XML字符串、QueryString格式的 body 内容字符串
+     * @returns
+     */
+    static createFromIncomingMessage(req: IncomingMessage, body?: Buffer | Record<string, any> | string): ServerRequest;
+}
+interface ServerRequest extends MessageMixin, RequestMixin {
+}
+export = ServerRequest;

package/dist/Core/Http/ServerRequest.js

@@ -0,0 +1,136 @@
+'use strict';
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+const merge_1 = __importDefault(require("merge"));
+const raw_body_1 = __importDefault(require("raw-body"));
+const url_1 = require("url");
+const Utils_1 = require("../Support/Utils");
+const MessageMixin_1 = __importDefault(require("./Minxins/MessageMixin"));
+const RequestMixin_1 = __importDefault(require("./Minxins/RequestMixin"));
+class ServerRequest {
+    constructor(method, url, headers = {}, body = null, version = 'v1.1', serverParams = {}) {
+        this.attributes = {};
+        this.cookieParams = {};
+        this.parsedBody = {};
+        this.queryParams = {};
+        this.serverParams = {};
+        this.uploadedFiles = {};
+        this.serverParams = serverParams;
+        this.withMethod(method)
+            .withUri(url)
+            .setHeaders(headers || {})
+            .withProtocolVersion(version)
+            .withQueryParams((0, url_1.parse)(url, true).query || {});
+        if (body) {
+            this.parseBody(body);
+        }
+    }
+    /**
+     * 解析 body 内容
+     * @param body 支持 Buffer、object对象、JSON字符串、XML字符串、QueryString等格式
+     */
+    parseBody(body) {
+        if (Buffer.isBuffer(body)) {
+            this.content = Buffer.from('');
+            this.content.copy(body);
+        }
+        else if (typeof body === 'object' && Object.keys(body).length > 0) {
+            this.parsedBody = body;
+            this.content = Buffer.from(JSON.stringify(body));
+            this.headers['content-type'] = 'application/json';
+        }
+        else if (typeof body === 'string') {
+            try {
+                this.parsedBody = JSON.parse(body);
+                this.headers['content-type'] = 'application/json';
+            }
+            catch (e) {
+                if (body.substring(0, 1) === '<') {
+                    (0, Utils_1.parseXml)(body).then(res => {
+                        this.parsedBody = res;
+                        this.headers['content-type'] = 'text/xml';
+                    });
+                }
+                else {
+                    this.parsedBody = (0, Utils_1.parseQueryString)(body);
+                    this.headers['content-type'] = 'application/x-www-form-urlencoded';
+                }
+            }
+            this.content = Buffer.from(body);
+        }
+    }
+    getServerParams() {
+        return this.serverParams;
+    }
+    getCookieParams() {
+        return this.cookieParams;
+    }
+    withCookieParams(cookies) {
+        this.cookieParams = merge_1.default.recursive(true, cookies);
+        return this;
+    }
+    getQueryParams() {
+        return this.queryParams;
+    }
+    withQueryParams(query) {
+        this.queryParams = merge_1.default.recursive(true, query);
+        return this;
+    }
+    getUploadedFiles() {
+        return this.uploadedFiles;
+    }
+    withUploadedFiles(files) {
+        this.uploadedFiles = merge_1.default.recursive(true, files);
+        return this;
+    }
+    getParsedBody() {
+        return this.parsedBody;
+    }
+    withParsedBody(data) {
+        this.parsedBody = merge_1.default.recursive(true, data);
+        return this;
+    }
+    getAttributes() {
+        return this.attributes;
+    }
+    getAttribute(name, defaultValue = null) {
+        if (this.attributes[name] === undefined) {
+            return defaultValue;
+        }
+        return this.attributes[name];
+    }
+    withAttribute(name, value) {
+        this.attributes[name] = value;
+        return this;
+    }
+    withoutAttribute(name) {
+        this.attributes[name] = undefined;
+        delete this.attributes[name];
+        return this;
+    }
+    /**
+     * 通过 IncomingMessage 创建实例
+     *
+     * 由于 IncomingMessage 的 body 流的特殊性，某些框架（目前已知：fastify）
+     * 可能会自动读取后挂载到上下文中，从而导致 node-easywechat 去尝试读取时报错。
+     * 这时可以选择传入第二个参数，即 body 的内容
+     *
+     * @param req
+     * @param body 支持 Buffer、object对象、JSON字符串、XML字符串、QueryString格式的 body 内容字符串
+     * @returns
+     */
+    static createFromIncomingMessage(req, body = null) {
+        let request = new ServerRequest(req.method, req.url, req.headers || {}, body, req.httpVersion, (0, url_1.parse)(req.url, true).query || {});
+        if (!body) {
+            (0, raw_body_1.default)(req).then(res => {
+                request.withBody(res);
+            });
+        }
+        return request;
+    }
+}
+;
+;
+(0, Utils_1.applyMixins)(ServerRequest, [MessageMixin_1.default, RequestMixin_1.default]);
+module.exports = ServerRequest;

package/dist/Core/HttpClient/AccessTokenAwareClient.d.ts

@@ -0,0 +1,19 @@
+import { Method, AxiosRequestConfig, AxiosInstance } from "axios";
+import AccessTokenAwareHttpClientInterface from "./Contracts/AccessTokenAwareHttpClientInterface";
+import AccessTokenInterface from "../Contracts/AccessTokenInterface";
+import HttpClientInterface from "./Contracts/HttpClientInterface";
+import HttpClientMethodsMixin from './Mixins/HttpClientMethodsMixin';
+import { HttpClientFailureJudgeClosure } from '../../Types/global';
+import HttpClientResponse from './HttpClientResponse';
+declare class AccessTokenAwareClient implements AccessTokenAwareHttpClientInterface, HttpClientInterface {
+    protected client: HttpClientInterface;
+    protected accessToken: AccessTokenInterface;
+    constructor(client: HttpClientInterface, accessToken: AccessTokenInterface, failureJudge?: HttpClientFailureJudgeClosure, throwError?: boolean);
+    withAccessToken(accessToken: AccessTokenInterface): this;
+    getInstance(): AxiosInstance;
+    setInstance(instance: AxiosInstance): this;
+    request(method: Method, url: string, payload?: AxiosRequestConfig<any>): Promise<HttpClientResponse>;
+}
+interface AccessTokenAwareClient extends HttpClientMethodsMixin {
+}
+export = AccessTokenAwareClient;

package/dist/Core/HttpClient/AccessTokenAwareClient.js

@@ -0,0 +1,47 @@
+'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 };
+};
+const merge_1 = __importDefault(require("merge"));
+const Utils_1 = require("../Support/Utils");
+const HttpClient_1 = __importDefault(require("./HttpClient"));
+const HttpClientMethodsMixin_1 = __importDefault(require("./Mixins/HttpClientMethodsMixin"));
+class AccessTokenAwareClient {
+    constructor(client, accessToken, failureJudge = null, throwError = true) {
+        this.client = null;
+        this.accessToken = null;
+        this.client = client || HttpClient_1.default.create(null, failureJudge, throwError);
+        this.accessToken = accessToken;
+    }
+    withAccessToken(accessToken) {
+        this.accessToken = accessToken;
+        return this;
+    }
+    getInstance() {
+        return this.client.getInstance();
+    }
+    setInstance(instance) {
+        this.client.setInstance(instance);
+        return this;
+    }
+    request(method, url, payload = {}) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (this.accessToken) {
+                payload.params = (0, merge_1.default)(true, payload.params || {}, yield this.accessToken.toQuery());
+            }
+            return this.client.request(method, (0, Utils_1.ltrim)(url, '\\/+'), payload);
+        });
+    }
+}
+;
+(0, Utils_1.applyMixins)(AccessTokenAwareClient, [HttpClientMethodsMixin_1.default]);
+module.exports = AccessTokenAwareClient;

package/dist/Core/HttpClient/Contracts/AccessTokenAwareHttpClientInterface.d.ts

@@ -0,0 +1,9 @@
+import AccessTokenInterface from "../../Contracts/AccessTokenInterface";
+import HttpClientInterface from "./HttpClientInterface";
+declare abstract class AccessTokenAwareHttpClientInterface extends HttpClientInterface {
+    /**
+     * 设置AccessToken实例
+     */
+    withAccessToken(accessToken: AccessTokenInterface): this;
+}
+export = AccessTokenAwareHttpClientInterface;

package/dist/Core/HttpClient/Contracts/AccessTokenAwareHttpClientInterface.js

@@ -0,0 +1,13 @@
+'use strict';
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+const HttpClientInterface_1 = __importDefault(require("./HttpClientInterface"));
+class AccessTokenAwareHttpClientInterface extends HttpClientInterface_1.default {
+    /**
+     * 设置AccessToken实例
+     */
+    withAccessToken(accessToken) { return this; }
+}
+;
+module.exports = AccessTokenAwareHttpClientInterface;

package/dist/Core/HttpClient/Contracts/HttpClientInterface.d.ts

@@ -0,0 +1,18 @@
+import { Method, AxiosRequestConfig, AxiosInstance } from 'axios';
+import HttpClientResponse from '../HttpClientResponse';
+declare abstract class HttpClientInterface {
+    /**
+     * 获取axios实例
+     * @returns
+     */
+    getInstance(): AxiosInstance;
+    /**
+     * 设置axios实例
+     */
+    setInstance(instance: AxiosInstance): this;
+    /**
+     * 发起http请求
+     */
+    request(method: Method, url: string, payload: AxiosRequestConfig): Promise<HttpClientResponse>;
+}
+export = HttpClientInterface;

package/dist/Core/HttpClient/Contracts/HttpClientInterface.js

@@ -0,0 +1,29 @@
+'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());
+    });
+};
+class HttpClientInterface {
+    /**
+     * 获取axios实例
+     * @returns
+     */
+    getInstance() { return null; }
+    /**
+     * 设置axios实例
+     */
+    setInstance(instance) { return this; }
+    /**
+     * 发起http请求
+     */
+    request(method, url, payload) {
+        return __awaiter(this, void 0, void 0, function* () { return null; });
+    }
+}
+;
+module.exports = HttpClientInterface;

package/dist/Core/HttpClient/Contracts/HttpClientResponseInterface.d.ts

@@ -0,0 +1,35 @@
+declare abstract class HttpClientResponseInterface {
+    /**
+     * 获取响应状态码
+     * @returns
+     */
+    getStatusCode(): number;
+    /**
+     * 获取headers
+     * @param throwError 错误码为3xx,4xx,5xx时是否报错
+     * @returns
+     */
+    getHeaders(throwError?: boolean): Record<string, any>;
+    /**
+     * 获取响应的内容
+     * @param throwError 错误码为3xx,4xx,5xx时是否报错
+     * @returns
+     */
+    getContent(throwError?: boolean): string;
+    /**
+     * 转为对象
+     * @param throwError 错误码为3xx,4xx,5xx时是否报错
+     * @returns
+     */
+    toObject(throwError?: boolean): Record<string, any>;
+    /**
+     * 清空响应流
+     */
+    cancel(): void;
+    /**
+     * 返回信息
+     * @param type 信息类型，默认：null表示返回全部
+     */
+    getInfo(type?: string): any;
+}
+export = HttpClientResponseInterface;