node-easywechat 2.10.1 → 3.0.0-alpha.2

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

@@ -0,0 +1,37 @@
+'use strict';
+class HttpClientResponseInterface {
+    /**
+     * 获取响应状态码
+     * @returns
+     */
+    getStatusCode() { return null; }
+    /**
+     * 获取headers
+     * @param throwError 错误码为3xx,4xx,5xx时是否报错
+     * @returns
+     */
+    getHeaders(throwError = true) { return null; }
+    /**
+     * 获取响应的内容
+     * @param throwError 错误码为3xx,4xx,5xx时是否报错
+     * @returns
+     */
+    getContent(throwError = true) { return null; }
+    /**
+     * 转为对象
+     * @param throwError 错误码为3xx,4xx,5xx时是否报错
+     * @returns
+     */
+    toObject(throwError = true) { return null; }
+    /**
+     * 清空响应流
+     */
+    cancel() { }
+    /**
+     * 返回信息
+     * @param type 信息类型，默认：null表示返回全部
+     */
+    getInfo(type = null) { }
+}
+;
+module.exports = HttpClientResponseInterface;

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

@@ -0,0 +1,20 @@
+import { AxiosInstance, AxiosRequestConfig, Method } from 'axios';
+import HttpClientInterface from './Contracts/HttpClientInterface';
+import HttpClientResponse from './HttpClientResponse';
+import { HttpClientFailureJudgeClosure } from '../../Types/global';
+declare class HttpClient implements HttpClientInterface {
+    protected axios: AxiosInstance;
+    protected failureJudge: HttpClientFailureJudgeClosure;
+    protected throwError: boolean;
+    constructor(axios: AxiosInstance, failureJudge?: HttpClientFailureJudgeClosure, throwError?: boolean);
+    request(method: Method, url: string, payload?: AxiosRequestConfig<any>): Promise<HttpClientResponse>;
+    getInstance(): AxiosInstance;
+    setInstance(instance: AxiosInstance): this;
+    /**
+     * 创建http客户端
+     * @param config
+     * @returns
+     */
+    static create(config?: AxiosRequestConfig, failureJudge?: HttpClientFailureJudgeClosure, throwError?: boolean): HttpClient;
+}
+export = HttpClient;

package/dist/Core/HttpClient/HttpClient.js

@@ -0,0 +1,89 @@
+'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 axios_1 = __importDefault(require("axios"));
+const HttpClientResponse_1 = __importDefault(require("./HttpClientResponse"));
+const Utils_1 = require("../Support/Utils");
+class HttpClient {
+    constructor(axios, failureJudge = null, throwError = false) {
+        this.axios = axios;
+        this.failureJudge = failureJudge;
+        this.throwError = throwError;
+    }
+    request(method, url, payload = {}) {
+        return __awaiter(this, void 0, void 0, function* () {
+            let options = merge_1.default.recursive(true, payload);
+            options.method = method;
+            options.url = url;
+            if (options['xml'] !== undefined) {
+                let xml = '';
+                if (typeof options['xml'] === 'object') {
+                    xml = (0, Utils_1.buildXml)(options['xml']);
+                }
+                else if (typeof options['xml'] === 'string') {
+                    xml = options['xml'];
+                }
+                else {
+                    throw new Error('The type of `xml` must be string or object.');
+                }
+                if (!options.headers)
+                    options.headers = {};
+                if (!options.headers['Content-Type'] && !options.headers['content-type']) {
+                    options.headers['content-type'] = 'text/xml';
+                }
+                options.data = xml;
+                options['xml'] = undefined;
+                delete options['xml'];
+            }
+            if (options['json'] !== undefined) {
+                let json = '';
+                if (typeof options['json'] === 'object') {
+                    json = JSON.stringify(options['json']);
+                }
+                else if (typeof options['json'] === 'string') {
+                    json = options['json'];
+                }
+                else {
+                    throw new Error('The type of `json` must be string or object.');
+                }
+                if (!options.headers)
+                    options.headers = {};
+                if (!options.headers['Content-Type'] && !options.headers['content-type']) {
+                    options.headers['content-type'] = 'application/json';
+                }
+                options.data = json;
+                options['json'] = undefined;
+                delete options['json'];
+            }
+            let response = yield this.axios.request(options);
+            return new HttpClientResponse_1.default(response, this.failureJudge, this.throwError);
+        });
+    }
+    getInstance() {
+        return this.axios;
+    }
+    setInstance(instance) {
+        this.axios = instance;
+        return this;
+    }
+    /**
+     * 创建http客户端
+     * @param config
+     * @returns
+     */
+    static create(config = null, failureJudge = null, throwError = false) {
+        return new HttpClient(axios_1.default.create(config), failureJudge, throwError);
+    }
+}
+module.exports = HttpClient;

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

