@polyv/request-plugin-authorize-token 2.0.0

package/README.md

@@ -0,0 +1,105 @@
+# AuthorizeTokenRequestPlugin
+
+用途：请求令牌插件，使用后会在所有请求中插入令牌信息。
+
+## 实例化参数
+
+| 参数名 | 用途 | 类型 | 默认值 |
+| - | - | - | - |
+| `useToken` | 默认使用 token 插件 | `boolean` | `true` |
+| `responseTokenField` | 在响应中返回的令牌字段 | `string` | - |
+| `getTokenInfo` | 获取授权令牌信息 | `function` | - |
+| `responseTokenCallback` | 响应中获取令牌后的回调 | `function` | - |
+
+## 请求选项
+
+| 参数名 | 用途 | 类型 | 默认值 |
+| - | - | - | - |
+| `useToken` | 是否使用 token 授权 | `boolean` | `true` |
+| `tokenInfo` | 令牌信息 | `TokenInfo` | - |
+
+## 令牌信息类型
+
+`TokenInfo` 类型如下：
+
+| 参数名 | 用途 | 类型 | 默认值 |
+| - | - | - | - |
+| `token` | 授权令牌 | `string` | - |
+| `tokenMode` | 令牌方式，仅在 request 中生效 | `TokenMode` | `TokenMode.Params` |
+| `tokenField` | 在请求中插入的令牌字段 | `string` | `'token'` |
+| `includeParams` | 插入的 params | `object` | - |
+
+## 使用方式
+
+```js
+import { PolyvRequest } from '@polyv/request-core';
+import { AuthorizeTokenRequestPlugin, TokenMode } from '@polyv/request-plugin-authorize-token';
+
+// 方式一：直接传入令牌信息
+const requester = new PolyvRequest({
+  requestPlugins: [
+    new AuthorizeTokenRequestPlugin({
+      token: 'xxxxx',
+      tokenMode: TokenMode.Header,
+      tokenField: 'xAuthToken',
+    }),
+  ]
+});
+
+// 方式二（推荐）：支持传入 getTokenInfo 方法获取，返回 TokenInfo 类型，优先级高于直接传入
+const requester = new PolyvRequest({
+  requestPlugins: [
+    new AuthorizeTokenRequestPlugin({
+      getTokenInfo: async (options) => {
+        return {
+          token: 'xxxxx',
+          tokenMode: TokenMode.Header,
+          tokenField: 'xAuthToken',
+          // 额外插入到 params
+          includeParams: {
+            channelId: 'xxx',
+          },
+        };
+      },
+    }),
+  ]
+});
+
+// 方式三：调用时传入 tokenInfo
+requester.get('/xxx', {}, {
+  tokenInfo: {
+    token: 'xxxxx',
+    tokenMode: TokenMode.Params,
+    tokenField: 'xAuthToken',
+  },
+});
+
+// 如果你想在某个请求中，不处理令牌操作时
+requester.get('/xxxx', {}, {
+  useToken: false,
+});
+```
+
+### TokenMode 区别
+
+- `TokenMode.Params`：通过地址参数入参令牌
+- `TokenMode.Header`：通过请求头插入令牌
+
+### 自动获取响应头中的授权令牌
+
+实例化插件时入参 `responseTokenField`，插件内部会自动获取接口响应中的令牌，并在请求时如果不传入 tokenInfo，则使用响应中的令牌，示例如下：
+
+```js
+const requester = new PolyvRequest({
+  requestPlugins: [
+    new AuthorizeTokenRequestPlugin({
+      responseTokenField: 'x-auth-token',
+      responseTokenCallback: (data) => {
+        console.log('从接口响应中获取到的令牌', data.token);
+      },
+    }),
+  ]
+});
+```
+
+此时在每次接口请求后，会从响应头中获取 `x-auth-token` 作为令牌并记录，后续接口中，如果没有入参令牌则以该令牌传入。

package/authorize-token.d.ts

