befly 3.8.20 → 3.8.21

package/tests/fields-validate.test.ts

@@ -0,0 +1,99 @@
+/**
+ * 简单测试字段排除功能
+ * 直接测试 validateAndClassifyFields 方法
+ */
+
+// 模拟测试函数（从 dbHelper 复制的逻辑）
+function validateAndClassifyFields(fields?: string[]): {
+    type: 'all' | 'include' | 'exclude';
+    fields: string[];
+} {
+    // 情况1：空数组或 undefined，表示查询所有
+    if (!fields || fields.length === 0) {
+        return { type: 'all', fields: [] };
+    }
+
+    // 检测是否有星号（禁止）
+    if (fields.some((f) => f === '*')) {
+        throw new Error('fields 不支持 * 星号，请使用空数组 [] 或不传参数表示查询所有字段');
+    }
+
+    // 检测是否有空字符串或无效值
+    if (fields.some((f) => !f || typeof f !== 'string' || f.trim() === '')) {
+        throw new Error('fields 不能包含空字符串或无效值');
+    }
+
+    // 统计包含字段和排除字段
+    const includeFields = fields.filter((f) => !f.startsWith('!'));
+    const excludeFields = fields.filter((f) => f.startsWith('!'));
+
+    // 情况2：全部是包含字段
+    if (includeFields.length > 0 && excludeFields.length === 0) {
+        return { type: 'include', fields: includeFields };
+    }
+
+    // 情况3：全部是排除字段
+    if (excludeFields.length > 0 && includeFields.length === 0) {
+        // 去掉感叹号前缀
+        const cleanExcludeFields = excludeFields.map((f) => f.substring(1));
+        return { type: 'exclude', fields: cleanExcludeFields };
+    }
+
+    // 混用情况：报错
+    throw new Error('fields 不能同时包含普通字段和排除字段（! 开头）。只能使用以下3种方式之一：\n1. 空数组 [] 或不传（查询所有）\n2. 全部指定字段 ["id", "name"]\n3. 全部排除字段 ["!password", "!token"]');
+}
+
+console.log('\n========== 测试 validateAndClassifyFields ==========\n');
+
+// 测试1：空数组
+console.log('【测试1】空数组');
+const test1 = validateAndClassifyFields([]);
+console.log('结果:', test1);
+console.log('✅ 通过\n');
+
+// 测试2：undefined
+console.log('【测试2】undefined');
+const test2 = validateAndClassifyFields(undefined);
+console.log('结果:', test2);
+console.log('✅ 通过\n');
+
+// 测试3：包含字段
+console.log('【测试3】包含字段');
+const test3 = validateAndClassifyFields(['id', 'name', 'email']);
+console.log('结果:', test3);
+console.log('✅ 通过\n');
+
+// 测试4：排除字段
+console.log('【测试4】排除字段');
+const test4 = validateAndClassifyFields(['!password', '!salt']);
+console.log('结果:', test4);
+console.log('✅ 通过\n');
+
+// 测试5：混用（应该报错）
+console.log('【测试5】混用（应该报错）');
+try {
+    validateAndClassifyFields(['id', '!password']);
+    console.log('❌ 没有抛出错误\n');
+} catch (error: any) {
+    console.log('✅ 成功捕获错误:', error.message, '\n');
+}
+
+// 测试6：星号（应该报错）
+console.log('【测试6】星号（应该报错）');
+try {
+    validateAndClassifyFields(['*']);
+    console.log('❌ 没有抛出错误\n');
+} catch (error: any) {
+    console.log('✅ 成功捕获错误:', error.message, '\n');
+}
+
+// 测试7：空字符串（应该报错）
+console.log('【测试7】空字符串（应该报错）');
+try {
+    validateAndClassifyFields(['id', '', 'name']);
+    console.log('❌ 没有抛出错误\n');
+} catch (error: any) {
+    console.log('✅ 成功捕获错误:', error.message, '\n');
+}
+
+console.log('========== 所有测试完成 ==========\n');

