@be-link/shield-for-tcb-node-sdk 1.0.8 → 1.0.10

package/README.md

@@ -10,7 +10,96 @@ npm install @be-link/shield-for-tcb-node-sdk
 pnpm add @be-link/shield-for-tcb-node-sdk
 ```
 
-## 使用
+## V2 SDK（推荐）
+
+V2 SDK 从 MySQL 数据源读取配置，支持按 service + key 获取配置，并提供自动类型解析。
+
+### 基本使用
+
+```typescript
+import { backendConfigServiceV2 } from '@be-link/shield-for-tcb-node-sdk'
+```
+
+### 获取服务列表
+
+```typescript
+const services = await backendConfigServiceV2.getServices('local')
+// 返回: ['BackendUser', 'Trade', 'User', ...]
+```
+
+### 获取服务的配置键列表
+
+```typescript
+const keys = await backendConfigServiceV2.getServiceKeys('TestService', 'local')
+// 返回: ['TestServiceKey1', 'TestServiceKey2', 'TestServiceKey3', ...]
+```
+
+### 获取单个配置
+
+```typescript
+// 原始格式（包含元数据）
+const config = await backendConfigServiceV2.fetchConfig({
+  service: 'TestService',
+  key: 'TestServiceKey1',
+  env: 'local'
+})
+// 返回: { config_key: 'TestServiceKey1', value: 'xxx', value_type: 'string', updated_at: '...' }
+
+// 自动解析类型（推荐）
+const host = await backendConfigServiceV2.getConfigValue<string>('TestService', 'TestServiceKey1', 'local')
+// 返回: '127.0.0.1'
+
+const port = await backendConfigServiceV2.getConfigValue<number>('TestService', 'TestServiceKey1', 'local')
+// 返回: 1234（自动解析为数字）
+
+const enabled = await backendConfigServiceV2.getConfigValue<boolean>('TestService', 'TestServiceKey1', 'local')
+// 返回: true/false（自动解析为布尔值）
+
+const jsonConfig = await backendConfigServiceV2.getConfigValue<object>('BackendUser', 'TestServiceKey1', 'local')
+// 返回: { ... }（自动 JSON 解析）
+```
+
+### 批量获取配置
+
+```typescript
+// 原始格式
+const configs = await backendConfigServiceV2.fetchConfigs({
+  service: 'TestService',
+  keys: ['TestServiceKey1', 'TestServiceKey2'],
+  env: 'local'
+})
+// 返回: { 'TestServiceKey1': { value: 'xxx', value_type: 'string' }, ... }
+
+// 自动解析类型（推荐）
+const values = await backendConfigServiceV2.getConfigValues(
+  'TestService',
+  ['TestServiceKey1', 'TestServiceKey2', 'TestServiceKey3'],
+  'local'
+)
+// 返回: {
+// }
+```
+
+### 环境变量
+
+| 变量名 | 说明 | 示例 |
+|--------|------|------|
+| `SHIELD_SDK_HOST` | 覆盖 SDK 请求地址（本地开发用） | `http://localhost:8090` |
+| `CONTAINER_ENV` | 容器环境，默认 `SCF`（云函数），设置为其他值使用内网地址 | `ECS` |
+| `NODE_ENV` | 环境标识，`prod` 使用生产环境地址 | `local` / `ppe` / `prod` |
+
+### 本地开发
+
+```bash
+# 设置本地服务地址
+export SHIELD_SDK_HOST=http://localhost:8090
+```
+
+---
+
+## V1 SDK（旧版）
+
+V1 SDK 从 YAML 文件读取配置，保持向后兼容。
 
 ```typescript
 import { backendConfigService, frontendConfigService } from '@be-link/shield-for-tcb-node-sdk'
@@ -21,13 +110,22 @@ const config = await backendConfigService.fetchConfig({ key: 'your-key', type: '
 // 前端使用（跳过异常处理，直接抛出原始错误）
 const frontendConfig = await frontendConfigService.fetchConfig({ key: 'your-key', type: 'json' })
 
-// 获取全局动态配置
-const globalConfig = await backendConfigService.fetchGlobalDynamicConfig()
-
-// 获取 COS 临时密钥
-const cosTempSecret = await backendConfigService.getCosTempSecret()
 ```
 