@@ -0,0 +1,19 @@
+import type { RequestOptions, RequestPlugin, RequestResult } from '@polyv/request-core';
+import { AuthorizeTokenRequestPluginConfig, TokenInfo } from './types';
+/**
+ * 授权 token 请求插件
+ */
+export declare class AuthorizeTokenRequestPlugin implements RequestPlugin {
+    private __useToken;
+    private __config;
+    private __recordToken?;
+    constructor(config?: AuthorizeTokenRequestPluginConfig);
+    usePlugin(options: RequestOptions): boolean;
+    interceptAuthorizeRequest(options: RequestOptions): Promise<RequestOptions>;
+    interceptResponse(result: RequestResult, options: RequestOptions): Promise<RequestResult | void>;
+    /**
+     * 获取请求令牌信息
+     * @param options 插件请求选项
+     */
+    protected __getTokenInfo(options: RequestOptions): Promise<TokenInfo | undefined>;
+}

package/authorize-token.js

@@ -0,0 +1,87 @@
+import { DEFAULT_TOKEN_FIELD, DEFAULT_TOKEN_MODE } from './config';
+import { TokenMode } from './types';
+/**
+ * 授权 token 请求插件
+ */
+export class AuthorizeTokenRequestPlugin {
+    __useToken;
+    __config;
+    __recordToken;
+    constructor(config = {}) {
+        const { useToken = true } = config;
+        this.__config = config;
+        this.__useToken = useToken;
+    }
+    usePlugin(options) {
+        const { useToken = this.__useToken } = options;
+        return useToken;
+    }
+    async interceptAuthorizeRequest(options) {
+        // 获取令牌信息
+        const tokenInfo = await this.__getTokenInfo(options);
+        if (!tokenInfo) {
+            return options;
+        }
+        const token = tokenInfo.token || this.__recordToken;
+        if (!token) {
+            return options;
+        }
+        const { tokenField = DEFAULT_TOKEN_FIELD, tokenMode = DEFAULT_TOKEN_MODE, includeParams = {}, } = tokenInfo;
+        let params = (options.params || {});
+        const headers = (options.headers || {});
+        // 插入额外的 params
+        if (includeParams) {
+            params = Object.assign({}, params, includeParams);
+        }
+        // token 在 params 上
+        if (tokenMode === TokenMode.Params) {
+            params[tokenField] = token;
+        }
+        // token 在 header 上
+        if (tokenMode === TokenMode.Header) {
+            headers[tokenField] = token;
+        }
+        return {
+            ...options,
+            params,
+            headers,
+        };
+    }
+    async interceptResponse(result, options) {
+        if (!result.headers) {
+            return;
+        }
+        const responseTokenField = options.responseTokenField || this.__config.responseTokenField;
+        if (!responseTokenField) {
+            return;
+        }
+        const headers = result.headers;
+        const responseToken = headers[responseTokenField];
+        if (responseToken) {
+            this.__recordToken = responseToken;
+            // 触发回调
+            if (this.__config.responseTokenCallback) {
+                this.__config.responseTokenCallback({ token: responseToken });
+            }
+        }
+    }
+    /**
+     * 获取请求令牌信息
+     * @param options 插件请求选项
+     */
+    async __getTokenInfo(options) {
+        let info = {
+            ...this.__config,
+        };
+        if (typeof this.__config.getTokenInfo === 'function') {
+            // 第二优先：实例化参数的 getToken
+            const res = await this.__config.getTokenInfo(options) || {};
+            info = { ...info, ...res };
+        }
+        if (options.tokenInfo) {
+            // 第一优先：请求选项
+            info = { ...info, ...options.tokenInfo };
+        }
+        return info;
+    }
+}

package/config.d.ts

@@ -0,0 +1,9 @@
+import { TokenMode } from './types';
+/**
+ * 默认的 token 字段
+ */
+export declare const DEFAULT_TOKEN_FIELD = "token";
+/**
+ * 默认的 token 模式
+ */
+export declare const DEFAULT_TOKEN_MODE = TokenMode.Params;

