befly 3.8.33 → 3.8.34

package/lib/dbHelper.ts

@@ -595,8 +595,11 @@ export class DbHelper {
         // 转换表名：小驼峰 → 下划线
         const snakeTable = snakeCase(table);
 
-        // 批量生成 ID（一次性从 Redis 获取 N 个 ID）
-        const ids = await this.befly.redis.genTimeIDBatch(dataList.length);
+        // 批量生成 ID（逐个获取）
+        const ids: number[] = [];
+        for (let i = 0; i < dataList.length; i++) {
+            ids.push(await this.befly.redis.genTimeID());
+        }
         const now = Date.now();
 
         // 处理所有数据（自动添加系统字段）

package/lib/redisHelper.ts

@@ -80,51 +80,28 @@ export class RedisHelper {
     }
 
     // ==================== ID 生成 ====================
-    // 注意：ID 生成功能强依赖 Redis 原子操作（INCR/INCRBY）保证分布式唯一性
-    // 主要被 DbHelper.insData/insBatch 使用
-    // 如未来有其他 ID 生成需求，可考虑提取到独立模块
+    // 注意：ID 生成功能强依赖 Redis 原子操作（INCR）保证分布式唯一性
+    // 主要被 DbHelper.insData 使用
 
     /**
      * 生成基于时间的唯一 ID
-     * 格式: 毫秒时间戳(13位) + 3位自增 = 16位纯数字
-     * 容量: 1000/毫秒 = 1,000,000/秒
-     * 范围: 到 2286年
+     * 格式: 毫秒时间戳(13位) + 3位后缀(100-999) = 16位纯数字
+     * 每毫秒起点基于时间戳偏移，后缀分布更均匀
      * @returns 唯一 ID (16位纯数字)
      */
     async genTimeID(): Promise<number> {
-        const ids = await this.genTimeIDBatch(1);
-        return ids[0];
-    }
-
-    /**
-     * 批量生成基于时间的唯一 ID
-     * 格式: 毫秒时间戳(13位) + 3位自增 = 16位纯数字
-     * @param count - 需要生成的 ID 数量
-     * @returns ID 数组 (16位纯数字)
-     */
-    async genTimeIDBatch(count: number): Promise<number[]> {
-        if (count <= 0) {
-            return [];
-        }
-
-        const MAX_BATCH_SIZE = 1000;
-        if (count > MAX_BATCH_SIZE) {
-            throw new Error(`批量大小 ${count} 超过最大限制 ${MAX_BATCH_SIZE}`);
-        }
-
         const timestamp = Date.now();
-        const key = `${this.prefix}time_id_counter:${timestamp}`;
-        const endCounter = await this.client.incrby(key, count);
-        await this.client.expire(key, 1);
+        const key = `${this.prefix}time_id:${timestamp}`;
 
-        const ids: number[] = [];
-        for (let i = 0; i < count; i++) {
-            const counter = endCounter - count + i + 1;
-            const suffix = (counter % 1000).toString().padStart(3, '0');
-            ids.push(Number(`${timestamp}${suffix}`));
+        const counter = await this.client.incr(key);
+        if (counter === 1) {
+            await this.client.expire(key, 1);
         }
 
-        return ids;
+        // 基于时间戳偏移起点，后缀 100-999 循环
+        const suffix = 100 + (((timestamp % 900) + counter - 1) % 900);
+
+        return Number(`${timestamp}${suffix}`);
     }
 
     /**

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "befly",
-    "version": "3.8.33",
+    "version": "3.8.34",
     "description": "Befly - 为 Bun 专属打造的 TypeScript API 接口框架核心引擎",
     "type": "module",
     "private": false,
@@ -73,7 +73,7 @@
         "pino": "^10.1.0",
         "pino-roll": "^4.0.0"
     },
-    "gitHead": "d470173b6ce7461cf8b66adbebe2ec7888e7b32d",
+    "gitHead": "e6528128e0532df2c2f0ad96e32bc73e167aac84",
     "devDependencies": {
         "typescript": "^5.9.3"
     }

package/tests/redisHelper.test.ts

@@ -462,33 +462,25 @@ describe('RedisHelper - ID 生成', () => {
         expect(typeof id2).toBe('number');
         expect(id1).not.toBe(id2);
         expect(id1.toString().length).toBe(16);
-    });
 
-    test('genTimeIDBatch - 批量生成 ID', async () => {
-        const ids = await redis.genTimeIDBatch(10);
+        // 验证后缀在 100-999 范围内
+        const suffix1 = id1 % 1000;
+        const suffix2 = id2 % 1000;
+        expect(suffix1).toBeGreaterThanOrEqual(100);
+        expect(suffix1).toBeLessThan(1000);
+        expect(suffix2).toBeGreaterThanOrEqual(100);
+        expect(suffix2).toBeLessThan(1000);
+    });
 
-        expect(ids.length).toBe(10);
-        expect(ids.every((id) => typeof id === 'number')).toBe(true);
-        expect(ids.every((id) => id.toString().length === 16)).toBe(true);
+    test('genTimeID - 多次生成保持唯一', async () => {
+        const ids: number[] = [];
+        for (let i = 0; i < 10; i++) {
+            ids.push(await redis.genTimeID());
+        }
 
-        // 验证 ID 唯一性
         const uniqueIds = new Set(ids);
         expect(uniqueIds.size).toBe(10);
     });
-
-    test('genTimeIDBatch - 空数组', async () => {
-        const ids = await redis.genTimeIDBatch(0);
-        expect(ids.length).toBe(0);
-    });
-
-    test('genTimeIDBatch - 超过最大限制', async () => {
-        try {
-            await redis.genTimeIDBatch(1001);
-            expect(true).toBe(false); // 不应该执行到这里
-        } catch (error: any) {
-            expect(error.message).toContain('超过最大限制');
-        }
-    });
 });
 
 describe('RedisHelper - 连接测试', () => {

package/types/redis.d.ts

@@ -46,10 +46,8 @@ export interface RedisHelper {
     ping(): Promise<string>;
 
     // ==================== ID 生成 ====================
-    /** 生成基于时间的唯一 ID (14位纯数字) */
+    /** 生成基于时间的唯一 ID (16位纯数字: 13位毫秒时间戳 + 3位后缀100-999) */
     genTimeID(): Promise<number>;
-    /** 批量生成基于时间的唯一 ID */
-    genTimeIDBatch(count: number): Promise<number[]>;
 
     // ==================== Set 操作 ====================
     /** 向 Set 中添加一个或多个成员 */