+---
+
+## V1 vs V2 对比
+
+| 特性 | V1 SDK | V2 SDK |
+|------|--------|--------|
+| 数据源 | YAML 文件 | MySQL |
+| 获取方式 | 按 key | 按 service + key |
+| 类型解析 | 手动指定 type | 自动根据 value_type 解析 |
+| 批量获取 | ❌ | ✅ |
+| 配置管理 | ❌ | ✅（通过管理后台） |
+| 版本追踪 | ❌ | ✅ |
+| 审计日志 | ❌ | ✅ |
+
 ## 发布流程
 
 ### 自动发布（推荐）

package/index.d.ts

@@ -1,2 +1,6 @@
 export { backendConfigService } from './modules/config/service';
 export type { Service as ConfigControllerTypes } from './modules/config/types';
+export { backendConfigServiceV2, ConfigServiceV2 } from './modules/config/serviceV2';
+export type { ServiceV2 as ConfigControllerTypesV2 } from './modules/config/typesV2';
+export { ShieldConfigManager } from './modules/config/ShieldConfigManager';
+export type { ShieldConfigManagerOptions, Logger } from './modules/config/ShieldConfigManager';

package/index.js

@@ -1,5 +1,13 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.backendConfigService = void 0;
+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; } });
+// V2 SDK (MySQL 数据源)
+var serviceV2_1 = require("./modules/config/serviceV2");
+Object.defineProperty(exports, "backendConfigServiceV2", { enumerable: true, get: function () { return serviceV2_1.backendConfigServiceV2; } });
+Object.defineProperty(exports, "ConfigServiceV2", { enumerable: true, get: function () { return serviceV2_1.ConfigServiceV2; } });
+// ShieldConfigManager
+var ShieldConfigManager_1 = require("./modules/config/ShieldConfigManager");
+Object.defineProperty(exports, "ShieldConfigManager", { enumerable: true, get: function () { return ShieldConfigManager_1.ShieldConfigManager; } });

package/modules/BaseService.d.ts

@@ -9,6 +9,12 @@ export default abstract class BaseService {
     protected readonly publicDevHost = "https://ecommerce-dev.wejourney.top";
     protected readonly publicProdHost = "https://ecommerce-release.wejourney.top";
     constructor();
+    /** 获取 Host */
+    protected getHost(): string;
+    /** 获取 Host (V2，支持环境变量覆盖) */
+    protected getHostV2(): string;
     /** 获取API URL */
     protected getApiUrl(func: Function): string;
+    /** 获取API URL (V2，支持环境变量覆盖) */
+    protected getApiUrlV2(path: string): string;
 }

package/modules/BaseService.js

@@ -16,16 +16,32 @@ class BaseService {
         /** 如果是云函数环境, 默认走公网访问 */
         this.isPublicEnv = (process.env.CONTAINER_ENV || 'SCF') === 'SCF';
     }
-    /** 获取API URL */
-    getApiUrl(func) {
-        const host = this.isPublicEnv
+    /** 获取 Host */
+    getHost() {
+        return this.isPublicEnv
             ? env_1.default.isProduction()
                 ? this.publicProdHost
                 : this.publicDevHost
             : env_1.default.isProduction()
                 ? this.natProdHost
                 : this.natDevHost;
-        return `${host}${this.prefixUrl}/${(0, string_1.camelToKebabCase)(func.name)}`;
+    }
+    /** 获取 Host (V2，支持环境变量覆盖) */
+    getHostV2() {
+        // 支持通过环境变量覆盖 host（用于本地测试）
+        const overrideHost = process.env.SHIELD_SDK_HOST;
+        if (overrideHost) {
+            return overrideHost;
+        }
+        return this.getHost();
+    }
+    /** 获取API URL */
+    getApiUrl(func) {
+        return `${this.getHost()}${this.prefixUrl}/${(0, string_1.camelToKebabCase)(func.name)}`;
+    }
+    /** 获取API URL (V2，支持环境变量覆盖) */
+    getApiUrlV2(path) {
+        return `${this.getHostV2()}${this.prefixUrl}${path}`;
     }
 }
 exports.default = BaseService;