package/config.js

@@ -0,0 +1,9 @@
+import { TokenMode } from './types';
+/**
+ * 默认的 token 字段
+ */
+export const DEFAULT_TOKEN_FIELD = 'token';
+/**
+ * 默认的 token 模式
+ */
+export const DEFAULT_TOKEN_MODE = TokenMode.Params;

package/index.d.ts

@@ -0,0 +1,3 @@
+export * from './authorize-token';
+export * from './request-options';
+export * from './types';

package/index.js

@@ -0,0 +1,3 @@
+export * from './authorize-token';
+export * from './request-options';
+export * from './types';

package/package.json

@@ -0,0 +1,9 @@
+{
+  "name": "@polyv/request-plugin-authorize-token",
+  "version": "2.0.0",
+  "main": "./index.js",
+  "dependencies": {
+    "@polyv/request-core": "2.0.0"
+  },
+  "types": "./index.d.ts"
+}

package/request-options.d.ts

@@ -0,0 +1,26 @@
+import { TokenInfo } from './types';
+export interface AuthorizeTokenRequestOptions {
+    /**
+     * 是否使用 token 授权
+     * @default true
+     * @plugin `AuthorizeTokenRequestPlugin`
+     */
+    useToken?: boolean;
+    /**
+     * 令牌信息
+     * @plugin `AuthorizeTokenRequestPlugin`
+     */
+    tokenInfo?: TokenInfo;
+    /**
+     * 在响应中返回的令牌字段
+     */
+    responseTokenField?: string;
+}
+declare module '@polyv/request-core' {
+    interface RequestCustomOptions extends AuthorizeTokenRequestOptions {
+    }
+}
+declare module 'axios' {
+    interface AxiosRequestConfig extends AuthorizeTokenRequestOptions {
+    }
+}

package/request-options.js

@@ -0,0 +1 @@
+export {};

package/types.d.ts

@@ -0,0 +1,59 @@
+import { RequestOptions } from "@polyv/request-core";
+export interface AuthorizeTokenRequestPluginConfig extends TokenInfo {
+    /**
+     * 默认使用 token 插件
+     * @default true
+     */
+    useToken?: boolean;
+    /**
+     * 在响应中返回的令牌字段
+     */
+    responseTokenField?: string;
+    /**
+     * 获取授权令牌信息
+     */
+    getTokenInfo?: GetTokenFn;
+    /**
+     * 响应中获取令牌后的回调
+     */
+    responseTokenCallback?: (data: {
+        token: string;
+    }) => unknown;
+}
+export type GetTokenFn = (options: RequestOptions) => Promise<TokenInfo | void> | TokenInfo | void;
+/**
+ * 授权令牌模式
+ */
+export declare enum TokenMode {
+    /**
+     * 通过请求头插入
+     */
+    Header = "header",
+    /**
+     * 通过地址参数插入
+     */
+    Params = "params"
+}
+/**
+ * 令牌信息
+ */
+export interface TokenInfo {
+    /**
+     * 授权令牌
+     */
+    token?: string;
+    /**
+     * 令牌模式，仅在 request 中生效
+     * @default TokenMode.Params
+     */
+    tokenMode?: TokenMode;
+    /**
+     * 在请求中插入的令牌字段
+     * @default 'token'
+     */
+    tokenField?: string;
+    /**
+     * 插入的 params
+     */
+    includeParams?: object;
+}

package/types.js

@@ -0,0 +1,14 @@
+/**
+ * 授权令牌模式
+ */
+export var TokenMode;
+(function (TokenMode) {
+    /**
+     * 通过请求头插入
+     */
+    TokenMode["Header"] = "header";
+    /**
+     * 通过地址参数插入
+     */
+    TokenMode["Params"] = "params";
+})(TokenMode || (TokenMode = {}));