package/tests/integration.test.ts

@@ -0,0 +1,202 @@
+import { describe, test, expect, beforeAll } from 'bun:test';
+import { Cipher } from '../lib/cipher';
+import { Jwt } from '../lib/jwt';
+import { Validator } from '../lib/validator';
+import { SqlBuilder } from '../lib/sqlBuilder';
+import { Xml } from '../lib/xml';
+import { keysToCamel, keysToSnake } from 'befly-util';
+
+describe('Integration - 密码验证流程', () => {
+    test('用户注册：密码加密 + 验证', async () => {
+        const password = 'MySecurePass123';
+
+        // 1. 密码加密
+        const hashedPassword = await Cipher.hashPassword(password);
+        expect(hashedPassword).toBeDefined();
+        expect(hashedPassword.length).toBeGreaterThan(0);
+
+        // 2. 密码验证
+        const isValid = await Cipher.verifyPassword(password, hashedPassword);
+        expect(isValid).toBe(true);
+
+        // 3. 错误密码验证
+        const isInvalid = await Cipher.verifyPassword('WrongPassword', hashedPassword);
+        expect(isInvalid).toBe(false);
+    });
+});
+
+describe('Integration - JWT + 权限验证', () => {
+    beforeAll(() => {
+        Jwt.configure({
+            secret: 'test-integration-secret',
+            algorithm: 'HS256',
+            expiresIn: '1h'
+        });
+    });
+
+    test('用户登录：JWT 签名 + 权限检查', async () => {
+        // 1. 用户登录生成 token
+        const payload = {
+            userId: 123,
+            username: 'john',
+            roles: ['admin', 'user'],
+            permissions: ['read', 'write', 'delete']
+        };
+
+        const token = await Jwt.sign(payload);
+        expect(token).toBeDefined();
+        expect(typeof token).toBe('string');
+
+        // 2. 验证 token
+        const verified = await Jwt.verify(token);
+        expect(verified.userId).toBe(123);
+        expect(verified.username).toBe('john');
+
+        // 3. 检查角色
+        expect(Jwt.hasRole(verified, 'admin')).toBe(true);
+        expect(Jwt.hasRole(verified, 'guest')).toBe(false);
+
+        // 4. 检查权限
+        expect(Jwt.hasPermission(verified, 'write')).toBe(true);
+        expect(Jwt.hasPermission(verified, 'admin')).toBe(false);
+
+        // 5. 检查所有权限
+        expect(Jwt.hasAllPermissions(verified, ['read', 'write'])).toBe(true);
+        expect(Jwt.hasAllPermissions(verified, ['read', 'admin'])).toBe(false);
+    });
+});
+
+describe('Integration - 数据验证 + SQL 构建', () => {
+    test('API 请求：验证数据 + 构建查询', () => {
+        const validator = new Validator();
+
+        // 1. 验证用户输入
+        const userData = {
+            email: 'test@example.com',
+            age: 25,
+            username: 'john'
+        };
+
+        const rules = {
+            email: { name: '邮箱', type: 'string', regexp: '@email' },
+            age: { name: '年龄', type: 'number', min: 0, max: 150 },
+            username: { name: '用户名', type: 'string', min: 2, max: 20 }
+        };
+
+        const validationResult = validator.validate(userData, rules, ['email', 'username']);
+        expect(validationResult.code).toBe(0);
+
+        // 2. 验证通过后构建 SQL 查询
+        const builder = new SqlBuilder();
+        const sqlResult = builder.select(['id', 'username', 'email']).from('users').where({ email: userData.email }).toSelectSql();
+
+        expect(sqlResult.sql).toContain('SELECT');
+        expect(sqlResult.sql).toContain('FROM `users`');
+        expect(sqlResult.sql).toContain('WHERE `email` = ?');
+        expect(sqlResult.params).toContain('test@example.com');
+    });
+
+    test('数据插入：验证 + 字段转换 + SQL 构建', () => {
+        const validator = new Validator();
+
+        // 1. 验证数据
+        const newUser = {
+            userName: 'jane',
+            userEmail: 'jane@example.com',
+            userAge: 30
+        };
+
+        const rules = {
+            userName: { name: '用户名', type: 'string', min: 2, max: 20 },
+            userEmail: { name: '邮箱', type: 'string', regexp: '@email' },
+            userAge: { name: '年龄', type: 'number', min: 0, max: 150 }
+        };
+
+        const validationResult = validator.validate(newUser, rules, ['userName', 'userEmail']);
+        expect(validationResult.code).toBe(0);
+
+        // 2. 字段转换（驼峰转下划线）
+        const dbData = keysToSnake(newUser);
+        expect(dbData.user_name).toBe('jane');
+        expect(dbData.user_email).toBe('jane@example.com');
+        expect(dbData.user_age).toBe(30);
+
+        // 3. 构建插入 SQL
+        const builder = new SqlBuilder();
+        const sqlResult = builder.toInsertSql('users', dbData);
+
+        expect(sqlResult.sql).toContain('INSERT INTO `users`');
+        expect(sqlResult.params).toContain('jane');
+        expect(sqlResult.params).toContain('jane@example.com');
+    });
+});
+
+describe('Integration - XML 解析 + 数据转换', () => {
+    test('XML API 响应：解析 + 字段转换', () => {
+        const xml = new Xml();
+
+        // 1. 解析 XML 响应
+        const xmlData = '<response><user_id>123</user_id><user_name>John</user_name><is_active>true</is_active></response>';
+        const parsed = xml.parse(xmlData) as any;
+
+        expect(parsed.user_id).toBe(123);
+        expect(parsed.user_name).toBe('John');
+        expect(parsed.is_active).toBe(true);
+
+        // 2. 字段转换（下划线转驼峰）
+        const camelData = keysToCamel(parsed);
+        expect(camelData.userId).toBe(123);
+        expect(camelData.userName).toBe('John');
+        expect(camelData.isActive).toBe(true);
+    });
+});
+
+describe('Integration - 加密 + JWT + 哈希', () => {
+    test('安全令牌生成：多层加密', () => {
+        // 1. 生成随机字符串作为 secret
+        const secret = Cipher.randomString(32);
+        expect(secret.length).toBe(32);
+
+        // 2. 对 secret 进行 SHA256 哈希
+        const hashedSecret = Cipher.sha256(secret);
+        expect(hashedSecret.length).toBe(64);
+
+        // 3. 使用 HMAC 签名
+        const data = 'user123:session456';
+        const signature = Cipher.hmacSha256(data, hashedSecret);
+        expect(signature).toBeDefined();
+
+        // 4. Base64 编码
+        const encoded = Cipher.base64Encode(signature);
+        expect(encoded).toBeDefined();
+
+        // 5. Base64 解码验证
+        const decoded = Cipher.base64Decode(encoded);
+        expect(decoded).toBe(signature);
+    });
+});
+
+describe('Integration - SQL 构建 + 字段转换', () => {
+    test('复杂查询：驼峰转下划线 + WHERE 条件 + 排序分页', () => {
+        const builder = new SqlBuilder();
+
+        // 1. 原始查询条件（驼峰格式）
+        const queryConditions = {
+            userId: 123,
+            userStatus: 'active',
+            createdAt: { $gte: 1609459200000 }
+        };
+
+        // 2. 转换为下划线格式
+        const dbConditions = keysToSnake(queryConditions);
+
+        // 3. 构建复杂查询
+        const sqlResult = builder.select(['id', 'user_name', 'user_email', 'created_at']).from('users').where(dbConditions).orderBy(['created_at#DESC']).limit(20).offset(0).toSelectSql();
+
+        expect(sqlResult.sql).toContain('SELECT');
+        expect(sqlResult.sql).toContain('WHERE');
+        expect(sqlResult.sql).toContain('ORDER BY');
+        expect(sqlResult.sql).toContain('LIMIT 20');
+        expect(sqlResult.params.length).toBeGreaterThan(0);
+    });
+});

