node-easywechat 3.5.9 → 3.5.11

package/CHANGELOG.md

@@ -1,6 +1,19 @@
 # CHANGELOG
 
 
+## v3.5.11 (2023-12-19)
+
+- Fix: 微信支付获取平台证书优化为随用随获取的方式，并增加缓存 (#57)
+- Fix: 修复微信支付请求无参数时，签名计算异常的问题 (#60)
+
+## 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.d.ts

@@ -60,11 +60,6 @@ declare class Application implements ApplicationInterface {
      * @returns
      */
     protected getHttpClientDefaultOptions(): Record<string, any>;
-    /**
-     * 如果未配置平台证书，则尝试从接口读取
-     * @param force 是否强制读取，默认：false
-     */
-    loadPlatformCerts(force?: boolean): Promise<void>;
 }
 interface Application extends ConfigMixin, CacheMixin, ServerRequestMixin, HttpClientMixin {
 }

package/dist/Pay/Application.js

@@ -1,13 +1,4 @@
 '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 };
 };
@@ -24,8 +15,6 @@ const Utils_2 = __importDefault(require("./Utils"));
 const Config_1 = __importDefault(require("../OfficialAccount/Config"));
 const Client_1 = __importDefault(require("./Client"));
 const Validator_1 = __importDefault(require("./Validator"));
-const PublicKey_1 = require("../Core/Support/PublicKey");
-const AES_1 = require("../Core/Support/AES");
 /**
  * 微信支付应用
  */
@@ -47,7 +36,7 @@ class Application {
     getMerchant() {
         var _a;
         if (!this.merchant) {
-            this.merchant = new Merchant_1.default(this.config.get('mch_id'), this.config.get('private_key'), this.config.get('certificate'), this.config.get('secret_key'), this.config.get('v2_secret_key'), (_a = this.config.get('platform_certs')) !== null && _a !== void 0 ? _a : []);
+            this.merchant = new Merchant_1.default(this.config.get('mch_id'), this.config.get('private_key'), this.config.get('certificate'), this.config.get('secret_key'), this.config.get('v2_secret_key'), (_a = this.config.get('platform_certs')) !== null && _a !== void 0 ? _a : [], this);
         }
         return this.merchant;
     }
@@ -128,28 +117,6 @@ class Application {
             baseURL: 'https://api.mch.weixin.qq.com',
         }, this.getConfig().get('http'));
     }
-    /**
-     * 如果未配置平台证书，则尝试从接口读取
-     * @param force 是否强制读取，默认：false
-     */
-    loadPlatformCerts(force = false) {
-        return __awaiter(this, void 0, void 0, function* () {
-            let exists_certs = this.config.get('platform_certs', []);
-            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) {
-                    let certs = {};
-                    let key = this.config.get('secret_key');
-                    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);
-                    });
-                    this.getMerchant().setPlatformCerts(certs);
-                }
-            }
-        });
-    }
 }
 ;
 ;

package/dist/Pay/Contracts/MerchantInterface.d.ts

@@ -26,15 +26,29 @@ declare abstract class MerchantInterface {
      */
     getCertificate(): PublicKey;
     /**
-     * 获取平台证书
+     * 获取平台证书缓存名称
+     */
+    getPlatformCertKey(): string;
+    /**
+     * 设置平台证书缓存名称
+     * @param key
+     */
+    setPlatformCertKey(key: string): this;
+    /**
+     * 更具证书序列号获取平台证书
      * @param serial
      * @returns
      */
-    getPlatformCert(serial: string): PublicKey;
+    getPlatformCert(serial: string): Promise<PublicKey>;
+    /**
+     * 获取平台证书
+     * @param force 是否强制刷新缓存
+     */
+    loadPlatformCerts(force: boolean): void;
     /**
      * 设置平台证书
-     * @param certs 键名：序列号，键值：PublicKey实例
+     * @param certs 键名：序列号，键值：PublicKey实例或者文件内容字符串
      */
-    setPlatformCerts(certs: Record<string, PublicKey>): void;
+    setPlatformCerts(certs: Record<string, PublicKey | string>): void;
 }
 export = MerchantInterface;

package/dist/Pay/Contracts/MerchantInterface.js

@@ -25,14 +25,28 @@ class MerchantInterface {
      */
     getCertificate() { return null; }
     /**
-     * 获取平台证书
+     * 获取平台证书缓存名称
+     */
+    getPlatformCertKey() { return null; }
+    /**
+     * 设置平台证书缓存名称
+     * @param key
+     */
+    setPlatformCertKey(key) { return this; }
+    /**
+     * 更具证书序列号获取平台证书
      * @param serial
      * @returns
      */
     getPlatformCert(serial) { return null; }
+    /**
+     * 获取平台证书
+     * @param force 是否强制刷新缓存
+     */
+    loadPlatformCerts(force) { }
     /**
      * 设置平台证书
-     * @param certs 键名：序列号，键值：PublicKey实例
+     * @param certs 键名：序列号，键值：PublicKey实例或者文件内容字符串
      */
     setPlatformCerts(certs) { }
 }

