node-easywechat 3.0.0-alpha.2 → 3.0.0-beta.3

package/CHANGELOG.md

@@ -1,8 +1,38 @@
 # CHANGELOG
 
 
+## v3.0.0-beta.3 (2022-06-22)
+
+- Fix: 修复获取js ticket时无法自动获取access_token的问题
+- Fix: 修复日志处理回调函数的参数提示异常的问题
+
+## v3.0.0-beta.2 (2022-06-21)
+
+- Feat: 统一调用入口增加一些常用的类
+
+- Fix: 修复获取的服务端实例没有代码提示的问题
+
+## v3.0.0-beta.1 (2022-06-21)
+
+- Feat: 新增设置预置参数相关方法
+- Feat: 增加设置日志处理器的方法
+- Feat: 增加统一的对象调用入口
+
+- Fix: 调整获取响应内容时的返回类型
+- Fix: 修复微信小程序access_token键名前缀与公众号相同的问题
+- Fix: 优化并导出配置项声明
+- Fix: 修复请求响应结果非字符串类型时转化数据格式报错的问题
+- Fix: 未设置ServerRequest实例就调用getRequest时提示异常
+- Fix: 修复未自动创建客户端实例的问题
+
+- Perf: 调整接口请求返回的HttpResponse对象toObject时的数据类型
+
 ## v3.0.0-alpha.2 (2022-06-08)
 
+- Feat: 新增小程序相关接口
+
+- Fix: 修复content-type非json时，错误判断不正确问题
+
 - Perf: 优化消息对象的提示信息
 
 - Refactor: 简化构造函数的写法

package/README.md

@@ -5,7 +5,7 @@
 
 **注：3.x分支针对 EasyWechat 的 6.x版本。**
 