package/tests/jwt.test.ts

@@ -0,0 +1,122 @@
+import { describe, test, expect, beforeAll } from 'bun:test';
+import { Jwt } from '../lib/jwt';
+
+beforeAll(() => {
+    Jwt.configure({
+        secret: 'test-secret',
+        algorithm: 'HS256',
+        expiresIn: '7d'
+    });
+});
+
+describe('JWT - 签名和验证', () => {
+    test('签名创建 token', async () => {
+        const token = await Jwt.sign({ userId: 1, name: 'test' });
+        expect(typeof token).toBe('string');
+        expect(token.split('.').length).toBe(3);
+    });
+
+    test('验证有效 token', async () => {
+        const token = await Jwt.sign({ userId: 123, email: 'test@test.com' });
+        const decoded = await Jwt.verify(token);
+        expect(decoded.userId).toBe(123);
+        expect(decoded.email).toBe('test@test.com');
+    });
+
+    test('验证过期 token 抛出错误', async () => {
+        const token = await Jwt.sign({ userId: 1 }, { expiresIn: '-1s' });
+        expect(Jwt.verify(token)).rejects.toThrow('Token 已过期');
+    });
+
+    test('忽略过期验证', async () => {
+        const token = await Jwt.sign({ userId: 1 }, { expiresIn: '-1s' });
+        const decoded = await Jwt.verify(token, { ignoreExpiration: true });
+        expect(decoded.userId).toBe(1);
+    });
+
+    test('自定义密钥', async () => {
+        const secret = 'custom-secret';
+        const token = await Jwt.sign({ userId: 1 }, { secret });
+        const decoded = await Jwt.verify(token, { secret });
+        expect(decoded.userId).toBe(1);
+    });
+
+    test('密钥不匹配验证失败', async () => {
+        const token = await Jwt.sign({ userId: 1 }, { secret: 'secret1' });
+        expect(Jwt.verify(token, { secret: 'secret2' })).rejects.toThrow('Token 签名无效');
+    });
+});
+
+describe('JWT - 解码', () => {
+    test('解码不验证签名', async () => {
+        const token = await Jwt.sign({ userId: 456 });
+        const decoded = Jwt.decode(token);
+        expect(decoded.userId).toBe(456);
+    });
+
+    test('解码完整信息', async () => {
+        const token = await Jwt.sign({ userId: 1 });
+        const decoded = Jwt.decode(token, true);
+        expect(decoded.header).toBeDefined();
+        expect(decoded.payload).toBeDefined();
+        expect(decoded.signature).toBeDefined();
+    });
+});
+
+describe('JWT - 时间相关', () => {
+    test('获取剩余时间', async () => {
+        const token = await Jwt.sign({ userId: 1 }, { expiresIn: '1h' });
+        const remaining = Jwt.getTimeToExpiry(token);
+        expect(remaining).toBeGreaterThan(3500);
+    });
+
+    test('检查是否过期', async () => {
+        const valid = await Jwt.sign({ userId: 1 }, { expiresIn: '1h' });
+        expect(Jwt.isExpired(valid)).toBe(false);
+
+        const expired = await Jwt.sign({ userId: 1 }, { expiresIn: '-1s' });
+        expect(Jwt.isExpired(expired)).toBe(true);
+    });
+
+    test('检查即将过期', async () => {
+        const longToken = await Jwt.sign({ userId: 1 }, { expiresIn: '1h' });
+        expect(Jwt.isNearExpiry(longToken, 300)).toBe(false);
+
+        const shortToken = await Jwt.sign({ userId: 1 }, { expiresIn: '2m' });
+        expect(Jwt.isNearExpiry(shortToken, 300)).toBe(true);
+    });
+});
+
+describe('JWT - 权限检查', () => {
+    test('检查角色', () => {
+        const payload = { userId: 1, role: 'admin' };
+        expect(Jwt.hasRole(payload, 'admin')).toBe(true);
+        expect(Jwt.hasRole(payload, 'user')).toBe(false);
+    });
+
+    test('检查权限', () => {
+        const payload = { userId: 1, permissions: ['read', 'write'] };
+        expect(Jwt.hasPermission(payload, 'read')).toBe(true);
+        expect(Jwt.hasPermission(payload, 'delete')).toBe(false);
+    });
+
+    test('检查所有权限', () => {
+        const payload = { userId: 1, permissions: ['read', 'write', 'delete'] };
+        expect(Jwt.hasAllPermissions(payload, ['read', 'write'])).toBe(true);
+        expect(Jwt.hasAllPermissions(payload, ['read', 'admin'])).toBe(false);
+    });
+});
+
+describe('JWT - 快捷方法', () => {
+    test('create 和 check', async () => {
+        const token = await Jwt.create({ userId: 789 });
+        const decoded = await Jwt.check(token);
+        expect(decoded.userId).toBe(789);
+    });
+
+    test('parse 方法', async () => {
+        const token = await Jwt.create({ userId: 1 });
+        const decoded = Jwt.parse(token);
+        expect(decoded.userId).toBe(1);
+    });
+});

