node-easywechat 2.10.1 → 3.0.0-alpha.2

package/dist/Core/Mixins/HandlersMixin.js

@@ -0,0 +1,163 @@
+'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());
+    });
+};
+const Utils_1 = require("../Support/Utils");
+class HandlersMixin {
+    constructor() {
+        this.handlers = [];
+    }
+    /**
+     * 获取所有处理器
+     * @returns
+     */
+    getHandlers() {
+        return this.handlers;
+    }
+    /**
+     * 创建处理器项
+     * @param handler
+     * @returns
+     */
+    createHandlerItem(handler) {
+        return {
+            hash: this.getHandlerHash(handler),
+            handler: handler,
+        };
+    }
+    /**
+     * 计算处理器hash
+     * @param handler
+     * @returns
+     */
+    getHandlerHash(handler) {
+        return (0, Utils_1.createHash)(handler.toString(), 'md5');
+    }
+    /**
+     * @alias withHandler()
+     */
+    with(handler) {
+        return this.withHandler(handler);
+    }
+    /**
+     * 从最后添加处理器
+     * @param handler
+     * @returns
+     */
+    withHandler(handler) {
+        this.handlers.push(this.createHandlerItem(handler));
+        return this;
+    }
+    /**
+     * @alias prependHandler()
+     */
+    prepend(handler) {
+        return this.prependHandler(handler);
+    }
+    /**
+     * 从最前添加处理器
+     * @param handler
+     * @returns
+     */
+    prependHandler(handler) {
+        this.handlers.unshift(this.createHandlerItem(handler));
+        return this;
+    }
+    /**
+     * @alias withoutHandler()
+     */
+    without(handler) {
+        return this.withoutHandler(handler);
+    }
+    /**
+     * 删除处理器
+     * @param handler
+     * @returns
+     */
+    withoutHandler(handler) {
+        let index = this.indexOf(handler);
+        if (index > -1) {
+            this.handlers.splice(index, 1);
+        }
+        return this;
+    }
+    /**
+     * 获取处理器的索引
+     * @param handler
+     * @returns
+     */
+    indexOf(handler) {
+        return this.handlers.findIndex((item) => {
+            return item.hash === this.getHandlerHash(handler);
+        });
+    }
+    /**
+     * 当 value 为true或者返回true时，添加处理器
+     * @param value
+     * @param handler
+     * @returns
+     */
+    when(value, handler) {
+        if (typeof value === 'function') {
+            value = value.call(this);
+        }
+        if (typeof value === 'boolean' && value) {
+            return this.withHandler(handler);
+        }
+        else if (typeof value.then === 'function') {
+            value.then(val => {
+                if (val) {
+                    return this.withHandler(handler);
+                }
+                return this;
+            });
+        }
+        return this;
+    }
+    /**
+     * 执行处理器
+     * @param result
+     * @param payload
+     * @returns
+     */
+    handle(result, payload) {
+        return __awaiter(this, void 0, void 0, function* () {
+            // 默认返回值处理函数
+            let resultClosure = (p) => __awaiter(this, void 0, void 0, function* () { return result; });
+            if (typeof result === 'function') {
+                resultClosure = result;
+            }
+            let handlers = [...this.handlers];
+            const nextClosure = function (p) {
+                return __awaiter(this, void 0, void 0, function* () {
+                    if (handlers.length > 0) {
+                        let item = handlers.shift();
+                        let closureRes = yield item.handler(p, nextClosure);
+                        if (closureRes)
+                            return closureRes;
+                    }
+                    // 处理器无返回值则返回默认的返回值
+                    return yield resultClosure(p);
+                });
+            };
+            // 开始处理
+            return yield nextClosure(payload);
+        });
+    }
+    /**
+     * 判断处理器是否已存在
+     * @param handler
+     * @returns
+     */
+    has(handler) {
+        return this.indexOf(handler) > -1;
+    }
+}
+;
+module.exports = HandlersMixin;

package/dist/Core/Mixins/HasAttributesMixin.d.ts

@@ -0,0 +1,46 @@
+import ObjectAccessInterface from '../Contracts/ObjectAccessInterface';
+declare class HasAttributesMixin implements ObjectAccessInterface {
+    /**
+     * 属性对象
+     */
+    protected attributes: Record<string, any>;
+    /**
+     * 返回对象格式
+     * @returns
+     */
+    toObject(): Record<string, any>;
+    /**
+     * 返回json字符串
+     * @returns
+     */
+    toJson(): string;
+    /**
+     * 判断键是否存在
+     * @param key
+     * @returns
+     */
+    has(key: string): boolean;
+    /**
+     * 合并属性对象
+     * @param attributes 新属性对象
+     * @returns
+     */
+    merge(attributes: Record<string, any>): this;
+    /**
+     * 设置单个属性值
+     * @param key
+     * @param value
+     */
+    set(key: string, value: any): void;
+    /**
+     * 获取单个属性值
+     * @param key
+     * @returns
+     */
+    get(key: string): any;
+    offsetExists(key: any): boolean;
+    offsetGet(key: any): any;
+    offsetSet(key: any, value: any): void;
+    offsetUnset(key: any): void;
+}
+export = HasAttributesMixin;

