node-easywechat 2.9.1 → 3.0.0-alpha.1

package/dist/Core/Mixins/ConfigMixin.js

@@ -0,0 +1,21 @@
+'use strict';
+class ConfigMixin {
+    /**
+     * 获取配置实例
+     * @returns
+     */
+    getConfig() {
+        return this.config;
+    }
+    /**
+     * 设置配置实例
+     * @param config
+     * @returns
+     */
+    setConfig(config) {
+        this.config = config;
+        return this;
+    }
+}
+;
+module.exports = ConfigMixin;

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

@@ -0,0 +1,11 @@
+import Encryptor from "../Encryptor";
+import Message from "../Message";
+declare class DecryptXmlMessageMixin {
+    /**
+     * 解密消息
+     * @returns
+     */
+    decryptMessage(message: Message, encryptor: Encryptor, signature: string, timestamp: number, nonce: string): Promise<Message>;
+    protected validateSignature(token: string, ciphertext: string, signature: string, timestamp: number, nonce: string): void;
+}
+export = DecryptXmlMessageMixin;

package/dist/Core/Mixins/DecryptXmlMessageMixin.js

@@ -0,0 +1,38 @@
+'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 DecryptXmlMessageMixin {
+    /**
+     * 解密消息
+     * @returns
+     */
+    decryptMessage(message, encryptor, signature, timestamp, nonce) {
+        return __awaiter(this, void 0, void 0, function* () {
+            let ciphertext = message.Encrypt;
+            this.validateSignature(encryptor.getToken(), ciphertext, signature, timestamp, nonce);
+            let attributes = yield (0, Utils_1.parseXml)(encryptor.decrypt(ciphertext, signature, nonce, timestamp));
+            message.merge(attributes);
+            return message;
+        });
+    }
+    validateSignature(token, ciphertext, signature, timestamp, nonce) {
+        if (!signature) {
+            throw new Error('Request signature must not be empty.');
+        }
+        let params = [token, timestamp, nonce, ciphertext];
+        params.sort();
+        if (signature !== (0, Utils_1.createHash)(params.join(''), 'sha1')) {
+            throw new Error('Invalid request signature.');
+        }
+    }
+}
+;
+module.exports = DecryptXmlMessageMixin;

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

@@ -0,0 +1,79 @@
+import { ServerHandlerClosure, ServerHandlerItem } from "../../Types/global";
+import Message from "../Message";
+declare class HandlersMixin {
+    protected handlers: ServerHandlerItem[];
+    /**
+     * 获取所有处理器
+     * @returns
+     */
+    getHandlers(): ServerHandlerItem[];
+    /**
+     * 创建处理器项
+     * @param handler
+     * @returns
+     */
+    createHandlerItem(handler: ServerHandlerClosure): ServerHandlerItem;
+    /**
+     * 计算处理器hash
+     * @param handler
+     * @returns
+     */
+    protected getHandlerHash(handler: ServerHandlerClosure): string;
+    /**
+     * @alias withHandler()
+     */
+    with(handler: ServerHandlerClosure): this;
+    /**
+     * 从最后添加处理器
+     * @param handler
+     * @returns
+     */
+    withHandler(handler: ServerHandlerClosure): this;
+    /**
+     * @alias prependHandler()
+     */
+    prepend(handler: ServerHandlerClosure): this;
+    /**
+     * 从最前添加处理器
+     * @param handler
+     * @returns
+     */
+    prependHandler(handler: ServerHandlerClosure): this;
+    /**
+     * @alias withoutHandler()
+     */
+    without(handler: ServerHandlerClosure): this;
+    /**
+     * 删除处理器
+     * @param handler
+     * @returns
+     */
+    withoutHandler(handler: ServerHandlerClosure): this;
+    /**
+     * 获取处理器的索引
+     * @param handler
+     * @returns
+     */
+    indexOf(handler: ServerHandlerClosure): number;
+    /**
+     * 当 value 为true或者返回true时，添加处理器
+     * @param value
+     * @param handler
+     * @returns
+     */
+    when(value: boolean | Function | Promise<boolean>, handler: ServerHandlerClosure): this;
+    /**
+     * 执行处理器
+     * @param result
+     * @param payload
+     * @returns
+     */
+    handle(result: any, payload: Message): Promise<any>;
+    /**
+     * 判断处理器是否已存在
+     * @param handler
+     * @returns
+     */
+    has(handler: ServerHandlerClosure): boolean;
+}
+export = HandlersMixin;

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;