package/tests/logger.test.ts

@@ -0,0 +1,94 @@
+import { describe, test, expect, beforeAll, afterAll } from 'bun:test';
+import { Logger } from '../lib/logger';
+import { existsSync, mkdirSync, rmSync } from 'node:fs';
+import { join } from 'node:path';
+
+const testLogDir = join(process.cwd(), 'temp', 'test-logs');
+
+beforeAll(() => {
+    if (!existsSync(testLogDir)) {
+        mkdirSync(testLogDir, { recursive: true });
+    }
+    Logger.configure({
+        dir: testLogDir,
+        console: 0,
+        debug: 1
+    });
+});
+
+afterAll(() => {
+    if (existsSync(testLogDir)) {
+        rmSync(testLogDir, { recursive: true, force: true });
+    }
+});
+
+describe('Logger - 基本功能', () => {
+    test('记录 info 日志', async () => {
+        await Logger.log('info', 'Test info message');
+        expect(true).toBe(true);
+    });
+
+    test('记录 warn 日志', async () => {
+        await Logger.log('warn', 'Test warning');
+        expect(true).toBe(true);
+    });
+
+    test('记录 error 日志', async () => {
+        await Logger.log('error', 'Test error');
+        expect(true).toBe(true);
+    });
+
+    test('记录 debug 日志', async () => {
+        await Logger.log('debug', 'Test debug');
+        expect(true).toBe(true);
+    });
+
+    test('记录 success 日志', async () => {
+        await Logger.success('Test success');
+        expect(true).toBe(true);
+    });
+});
+
+describe('Logger - 不同类型消息', () => {
+    test('记录字符串', async () => {
+        await Logger.log('info', 'String message');
+        expect(true).toBe(true);
+    });
+
+    test('记录数字', async () => {
+        await Logger.log('info', 12345);
+        expect(true).toBe(true);
+    });
+
+    test('记录对象', async () => {
+        await Logger.log('info', { userId: 1, action: 'test' });
+        expect(true).toBe(true);
+    });
+
+    test('记录数组', async () => {
+        await Logger.log('info', ['item1', 'item2']);
+        expect(true).toBe(true);
+    });
+});
+
+describe('Logger - 便捷方法', () => {
+    test('info 方法', () => {
+        Logger.info('Info test');
+        expect(true).toBe(true);
+    });
+
+    test('warn 方法', () => {
+        Logger.warn('Warn test');
+        expect(true).toBe(true);
+    });
+
+    test('error 方法', () => {
+        Logger.error('Error test');
+        expect(true).toBe(true);
+    });
+
+    test('debug 方法', () => {
+        Logger.debug('Debug test');
+        expect(true).toBe(true);
+    });
+});