package/dist/Core/Mixins/HasAttributesMixin.js

@@ -0,0 +1,75 @@
+'use strict';
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+const merge_1 = __importDefault(require("merge"));
+class HasAttributesMixin {
+    constructor() {
+        /**
+         * 属性对象
+         */
+        this.attributes = {};
+    }
+    /**
+     * 返回对象格式
+     * @returns
+     */
+    toObject() {
+        return this.attributes;
+    }
+    /**
+     * 返回json字符串
+     * @returns
+     */
+    toJson() {
+        return JSON.stringify(this.attributes);
+    }
+    /**
+     * 判断键是否存在
+     * @param key
+     * @returns
+     */
+    has(key) {
+        return this.attributes[key] !== undefined;
+    }
+    /**
+     * 合并属性对象
+     * @param attributes 新属性对象
+     * @returns
+     */
+    merge(attributes) {
+        this.attributes = merge_1.default.recursive(true, this.attributes, attributes);
+        return this;
+    }
+    /**
+     * 设置单个属性值
+     * @param key
+     * @param value
+     */
+    set(key, value) {
+        this.attributes[key] = value;
+    }
+    /**
+     * 获取单个属性值
+     * @param key
+     * @returns
+     */
+    get(key) {
+        return this.attributes[key] || null;
+    }
+    offsetExists(key) {
+        return this.attributes[key] !== undefined;
+    }
+    offsetGet(key) {
+        return this.attributes[key];
+    }
+    offsetSet(key, value) {
+        this.attributes[key] = value;
+    }
+    offsetUnset(key) {
+        this.attributes[key] = undefined;
+        delete this.attributes[key];
+    }
+}
+;
+module.exports = HasAttributesMixin;

package/dist/Core/Mixins/HttpClientMixin.d.ts

@@ -0,0 +1,26 @@
+import HttpClientInterface from '../HttpClient/Contracts/HttpClientInterface';
+declare class HttpClientMixin {
+    protected httpClient: HttpClientInterface;
+    /**
+     * 获取请求客户端实例
+     * @returns
+     */
+    getHttpClient(): HttpClientInterface;
+    /**
+     * 设置请求客户端实例
+     * @param httpClient
+     * @returns
+     */
+    setHttpClient(httpClient: HttpClientInterface): this;
+    /**
+     * 创建请求客户端实例
+     * @returns
+     */
+    protected createHttpClient(): HttpClientInterface;
+    /**
+     * 获取请求默认配置
+     * @returns
+     */
+    protected getHttpClientDefaultOptions(): Record<string, any>;
+}
+export = HttpClientMixin;

package/dist/Core/Mixins/HttpClientMixin.js

@@ -0,0 +1,45 @@
+'use strict';
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+const HttpClient_1 = __importDefault(require("../HttpClient/HttpClient"));
+class HttpClientMixin {
+    constructor() {
+        this.httpClient = null;
+    }
+    /**
+     * 获取请求客户端实例
+     * @returns
+     */
+    getHttpClient() {
+        if (!this.httpClient) {
+            this.httpClient = this.createHttpClient();
+        }
+        return this.httpClient;
+    }
+    /**
+     * 设置请求客户端实例
+     * @param httpClient
+     * @returns
+     */
+    setHttpClient(httpClient) {
+        this.httpClient = httpClient;
+        return this;
+    }
+    /**
+     * 创建请求客户端实例
+     * @returns
+     */
+    createHttpClient() {
+        return HttpClient_1.default.create(this.getHttpClientDefaultOptions());
+    }
+    /**
+     * 获取请求默认配置
+     * @returns
+     */
+    getHttpClientDefaultOptions() {
+        return {};
+    }
+}
+;
+module.exports = HttpClientMixin;

package/dist/Core/Mixins/ResponseXmlMessageMixin.d.ts

@@ -0,0 +1,13 @@
+import Encryptor from "../Encryptor";
+import ResponseInterface from "../Http/Contracts/ResponseInterface";
+import Message from "../Message";
+declare class ResponseXmlMessageMixin {
+    /**
+     * 转化为回复消息
+     * @returns
+     */
+    transformToReply(response: any, message: Message, encryptor?: Encryptor): Promise<ResponseInterface>;
+    protected normalizeResponse(response: any): Promise<Record<string, any>>;
+    protected createXmlResponse(attributes: Record<string, any>, encryptor?: Encryptor): ResponseInterface;
+}
+export = ResponseXmlMessageMixin;