package/modules/config/ShieldConfigManager.d.ts

@@ -0,0 +1,80 @@
+/**
+ * ShieldConfigManager - SDK 级别的配置管理器
+ *
+ * 提供配置自动拉取、缓存、定时刷新功能
+ *
+ * @example
+ * ```ts
+ * // 方式一：使用单例（推荐）
+ * import { backendShieldConfigManager } from '@be-link/shield-for-tcb-node-sdk'
+ *
+ * await backendShieldConfigManager.setup('BackendBff', 'local')
+ * const config = backendShieldConfigManager.getConfig<MyConfig>()
+ * backendShieldConfigManager.stop()
+ *
+ * // 方式二：创建独立实例
+ * import { ShieldConfigManager } from '@be-link/shield-for-tcb-node-sdk'
+ *
+ * const manager = new ShieldConfigManager({
+ *   serviceName: 'BackendBff',
+ *   env: 'local',
+ * })
+ *
+ * await manager.setup()
+ * const config = manager.getConfig<MyConfig>()
+ * manager.stop()
+ * ```
+ */
+export interface ShieldConfigManagerOptions {
+    /** 服务名称 */
+    serviceName: string;
+    /** 环境，默认取 NODE_ENV */
+    env?: string;
+    /** 刷新间隔(ms)，默认 5000 */
+    refreshIntervalMs?: number;
+    /** 请求超时(ms)，默认 10000 */
+    fetchTimeoutMs?: number;
+    /** 自定义日志函数，默认 console */
+    logger?: Logger;
+}
+export interface Logger {
+    info: (message: string, ...args: any[]) => void;
+    warn: (message: string, ...args: any[]) => void;
+    error: (message: string, ...args: any[]) => void;
+}
+/**
+ * 配置管理器
+ *
+ * 自动从 Shield 配置中心拉取服务配置，支持定时刷新和泛型类型推导
+ */
+export declare class ShieldConfigManager<T = Record<string, any>> {
+    #private;
+    constructor(options: ShieldConfigManagerOptions);
+    /** 当前缓存的配置副本（原始 Record） */
+    get config(): Record<string, any> | null;
+    /** 是否已完成初始化 */
+    get isSetup(): boolean;
+    /**
+     * 等待初始化完成
+     * @returns Promise，初始化完成后 resolve
+     */
+    waitForSetup(): Promise<void>;
+    /**
+     * 初始化配置管理器，启动定时刷新
+     * 幂等：重复调用无效
+     */
+    setup(): Promise<void>;
+    /**
+     * 手动刷新配置（立即触发一次拉取）
+     */
+    refresh(): Promise<void>;
+    /**
+     * 获取类型化的配置
+     * @returns 泛型 T 类型的配置对象
+     */
+    getConfig(): T | null;
+    /**
+     * 停止定时刷新，清理资源
+     */
+    stop(): void;
+}

package/modules/config/ShieldConfigManager.js

