@be-link/shield-for-tcb-node-sdk 1.0.16 → 1.0.17

package/README.md

@@ -254,6 +254,46 @@ const values = await backendConfigServiceV2.getConfigValues(
   // }
 ```
 
+## 云函数场景：按单 Key 读取配置
+
+云函数等短生命周期场景不适合在每次请求中初始化 `ShieldConfigManager` 并拉取全量配置。可以使用 `ShieldCloudFunctionConfig` 按需读取单个 key：构造不发请求、不 `setup()`、不启动定时器、SDK 侧不维护本地缓存，每次 `fetchKey()` 只发一次单 key HTTP 请求，缓存集中在 Shield 服务端（本地内存 + Redis + MySQL）。
+
+```ts
+import { ShieldCloudFunctionConfig } from '@be-link/shield-for-tcb-node-sdk'
+
+const configClient = new ShieldCloudFunctionConfig({
+  serviceName: 'TheVitality',
+  env: 'prod',
+  fetchTimeoutMs: 2000,
+})
+
+export async function handler() {
+  const redisConfig = await configClient.fetchKey<{
+    HOST: string
+    PORT: number
+  }>('REDIS')
+
+  const timeout = await configClient.fetchKey<number>('API_TIMEOUT', 3000)
+  const enabled = await configClient.isSwitchEnabled('FEATURE_ENABLED', false)
+  const isHit = await configClient.isHitGrey('TRAFFIC_SPLIT', 'user_001', false)
+
+  return { redisConfig, timeout, enabled, isHit }
+}
+```
+
+### 行为说明
+
+- 构造 `ShieldCloudFunctionConfig` 不会发起 HTTP 请求。
+- 不需要调用 `setup()`。
+- 不会启动定时器。
+- SDK 侧不维护本地缓存。
+- 每次 `fetchKey()` 都会请求 Shield 服务端单 key 接口 `POST /shield/v2/config/cloud-function/fetch-key`。
+- 默认超时时间为 2 秒，可以通过 `fetchTimeoutMs` 覆盖。
+- 配置不存在、HTTP 超时、网络异常、Shield 5xx 时，`fetchKey()` 返回 `defaultValue` 或 `undefined`。
+- `defaultValue` 同时适用于「配置不存在」和「远程读取失败」，安全敏感开关应选择 fail-safe 默认值。
+- 多个 key 会产生多次 HTTP 请求；如果同一次云函数调用需要多个 key，调用方应评估延迟预算。
+- `isSwitchEnabled()` / `isHitGrey()` 与 `ShieldConfigManager` 保持一致的解析与灰度规则，灰度判断复用同一套逻辑，结果不会漂移。
+
 ## 发布流程
 
 ### 自动发布（推荐）

package/index.d.ts

@@ -4,3 +4,5 @@ export { backendConfigServiceV2, ConfigServiceV2 } from './modules/config/servic
 export type { ServiceV2 as ConfigControllerTypesV2 } from './modules/config/typesV2';
 export { ShieldConfigManager } from './modules/config/ShieldConfigManager';
 export type { ShieldConfigManagerOptions, Logger } from './modules/config/ShieldConfigManager';
+export { ShieldCloudFunctionConfig } from './modules/config/ShieldCloudFunctionConfig';
+export type { ShieldCloudFunctionConfigOptions } from './modules/config/ShieldCloudFunctionConfig';

package/index.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.ShieldConfigManager = exports.ConfigServiceV2 = exports.backendConfigServiceV2 = exports.backendConfigService = void 0;
+exports.ShieldCloudFunctionConfig = exports.ShieldConfigManager = exports.ConfigServiceV2 = exports.backendConfigServiceV2 = exports.backendConfigService = void 0;
 // V1 SDK (YAML 数据源)
 var service_1 = require("./modules/config/service");
 Object.defineProperty(exports, "backendConfigService", { enumerable: true, get: function () { return service_1.backendConfigService; } });
@@ -11,3 +11,6 @@ Object.defineProperty(exports, "ConfigServiceV2", { enumerable: true, get: funct
 // ShieldConfigManager
 var ShieldConfigManager_1 = require("./modules/config/ShieldConfigManager");
 Object.defineProperty(exports, "ShieldConfigManager", { enumerable: true, get: function () { return ShieldConfigManager_1.ShieldConfigManager; } });
+// Cloud Function SDK
+var ShieldCloudFunctionConfig_1 = require("./modules/config/ShieldCloudFunctionConfig");
+Object.defineProperty(exports, "ShieldCloudFunctionConfig", { enumerable: true, get: function () { return ShieldCloudFunctionConfig_1.ShieldCloudFunctionConfig; } });

package/modules/config/ShieldCloudFunctionConfig.d.ts

@@ -0,0 +1,32 @@
+import type { Logger } from './ShieldConfigManager';
+export interface ShieldCloudFunctionConfigOptions {
+    serviceName: string;
+    env?: string;
+    fetchTimeoutMs?: number;
+    logger?: Logger;
+}
+/**
+ * 云函数专用单 Key 配置客户端
+ *
+ * 面向云函数等短生命周期场景：构造函数不发 HTTP、不 setup、不启动定时器、不维护 SDK 本地缓存。
+ * 每次 fetchKey 只按指定 key 发一次 HTTP 请求到 Shield 服务，缓存集中在服务端。
+ */
+export declare class ShieldCloudFunctionConfig {
+    #private;
+    constructor(options: ShieldCloudFunctionConfigOptions);
+    /**
+     * 按单 Key 读取配置
+     * @param key 配置键
+     * @param defaultValue 配置不存在或读取异常时的默认值
+     * @returns 解析后的配置值，配置不存在或异常时返回 defaultValue / undefined
+     */
+    fetchKey<T = any>(key: string, defaultValue?: T): Promise<T | undefined>;
+    /**
+     * 开关判断：按 ShieldConfigManager.isSwitchEnabled 兼容规则解析布尔值
+     */
+    isSwitchEnabled(key: string, defaultValue?: boolean): Promise<boolean>;
+    /**
+     * 灰度判断：复用共享 greyMatcher，保证与 ShieldConfigManager.isHitGrey 结果一致
+     */
+    isHitGrey(configKey: string, identifier: string, defaultValue?: boolean): Promise<boolean>;
+}

package/modules/config/ShieldCloudFunctionConfig.js

@@ -0,0 +1,103 @@
+"use strict";
+var __classPrivateFieldSet = (this && this.__classPrivateFieldSet) || function (receiver, state, value, kind, f) {
+    if (kind === "m") throw new TypeError("Private method is not writable");
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a setter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
+    return (kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;
+};
+var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, state, kind, f) {
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
+    return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
+};
+var _ShieldCloudFunctionConfig_serviceName, _ShieldCloudFunctionConfig_env, _ShieldCloudFunctionConfig_fetchTimeoutMs, _ShieldCloudFunctionConfig_logger;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ShieldCloudFunctionConfig = void 0;
+const serviceV2_1 = require("./serviceV2");
+const greyMatcher_1 = require("./greyMatcher");
+const defaultLogger = {
+    info: (msg, ...args) => console.log(`[ShieldCloudFunctionConfig] ${msg}`, ...args),
+    warn: (msg, ...args) => console.warn(`[ShieldCloudFunctionConfig] ${msg}`, ...args),
+    error: (msg, ...args) => console.error(`[ShieldCloudFunctionConfig] ${msg}`, ...args),
+};
+const DEFAULT_FETCH_TIMEOUT_MS = 2 * 1000;
+/**
+ * 云函数专用单 Key 配置客户端
+ *
+ * 面向云函数等短生命周期场景：构造函数不发 HTTP、不 setup、不启动定时器、不维护 SDK 本地缓存。
+ * 每次 fetchKey 只按指定 key 发一次 HTTP 请求到 Shield 服务，缓存集中在服务端。
+ */
+class ShieldCloudFunctionConfig {
+    constructor(options) {
+        _ShieldCloudFunctionConfig_serviceName.set(this, void 0);
+        _ShieldCloudFunctionConfig_env.set(this, void 0);
+        _ShieldCloudFunctionConfig_fetchTimeoutMs.set(this, void 0);
+        _ShieldCloudFunctionConfig_logger.set(this, void 0);
+        if (!options.serviceName) {
+            throw new Error('[ShieldCloudFunctionConfig] serviceName is required');
+        }
+        __classPrivateFieldSet(this, _ShieldCloudFunctionConfig_serviceName, options.serviceName, "f");
+        __classPrivateFieldSet(this, _ShieldCloudFunctionConfig_env, options.env || process.env.NODE_ENV, "f");
+        __classPrivateFieldSet(this, _ShieldCloudFunctionConfig_fetchTimeoutMs, options.fetchTimeoutMs ?? DEFAULT_FETCH_TIMEOUT_MS, "f");
+        __classPrivateFieldSet(this, _ShieldCloudFunctionConfig_logger, options.logger || defaultLogger, "f");
+    }
+    /**
+     * 按单 Key 读取配置
+     * @param key 配置键
+     * @param defaultValue 配置不存在或读取异常时的默认值
+     * @returns 解析后的配置值，配置不存在或异常时返回 defaultValue / undefined
+     */
+    async fetchKey(key, defaultValue) {
+        if (!key) {
+            throw new Error('[ShieldCloudFunctionConfig] key is required');
+        }
+        const startTime = Date.now();
+        try {
+            const result = await serviceV2_1.backendConfigServiceV2.fetchCloudFunctionConfigKey({ service: __classPrivateFieldGet(this, _ShieldCloudFunctionConfig_serviceName, "f"), key, env: __classPrivateFieldGet(this, _ShieldCloudFunctionConfig_env, "f") }, { timeoutMs: __classPrivateFieldGet(this, _ShieldCloudFunctionConfig_fetchTimeoutMs, "f") });
+            if (!result) {
+                return defaultValue;
+            }
+            return result.value;
+        }
+        catch (error) {
+            const durationMs = Date.now() - startTime;
+            const message = error instanceof Error ? error.message : JSON.stringify(error);
+            __classPrivateFieldGet(this, _ShieldCloudFunctionConfig_logger, "f").error(`[ShieldCloudFunctionConfig] fetch key error service=${__classPrivateFieldGet(this, _ShieldCloudFunctionConfig_serviceName, "f")} env=${__classPrivateFieldGet(this, _ShieldCloudFunctionConfig_env, "f") || ''} key=${key} durationMs=${durationMs} error=${message}`);
+            return defaultValue;
+        }
+    }
+    /**
+     * 开关判断：按 ShieldConfigManager.isSwitchEnabled 兼容规则解析布尔值
+     */
+    async isSwitchEnabled(key, defaultValue = false) {
+        const value = await this.fetchKey(key);
+        if (value === undefined || value === null) {
+            return defaultValue;
+        }
+        if (typeof value === 'boolean') {
+            return value;
+        }
+        if (typeof value === 'number') {
+            return value !== 0;
+        }
+        if (typeof value === 'string') {
+            const lower = value.trim().toLowerCase();
+            if (lower === 'true' || lower === '1' || lower === 'yes' || lower === 'on') {
+                return true;
+            }
+            if (lower === 'false' || lower === '0' || lower === 'no' || lower === 'off') {
+                return false;
+            }
+        }
+        return defaultValue;
+    }
+    /**
+     * 灰度判断：复用共享 greyMatcher，保证与 ShieldConfigManager.isHitGrey 结果一致
+     */
+    async isHitGrey(configKey, identifier, defaultValue = false) {
+        const config = await this.fetchKey(configKey);
+        return (0, greyMatcher_1.isHitGreyConfig)(config, identifier, defaultValue);
+    }
+}
+exports.ShieldCloudFunctionConfig = ShieldCloudFunctionConfig;
+_ShieldCloudFunctionConfig_serviceName = new WeakMap(), _ShieldCloudFunctionConfig_env = new WeakMap(), _ShieldCloudFunctionConfig_fetchTimeoutMs = new WeakMap(), _ShieldCloudFunctionConfig_logger = new WeakMap();

package/modules/config/ShieldConfigManager.d.ts

@@ -46,7 +46,7 @@ export interface Logger {
     error: (message: string, ...args: any[]) => void;
 }
 /**
- * 流量控制配置
+ * 流量控制配置（类型从 greyMatcher 复用，保证灰度判断逻辑统一）
  *
  * @example
  * ```json
@@ -59,18 +59,7 @@ export interface Logger {
  * }
  * ```
  */
-export interface TrafficControlConfig {
-    /** 总开关 */
-    enabled: boolean;
-    /** 总桶数 */
-    totalBuckets: number;
-    /** 生效桶数（bucket 0 到 effectiveBuckets-1 生效） */
-    effectiveBuckets: number;
-    /** 白名单（命中后视为生效） */
-    whitelist?: string[];
-    /** 黑名单（命中后视为不生效） */
-    blacklist?: string[];
-}
+export type { TrafficControlConfig } from './greyMatcher';
 /**
  * 配置管理器
  *

package/modules/config/ShieldConfigManager.js

@@ -71,11 +71,12 @@ var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (
     if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
     return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
 };
-var _ShieldConfigManager_instances, _ShieldConfigManager_serviceName, _ShieldConfigManager_env, _ShieldConfigManager_refreshIntervalMs, _ShieldConfigManager_fetchTimeoutMs, _ShieldConfigManager_enableInfoLog, _ShieldConfigManager_logger, _ShieldConfigManager_config, _ShieldConfigManager_refreshTimer, _ShieldConfigManager_isSetup, _ShieldConfigManager_setupPromise, _ShieldConfigManager_doSetup, _ShieldConfigManager_hashString, _ShieldConfigManager_startRefreshTimer;
+var _ShieldConfigManager_instances, _ShieldConfigManager_serviceName, _ShieldConfigManager_env, _ShieldConfigManager_refreshIntervalMs, _ShieldConfigManager_fetchTimeoutMs, _ShieldConfigManager_enableInfoLog, _ShieldConfigManager_logger, _ShieldConfigManager_config, _ShieldConfigManager_refreshTimer, _ShieldConfigManager_isSetup, _ShieldConfigManager_setupPromise, _ShieldConfigManager_doSetup, _ShieldConfigManager_startRefreshTimer;
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ShieldConfigManager = void 0;
 const serviceV2_1 = require("./serviceV2");
 const shieldClient = __importStar(require("./service"));
+const greyMatcher_1 = require("./greyMatcher");
 const defaultLogger = {
     info: (msg, ...args) => console.log(`[ShieldConfigManager] ${msg}`, ...args),
     warn: (msg, ...args) => console.warn(`[ShieldConfigManager] ${msg}`, ...args),
@@ -264,26 +265,7 @@ class ShieldConfigManager {
      */
     isHitGrey(configKey, identifier, defaultValue = false) {
         const config = this.getValue(configKey);
-        if (!config) {
-            return defaultValue;
-        }
-        // 总开关关闭，返回 false
-        if (!config.enabled) {
-            return false;
-        }
-        // 黑名单检查（精确匹配）- 命中后返回 false
-        if (config.blacklist && config.blacklist.includes(identifier)) {
-            return false;
-        }
-        // 白名单检查（精确匹配）- 命中后返回 true
-        if (config.whitelist && config.whitelist.includes(identifier)) {
-            return true;
-        }
-        // 桶路由
-        const totalBuckets = config.totalBuckets || 100;
-        const effectiveBuckets = config.effectiveBuckets || 0;
-        const hash = __classPrivateFieldGet(this, _ShieldConfigManager_instances, "m", _ShieldConfigManager_hashString).call(this, identifier);
-        return hash % totalBuckets < effectiveBuckets;
+        return (0, greyMatcher_1.isHitGreyConfig)(config, identifier, defaultValue);
     }
     /**
      * 停止定时刷新，清理资源
@@ -312,14 +294,6 @@ _ShieldConfigManager_serviceName = new WeakMap(), _ShieldConfigManager_env = new
     __classPrivateFieldGet(this, _ShieldConfigManager_instances, "m", _ShieldConfigManager_startRefreshTimer).call(this);
     __classPrivateFieldSet(this, _ShieldConfigManager_isSetup, true, "f");
     __classPrivateFieldGet(this, _ShieldConfigManager_logger, "f").info('ShieldConfigManager initialized successfully');
-}, _ShieldConfigManager_hashString = function _ShieldConfigManager_hashString(str) {
-    let hash = 0;
-    for (let i = 0; i < str.length; i++) {
-        const char = str.charCodeAt(i);
-        hash = (hash << 5) - hash + char;
-        hash = hash & hash; // Convert to 32bit integer
-    }
-    return Math.abs(hash);
 }, _ShieldConfigManager_startRefreshTimer = function _ShieldConfigManager_startRefreshTimer() {
     __classPrivateFieldSet(this, _ShieldConfigManager_refreshTimer, setInterval(() => {
         this.refresh().catch((error) => {

package/modules/config/greyMatcher.d.ts

@@ -0,0 +1,18 @@
+/**
+ * 流量控制配置
+ * Shared by ShieldConfigManager and ShieldCloudFunctionConfig.
+ */
+export interface TrafficControlConfig {
+    /** 总开关 */
+    enabled: boolean;
+    /** 总桶数 */
+    totalBuckets: number;
+    /** 生效桶数（bucket 0 到 effectiveBuckets-1 生效） */
+    effectiveBuckets: number;
+    /** 白名单（命中后视为生效） */
+    whitelist?: string[];
+    /** 黑名单（命中后视为不生效） */
+    blacklist?: string[];
+}
+export declare function hashString(str: string): number;
+export declare function isHitGreyConfig(config: TrafficControlConfig | null | undefined, identifier: string, defaultValue?: boolean): boolean;

package/modules/config/greyMatcher.js

@@ -0,0 +1,31 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.hashString = hashString;
+exports.isHitGreyConfig = isHitGreyConfig;
+function hashString(str) {
+    let hash = 0;
+    for (let i = 0; i < str.length; i++) {
+        const char = str.charCodeAt(i);
+        hash = (hash << 5) - hash + char;
+        hash = hash & hash; // Convert to 32bit integer
+    }
+    return Math.abs(hash);
+}
+function isHitGreyConfig(config, identifier, defaultValue = false) {
+    if (!config) {
+        return defaultValue;
+    }
+    if (!config.enabled) {
+        return false;
+    }
+    if (config.blacklist && config.blacklist.includes(identifier)) {
+        return false;
+    }
+    if (config.whitelist && config.whitelist.includes(identifier)) {
+        return true;
+    }
+    const totalBuckets = config.totalBuckets || 100;
+    const effectiveBuckets = config.effectiveBuckets || 0;
+    const hash = hashString(identifier);
+    return hash % totalBuckets < effectiveBuckets;
+}

package/modules/config/serviceV2.d.ts

@@ -18,6 +18,15 @@ export declare class ConfigServiceV2 extends BaseService implements ServiceV2.Co
      * @returns 配置数据映射
      */
     fetchConfigs(req: ServiceV2.Request.FetchConfigs): Promise<ServiceV2.Response.FetchConfigsResponse>;
+    /**
+     * 云函数单 Key 配置读取
+     * @param req 请求参数
+     * @param options 请求选项
+     * @returns 解析后的配置数据，如果配置不存在返回 null
+     */
+    fetchCloudFunctionConfigKey(req: ServiceV2.Request.FetchCloudFunctionConfigKey, options?: {
+        timeoutMs?: number;
+    }): Promise<ServiceV2.Response.FetchCloudFunctionConfigKeyResponse | null>;
     /**
      * 获取所有服务列表
      * @param env 环境名称（可选，默认使用当前环境）

package/modules/config/serviceV2.js

@@ -5,6 +5,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.backendConfigServiceV2 = exports.ConfigServiceV2 = void 0;
 const http_1 = require("../../utils/http");
+const cloudFunctionHttp_1 = require("../../utils/cloudFunctionHttp");
 const BaseService_1 = __importDefault(require("../BaseService"));
 /**
  * V2 配置服务
@@ -33,6 +34,15 @@ class ConfigServiceV2 extends BaseService_1.default {
     fetchConfigs(req) {
         return (0, http_1.callApi)(this.getApiUrlV2('/fetch-batch'), req).catch(() => ({}));
     }
+    /**
+     * 云函数单 Key 配置读取
+     * @param req 请求参数
+     * @param options 请求选项
+     * @returns 解析后的配置数据，如果配置不存在返回 null
+     */
+    fetchCloudFunctionConfigKey(req, options) {
+        return (0, cloudFunctionHttp_1.quietPost)(this.getApiUrlV2('/cloud-function/fetch-key'), req, { timeoutMs: options?.timeoutMs ?? 2000 });
+    }
     /**
      * 获取所有服务列表
      * @param env 环境名称（可选，默认使用当前环境）

package/modules/config/typesV2.d.ts

@@ -47,6 +47,14 @@ export declare namespace ServiceV2 {
             serviceName: string;
             env?: string;
         }
+        /**
+         * 云函数单 Key 配置请求参数
+         */
+        interface FetchCloudFunctionConfigKey {
+            service: string;
+            key: string;
+            env?: string;
+        }
     }
     namespace Response {
         /**
@@ -72,6 +80,20 @@ export declare namespace ServiceV2 {
          * 获取服务配置键列表响应
          */
         type GetServiceKeysResponse = string[];
+        /**
+         * 云函数单 Key 配置缓存命中来源
+         */
+        type CloudFunctionConfigKeySource = 'local' | 'redis' | 'mysql';
+        /**
+         * 云函数单 Key 配置响应
+         */
+        interface FetchCloudFunctionConfigKeyResponse {
+            key: string;
+            value: any;
+            value_type: 'string' | 'number' | 'boolean' | 'object' | 'array' | string;
+            updated_at?: string;
+            source: CloudFunctionConfigKeySource;
+        }
     }
     /**
      * V2 配置控制器接口
@@ -102,5 +124,13 @@ export declare namespace ServiceV2 {
          * @returns 配置键列表
          */
         getServiceKeys(serviceName: string, env?: string): Promise<Response.GetServiceKeysResponse>;
+        /**
+         * 云函数单 Key 配置读取
+         * @param req 请求参数
+         * @returns 解析后的配置数据，配置不存在时返回 null
+         */
+        fetchCloudFunctionConfigKey(req: Request.FetchCloudFunctionConfigKey, options?: {
+            timeoutMs?: number;
+        }): Promise<Response.FetchCloudFunctionConfigKeyResponse | null>;
     }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@be-link/shield-for-tcb-node-sdk",
-  "version": "1.0.16",
+  "version": "1.0.17",
   "description": "ShieldForTCB Node.js SDK",
   "main": "index.js",
   "types": "index.d.ts",

package/utils/cloudFunctionHttp.d.ts

@@ -0,0 +1,5 @@
+type QuietPostOptions = {
+    timeoutMs: number;
+};
+export declare function quietPost<T>(url: string, request: Record<string, any>, options: QuietPostOptions): Promise<T>;
+export {};

package/utils/cloudFunctionHttp.js

@@ -0,0 +1,19 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.quietPost = quietPost;
+const axios_1 = __importDefault(require("axios"));
+const uuid_1 = require("uuid");
+// 云函数单 Key 接口专用 axios 实例：不挂载 axios-retry，避免对每次单 key 读取做重试放大请求。
+const cloudFunctionAxios = axios_1.default.create();
+async function quietPost(url, request, options) {
+    const requestId = (0, uuid_1.v4)();
+    const response = await cloudFunctionAxios.post(url, request || {}, {
+        timeout: options.timeoutMs,
+        headers: { 'x-request-id': requestId, 'content-type': 'application/json' },
+    });
+    const responseData = response.data;
+    return responseData.data;
+}