package/dist/Pay/Contracts/ValidatorInterface.d.ts

@@ -4,7 +4,7 @@ declare abstract class ValidatorInterface {
     /**
      * 验证请求是否正确
      */
-    validate(request: Request): boolean;
+    validate(request: Request): Promise<boolean>;
     /**
      * 验证请求是否正确（v2）
      */

package/dist/Pay/Contracts/ValidatorInterface.js

@@ -3,7 +3,7 @@ class ValidatorInterface {
     /**
      * 验证请求是否正确
      */
-    validate(request) { return true; }
+    validate(request) { return Promise.resolve(true); }
     /**
      * 验证请求是否正确（v2）
      */

package/dist/Pay/Merchant.d.ts

@@ -1,14 +1,17 @@
 import { PrivateKey } from "../Core/Support/PrivateKey";
 import { PublicKey } from "../Core/Support/PublicKey";
+import Application from "./Application";
 import MerchantInterface from "./Contracts/MerchantInterface";
 declare class Merchant implements MerchantInterface {
     protected mchId: string;
     protected secretKey: string;
     protected v2SecretKey: string;
+    protected app: Application;
     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[]);
+    protected cacheKeyPlatformCert: string;
+    constructor(mchId: string, privateKey: string | PrivateKey, certificate: string | PublicKey, secretKey: string, v2SecretKey: string, platformCerts?: Record<string, string | PublicKey> | string[] | PublicKey[], app?: Application);
     /**
      * 统一规范化平台证书
      * @param platformCerts 平台证书列表
@@ -20,7 +23,10 @@ declare class Merchant implements MerchantInterface {
     getSecretKey(): string;
     getV2SecretKey(): string;
     getCertificate(): PublicKey;
-    getPlatformCert(serial: string): PublicKey;
-    setPlatformCerts(certs: Record<string, PublicKey>): void;
+    getPlatformCert(serial: string): Promise<PublicKey>;
+    setPlatformCerts(certs: Record<string, PublicKey | string>): void;
+    getPlatformCertKey(): string;
+    setPlatformCertKey(key: string): this;
+    loadPlatformCerts(force?: boolean): Promise<Record<string, string>>;
 }
 export = Merchant;

package/dist/Pay/Merchant.js

@@ -1,11 +1,22 @@
 '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 AES_1 = require("../Core/Support/AES");
 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 = [], app = null) {
         this.mchId = mchId;
         this.secretKey = secretKey;
         this.v2SecretKey = v2SecretKey;
+        this.app = app;
         this.platformCerts = {};
         if (!(privateKey instanceof PrivateKey_1.PrivateKey)) {
             this.privateKey = new PrivateKey_1.PrivateKey(privateKey);
@@ -58,10 +69,55 @@ class Merchant {
     }
     getPlatformCert(serial) {
         var _a;
-        return (_a = this.platformCerts[serial]) !== null && _a !== void 0 ? _a : null;
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!this.platformCerts || Object.keys(this.platformCerts).length === 0) {
+                yield this.loadPlatformCerts();
+            }
+            return (_a = this.platformCerts[serial]) !== null && _a !== void 0 ? _a : null;
+        });
     }
     setPlatformCerts(certs) {
-        this.platformCerts = certs;
+        let newCerts = {};
+        for (let key of Object.keys(certs)) {
+            let cert = certs[key];
+            if (typeof cert === 'string') {
+                newCerts[key] = PublicKey_1.PublicKey.createByCertificateContent(cert, key);
+            }
+            else {
+                newCerts[key] = cert;
+            }
+        }
+        this.platformCerts = newCerts;
+    }
+    getPlatformCertKey() {
+        if (!this.cacheKeyPlatformCert) {
+            this.cacheKeyPlatformCert = `pay.platform_certs.${this.mchId}`;
+        }
+        return this.cacheKeyPlatformCert;
+    }
+    setPlatformCertKey(key) {
+        this.cacheKeyPlatformCert = key;
+        return this;
+    }
+    loadPlatformCerts(force = false) {
+        return __awaiter(this, void 0, void 0, function* () {
+            let cacheKey = this.getPlatformCertKey();
+            let cache = this.app.getCache();
+            let certs = yield cache.get(cacheKey);
+            if (force || !certs || Object.keys(certs).length === 0) {
+                certs = {};
+                let response = yield this.app.getClient().get('/v3/certificates');
+                let data = response.toObject();
+                if (!data || !data.data || data.data.length === 0)
+                    return certs;
+                data.data.forEach((item) => {
+                    let content = AES_1.AES_GCM.decrypt(item.encrypt_certificate.ciphertext, this.app.getConfig().get('secret_key'), item.encrypt_certificate.nonce, item.encrypt_certificate.associated_data).toString();
+                    certs[item.serial_no] = content;
+                });
+                yield cache.set(cacheKey, certs, 36000); // 缓存10小时
+            }
+            this.setPlatformCerts(certs);
+        });
     }
 }
 module.exports = Merchant;

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,35 @@ 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 {
+            let search = '';
+            if (payload.params) {
+                if (typeof payload.params === 'string') {
+                    search = payload.params.replace(/^\?|&/, '');
+                }
+                else if (Object.keys(payload.params).length > 0) {
+                    search = (0, Utils_1.buildQueryString)(payload.params);
+                }
+            }
+            if (search) {
+                pathname += (pathname.indexOf('?') > -1 ? '&' : '?') + search;
+            }
+        }
+        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/Pay/Validator.d.ts

@@ -10,7 +10,7 @@ declare class Validator implements ValidatorInterface {
     static HEADER_SERIAL: string;
     static HEADER_SIGNATURE: string;
     constructor(merchant: MerchantInterface);
-    validate(request: MessageInterface): boolean;
+    validate(request: MessageInterface): Promise<boolean>;
     validateV2(message: Message): boolean;
 }
 export = Validator;

package/dist/Pay/Validator.js

@@ -1,4 +1,13 @@
 '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 };
 };
@@ -10,35 +19,37 @@ class Validator {
         this.merchant = merchant;
     }
     validate(request) {
-        [
-            Validator.HEADER_TIMESTAMP,
-            Validator.HEADER_NONCE,
-            Validator.HEADER_SERIAL,
-            Validator.HEADER_SIGNATURE,
-        ].forEach(key => {
-            if (!request.hasHeader(key)) {
-                throw new Error(`Missing Header: ${key}`);
+        return __awaiter(this, void 0, void 0, function* () {
+            [
+                Validator.HEADER_TIMESTAMP,
+                Validator.HEADER_NONCE,
+                Validator.HEADER_SERIAL,
+                Validator.HEADER_SIGNATURE,
+            ].forEach(key => {
+                if (!request.hasHeader(key)) {
+                    throw new Error(`Missing Header: ${key}`);
+                }
+            });
+            let timestamp = request.getHeader(Validator.HEADER_TIMESTAMP) || '';
+            let nonce = request.getHeader(Validator.HEADER_NONCE) || '';
+            let serial = request.getHeader(Validator.HEADER_SERIAL) || '';
+            let signature = request.getHeader(Validator.HEADER_SIGNATURE) || '';
+            let body = request.getBody().toString();
+            let message = `${timestamp}\n${nonce}\n${body}\n`;
+            if ((0, Utils_1.getTimestamp)() - parseInt(timestamp) > Validator.MAX_ALLOWED_CLOCK_OFFSET) {
+                throw new Error('Clock Offset Exceeded');
+            }
+            let publicKey = yield this.merchant.getPlatformCert(serial);
+            if (!publicKey) {
+                throw new Error(`No platform certs found for serial: ${serial}, please download from wechat pay and set it in merchant config with key \`platform_certs\`.`);
             }
+            let rsa = new RSA_1.default;
+            rsa.setPublicKey(publicKey.getValue());
+            if (false === rsa.verify(signature, message)) {
+                throw new Error('Invalid Signature');
+            }
+            return true;
         });
-        let timestamp = request.getHeader(Validator.HEADER_TIMESTAMP) || '';
-        let nonce = request.getHeader(Validator.HEADER_NONCE) || '';
-        let serial = request.getHeader(Validator.HEADER_SERIAL) || '';
-        let signature = request.getHeader(Validator.HEADER_SIGNATURE) || '';
-        let body = request.getBody().toString();
-        let message = `${timestamp}\n${nonce}\n${body}\n`;
-        if ((0, Utils_1.getTimestamp)() - parseInt(timestamp) > Validator.MAX_ALLOWED_CLOCK_OFFSET) {
-            throw new Error('Clock Offset Exceeded');
-        }
-        let publicKey = this.merchant.getPlatformCert(serial);
-        if (!publicKey) {
-            throw new Error(`No platform certs found for serial: ${serial}, please download from wechat pay and set it in merchant config with key \`platform_certs\`.`);
-        }
-        let rsa = new RSA_1.default;
-        rsa.setPublicKey(publicKey.getValue());
-        if (false === rsa.verify(signature, message)) {
-            throw new Error('Invalid Signature');
-        }
-        return true;
     }
     validateV2(message) {
         let messageSign = (message.get('sign') + '' || '').toUpperCase();

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.11",
   "description": "EasyWechat SDK for Node.js (NOT OFFICIAL)",
   "main": "dist/index.js",
   "scripts": {