@@ -0,0 +1,82 @@
+import { AxiosResponse } from "axios";
+import { HttpClientFailureJudgeClosure } from "../../Types/global";
+import HttpClientResponseInterface from "./Contracts/HttpClientResponseInterface";
+declare class HttpClientResponse implements HttpClientResponseInterface {
+    protected response: AxiosResponse;
+    protected failureJudge: HttpClientFailureJudgeClosure;
+    protected throwError: boolean;
+    constructor(response: AxiosResponse, failureJudge?: HttpClientFailureJudgeClosure, throwError?: boolean);
+    withThrowError(throwError: boolean): this;
+    throwOnFailure(): this;
+    quietly(): this;
+    /**
+     * 设置错误判断方法
+     * @param closure
+     * @returns
+     */
+    judgeFailureUsing(closure: HttpClientFailureJudgeClosure): this;
+    /**
+     * 获取请求是否失败
+     * @returns
+     */
+    isFailed(): boolean;
+    /**
+     * 获取请求是否成功
+     * @returns
+     */
+    isSuccessful(): boolean;
+    /**
+     * 返回对象格式
+     * @param throwError
+     * @returns
+     */
+    toObject(throwError?: boolean): Promise<Record<string, any>>;
+    /**
+     * 返回json字符串
+     * @param throwError
+     * @returns
+     */
+    toJson(throwError?: boolean): Promise<string>;
+    /**
+     * 返回字符串
+     * @returns
+     */
+    toString(): Promise<string>;
+    /**
+     * 另存为文件
+     * @param filename 完整的文件名（含路径）
+     * @returns
+     */
+    saveAs(filename: string): string;
+    /**
+     * 返回base64字符串
+     * @returns
+     */
+    toDataUrl(): string;
+    /**
+     * 判断 content-type 是否指定类型
+     * @param type
+     * @returns
+     */
+    is(type: 'json' | 'xml' | 'html' | 'image' | 'audio' | 'video' | 'text'): boolean;
+    /**
+     * 判断header是否存在
+     * @param key
+     * @returns
+     */
+    hasHeader(key: string): any;
+    /**
+     * 获取单个header
+     * @param key
+     * @returns
+     */
+    getHeader(key: string): any;
+    getStatusCode(): number;
+    getHeaders(throwError?: boolean): Record<string, any>;
+    getContent(throwError?: boolean): string;
+    cancel(): void;
+    getInfo(type?: string): import("axios").AxiosRequestConfig<any>;
+    offsetExists(key: any): Promise<boolean>;
+    offsetGet(key: any): Promise<any>;
+}
+export = HttpClientResponse;

package/dist/Core/HttpClient/HttpClientResponse.js