-~~若您需要 EasyWechat 的 5.x版本，请切换到 [2.x](https://github.com/hpyer/node-easywechat/tree/2.x) 分支。~~
+若您需要 EasyWechat 的 5.x版本，请切换到 [2.x](https://github.com/hpyer/node-easywechat/tree/2.x) 分支。
 
 [EasyWechat](https://github.com/w7corp/easywechat) 是一个由 `安正超` 大神用 PHP 开发的开源的微信非官方 SDK（现由微擎团队团队维护）。其功能强大，使用方便，个人一直很喜欢，所以近日将其在 Node.js 上实现。本人会尽量还原其配置项以及接口的调用方式，但毕竟语言环境不同，具体的实现方式会有些许差别，还请各位开发者见谅。
 
@@ -20,16 +20,25 @@
 
 绝大部分API都可以根据 [EasyWechat 的文档](https://www.easywechat.com/5.x/) 来使用。小部分（如获取请求相关数据、返回响应数据、支付证书等）的操作，由于语言环境的不同，会有不同处理。具体可以查看 [node-easywechat-demo](https://github.com/hpyer/node-easywechat-demo/) 以及下方的[自定义模块说明](#自定义模块模块替换使用方法) 。如果仍有疑问，请提issue，谢谢～
 
+从 `3.x` 起 SDK 中不再内置具体业务的接口，仅封装底层基础部分，如认证、授权和 API 客户端。至于为什么不再封装业务接口，可以查看 [EasyWechat 给出说明](https://easywechat.com/6.x/introduction.html#不再封装业务接口)。
+
 ```js
-// 按需引入所需要的模块
 // 公众号
-const Application = require('node-easywechat/OfficialAccount/Application');
+const { OfficialAccount } = require('node-easywechat');
+// 实例化应用
+let app = new OfficialAccount({
+  // 配置项
+});
 
+// 小程序
+const { MiniApp } = require('node-easywechat');
 // 实例化应用
-let app = new Application({
-  // ...
+let app = new MiniApp({
+  // 配置项
 });
 
+// ----- 以下为通用的 api 调用方法 -----
+
 // 获取 api 调用客户端
 let client = app.getClient();
 
@@ -43,26 +52,32 @@ let response = await client.post('/cgi-bin/user/info/updateremark', {
 ### 配置项示例
 
 ``` js
-// 公众号配置
+// 通用配置，即所有模块都可以设置
 {
-  // 微信公众号的 app key
-  app_id: '',
-  // 微信公众号的 app secret
-  secret: '',
-  // 微信公众号的 token
-  token: '',
-  // EncodingAESKey
-  aes_key: '',
+  // axios 请求参数
+  // 详见：https://github.com/axios/axios#request-config
+  http: {},
 
   // 缓存以文件(默认设置)存储时，需要的配置项
   file_cache: {
     path: './cache/', // 文件存储目录（请确保该目录有读写权限）
     fileMode: 0o666,  // 文件权限
     ext: '.cache'     // 文件扩展名
-  },
-  // 自定义缓存驱动
-  // 您需要实现一个继承 EasyWechat.CacheInterface 的缓存驱动类
-  // 实例化以后利用 “模块替换” 功能赋值给 app.cache
+  }
+}
+```
+
+``` js
+// 公众号配置
+{
+  // 公众号的 app key
+  app_id: '',
+  // 公众号的 app secret
+  secret: '',
+  // 公众号的 token
+  token: '',
+  // EncodingAESKey
+  aes_key: '',
 
   // 网页授权认证
   oauth: {
@@ -74,11 +89,133 @@ let response = await client.post('/cgi-bin/user/info/updateremark', {
 }
 ```
 
+``` js
+// 小程序配置
+{
+  // 小程序的 app key
+  app_id: '',
+  // 小程序的 app secret
+  secret: '',
+  // 小程序的 token
+  token: '',
+  // EncodingAESKey
+  aes_key: ''
+}
+```
+
+### 自定义模块（模块替换）使用方法
+
+#### 日志模块
+
+框架默认不记录任何日志。如果需要，可以通过 `client` 实例的 `setLogger` 方法设置日志处理回调方法。
+
+```js
+// 以公众号为例
+const { OfficialAccount } = require('node-easywechat');
+// 实例化应用
+let app = new OfficialAccount({
+  // ...
+});
+
+// 获取 api 调用客户端
+let client = app.getClient();
+
+/**
+ * 该回调方法会接收两种日志信息
+ * 1、接口请求调用前的参数：
+ *  string  固定值，'before'
+ *  object  请求参数
+ * 2、接口请求调用后的参数：
+ *  string  固定值，'after'
+ *  object  请求参数
+ *  number  请求耗时（ms）
+ *  Response  请求响应对象
+ */
+client.setLogger((...args) => {
+  console.log(args)
+});
+```
+
+#### 缓存模块
+
+框架默认使用文件缓存读取到的 `access_token` 等值，如需要改用其他缓存方式（如：redis），请实现接口 `CacheInterface` 并通过 `app.setCacher` 方法进行模块替换。
+
+```js
+const { OfficialAccount, CacheInterface } = require('node-easywechat');
+const Redis = require("ioredis");
+
+class RedisCacher extends CacheInterface {
+  constructor(redis) {
+    this.redis = redis;
+  }
+
+  get(id)
+  {
+    return this.redis.get(id);
+  }
+
+  async has(id)
+  {
+    return (await this.redis.exists(id)) > 0;
+  }
+
+  async set(id, data = null, lifeTime = 0)
+  {
+    if (lifeTime > 0) {
+      await this.redis.set(id, data, 'EX', lifeTime);
+    }
+    else {
+      await this.redis.set(id, data);
+    }
+    return true;
+  }
+
+  async delete(id)
+  {
+    await this.redis.del(id);
+    return true;
+  }
+}
+
+// 实例化应用
+let app = new OfficialAccount({
+  // ...
+});
+
+// 替换缓存实例
+app.setCacher(new RedisCacher(new Redis));
+```
+
+#### 请求模块
+
+通常，如果你的应用不需要处理服务端回调、支付回调等逻辑的话，是不需要传递请求对象的。
+
+```js
+const { OfficialAccount, ServerRequest } = require('node-easywechat');
+
+// 实例化应用
+let app = new OfficialAccount({
+  // ...
+});
+
+// 根据 IncomingMessage 实例（即 Node.js 原始请求对象）创建 ServerRequest 实例
+//
+// 由于 IncomingMessage 的 body 流的特殊性，某些框架（目前已知：fastify）
+// 可能会自动读取后挂载到上下文中，从而导致 node-easywechat 去尝试读取时报错。
+// 这时可以选择传入第二个参数，即 body 的内容
+//
+// 如果此方法 不能解决你的问题，可以选择继承 ServerRequest，重写相关方法
+let request = ServerRequest.createFromIncomingMessage(req);
+
+// 设置请求实例
+app.setRequest(request);
+```
+
 ### 模块支持情况
 
 - [x] 公众号模块
 - [ ] 微信支付
-- [ ] 小程序
+- [x] 小程序
 - [ ] 开放平台
 - [ ] 企业微信
 - [ ] 企业微信开放平台

package/dist/Core/Contracts/AccessTokenInterface.d.ts

@@ -8,6 +8,6 @@ declare abstract class AccessTokenInterface {
      * 转成url参数
      * @returns
      */
-    toQuery(): Promise<object>;
+    toQuery(): Promise<Record<string, any>>;
 }
 export = AccessTokenInterface;

package/dist/Core/Contracts/CacheInterface.d.ts

@@ -1,3 +1,6 @@
+/**
+ * 缓存接口
+ */
 declare abstract class CacheInterface {
     /**
      * 获取缓存

package/dist/Core/Contracts/CacheInterface.js

@@ -8,6 +8,9 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
         step((generator = generator.apply(thisArg, _arguments || [])).next());
     });
 };
+/**
+ * 缓存接口
+ */
 class CacheInterface {
     /**
      * 获取缓存

package/dist/Core/Contracts/ServerInterface.d.ts

@@ -1,8 +1,14 @@
 import ResponseInterface from "../Http/Contracts/ResponseInterface";
+import DecryptXmlMessageMixin from "../Mixins/DecryptXmlMessageMixin";
+import HandlersMixin from "../Mixins/HandlersMixin";
+import ResponseXmlMessageMixin from "../Mixins/ResponseXmlMessageMixin";
 declare abstract class ServerInterface {
+    constructor();
     /**
      * 处理消息
      */
     serve(): Promise<ResponseInterface>;
 }
+interface ServerInterface extends HandlersMixin, DecryptXmlMessageMixin, ResponseXmlMessageMixin {
+}
 export = ServerInterface;

package/dist/Core/Contracts/ServerInterface.js

@@ -8,7 +8,17 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
         step((generator = generator.apply(thisArg, _arguments || [])).next());
     });
 };
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+const DecryptXmlMessageMixin_1 = __importDefault(require("../Mixins/DecryptXmlMessageMixin"));
+const HandlersMixin_1 = __importDefault(require("../Mixins/HandlersMixin"));
+const ResponseXmlMessageMixin_1 = __importDefault(require("../Mixins/ResponseXmlMessageMixin"));
+const Utils_1 = require("../Support/Utils");
 class ServerInterface {
+    constructor() {
+        this.handlers = [];
+    }
     /**
      * 处理消息
      */
@@ -17,4 +27,6 @@ class ServerInterface {
     }
 }
 ;
+;
+(0, Utils_1.applyMixins)(ServerInterface, [HandlersMixin_1.default, DecryptXmlMessageMixin_1.default, ResponseXmlMessageMixin_1.default]);
 module.exports = ServerInterface;

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

@@ -3,6 +3,9 @@ import { IncomingMessage } from "http";
 import ServerRequestInterface from "./Contracts/ServerRequestInterface";
 import MessageMixin from "./Minxins/MessageMixin";
 import RequestMixin from "./Minxins/RequestMixin";
+/**
+ * 服务器收到的请求对象
+ */
 declare class ServerRequest implements ServerRequestInterface {
     protected attributes: Record<string, any>;
     protected cookieParams: Record<string, any>;

package/dist/Core/Http/ServerRequest.js

@@ -8,6 +8,9 @@ const url_1 = require("url");
 const Utils_1 = require("../Support/Utils");
 const MessageMixin_1 = __importDefault(require("./Minxins/MessageMixin"));
 const RequestMixin_1 = __importDefault(require("./Minxins/RequestMixin"));
+/**
+ * 服务器收到的请求对象
+ */
 class ServerRequest {
     constructor(method, url, headers = {}, body = null, version = 'v1.1', serverParams = {}) {
         this.attributes = {};

package/dist/Core/HttpClient/AccessTokenAwareClient.d.ts

@@ -3,17 +3,19 @@ import AccessTokenAwareHttpClientInterface from "./Contracts/AccessTokenAwareHtt
 import AccessTokenInterface from "../Contracts/AccessTokenInterface";
 import HttpClientInterface from "./Contracts/HttpClientInterface";
 import HttpClientMethodsMixin from './Mixins/HttpClientMethodsMixin';
-import { HttpClientFailureJudgeClosure } from '../../Types/global';
+import { HttpClientFailureJudgeClosure, LogHandler } from '../../Types/global';
 import HttpClientResponse from './HttpClientResponse';
+import PresetMixin from './Mixins/PresetMixin';
 declare class AccessTokenAwareClient implements AccessTokenAwareHttpClientInterface, HttpClientInterface {
     protected client: HttpClientInterface;
     protected accessToken: AccessTokenInterface;
-    constructor(client: HttpClientInterface, accessToken: AccessTokenInterface, failureJudge?: HttpClientFailureJudgeClosure, throwError?: boolean);
+    constructor(client: HttpClientInterface, accessToken?: AccessTokenInterface, failureJudge?: HttpClientFailureJudgeClosure, throwError?: boolean);
     withAccessToken(accessToken: AccessTokenInterface): this;
     getInstance(): AxiosInstance;
     setInstance(instance: AxiosInstance): this;
+    setLogger(logger: LogHandler): this;
     request(method: Method, url: string, payload?: AxiosRequestConfig<any>): Promise<HttpClientResponse>;
 }
-interface AccessTokenAwareClient extends HttpClientMethodsMixin {
+interface AccessTokenAwareClient extends HttpClientMethodsMixin, PresetMixin {
 }
 export = AccessTokenAwareClient;

package/dist/Core/HttpClient/AccessTokenAwareClient.js

@@ -15,8 +15,9 @@ const merge_1 = __importDefault(require("merge"));
 const Utils_1 = require("../Support/Utils");
 const HttpClient_1 = __importDefault(require("./HttpClient"));
 const HttpClientMethodsMixin_1 = __importDefault(require("./Mixins/HttpClientMethodsMixin"));
+const PresetMixin_1 = __importDefault(require("./Mixins/PresetMixin"));
 class AccessTokenAwareClient {
-    constructor(client, accessToken, failureJudge = null, throwError = true) {
+    constructor(client, accessToken = null, failureJudge = null, throwError = true) {
         this.client = null;
         this.accessToken = null;
         this.client = client || HttpClient_1.default.create(null, failureJudge, throwError);
@@ -33,15 +34,20 @@ class AccessTokenAwareClient {
         this.client.setInstance(instance);
         return this;
     }
+    setLogger(logger) {
+        this.client.setLogger(logger);
+        return this;
+    }
     request(method, url, payload = {}) {
         return __awaiter(this, void 0, void 0, function* () {
             if (this.accessToken) {
                 payload.params = (0, merge_1.default)(true, payload.params || {}, yield this.accessToken.toQuery());
             }
-            return this.client.request(method, (0, Utils_1.ltrim)(url, '\\/+'), payload);
+            let options = this.mergeThenResetPrepends(payload, method);
+            return this.client.request(method, (0, Utils_1.ltrim)(url, '\\/+'), options);
         });
     }
 }
 ;
-(0, Utils_1.applyMixins)(AccessTokenAwareClient, [HttpClientMethodsMixin_1.default]);
+(0, Utils_1.applyMixins)(AccessTokenAwareClient, [HttpClientMethodsMixin_1.default, PresetMixin_1.default]);
 module.exports = AccessTokenAwareClient;

package/dist/Core/HttpClient/Contracts/HttpClientInterface.d.ts

@@ -1,4 +1,5 @@
 import { Method, AxiosRequestConfig, AxiosInstance } from 'axios';
+import { LogHandler } from '../../../Types/global';
 import HttpClientResponse from '../HttpClientResponse';
 declare abstract class HttpClientInterface {
     /**
@@ -10,6 +11,10 @@ declare abstract class HttpClientInterface {
      * 设置axios实例
      */
     setInstance(instance: AxiosInstance): this;
+    /**
+     * 设置日志方法
+     */
+    setLogger(logger: LogHandler): this;
     /**
      * 发起http请求
      */

package/dist/Core/HttpClient/Contracts/HttpClientInterface.js

@@ -18,6 +18,10 @@ class HttpClientInterface {
      * 设置axios实例
      */
     setInstance(instance) { return this; }
+    /**
+     * 设置日志方法
+     */
+    setLogger(logger) { return this; }
     /**
      * 发起http请求
      */

package/dist/Core/HttpClient/HttpClient.d.ts

@@ -1,12 +1,21 @@
 import { AxiosInstance, AxiosRequestConfig, Method } from 'axios';
 import HttpClientInterface from './Contracts/HttpClientInterface';
 import HttpClientResponse from './HttpClientResponse';
-import { HttpClientFailureJudgeClosure } from '../../Types/global';
+import { HttpClientFailureJudgeClosure, LogHandler } from '../../Types/global';
 declare class HttpClient implements HttpClientInterface {
     protected axios: AxiosInstance;
     protected failureJudge: HttpClientFailureJudgeClosure;
     protected throwError: boolean;
+    /**
+     * 日志处理方法
+     */
+    protected logger: LogHandler;
     constructor(axios: AxiosInstance, failureJudge?: HttpClientFailureJudgeClosure, throwError?: boolean);
+    /**
+     * 设置日志处理方法
+     * @param logger
+     */
+    setLogger(logger: LogHandler): this;
     request(method: Method, url: string, payload?: AxiosRequestConfig<any>): Promise<HttpClientResponse>;
     getInstance(): AxiosInstance;
     setInstance(instance: AxiosInstance): this;

package/dist/Core/HttpClient/HttpClient.js

@@ -20,6 +20,18 @@ class HttpClient {
         this.axios = axios;
         this.failureJudge = failureJudge;
         this.throwError = throwError;
+        /**
+         * 日志处理方法
+         */
+        this.logger = null;
+    }
+    /**
+     * 设置日志处理方法
+     * @param logger
+     */
+    setLogger(logger) {
+        this.logger = logger;
+        return this;
     }
     request(method, url, payload = {}) {
         return __awaiter(this, void 0, void 0, function* () {
@@ -66,7 +78,15 @@ class HttpClient {
                 options['json'] = undefined;
                 delete options['json'];
             }
+            let starttime = Date.now();
+            if (typeof this.logger === 'function') {
+                yield this.logger('before', options);
+            }
             let response = yield this.axios.request(options);
+            if (typeof this.logger === 'function') {
+                let usedTime = Date.now() - starttime;
+                yield this.logger('after', options, usedTime, response);
+            }
             return new HttpClientResponse_1.default(response, this.failureJudge, this.throwError);
         });
     }

package/dist/Core/HttpClient/HttpClientResponse.d.ts

@@ -1,5 +1,5 @@
 import { AxiosResponse } from "axios";
-import { HttpClientFailureJudgeClosure } from "../../Types/global";
+import { HttpClientFailureJudgeClosure, WeixinResponse } from "../../Types/global";
 import HttpClientResponseInterface from "./Contracts/HttpClientResponseInterface";
 declare class HttpClientResponse implements HttpClientResponseInterface {
     protected response: AxiosResponse;
@@ -30,7 +30,7 @@ declare class HttpClientResponse implements HttpClientResponseInterface {
      * @param throwError
      * @returns
      */
-    toObject(throwError?: boolean): Promise<Record<string, any>>;
+    toObject<T = WeixinResponse>(throwError?: boolean): Promise<T>;
     /**
      * 返回json字符串
      * @param throwError
@@ -73,7 +73,7 @@ declare class HttpClientResponse implements HttpClientResponseInterface {
     getHeader(key: string): any;
     getStatusCode(): number;
     getHeaders(throwError?: boolean): Record<string, any>;
-    getContent(throwError?: boolean): string;
+    getContent(throwError?: boolean): any;
     cancel(): void;
     getInfo(type?: string): import("axios").AxiosRequestConfig<any>;
     offsetExists(key: any): Promise<boolean>;

package/dist/Core/HttpClient/HttpClientResponse.js

@@ -73,9 +73,10 @@ class HttpClientResponse {
             if (!content) {
                 throw new Error('Response body is empty.');
             }
-            let contentType = this.getHeader('content-type') || '';
-            if (contentType && (contentType.indexOf('text/xml') > -1 || contentType.indexOf('application/xml') > -1 || content.indexOf('<xml>') > -1)) {
-                return (0, Utils_1.parseXml)(content);
+            if (typeof content === 'string') {
+                if (this.is('xml') && content.indexOf('<xml>') > -1) {
+                    return (0, Utils_1.parseXml)(content);
+                }
             }
             return content;
         });
@@ -116,7 +117,7 @@ class HttpClientResponse {
      * @returns
      */
     toDataUrl() {
-        return 'data:' + this.getHeader('content-type') + ';base64,' + this.response.data;
+        return 'data:' + this.getHeader('content-type') + ';base64,' + this.response.data.toString('base64');
     }
     /**
      * 判断 content-type 是否指定类型

package/dist/Core/HttpClient/Mixins/PresetMixin.d.ts

@@ -0,0 +1,79 @@
+import { AxiosRequestConfig, Method } from "axios";
+declare class PresetMixin {
+    /**
+     * 存储预置参数
+     */
+    protected presets: Record<string, any>;
+    /**
+     * 存储预置headers数据
+     */
+    protected prependHeaders: Record<string, any>;
+    /**
+     * 存储预置数据
+     */
+    protected prependData: Record<string, any>;
+    /**
+     * 设置预置参数
+     * @param presets
+     * @returns
+     */
+    setPresets(presets: Record<string, any>): this;
+    /**
+     * 设置单个预置header
+     * @param key
+     * @param value
+     * @returns
+     */
+    withHeader(key: string, value: any): this;
+    /**
+     * 批量设置预置headers
+     * @param headers
+     * @returns
+     */
+    withHeaders(headers: Record<string, any>): this;
+    /**
+     * 设置预置数据
+     * @param key 参数名
+     * @param value 参数值，不设置则尝试从预置参数中获取
+     * @returns
+     */
+    with(key: string | string[] | Record<string, any>, value?: string): this;
+    /**
+     * 预设置app_id（因nodejs不支持魔术方法，只好预先设置几个常用的方法）
+     * @param new_appid
+     * @returns
+     */
+    withAppId(new_appid?: string): this;
+    /**
+     * 预设置app_id的别名（因nodejs不支持魔术方法，只好预先设置几个常用的方法）
+     * @param new_alias
+     * @returns
+     */
+    withAppIdAs(new_alias: string): this;
+    /**
+     * 预设置secret（因nodejs不支持魔术方法，只好预先设置几个常用的方法）
+     * @param new_secret
+     * @returns
+     */
+    withSecret(new_secret?: string): this;
+    /**
+     * 预设置mch_id（因nodejs不支持魔术方法，只好预先设置几个常用的方法）
+     * @param new_mch_id
+     * @returns
+     */
+    withMchId(new_mch_id?: string): this;
+    /**
+     * 预设置mch_id别名（因nodejs不支持魔术方法，只好预先设置几个常用的方法）
+     * @param new_alias
+     * @returns
+     */
+    withMchIdAs(new_alias?: string): this;
+    /**
+     * 合并预置参数并清空预置数据
+     * @param payload
+     * @param method
+     * @returns
+     */
+    mergeThenResetPrepends(payload: AxiosRequestConfig, method?: Method): any;
+}
+export = PresetMixin;