@@ -0,0 +1,218 @@
+"use strict";
+/**
+ * ShieldConfigManager - SDK 级别的配置管理器
+ *
+ * 提供配置自动拉取、缓存、定时刷新功能
+ *
+ * @example
+ * ```ts
+ * // 方式一：使用单例（推荐）
+ * import { backendShieldConfigManager } from '@be-link/shield-for-tcb-node-sdk'
+ *
+ * await backendShieldConfigManager.setup('BackendBff', 'local')
+ * const config = backendShieldConfigManager.getConfig<MyConfig>()
+ * backendShieldConfigManager.stop()
+ *
+ * // 方式二：创建独立实例
+ * import { ShieldConfigManager } from '@be-link/shield-for-tcb-node-sdk'
+ *
+ * const manager = new ShieldConfigManager({
+ *   serviceName: 'BackendBff',
+ *   env: 'local',
+ * })
+ *
+ * await manager.setup()
+ * const config = manager.getConfig<MyConfig>()
+ * manager.stop()
+ * ```
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+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 _ShieldConfigManager_instances, _ShieldConfigManager_serviceName, _ShieldConfigManager_env, _ShieldConfigManager_refreshIntervalMs, _ShieldConfigManager_fetchTimeoutMs, _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 defaultLogger = {
+    info: (msg, ...args) => console.log(`[ShieldConfigManager] ${msg}`, ...args),
+    warn: (msg, ...args) => console.warn(`[ShieldConfigManager] ${msg}`, ...args),
+    error: (msg, ...args) => console.error(`[ShieldConfigManager] ${msg}`, ...args),
+};
+const DEFAULT_REFRESH_INTERVAL_MS = 5 * 1000;
+const DEFAULT_FETCH_TIMEOUT_MS = 10 * 1000;
+function withTimeout(promise, timeoutMs) {
+    return Promise.race([
+        promise,
+        new Promise((_resolve, reject) => setTimeout(() => reject(new Error(`ShieldConfigManager fetch timeout after ${timeoutMs}ms`)), timeoutMs)),
+    ]);
+}
+/**
+ * 配置管理器
+ *
+ * 自动从 Shield 配置中心拉取服务配置，支持定时刷新和泛型类型推导
+ */
+class ShieldConfigManager {
+    constructor(options) {
+        _ShieldConfigManager_instances.add(this);
+        _ShieldConfigManager_serviceName.set(this, void 0);
+        _ShieldConfigManager_env.set(this, void 0);
+        _ShieldConfigManager_refreshIntervalMs.set(this, void 0);
+        _ShieldConfigManager_fetchTimeoutMs.set(this, void 0);
+        _ShieldConfigManager_logger.set(this, void 0);
+        _ShieldConfigManager_config.set(this, null);
+        _ShieldConfigManager_refreshTimer.set(this, null);
+        _ShieldConfigManager_isSetup.set(this, false);
+        _ShieldConfigManager_setupPromise.set(this, null);
+        if (!options.serviceName) {
+            throw new Error('[ShieldConfigManager] serviceName is required');
+        }
+        __classPrivateFieldSet(this, _ShieldConfigManager_serviceName, options.serviceName, "f");
+        __classPrivateFieldSet(this, _ShieldConfigManager_env, options.env || process.env.NODE_ENV, "f");
+        __classPrivateFieldSet(this, _ShieldConfigManager_refreshIntervalMs, options.refreshIntervalMs ?? DEFAULT_REFRESH_INTERVAL_MS, "f");
+        __classPrivateFieldSet(this, _ShieldConfigManager_fetchTimeoutMs, options.fetchTimeoutMs ?? DEFAULT_FETCH_TIMEOUT_MS, "f");
+        __classPrivateFieldSet(this, _ShieldConfigManager_logger, options.logger ?? defaultLogger, "f");
+    }
+    /** 当前缓存的配置副本（原始 Record） */
+    get config() {
+        return __classPrivateFieldGet(this, _ShieldConfigManager_config, "f");
+    }
+    /** 是否已完成初始化 */
+    get isSetup() {
+        return __classPrivateFieldGet(this, _ShieldConfigManager_isSetup, "f");
+    }
+    /**
+     * 等待初始化完成
+     * @returns Promise，初始化完成后 resolve
+     */
+    async waitForSetup() {
+        if (!__classPrivateFieldGet(this, _ShieldConfigManager_setupPromise, "f")) {
+            __classPrivateFieldSet(this, _ShieldConfigManager_setupPromise, __classPrivateFieldGet(this, _ShieldConfigManager_instances, "m", _ShieldConfigManager_doSetup).call(this), "f");
+        }
+        return __classPrivateFieldGet(this, _ShieldConfigManager_setupPromise, "f");
+    }
+    /**
+     * 初始化配置管理器，启动定时刷新
+     * 幂等：重复调用无效
+     */
+    async setup() {
+        if (__classPrivateFieldGet(this, _ShieldConfigManager_isSetup, "f")) {
+            __classPrivateFieldGet(this, _ShieldConfigManager_logger, "f").warn('ShieldConfigManager already initialized, skipping...');
+            return;
+        }
+        return this.waitForSetup();
+    }
+    /**
+     * 手动刷新配置（立即触发一次拉取）
+     */
+    async refresh() {
+        try {
+            const config = await withTimeout(serviceV2_1.backendConfigServiceV2.fetchAllConfigs(__classPrivateFieldGet(this, _ShieldConfigManager_serviceName, "f"), __classPrivateFieldGet(this, _ShieldConfigManager_env, "f")), __classPrivateFieldGet(this, _ShieldConfigManager_fetchTimeoutMs, "f"));
+            if (config && Object.keys(config).length > 0) {
+                __classPrivateFieldSet(this, _ShieldConfigManager_config, config, "f");
+                __classPrivateFieldGet(this, _ShieldConfigManager_logger, "f").info('ShieldConfigManager config refreshed', { keys: Object.keys(config) });
+            }
+            else {
+                __classPrivateFieldGet(this, _ShieldConfigManager_logger, "f").warn('ShieldConfigManager fetched empty config');
+            }
+        }
+        catch (error) {
+            __classPrivateFieldGet(this, _ShieldConfigManager_logger, "f").error('ShieldConfigManager refresh error', error);
+        }
+        // 兼容旧的逻辑
+        try {
+            const dynamicConfig = await withTimeout(shieldClient.backendConfigService.fetchGlobalDynamicConfig(), __classPrivateFieldGet(this, _ShieldConfigManager_fetchTimeoutMs, "f"));
+            if (dynamicConfig) {
+                process.env.authorizationTokenInside = dynamicConfig.tokenKey;
+            }
+        }
+        catch (error) {
+            __classPrivateFieldGet(this, _ShieldConfigManager_logger, "f").error('fetch dynamic config error', error);
+        }
+        __classPrivateFieldGet(this, _ShieldConfigManager_logger, "f").info('ShieldConfigManager config refreshed finally', { config: __classPrivateFieldGet(this, _ShieldConfigManager_config, "f") });
+    }
+    /**
+     * 获取类型化的配置
+     * @returns 泛型 T 类型的配置对象
+     */
+    getConfig() {
+        return __classPrivateFieldGet(this, _ShieldConfigManager_config, "f") ?? null;
+    }
+    /**
+     * 停止定时刷新，清理资源
+     */
+    stop() {
+        if (__classPrivateFieldGet(this, _ShieldConfigManager_refreshTimer, "f")) {
+            clearInterval(__classPrivateFieldGet(this, _ShieldConfigManager_refreshTimer, "f"));
+            __classPrivateFieldSet(this, _ShieldConfigManager_refreshTimer, null, "f");
+        }
+        __classPrivateFieldSet(this, _ShieldConfigManager_isSetup, false, "f");
+        __classPrivateFieldSet(this, _ShieldConfigManager_setupPromise, null, "f");
+        __classPrivateFieldGet(this, _ShieldConfigManager_logger, "f").info('ShieldConfigManager stopped');
+    }
+}
+exports.ShieldConfigManager = ShieldConfigManager;
+_ShieldConfigManager_serviceName = new WeakMap(), _ShieldConfigManager_env = new WeakMap(), _ShieldConfigManager_refreshIntervalMs = new WeakMap(), _ShieldConfigManager_fetchTimeoutMs = new WeakMap(), _ShieldConfigManager_logger = new WeakMap(), _ShieldConfigManager_config = new WeakMap(), _ShieldConfigManager_refreshTimer = new WeakMap(), _ShieldConfigManager_isSetup = new WeakMap(), _ShieldConfigManager_setupPromise = new WeakMap(), _ShieldConfigManager_instances = new WeakSet(), _ShieldConfigManager_doSetup = async function _ShieldConfigManager_doSetup() {
+    try {
+        await this.refresh();
+    }
+    catch (error) {
+        __classPrivateFieldGet(this, _ShieldConfigManager_logger, "f").error('ShieldConfigManager initial refresh failed', error);
+    }
+    if (!__classPrivateFieldGet(this, _ShieldConfigManager_config, "f")) {
+        __classPrivateFieldGet(this, _ShieldConfigManager_logger, "f").error('ShieldConfigManager config is empty after initial refresh');
+    }
+    __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_startRefreshTimer = function _ShieldConfigManager_startRefreshTimer() {
+    __classPrivateFieldSet(this, _ShieldConfigManager_refreshTimer, setInterval(() => {
+        this.refresh().catch((error) => {
+            __classPrivateFieldGet(this, _ShieldConfigManager_logger, "f").error('ShieldConfigManager timer refresh error', error);
+        });
+    }, __classPrivateFieldGet(this, _ShieldConfigManager_refreshIntervalMs, "f")), "f");
+    __classPrivateFieldGet(this, _ShieldConfigManager_logger, "f").info(`ShieldConfigManager refresh timer started (interval: ${__classPrivateFieldGet(this, _ShieldConfigManager_refreshIntervalMs, "f")}ms)`);
+};
+// 导出单例
+// export const backendShieldConfigManager = new ShieldConfigManager({ serviceName: '' })

package/modules/config/service.js

@@ -15,7 +15,7 @@ class ConfigService extends BaseService_1.default {
         return (0, http_1.callApi)(this.getApiUrl(this.fetchConfig), req);
     }
     fetchGlobalDynamicConfig() {
-        return (0, http_1.callApi)(this.getApiUrl(this.fetchGlobalDynamicConfig), undefined);
+        return (0, http_1.callApi)(this.getApiUrl(this.fetchGlobalDynamicConfig), undefined).catch(() => ({}));
     }
     getCosTempSecret() {
         return (0, http_1.callApi)(this.getApiUrl(this.getCosTempSecret), undefined);

package/modules/config/serviceV2.d.ts

@@ -0,0 +1,58 @@
+import { ServiceV2 } from './typesV2';
+import BaseService from '../BaseService';
+/**
+ * V2 配置服务
+ * 从 MySQL 数据源读取配置，支持按 service + key 获取
+ */
+export declare class ConfigServiceV2 extends BaseService implements ServiceV2.ConfigController {
+    protected prefixUrl: string;
+    /**
+     * 获取单个配置
+     * @param req 请求参数
+     * @returns 配置数据，如果配置不存在返回 null
+     */
+    fetchConfig(req: ServiceV2.Request.FetchConfig): Promise<ServiceV2.Response.FetchConfigResponse | null>;
+    /**
+     * 批量获取配置
+     * @param req 请求参数
+     * @returns 配置数据映射
+     */
+    fetchConfigs(req: ServiceV2.Request.FetchConfigs): Promise<ServiceV2.Response.FetchConfigsResponse>;
+    /**
+     * 获取所有服务列表
+     * @param env 环境名称（可选，默认使用当前环境）
+     * @returns 服务名称列表
+     */
+    getServices(env?: string): Promise<ServiceV2.Response.GetServicesResponse>;
+    /**
+     * 获取指定服务的配置键列表
+     * @param serviceName 服务名称
+     * @param env 环境名称（可选，默认使用当前环境）
+     * @returns 配置键列表
+     */
+    getServiceKeys(serviceName: string, env?: string): Promise<ServiceV2.Response.GetServiceKeysResponse>;
+    /**
+     * 获取配置值（自动解析类型）
+     * @param service 服务名称
+     * @param key 配置键
+     * @param env 环境（可选）
+     * @returns 解析后的配置值
+     */
+    getConfigValue<T = any>(service: string, key: string, env?: string): Promise<T | null>;
+    /**
+     * 批量获取配置值
+     * @param service 服务名称
+     * @param keys 配置键列表（可选，不传则获取该服务所有配置）
+     * @param env 环境（可选）
+     * @returns 配置值映射（服务端已自动解析类型）
+     */
+    getConfigValues<T = any>(service: string, keys?: string[], env?: string): Promise<Record<string, T>>;
+    /**
+     * 获取指定服务的所有配置
+     * @param service 服务名称
+     * @param env 环境（可选）
+     * @returns 该服务所有配置（Map<config_key, parsed_value> 格式）
+     */
+    fetchAllConfigs<T = any>(service: string, env?: string): Promise<Record<string, T>>;
+}
+export declare const backendConfigServiceV2: ConfigServiceV2;

package/modules/config/serviceV2.js

@@ -0,0 +1,107 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.backendConfigServiceV2 = exports.ConfigServiceV2 = void 0;
+const http_1 = require("../../utils/http");
+const BaseService_1 = __importDefault(require("../BaseService"));
+/**
+ * V2 配置服务
+ * 从 MySQL 数据源读取配置，支持按 service + key 获取
+ */
+class ConfigServiceV2 extends BaseService_1.default {
+    constructor() {
+        super(...arguments);
+        this.prefixUrl = '/shield/v2/config';
+    }
+    /**
+     * 获取单个配置
+     * @param req 请求参数
+     * @returns 配置数据，如果配置不存在返回 null
+     */
+    fetchConfig(req) {
+        return (0, http_1.callApi)(this.getApiUrlV2('/fetch'), req, {
+            skipErrorHandling: true,
+        }).catch(() => null);
+    }
+    /**
+     * 批量获取配置
+     * @param req 请求参数
+     * @returns 配置数据映射
+     */
+    fetchConfigs(req) {
+        return (0, http_1.callApi)(this.getApiUrlV2('/fetch-batch'), req).catch(() => ({}));
+    }
+    /**
+     * 获取所有服务列表
+     * @param env 环境名称（可选，默认使用当前环境）
+     * @returns 服务名称列表
+     */
+    async getServices(env) {
+        const query = env ? `?env=${encodeURIComponent(env)}` : '';
+        return (0, http_1.getApi)(this.getApiUrlV2('/services') + query).catch(() => []);
+    }
+    /**
+     * 获取指定服务的配置键列表
+     * @param serviceName 服务名称
+     * @param env 环境名称（可选，默认使用当前环境）
+     * @returns 配置键列表
+     */
+    async getServiceKeys(serviceName, env) {
+        const query = env ? `?env=${encodeURIComponent(env)}` : '';
+        return (0, http_1.getApi)(this.getApiUrlV2(`/services/${serviceName}/keys`) + query).catch(() => []);
+    }
+    /**
+     * 获取配置值（自动解析类型）
+     * @param service 服务名称
+     * @param key 配置键
+     * @param env 环境（可选）
+     * @returns 解析后的配置值
+     */
+    async getConfigValue(service, key, env) {
+        const result = await this.fetchConfig({ service, key, env });
+        if (!result) {
+            return null;
+        }
+        // 根据类型解析值
+        switch (result.value_type) {
+            case 'number':
+                return Number(result.value);
+            case 'boolean':
+                return (result.value === 'true' || result.value === '1');
+            case 'object':
+            case 'array':
+                try {
+                    return JSON.parse(result.value);
+                }
+                catch {
+                    return result.value;
+                }
+            default:
+                return result.value;
+        }
+    }
+    /**
+     * 批量获取配置值
+     * @param service 服务名称
+     * @param keys 配置键列表（可选，不传则获取该服务所有配置）
+     * @param env 环境（可选）
+     * @returns 配置值映射（服务端已自动解析类型）
+     */
+    async getConfigValues(service, keys, env) {
+        return this.fetchConfigs({ service, keys, env });
+    }
+    /**
+     * 获取指定服务的所有配置
+     * @param service 服务名称
+     * @param env 环境（可选）
+     * @returns 该服务所有配置（Map<config_key, parsed_value> 格式）
+     */
+    async fetchAllConfigs(service, env) {
+        return this.fetchConfigs({ service, env });
+    }
+}
+exports.ConfigServiceV2 = ConfigServiceV2;
+// 导出单例
+exports.backendConfigServiceV2 = new ConfigServiceV2();

package/modules/config/typesV2.d.ts

@@ -0,0 +1,106 @@
+export declare namespace ServiceV2 {
+    namespace Entity {
+        /**
+         * 配置项
+         */
+        interface ConfigItem {
+            config_key: string;
+            value: string;
+            value_type: 'string' | 'number' | 'boolean' | 'object' | 'array';
+            updated_at: string;
+        }
+        /**
+         * 批量配置项
+         */
+        interface BatchConfigItem {
+            value: string;
+            value_type: 'string' | 'number' | 'boolean' | 'object' | 'array';
+        }
+    }
+    namespace Request {
+        /**
+         * 获取单个配置请求参数
+         */
+        interface FetchConfig {
+            service: string;
+            key: string;
+            env?: string;
+        }
+        /**
+         * 批量获取配置请求参数
+         */
+        interface FetchConfigs {
+            service: string;
+            keys?: string[];
+            env?: string;
+        }
+        /**
+         * 获取服务列表请求参数
+         */
+        interface GetServices {
+            env?: string;
+        }
+        /**
+         * 获取服务配置键列表请求参数
+         */
+        interface GetServiceKeys {
+            serviceName: string;
+            env?: string;
+        }
+    }
+    namespace Response {
+        /**
+         * 获取单个配置响应
+         */
+        interface FetchConfigResponse {
+            config_key: string;
+            value: string;
+            value_type: 'string' | 'number' | 'boolean' | 'object' | 'array';
+            updated_at: string;
+        }
+        /**
+         * 批量获取配置响应
+         * 返回 Map<config_key, parsed_value> 格式
+         * value 会自动解析：JSON 对象/数组会解析，其他返回原始字符串
+         */
+        type FetchConfigsResponse = Record<string, any>;
+        /**
+         * 获取服务列表响应
+         */
+        type GetServicesResponse = string[];
+        /**
+         * 获取服务配置键列表响应
+         */
+        type GetServiceKeysResponse = string[];
+    }
+    /**
+     * V2 配置控制器接口
+     */
+    interface ConfigController {
+        /**
+         * 获取单个配置
+         * @param req 请求参数
+         * @returns 配置数据
+         */
+        fetchConfig(req: Request.FetchConfig): Promise<Response.FetchConfigResponse | null>;
+        /**
+         * 批量获取配置
+         * @param req 请求参数
+         * @returns 配置数据映射
+         */
+        fetchConfigs(req: Request.FetchConfigs): Promise<Response.FetchConfigsResponse>;
+        /**
+         * 获取所有服务列表
+         * @param env 环境名称
+         * @returns 服务列表
+         */
+        getServices(env?: string): Promise<Response.GetServicesResponse>;
+        /**
+         * 获取指定服务的配置键列表
+         * @param serviceName 服务名称
+         * @param env 环境名称
+         * @returns 配置键列表
+         */
+        getServiceKeys(serviceName: string, env?: string): Promise<Response.GetServiceKeysResponse>;
+    }
+}

package/modules/config/typesV2.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/package.json

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

package/utils/http.d.ts

@@ -1,5 +1,12 @@
 type CallApiOptions = {
     skipErrorHandling?: boolean;
 };
+type GetApiOptions = {
+    skipErrorHandling?: boolean;
+};
 export declare function callApi<T extends (args: any) => Promise<any>>(url: string, request?: Parameters<T>[0], options?: CallApiOptions): Promise<Awaited<ReturnType<T>>>;
+/**
+ * GET 请求 API
+ */
+export declare function getApi<T extends (args: any) => Promise<any>>(url: string, options?: GetApiOptions): Promise<Awaited<ReturnType<T>>>;
 export {};

package/utils/http.js

@@ -37,6 +37,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.callApi = callApi;
+exports.getApi = getApi;
 const axios_1 = __importDefault(require("axios"));
 const uuid_1 = require("uuid");
 const axios_retry_1 = __importDefault(require("axios-retry"));
@@ -99,3 +100,33 @@ async function callApi(url, request, options) {
         throw error;
     }
 }
+/**
+ * GET 请求 API
+ */
+async function getApi(url, options) {
+    const requestId = (0, uuid_1.v4)();
+    try {
+        console.info(`准备发起shield-for-tcb GET请求[${requestId}]: ${url}`);
+        const response = await axios_1.default.get(url, {
+            headers: { 'x-request-id': requestId, 'content-type': 'application/json' },
+        });
+        const responseData = response.data;
+        return responseData.data;
+    }
+    catch (error) {
+        if (options?.skipErrorHandling) {
+            throw error;
+        }
+        const axiosError = error;
+        if (axiosError.response) {
+            const response = axiosError.response;
+            const data = response.data;
+            console.error(`shield-for-tcb GET异常: ${axiosError.message}, requestId: ${requestId}`);
+            console.info('响应信息', data.message);
+            console.error('异常堆栈', JSON.stringify(error.stack));
+            throw axiosError;
+        }
+        console.error(`shield-for-tcb GET未知异常: ${axiosError.message}`, error.stack);
+        throw error;
+    }
+}