@@ -0,0 +1,203 @@
+'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 fs_1 = __importDefault(require("fs"));
+const merge_1 = __importDefault(require("merge"));
+const Utils_1 = require("../Support/Utils");
+class HttpClientResponse {
+    constructor(response, failureJudge = null, throwError = true) {
+        this.response = response;
+        this.failureJudge = failureJudge;
+        this.throwError = throwError;
+    }
+    withThrowError(throwError) {
+        this.throwError = throwError;
+        return this;
+    }
+    throwOnFailure() {
+        return this.withThrowError(true);
+    }
+    quietly() {
+        return this.withThrowError(false);
+    }
+    /**
+     * 设置错误判断方法
+     * @param closure
+     * @returns
+     */
+    judgeFailureUsing(closure) {
+        this.failureJudge = closure;
+        return this;
+    }
+    /**
+     * 获取请求是否失败
+     * @returns
+     */
+    isFailed() {
+        if (this.is('text') && this.failureJudge) {
+            return this.failureJudge(this);
+        }
+        try {
+            return 400 <= this.getStatusCode();
+        }
+        catch (e) {
+            return true;
+        }
+    }
+    /**
+     * 获取请求是否成功
+     * @returns
+     */
+    isSuccessful() {
+        return !this.isFailed();
+    }
+    /**
+     * 返回对象格式
+     * @param throwError
+     * @returns
+     */
+    toObject(throwError = null) {
+        return __awaiter(this, void 0, void 0, function* () {
+            throwError = throwError === null ? this.throwError : throwError;
+            let content = this.response.data;
+            if (!content) {
+                throw new Error('Response body is empty.');
+            }
+            let contentType = this.getHeader('content-type') || '';
+            if (contentType && (contentType.indexOf('text/xml') > -1 || contentType.indexOf('application/xml') > -1 || content.indexOf('<xml>') > -1)) {
+                return (0, Utils_1.parseXml)(content);
+            }
+            return content;
+        });
+    }
+    /**
+     * 返回json字符串
+     * @param throwError
+     * @returns
+     */
+    toJson(throwError = null) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return JSON.stringify(yield this.toObject(throwError));
+        });
+    }
+    /**
+     * 返回字符串
+     * @returns
+     */
+    toString() {
+        return this.toJson();
+    }
+    /**
+     * 另存为文件
+     * @param filename 完整的文件名（含路径）
+     * @returns
+     */
+    saveAs(filename) {
+        let buffer = this.response.data;
+        let content = buffer.toString();
+        if (!content || '{' === content[0]) {
+            throw new Error('Invalid media response content.');
+        }
+        fs_1.default.writeFileSync(filename, buffer);
+        return filename;
+    }
+    /**
+     * 返回base64字符串
+     * @returns
+     */
+    toDataUrl() {
+        return 'data:' + this.getHeader('content-type') + ';base64,' + this.response.data;
+    }
+    /**
+     * 判断 content-type 是否指定类型
+     * @param type
+     * @returns
+     */
+    is(type) {
+        let contentType = this.getHeader('content-type');
+        let res = false;
+        switch (type.toLowerCase()) {
+            case 'json':
+                res = contentType.indexOf('/json') > -1;
+                break;
+            case 'xml':
+                res = contentType.indexOf('/xml') > -1;
+                break;
+            case 'html':
+                res = contentType.indexOf('/html') > -1;
+                break;
+            case 'image':
+                res = contentType.indexOf('image/') > -1;
+                break;
+            case 'audio':
+                res = contentType.indexOf('audio/') > -1;
+                break;
+            case 'video':
+                res = contentType.indexOf('video/') > -1;
+                break;
+            case 'text':
+                res = contentType.indexOf('text/') > -1
+                    || contentType.indexOf('/json') > -1
+                    || contentType.indexOf('/xml') > -1;
+                break;
+        }
+        return res;
+    }
+    /**
+     * 判断header是否存在
+     * @param key
+     * @returns
+     */
+    hasHeader(key) {
+        return Object.keys(this.getHeaders()).findIndex(o => o === key) > -1;
+    }
+    /**
+     * 获取单个header
+     * @param key
+     * @returns
+     */
+    getHeader(key) {
+        return this.getHeaders()[key] || null;
+    }
+    getStatusCode() {
+        return this.response.status;
+    }
+    getHeaders(throwError) {
+        let headers = merge_1.default.recursive(true, this.response.headers);
+        for (let key in this.response.headers) {
+            if (key !== key.toLowerCase()) {
+                this.response.headers[key.toLowerCase()] = this.response.headers[key];
+            }
+        }
+        return headers;
+    }
+    getContent(throwError) {
+        return this.response.data;
+    }
+    cancel() {
+    }
+    getInfo(type) {
+        return this.response.config;
+    }
+    offsetExists(key) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return Object.keys(yield this.toObject()).findIndex(o => o === key) > -1;
+        });
+    }
+    offsetGet(key) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return (yield this.toObject())[key] || null;
+        });
+    }
+}
+module.exports = HttpClientResponse;

