node-easywechat 3.5.9 → 3.5.10

package/CHANGELOG.md

@@ -1,6 +1,14 @@
 # CHANGELOG
 
 
+## v3.5.10 (2023-12-19)
+
+- Feat: 微信支付通知处理增加v2接口xml格式的消息处理 (#56)
+
+- Fix: 修复计算v3签名时请求的querystring参数丢失导致签名错误的问题 (#60)
+- Fix: 修复回调方法的消息类型推到错误的问题
+- Fix: 修复获取平台证书时，响应数据解析异常的问题 (#57)
+
 ## v3.5.9 (2023-12-18)
 
 - Feat: 微信支付增加读取平台证书的方法loadPlatformCerts，并自动写入商户配置 (#57)

package/dist/Core/Http/Contracts/ServerRequestInterface.d.ts

@@ -42,7 +42,7 @@ declare abstract class ServerRequestInterface extends RequestInterface {
      * 获取所有post参数
      * @returns
      */
-    getParsedBody(): Record<string, any>;
+    getParsedBody(): Promise<Record<string, any>>;
     /**
      * 设置post参数
      * @param data

package/dist/Core/Http/Minxins/MessageMixin.js

@@ -63,7 +63,8 @@ class MessageMixin {
     }
     withBody(body) {
         if (Buffer.isBuffer(body)) {
-            this.content = body;
+            this.content = Buffer.from('');
+            this.content.copy(body);
         }
         else if (typeof body === 'string') {
             this.content = Buffer.from(body);

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

@@ -17,9 +17,9 @@ declare class ServerRequest implements ServerRequestInterface {
     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等格式
+     * 支持 JSON字符串、XML字符串、QueryString等格式
      */
-    protected parseBody(body: Buffer | Record<string, any> | string): void;
+    protected parseBody(): Promise<void>;
     getServerParams(): Record<string, any>;
     getCookieParams(): Record<string, any>;
     withCookieParams(cookies: Record<string, any>): this;
@@ -27,7 +27,7 @@ declare class ServerRequest implements ServerRequestInterface {
     withQueryParams(query: Record<string, any>): this;
     getUploadedFiles(): Record<string, any>;
     withUploadedFiles(files: Record<string, any>): this;
-    getParsedBody(): Record<string, any>;
+    getParsedBody(): Promise<Record<string, any>>;
     withParsedBody(data: Record<string, any>): this;
     getAttributes(): Record<string, any>;
     getAttribute(name: string, defaultValue?: any): any;

package/dist/Core/Http/ServerRequest.js

@@ -35,42 +35,40 @@ class ServerRequest {
             .withProtocolVersion(version)
             .withQueryParams((0, url_1.parse)(url, true).query || {});
         if (body) {
-            this.parseBody(body);
+            this.withBody(body);
         }
     }
     /**
      * 解析 body 内容
-     * @param body 支持 Buffer、object对象、JSON字符串、XML字符串、QueryString等格式
+     * 支持 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';
+    parseBody() {
+        return __awaiter(this, void 0, void 0, function* () {
+            let body = this.content.toString();
+            if (body.startsWith('<xml')) {
+                let res = yield (0, Utils_1.parseXml)(body);
+                this.parsedBody = res;
+                this.headers['content-type'] = 'text/xml';
             }
-            catch (e) {
-                if (body.substring(0, 1) === '<') {
-                    (0, Utils_1.parseXml)(body).then(res => {
-                        this.parsedBody = res;
-                        this.headers['content-type'] = 'text/xml';
-                    });
+            else if (body.startsWith('{') || body.startsWith('[')) {
+                try {
+                    this.parsedBody = JSON.parse(body);
+                    this.headers['content-type'] = 'application/json';
                 }
-                else {
+                catch (e) {
+                    this.parsedBody = {};
+                }
+            }
+            else {
+                try {
                     this.parsedBody = (0, Utils_1.parseQueryString)(body);
                     this.headers['content-type'] = 'application/x-www-form-urlencoded';
                 }
+                catch (e) {
+                    this.parsedBody = {};
+                }
             }
-            this.content = Buffer.from(body);
-        }
+        });
     }
     getServerParams() {
         return this.serverParams;
@@ -97,7 +95,12 @@ class ServerRequest {
         return this;
     }
     getParsedBody() {
-        return this.parsedBody;
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!this.parsedBody || Object.keys(this.parsedBody).length === 0) {
+                yield this.parseBody();
+            }
+            return this.parsedBody;
+        });
     }
     withParsedBody(data) {
         this.parsedBody = merge_1.default.recursive(true, data);

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

@@ -12,56 +12,56 @@ declare class HandlersMixin {
      * @param handler
      * @returns
      */
-    createHandlerItem(handler: ServerHandlerClosure): ServerHandlerItem;
+    createHandlerItem(handler: ServerHandlerClosure<Message>): ServerHandlerItem;
     /**
      * 计算处理器hash
      * @param handler
      * @returns
      */
-    protected getHandlerHash(handler: ServerHandlerClosure): string;
+    protected getHandlerHash(handler: ServerHandlerClosure<Message>): string;
     /**
      * @alias withHandler()
      */
-    with(handler: ServerHandlerClosure): this;
+    with(handler: ServerHandlerClosure<Message>): this;
     /**
      * 从最后添加处理器
      * @param handler
      * @returns
      */
-    withHandler(handler: ServerHandlerClosure): this;
+    withHandler(handler: ServerHandlerClosure<Message>): this;
     /**
      * @alias prependHandler()
      */
-    prepend(handler: ServerHandlerClosure): this;
+    prepend(handler: ServerHandlerClosure<Message>): this;
     /**
      * 从最前添加处理器
      * @param handler
      * @returns
      */
-    prependHandler(handler: ServerHandlerClosure): this;
+    prependHandler(handler: ServerHandlerClosure<Message>): this;
     /**
      * @alias withoutHandler()
      */
-    without(handler: ServerHandlerClosure): this;
+    without(handler: ServerHandlerClosure<Message>): this;
     /**
      * 删除处理器
      * @param handler
      * @returns
      */
-    withoutHandler(handler: ServerHandlerClosure): this;
+    withoutHandler(handler: ServerHandlerClosure<Message>): this;
     /**
      * 获取处理器的索引
      * @param handler
      * @returns
      */
-    indexOf(handler: ServerHandlerClosure): number;
+    indexOf(handler: ServerHandlerClosure<Message>): number;
     /**
      * 当 value 为true或者返回true时，添加处理器
      * @param value
      * @param handler
      * @returns
      */
-    when(value: boolean | Function | Promise<boolean>, handler: ServerHandlerClosure): this;
+    when(value: boolean | Function | Promise<boolean>, handler: ServerHandlerClosure<Message>): this;
     /**
      * 执行处理器
      * @param result

package/dist/OfficialAccount/Server.d.ts

@@ -19,20 +19,28 @@ declare class Server extends ServerInterface {
      * @param handler
      * @returns
      */
-    addMessageListener(type: ServerMessageType, handler: ServerHandlerClosure): this;
+    addMessageListener(type: ServerMessageType, handler: ServerHandlerClosure<Message>): this;
     /**
      * 添加事件消息处理器
      * @param event
      * @param handler
      * @returns
      */
-    addEventListener(event: ServerEventType, handler: ServerHandlerClosure): this;
+    addEventListener(event: ServerEventType, handler: ServerHandlerClosure<Message>): this;
     /**
      * 获取来自微信服务器的推送消息
      * @param request 未设置该参数时，则从当前服务端收到的请求中获取
      * @returns
      */
     getRequestMessage(request?: ServerRequestInterface): Promise<Message>;
-    protected decryptRequestMessage(query: Record<string, any>): ServerHandlerClosure;
+    protected decryptRequestMessage(query: Record<string, any>): ServerHandlerClosure<Message>;
+}
+interface Server {
+    with(next: ServerHandlerClosure<Message>): this;
+    withHandler(next: ServerHandlerClosure<Message>): this;
+    prepend(next: ServerHandlerClosure<Message>): this;
+    prependHandler(next: ServerHandlerClosure<Message>): this;
+    without(next: ServerHandlerClosure<Message>): this;
+    withoutHandler(next: ServerHandlerClosure<Message>): this;
 }
 export = Server;

package/dist/OpenPlatform/Server.d.ts

@@ -7,7 +7,7 @@ import { ServerHandlerClosure } from '../Types/global';
 declare class Server extends ServerInterface {
     protected encryptor: Encryptor;
     protected request: ServerRequestInterface;
-    protected defaultVerifyTicketHandler: ServerHandlerClosure;
+    protected defaultVerifyTicketHandler: ServerHandlerClosure<Message>;
     constructor(encryptor: Encryptor, request?: ServerRequestInterface);
     /**
      * 服务端消息处理
@@ -19,32 +19,32 @@ declare class Server extends ServerInterface {
      * @param handler
      * @returns
      */
-    handleAuthorized(handler: ServerHandlerClosure): this;
+    handleAuthorized(handler: ServerHandlerClosure<Message>): this;
     /**
      * 处理取消授权通知
      * @param handler
      * @returns
      */
-    handleUnauthorized(handler: ServerHandlerClosure): this;
+    handleUnauthorized(handler: ServerHandlerClosure<Message>): this;
     /**
      * 处理授权更新通知
      * @param handler
      * @returns
      */
-    handleAuthorizeUpdated(handler: ServerHandlerClosure): this;
+    handleAuthorizeUpdated(handler: ServerHandlerClosure<Message>): this;
     /**
      * 设置默认的验证票据通知处理回调
      * @param handler
      * @returns
      */
-    withDefaultVerifyTicketHandler(handler: ServerHandlerClosure): void;
+    withDefaultVerifyTicketHandler(handler: ServerHandlerClosure<Message>): void;
     /**
      * 处理验证票据通知
      * @param handler
      * @returns
      */
-    handleVerifyTicketRefreshed(handler: ServerHandlerClosure): this;
-    protected decryptRequestMessage(): ServerHandlerClosure;
+    handleVerifyTicketRefreshed(handler: ServerHandlerClosure<Message>): this;
+    protected decryptRequestMessage(): ServerHandlerClosure<Message>;
     /**
      * 获取来自微信服务器的推送消息
      * @param request 未设置该参数时，则从当前服务端收到的请求中获取
@@ -58,4 +58,12 @@ declare class Server extends ServerInterface {
      */
     getDecryptedMessage(request?: ServerRequestInterface): Promise<Message>;
 }
+interface Server {
+    with(next: ServerHandlerClosure<Message>): this;
+    withHandler(next: ServerHandlerClosure<Message>): this;
+    prepend(next: ServerHandlerClosure<Message>): this;
+    prependHandler(next: ServerHandlerClosure<Message>): this;
+    without(next: ServerHandlerClosure<Message>): this;
+    withoutHandler(next: ServerHandlerClosure<Message>): this;
+}
 export = Server;

package/dist/OpenWork/Server.d.ts

@@ -8,91 +8,91 @@ declare class Server extends ServerInterface {
     protected encryptor: Encryptor;
     protected providerEncryptor: Encryptor;
     protected request: ServerRequestInterface;
-    protected defaultSuiteTicketHandler: ServerHandlerClosure;
+    protected defaultSuiteTicketHandler: ServerHandlerClosure<Message>;
     constructor(encryptor: Encryptor, providerEncryptor: Encryptor, request?: ServerRequestInterface);
     /**
      * 服务端消息处理
      * @returns
      */
     serve(): Promise<Response>;
-    withDefaultSuiteTicketHandler(handler: ServerHandlerClosure): this;
+    withDefaultSuiteTicketHandler(handler: ServerHandlerClosure<Message>): this;
     /**
      * 设置联系人变化的消息处理器
      * @param handler
      */
-    handleSuiteTicketRefreshed(handler: ServerHandlerClosure): this;
+    handleSuiteTicketRefreshed(handler: ServerHandlerClosure<Message>): this;
     /**
      * 设置授权成功的消息处理器
      * @param handler
      */
-    handleAuthCreated(handler: ServerHandlerClosure): this;
+    handleAuthCreated(handler: ServerHandlerClosure<Message>): this;
     /**
      * 设置变更授权的消息处理器
      * @param handler
      */
-    handleAuthUpdated(handler: ServerHandlerClosure): this;
+    handleAuthUpdated(handler: ServerHandlerClosure<Message>): this;
     /**
      * 设置取消授权的消息处理器
      * @param handler
      */
-    handleAuthCancelled(handler: ServerHandlerClosure): this;
+    handleAuthCancelled(handler: ServerHandlerClosure<Message>): this;
     /**
      * 设置用户创建的消息处理器
      * @param handler
      */
-    handleUserCreated(handler: ServerHandlerClosure): this;
+    handleUserCreated(handler: ServerHandlerClosure<Message>): this;
     /**
      * 设置用户更新的消息处理器
      * @param handler
      */
-    handleUserUpdated(handler: ServerHandlerClosure): this;
+    handleUserUpdated(handler: ServerHandlerClosure<Message>): this;
     /**
      * 设置用户删除的消息处理器
      * @param handler
      */
-    handleUserDeleted(handler: ServerHandlerClosure): this;
+    handleUserDeleted(handler: ServerHandlerClosure<Message>): this;
     /**
      * 设置部门创建的消息处理器
      * @param handler
      */
-    handlePartyCreated(handler: ServerHandlerClosure): this;
+    handlePartyCreated(handler: ServerHandlerClosure<Message>): this;
     /**
      * 设置部门更新的消息处理器
      * @param handler
      */
-    handlePartyUpdated(handler: ServerHandlerClosure): this;
+    handlePartyUpdated(handler: ServerHandlerClosure<Message>): this;
     /**
      * 设置部门删除的消息处理器
      * @param handler
      */
-    handlePartyDeleted(handler: ServerHandlerClosure): this;
+    handlePartyDeleted(handler: ServerHandlerClosure<Message>): this;
     /**
      * 设置用户标签变化的消息处理器
      * @param handler
      */
-    handleUserTagUpdated(handler: ServerHandlerClosure): this;
+    handleUserTagUpdated(handler: ServerHandlerClosure<Message>): this;
     /**
      * 设置共享应用事件的消息处理器
      * @param handler
      */
-    handleShareAgentChanged(handler: ServerHandlerClosure): this;
+    handleShareAgentChanged(handler: ServerHandlerClosure<Message>): this;
     /**
      * 设置重置永久授权码的消息处理器
      * @param handler
      */
-    handleResetPermanentCode(handler: ServerHandlerClosure): this;
+    handleResetPermanentCode(handler: ServerHandlerClosure<Message>): this;
     /**
      * 设置应用管理员变更的消息处理器
      * @param handler
      */
-    handleChangeAppAdmin(handler: ServerHandlerClosure): this;
+    handleChangeAppAdmin(handler: ServerHandlerClosure<Message>): this;
     /**
      * 获取来自微信服务器的推送消息
      * @param request 未设置该参数时，则从当前服务端收到的请求中获取
      * @returns
      */
     getRequestMessage(request?: ServerRequestInterface): Promise<Message>;
-    protected decryptRequestMessage(query: Record<string, any>): ServerHandlerClosure;
+    protected decryptRequestMessage(query: Record<string, any>): ServerHandlerClosure<Message>;
     /**
      * 获取解密后的消息
      * @param request 未设置该参数时，则从当前服务端收到的请求中获取
@@ -100,4 +100,12 @@ declare class Server extends ServerInterface {
      */
     getDecryptedMessage(request?: ServerRequestInterface): Promise<import("../Core/Message")>;
 }
+interface Server {
+    with(next: ServerHandlerClosure<Message>): this;
+    withHandler(next: ServerHandlerClosure<Message>): this;
+    prepend(next: ServerHandlerClosure<Message>): this;
+    prependHandler(next: ServerHandlerClosure<Message>): this;
+    without(next: ServerHandlerClosure<Message>): this;
+    withoutHandler(next: ServerHandlerClosure<Message>): this;
+}
 export = Server;

package/dist/Pay/Application.js

@@ -138,10 +138,10 @@ class Application {
             if (force || !exists_certs || exists_certs.length === 0) {
                 let response = yield this.getClient().get('/v3/certificates');
                 let data = response.toObject();
-                if (data && data.length > 0) {
+                if (data.data && data.data.length > 0) {
                     let certs = {};
                     let key = this.config.get('secret_key');
-                    data.forEach((item) => {
+                    data.data.forEach((item) => {
                         let content = AES_1.AES_GCM.decrypt(item.encrypt_certificate.ciphertext, key, item.encrypt_certificate.nonce, item.encrypt_certificate.associated_data).toString();
                         certs[item.serial_no] = PublicKey_1.PublicKey.createByCertificateContent(content, item.serial_no);
                     });

package/dist/Pay/Merchant.d.ts

@@ -8,7 +8,7 @@ declare class Merchant implements MerchantInterface {
     protected platformCerts: Record<string, PublicKey>;
     protected privateKey: PrivateKey;
     protected certificate: PublicKey;
-    constructor(mchId: string, privateKey: string | PrivateKey, certificate: string | PublicKey, secretKey: string, v2SecretKey?: string, platformCerts?: Record<string, string | PublicKey> | string[] | PublicKey[]);
+    constructor(mchId: string, privateKey: string | PrivateKey, certificate: string | PublicKey, secretKey: string, v2SecretKey: string, platformCerts?: Record<string, string | PublicKey> | string[] | PublicKey[]);
     /**
      * 统一规范化平台证书
      * @param platformCerts 平台证书列表

package/dist/Pay/Merchant.js

@@ -2,7 +2,7 @@
 const PrivateKey_1 = require("../Core/Support/PrivateKey");
 const PublicKey_1 = require("../Core/Support/PublicKey");
 class Merchant {
-    constructor(mchId, privateKey, certificate, secretKey, v2SecretKey = null, platformCerts = []) {
+    constructor(mchId, privateKey, certificate, secretKey, v2SecretKey, platformCerts = []) {
         this.mchId = mchId;
         this.secretKey = secretKey;
         this.v2SecretKey = v2SecretKey;

package/dist/Pay/Server.d.ts

@@ -19,6 +19,8 @@ declare class Server extends ServerInterface {
      * @returns
      */
     getRequestMessage(request?: ServerRequestInterface): Promise<Message>;
+    protected decodeXmlMessage(attributes: Record<string, any>): Promise<Record<string, any>>;
+    protected decodeJsonMessage(attributes: Record<string, any>): Record<string, any>;
     /**
      * 获取解密后的消息
      * @param request
@@ -30,12 +32,20 @@ declare class Server extends ServerInterface {
      * @param handler 消息处理器，需要接受两个参数，参数1是消息，参数2是下一个消息处理器
      * @returns
      */
-    handlePaid(handler: ServerHandlerClosure): this;
+    handlePaid(handler: ServerHandlerClosure<Message>): this;
     /**
      * 处理退款回调
      * @param handler 消息处理器，需要接受两个参数，参数1是消息，参数2是下一个消息处理器
      * @returns
      */
-    handleRefunded(handler: ServerHandlerClosure): this;
+    handleRefunded(handler: ServerHandlerClosure<Message>): this;
+}
+interface Server {
+    with(next: ServerHandlerClosure<Message>): this;
+    withHandler(next: ServerHandlerClosure<Message>): this;
+    prepend(next: ServerHandlerClosure<Message>): this;
+    prependHandler(next: ServerHandlerClosure<Message>): this;
+    without(next: ServerHandlerClosure<Message>): this;
+    withoutHandler(next: ServerHandlerClosure<Message>): this;
 }
 export = Server;

package/dist/Pay/Server.js

@@ -15,6 +15,7 @@ const ServerInterface_1 = __importDefault(require("../Core/Contracts/ServerInter
 const Response_1 = __importDefault(require("../Core/Http/Response"));
 const Message_1 = __importDefault(require("./Message"));
 const AES_1 = require("../Core/Support/AES");
+const Utils_1 = require("../Core/Support/Utils");
 class Server extends ServerInterface_1.default {
     constructor(merchant = null, request = null) {
         super();
@@ -28,10 +29,15 @@ class Server extends ServerInterface_1.default {
     serve() {
         return __awaiter(this, void 0, void 0, function* () {
             let message = yield this.getRequestMessage();
+            let isV2Message = message.getOriginalContents().startsWith('<xml');
             try {
-                let defaultResponse = new Response_1.default(200, {}, JSON.stringify({
-                    code: 'SUCCESS', message: '成功',
-                }));
+                let defaultResponse;
+                if (isV2Message) {
+                    defaultResponse = new Response_1.default(200, {}, (0, Utils_1.buildXml)({ return_code: 'SUCCESS', return_msg: '' }));
+                }
+                else {
+                    defaultResponse = new Response_1.default(200, {}, JSON.stringify({ code: 'SUCCESS', message: '成功' }));
+                }
                 let response = yield this.handle(defaultResponse, message);
                 if (!(response instanceof Response_1.default)) {
                     response = defaultResponse;
@@ -39,9 +45,12 @@ class Server extends ServerInterface_1.default {
                 return response;
             }
             catch (e) {
-                return new Response_1.default(200, {}, JSON.stringify({
-                    code: 'ERROR', message: e.message,
-                }));
+                if (isV2Message) {
+                    return new Response_1.default(200, {}, (0, Utils_1.buildXml)({ return_code: 'ERROR', return_msg: e.message }));
+                }
+                else {
+                    return new Response_1.default(200, {}, JSON.stringify({ code: 'ERROR', message: e.message }));
+                }
             }
         });
     }
@@ -60,27 +69,47 @@ class Server extends ServerInterface_1.default {
             if (body) {
                 originContent = body.toString();
             }
-            let attributes = {};
-            try {
-                attributes = JSON.parse(originContent);
-            }
-            catch (e) { }
-            if (Object.keys(attributes).length === 0) {
-                throw new Error('Invalid request body.');
+            let attributes = yield request.getParsedBody();
+            if (originContent.startsWith('<xml')) {
+                attributes = yield this.decodeXmlMessage(attributes);
             }
-            if (!attributes['resource']['ciphertext']) {
-                throw new Error('Invalid request.');
+            else {
+                attributes = this.decodeJsonMessage(attributes);
             }
-            try {
-                let decryptMessage = AES_1.AES_GCM.decrypt(attributes['resource']['ciphertext'], this.merchant.getSecretKey(), attributes['resource']['nonce'], attributes['resource']['associated_data']);
-                attributes = JSON.parse(decryptMessage.toString());
+            return new Message_1.default(attributes, originContent);
+        });
+    }
+    decodeXmlMessage(attributes) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (attributes['req_info']) {
+                let key = this.merchant.getV2SecretKey();
+                if (!key) {
+                    throw new Error('V2 secret key is required');
+                }
+                attributes = yield (0, Utils_1.parseXml)(AES_1.AES.decrypt(attributes['req_info'], (0, Utils_1.createHash)(key, 'md5'), '', true, 'aes-256-ecb').toString());
             }
-            catch (e) {
-                throw new Error('Failed to decrypt request message.');
+            if (!attributes || Object.keys(attributes).length === 0) {
+                throw new Error('Failed to decrypt request message');
             }
-            return new Message_1.default(attributes, originContent);
+            return attributes;
         });
     }
+    decodeJsonMessage(attributes) {
+        if (!attributes || Object.keys(attributes).length === 0) {
+            throw new Error('Invalid request body.');
+        }
+        if (!attributes['resource']['ciphertext']) {
+            throw new Error('Invalid request.');
+        }
+        try {
+            let decryptMessage = AES_1.AES_GCM.decrypt(attributes['resource']['ciphertext'], this.merchant.getSecretKey(), attributes['resource']['nonce'], attributes['resource']['associated_data']);
+            attributes = JSON.parse(decryptMessage.toString());
+        }
+        catch (e) {
+            throw new Error('Failed to decrypt request message.');
+        }
+        return attributes;
+    }
     /**
      * 获取解密后的消息
      * @param request

package/dist/Pay/Signature.d.ts

@@ -8,8 +8,10 @@ declare class Signature {
      * @param method 请求方式
      * @param url 请求地址
      * @param payload 请求载荷
+     * @param nonce 随机串，默认：随机生成
+     * @param timestamp 时间戳，默认：当前时间
      * @returns
      */
-    createHeader(method: string, url: string, payload: AxiosRequestConfig<any>): string;
+    createHeader(method: string, url: string, payload: AxiosRequestConfig<any>, nonce?: string, timestamp?: number): string;
 }
 export = Signature;

package/dist/Pay/Signature.js

@@ -14,17 +14,24 @@ class Signature {
      * @param method 请求方式
      * @param url 请求地址
      * @param payload 请求载荷
+     * @param nonce 随机串，默认：随机生成
+     * @param timestamp 时间戳，默认：当前时间
      * @returns
      */
-    createHeader(method, url, payload) {
+    createHeader(method, url, payload, nonce = null, timestamp = null) {
         let pathname = url;
         if (url.startsWith('https://') || url.startsWith('http://')) {
             let urlObj = new URL(url);
             let search = (0, Utils_1.buildQueryString)((0, merge_1.default)(true, urlObj.searchParams, payload.params));
             pathname = urlObj.pathname + (search ? '?' + search : '');
         }
-        let nonce = (0, Utils_1.randomString)();
-        let timestamp = (0, Utils_1.getTimestamp)();
+        else {
+            pathname += (pathname.indexOf('?') > -1 ? '&' : '?') + (0, Utils_1.buildQueryString)(payload.params);
+        }
+        if (!nonce)
+            nonce = (0, Utils_1.randomString)();
+        if (!timestamp)
+            timestamp = (0, Utils_1.getTimestamp)();
         let body = '';
         if (payload.data) {
             if (typeof payload.data === 'object') {

package/dist/Work/Server.d.ts

@@ -87,4 +87,12 @@ declare class Server extends ServerInterface {
      */
     getDecryptedMessage(request?: ServerRequestInterface): Promise<import("../Core/Message")>;
 }
+interface Server {
+    with(next: ServerHandlerClosure<Message>): this;
+    withHandler(next: ServerHandlerClosure<Message>): this;
+    prepend(next: ServerHandlerClosure<Message>): this;
+    prependHandler(next: ServerHandlerClosure<Message>): this;
+    without(next: ServerHandlerClosure<Message>): this;
+    withoutHandler(next: ServerHandlerClosure<Message>): this;
+}
 export = Server;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "node-easywechat",
-  "version": "3.5.9",
+  "version": "3.5.10",
   "description": "EasyWechat SDK for Node.js (NOT OFFICIAL)",
   "main": "dist/index.js",
   "scripts": {