node-easywechat 2.9.1 → 3.0.0-alpha.1

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;

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,92 @@
+'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 = null;
+        this.failureJudge = null;
+        this.throwError = true;
+        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,76 @@
+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;
+    /**
+     * 判断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;