package/dist/Core/HttpClient/Mixins/HttpClientMethodsMixin.d.ts

@@ -0,0 +1,48 @@
+import HttpClientInterface from "../Contracts/HttpClientInterface";
+import { AxiosRequestConfig } from 'axios';
+import HttpClientResponse from "../HttpClientResponse";
+declare class HttpClientMethodsMixin extends HttpClientInterface {
+    /**
+     * 发送get请求
+     * @param url
+     * @param payload
+     * @returns
+     */
+    get(url: string, payload?: AxiosRequestConfig): Promise<HttpClientResponse>;
+    /**
+     * 发送post请求
+     * @param url
+     * @param payload
+     * @returns
+     */
+    post(url: string, payload?: AxiosRequestConfig): Promise<HttpClientResponse>;
+    /**
+     * 发送post请求（JSON数据）
+     * @param url
+     * @param payload
+     * @returns
+     */
+    postJson(url: string, payload?: AxiosRequestConfig): Promise<HttpClientResponse>;
+    /**
+     * 发送patch请求
+     * @param url
+     * @param payload
+     * @returns
+     */
+    patch(url: string, payload?: AxiosRequestConfig): Promise<HttpClientResponse>;
+    /**
+     * 发送put请求
+     * @param url
+     * @param payload
+     * @returns
+     */
+    put(url: string, payload?: AxiosRequestConfig): Promise<HttpClientResponse>;
+    /**
+     * 发送delete请求
+     * @param url
+     * @param payload
+     * @returns
+     */
+    delete(url: string, payload?: AxiosRequestConfig): Promise<HttpClientResponse>;
+}
+export = HttpClientMethodsMixin;

package/dist/Core/HttpClient/Mixins/HttpClientMethodsMixin.js

@@ -0,0 +1,88 @@
+'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 HttpClientInterface_1 = __importDefault(require("../Contracts/HttpClientInterface"));
+class HttpClientMethodsMixin extends HttpClientInterface_1.default {
+    /**
+     * 发送get请求
+     * @param url
+     * @param payload
+     * @returns
+     */
+    get(url, payload = {}) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.request('get', url, payload);
+        });
+    }
+    /**
+     * 发送post请求
+     * @param url
+     * @param payload
+     * @returns
+     */
+    post(url, payload = {}) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.request('post', url, payload);
+        });
+    }
+    /**
+     * 发送post请求（JSON数据）
+     * @param url
+     * @param payload
+     * @returns
+     */
+    postJson(url, payload = {}) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!payload)
+                payload = {};
+            if (!payload['headers'])
+                payload['headers'] = {};
+            payload['headers']['Content-Type'] = 'application/json';
+            return this.request('post', url, payload);
+        });
+    }
+    /**
+     * 发送patch请求
+     * @param url
+     * @param payload
+     * @returns
+     */
+    patch(url, payload = {}) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.request('patch', url, payload);
+        });
+    }
+    /**
+     * 发送put请求
+     * @param url
+     * @param payload
+     * @returns
+     */
+    put(url, payload = {}) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.request('put', url, payload);
+        });
+    }
+    /**
+     * 发送delete请求
+     * @param url
+     * @param payload
+     * @returns
+     */
+    delete(url, payload = {}) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.request('delete', url, payload);
+        });
+    }
+}
+module.exports = HttpClientMethodsMixin;