package/dist/Core/Mixins/ResponseXmlMessageMixin.js

@@ -0,0 +1,63 @@
+'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 Response_1 = __importDefault(require("../Http/Response"));
+const Utils_1 = require("../Support/Utils");
+class ResponseXmlMessageMixin {
+    /**
+     * 转化为回复消息
+     * @returns
+     */
+    transformToReply(response, message, encryptor = null) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!response || response === true) {
+                return new Response_1.default(200, {}, 'success');
+            }
+            let attributes = merge_1.default.recursive({
+                ToUserName: message.FromUserName,
+                FromUserName: message.ToUserName,
+                CreateTime: (0, Utils_1.getTimestamp)(),
+            }, yield this.normalizeResponse(response));
+            return this.createXmlResponse(attributes, encryptor);
+        });
+    }
+    normalizeResponse(response) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (typeof response === 'function') {
+                response = yield response();
+            }
+            if (typeof response === 'object') {
+                if (!response['MsgType']) {
+                    throw new Error('`MsgType` cannot be empty.');
+                }
+                return response;
+            }
+            if (typeof response === 'string' || typeof response === 'number') {
+                return {
+                    MsgType: 'text',
+                    Content: response,
+                };
+            }
+            throw new Error(`Invalid Response "${response.toString()}".`);
+        });
+    }
+    createXmlResponse(attributes, encryptor = null) {
+        let xml = (0, Utils_1.buildXml)(attributes);
+        return new Response_1.default(200, {
+            'Content-Type': 'application/xml'
+        }, encryptor ? encryptor.encrypt(xml) : xml);
+    }
+}
+;
+module.exports = ResponseXmlMessageMixin;

package/dist/Core/Mixins/ServerRequestMixin.d.ts

@@ -0,0 +1,16 @@
+import ServerRequestInterface from "../Http/Contracts/ServerRequestInterface";
+declare class ServerRequestMixin {
+    protected request: ServerRequestInterface;
+    /**
+     * 获取请求实例
+     * @returns
+     */
+    getRequest(): ServerRequestInterface;
+    /**
+     * 设置请求实例
+     * @param request
+     * @returns
+     */
+    setRequest(request: ServerRequestInterface): this;
+}
+export = ServerRequestMixin;

package/dist/Core/Mixins/ServerRequestMixin.js

@@ -0,0 +1,21 @@
+'use strict';
+class ServerRequestMixin {
+    /**
+     * 获取请求实例
+     * @returns
+     */
+    getRequest() {
+        return this.request;
+    }
+    /**
+     * 设置请求实例
+     * @param request
+     * @returns
+     */
+    setRequest(request) {
+        this.request = request;
+        return this;
+    }
+}
+;
+module.exports = ServerRequestMixin;

package/dist/Core/Support/Obj.d.ts

@@ -0,0 +1,62 @@
+declare class Obj {
+    /**
+     * 获取属性
+     * @param obj 对象
+     * @param key 属性，支持“.”作为层级分隔符的多层级查询
+     * @param defaultValue 默认值，默认：null
+     * @returns
+     */
+    static get(obj: Record<string, any>, key: string, defaultValue?: any): any;
+    /**
+     * 判断属性是否存在
+     * @param obj 对象
+     * @param key 属性，不支持多层级查询
+     * @returns
+     */
+    static exists(obj: Record<string, any>, key: string): boolean;
+    /**
+     * 设置属性
+     * @param obj 对象
+     * @param key 属性，支持“.”作为层级分隔符的多层级查询
+     * @param value 值
+     * @returns
+     */
+    static set(obj: Record<string, any>, key: string, value: any): Record<string, any>;
+    /**
+     * 将所有属性的属性转为以“.”分隔。如：
+     * ```
+     * {
+     *   "aa": {
+     *     "b1": {
+     *       "cc":123
+     *     },
+     *     "b2": "xxx"
+     *   }
+     * }
+     * ```
+     * 转换后：
+     * ```
+     * {
+     *    "aa.b1.cc": 123,
+     *    "aa.b2": "xxx"
+     * }
+     * ```
+     * @param obj 对象
+     * @param prepend 前缀，默认：''
+     * @returns
+     */
+    static dot(obj: Record<string, any>, prepend?: string): Record<string, any>;
+    /**
+     * 判断属性是否存在。如：
+     * ```
+     * Obj.has(obj, 'attr');
+     * Obj.has(obj, 'aa.bb.cc');
+     * Obj.has(obj, ['attr', 'aa.bb.cc']);
+     * ```
+     * @param obj 对象
+     * @param keys 属性，支持“.”作为层级分隔符的多层级查询，也支持多个属性
+     * @returns
+     */
+    static has(obj: Record<string, any>, keys: string | string[]): boolean;
+}
+export = Obj;

