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

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "befly",
-    "version": "3.8.32",
+    "version": "3.8.34",
     "description": "Befly - 为 Bun 专属打造的 TypeScript API 接口框架核心引擎",
     "type": "module",
     "private": false,
@@ -67,13 +67,13 @@
         "befly-shared": "^1.1.2",
         "chalk": "^5.6.2",
         "es-toolkit": "^1.42.0",
-        "fast-jwt": "^6.0.2",
+        "fast-jwt": "^6.1.0",
         "fast-xml-parser": "^5.3.2",
         "pathe": "^2.0.3",
         "pino": "^10.1.0",
         "pino-roll": "^4.0.0"
     },
-    "gitHead": "a8cabbfa7932aabed195d53dc79b256b6c88602d",
+    "gitHead": "e6528128e0532df2c2f0ad96e32bc73e167aac84",
     "devDependencies": {
         "typescript": "^5.9.3"
     }

package/sync/syncDb/table.ts

@@ -124,7 +124,7 @@ export async function modifyTable(sql: SQL, tableName: string, fields: Record<st
             }
         } else {
             const lenPart = isStringOrArrayType(fieldDef.type) ? ` 长度:${parseInt(String(fieldDef.max))}` : '';
-            Logger.debug(`  + 新增字段 ${dbFieldName} (${fieldDef.type}${lenPart})`);
+            // Logger.debug(`  + 新增字段 ${dbFieldName} (${fieldDef.type}${lenPart})`);
             addClauses.push(generateDDLClause(fieldKey, fieldDef, true));
             changed = true;
         }

package/tests/redisHelper.test.ts

@@ -461,34 +461,26 @@ describe('RedisHelper - ID 生成', () => {
         expect(typeof id1).toBe('number');
         expect(typeof id2).toBe('number');
         expect(id1).not.toBe(id2);
-        expect(id1.toString().length).toBe(14);
-    });
+        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 === 14)).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(10001);
-            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 中添加一个或多个成员 */