package/dist/Core/Support/Obj.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"));
+class Obj {
+    /**
+     * 获取属性
+     * @param obj 对象
+     * @param key 属性，支持“.”作为层级分隔符的多层级查询
+     * @param defaultValue 默认值，默认：null
+     * @returns
+     */
+    static get(obj, key, defaultValue = null) {
+        if (key === null) {
+            return obj;
+        }
+        if (Obj.exists(obj, key)) {
+            return obj[key];
+        }
+        let newObj = merge_1.default.recursive(true, obj);
+        key.split('.').forEach((segment) => {
+            if (Obj.exists(newObj, segment)) {
+                newObj = newObj[segment];
+            }
+            else {
+                return defaultValue;
+            }
+        });
+        return newObj;
+    }
+    /**
+     * 判断属性是否存在
+     * @param obj 对象
+     * @param key 属性，不支持多层级查询
+     * @returns
+     */
+    static exists(obj, key) {
+        return typeof obj === 'object' && obj[key] !== undefined;
+    }
+    /**
+     * 设置属性
+     * @param obj 对象
+     * @param key 属性，支持“.”作为层级分隔符的多层级查询
+     * @param value 值
+     * @returns
+     */
+    static set(obj, key, value) {
+        if (-1 === key.indexOf('.')) {
+            return obj[key] = value;
+        }
+        let keys = key.split('.');
+        key = keys.shift();
+        let newObj = {};
+        if (obj[key] && typeof obj[key] === 'object') {
+            newObj = merge_1.default.recursive(true, obj[key]);
+        }
+        obj[key] = Obj.set(newObj, keys.join('.'), value);
+        return obj;
+    }
+    /**
+     * 将所有属性的属性转为以“.”分隔。如：
+     * ```
+     * {
+     *   "aa": {
+     *     "b1": {
+     *       "cc":123
+     *     },
+     *     "b2": "xxx"
+     *   }
+     * }
+     * ```
+     * 转换后：
+     * ```
+     * {
+     *    "aa.b1.cc": 123,
+     *    "aa.b2": "xxx"
+     * }
+     * ```
+     * @param obj 对象
+     * @param prepend 前缀，默认：''
+     * @returns
+     */
+    static dot(obj, prepend = '') {
+        let results = {};
+        obj.map((key, value) => {
+            if (typeof value === 'object') {
+                results = merge_1.default.recursive(results, Obj.dot(value, `${prepend}${key}.`));
+            }
+            else {
+                results[prepend + key] = value;
+            }
+        });
+        return results;
+    }
+    /**
+     * 判断属性是否存在。如：
+     * ```
+     * Obj.has(obj, 'attr');
+     * Obj.has(obj, 'aa.bb.cc');
+     * Obj.has(obj, ['attr', 'aa.bb.cc']);
+     * ```
+     * @param obj 对象
+     * @param keys 属性，支持“.”作为层级分隔符的多层级查询，也支持多个属性
+     * @returns
+     */
+    static has(obj, keys) {
+        if (!obj || Object.keys(obj).length === 0) {
+            return false;
+        }
+        if (keys === null || keys === undefined) {
+            return false;
+        }
+        if (typeof keys === 'string') {
+            keys = [keys];
+        }
+        for (let i = 0; i < keys.length; i++) {
+            let key = keys[i];
+            if (Obj.exists(obj, key))
+                continue;
+            let newObj = merge_1.default.recursive(true, obj);
+            let subKeys = key.split('.');
+            for (let j = 0; j < subKeys.length; i++) {
+                let subKey = subKeys[j];
+                if (Obj.exists(newObj, subKey)) {
+                    newObj = newObj[subKey];
+                }
+                else {
+                    return false;
+                }
+            }
+        }
+        return true;
+    }
+}
+module.exports = Obj;

package/dist/Core/{PKCS.d.ts → Support/PKCS.d.ts}

@@ -1,5 +1,5 @@
 /// <reference types="node" />
-export declare class PKCS7 {
+declare class PKCS7 {
     /**
      * 对需要加密的明文进行填充补位
      * @param text 需要进行填充补位操作的明文
@@ -13,3 +13,4 @@ export declare class PKCS7 {
      */
     static unpad(text: string | Buffer, blockSize?: number): Buffer;
 }
+export = PKCS7;