@onebots/core 0.5.0 → 1.0.0

package/README.md

@@ -1,10 +1,10 @@
 # @onebots/core
 
-OneBots 核心库 - 提供多平台多协议机器人应用的基础架构。
+onebots 核心库 - 提供多平台多协议机器人应用的基础架构。
 
 ## 简介
 
-`@onebots/core` 是 OneBots 框架的核心包，提供了构建多平台多协议机器人应用所需的基础类和工具。它包含：
+`@onebots/core` 是 onebots 框架的核心包，提供了构建多平台多协议机器人应用所需的基础类和工具。它包含：
 
 - **BaseApp**: 应用基类，提供核心功能
 - **Adapter**: 适配器基类，用于连接不同平台
@@ -157,7 +157,7 @@ pnpm test:run
 - [@onebots/adapter-wechat](../adapter-wechat) - 微信适配器
 - [@onebots/protocol-onebot-v11](../protocol-onebot-v11) - OneBot V11 协议
 - [@onebots/protocol-onebot-v12](../protocol-onebot-v12) - OneBot V12 协议
-- [@onebots/protocol-satori](../protocol-satori) - Satori 协议
+- [@onebots/protocol-satori-v1](../protocol-satori) - Satori 协议
 - [@onebots/protocol-milky-v1](../protocol-milky-v1) - Milky V1 协议
 
 ## 许可证

package/lib/__tests__/config-validator.test.d.ts

@@ -0,0 +1,4 @@
+/**
+ * 配置验证系统测试
+ */
+export {};

package/lib/__tests__/config-validator.test.js

@@ -0,0 +1,152 @@
+/**
+ * 配置验证系统测试
+ */
+import { describe, it, expect } from 'vitest';
+import { ConfigValidator, ValidationError } from '../config-validator.js';
+describe('Config Validator', () => {
+    describe('Basic Validation', () => {
+        it('should validate required fields', () => {
+            const schema = {
+                name: { type: 'string', required: true },
+                age: { type: 'number', required: true },
+            };
+            expect(() => {
+                ConfigValidator.validate({}, schema);
+            }).toThrow(ValidationError);
+            expect(() => {
+                ConfigValidator.validate({ name: 'test', age: 20 }, schema);
+            }).not.toThrow();
+        });
+        it('should apply default values', () => {
+            const schema = {
+                port: { type: 'number', default: 8080 },
+                enabled: { type: 'boolean', default: true },
+            };
+            const result = ConfigValidator.validate({}, schema);
+            expect(result.port).toBe(8080);
+            expect(result.enabled).toBe(true);
+        });
+        it('should validate type', () => {
+            const schema = {
+                port: { type: 'number' },
+                name: { type: 'string' },
+                enabled: { type: 'boolean' },
+            };
+            expect(() => {
+                ConfigValidator.validate({ port: '8080' }, schema);
+            }).toThrow(ValidationError);
+            expect(() => {
+                ConfigValidator.validate({ port: 8080, name: 'test', enabled: true }, schema);
+            }).not.toThrow();
+        });
+        it('should validate number range', () => {
+            const schema = {
+                port: { type: 'number', min: 1, max: 65535 },
+            };
+            expect(() => {
+                ConfigValidator.validate({ port: 0 }, schema);
+            }).toThrow(ValidationError);
+            expect(() => {
+                ConfigValidator.validate({ port: 70000 }, schema);
+            }).toThrow(ValidationError);
+            expect(() => {
+                ConfigValidator.validate({ port: 8080 }, schema);
+            }).not.toThrow();
+        });
+        it('should validate string length', () => {
+            const schema = {
+                name: { type: 'string', min: 3, max: 10 },
+            };
+            expect(() => {
+                ConfigValidator.validate({ name: 'ab' }, schema);
+            }).toThrow(ValidationError);
+            expect(() => {
+                ConfigValidator.validate({ name: 'abcdefghijklmnop' }, schema);
+            }).toThrow(ValidationError);
+            expect(() => {
+                ConfigValidator.validate({ name: 'test' }, schema);
+            }).not.toThrow();
+        });
+        it('should validate enum values', () => {
+            const schema = {
+                level: { type: 'string', enum: ['low', 'medium', 'high'] },
+            };
+            expect(() => {
+                ConfigValidator.validate({ level: 'invalid' }, schema);
+            }).toThrow(ValidationError);
+            expect(() => {
+                ConfigValidator.validate({ level: 'medium' }, schema);
+            }).not.toThrow();
+        });
+        it('should validate with pattern', () => {
+            const schema = {
+                email: { type: 'string', pattern: /^[^\s@]+@[^\s@]+\.[^\s@]+$/ },
+            };
+            expect(() => {
+                ConfigValidator.validate({ email: 'invalid-email' }, schema);
+            }).toThrow(ValidationError);
+            expect(() => {
+                ConfigValidator.validate({ email: 'test@example.com' }, schema);
+            }).not.toThrow();
+        });
+        it('should use custom validator', () => {
+            const schema = {
+                password: {
+                    type: 'string',
+                    validator: (value) => {
+                        if (value.length < 8) {
+                            return 'Password must be at least 8 characters';
+                        }
+                        return true;
+                    },
+                },
+            };
+            expect(() => {
+                ConfigValidator.validate({ password: 'short' }, schema);
+            }).toThrow(ValidationError);
+            expect(() => {
+                ConfigValidator.validate({ password: 'longpassword' }, schema);
+            }).not.toThrow();
+        });
+    });
+    describe('Nested Schema', () => {
+        it('should validate nested objects', () => {
+            const schema = {
+                server: {
+                    host: { type: 'string', required: true },
+                    port: { type: 'number', default: 8080 },
+                },
+            };
+            expect(() => {
+                ConfigValidator.validate({ server: {} }, schema);
+            }).toThrow(ValidationError);
+            const result = ConfigValidator.validate({ server: { host: 'localhost' } }, schema);
+            expect(result.server.host).toBe('localhost');
+            expect(result.server.port).toBe(8080);
+        });
+    });
+    describe('Transform', () => {
+        it('should transform values', () => {
+            const schema = {
+                port: {
+                    type: 'number',
+                    transform: (value) => parseInt(value, 10),
+                },
+            };
+            const result = ConfigValidator.validate({ port: '8080' }, schema);
+            expect(result.port).toBe(8080);
+            expect(typeof result.port).toBe('number');
+        });
+    });
+    describe('validateWithDefaults', () => {
+        it('should apply defaults to missing fields', () => {
+            const schema = {
+                port: { type: 'number', default: 8080 },
+                host: { type: 'string', default: 'localhost' },
+            };
+            const result = ConfigValidator.validateWithDefaults({}, schema);
+            expect(result.port).toBe(8080);
+            expect(result.host).toBe('localhost');
+        });
+    });
+});

package/lib/__tests__/di-container.test.d.ts

@@ -0,0 +1,4 @@
+/**
+ * 依赖注入容器测试
+ */
+export {};

package/lib/__tests__/di-container.test.js

@@ -0,0 +1,114 @@
+/**
+ * 依赖注入容器测试
+ */
+import { describe, it, expect, beforeEach } from 'vitest';
+import { Container } from '../di-container.js';
+describe('Dependency Injection Container', () => {
+    let container;
+    beforeEach(() => {
+        container = new Container();
+    });
+    describe('Service Registration', () => {
+        it('should register and retrieve singleton service', () => {
+            class TestService {
+                value = 1;
+            }
+            container.registerSingleton('TestService', TestService);
+            const instance1 = container.get('TestService');
+            const instance2 = container.get('TestService');
+            expect(instance1).toBe(instance2);
+            expect(instance1).toBeInstanceOf(TestService);
+        });
+        it('should register and retrieve transient service', () => {
+            class TestService {
+                value = Math.random();
+            }
+            container.registerTransient('TestService', TestService);
+            const instance1 = container.get('TestService');
+            const instance2 = container.get('TestService');
+            expect(instance1).not.toBe(instance2);
+            expect(instance1).toBeInstanceOf(TestService);
+        });
+        it('should register factory function', () => {
+            const factory = () => ({ value: 42 });
+            container.registerSingleton('TestService', factory);
+            const instance = container.get('TestService');
+            expect(instance.value).toBe(42);
+        });
+        it('should check if service exists', () => {
+            container.registerSingleton('TestService', class {
+            });
+            expect(container.has('TestService')).toBe(true);
+            expect(container.has('NonExistent')).toBe(false);
+        });
+    });
+    describe('Dependency Resolution', () => {
+        it('should resolve dependencies', () => {
+            class Dependency {
+                value = 'dependency';
+            }
+            class Service {
+                dep;
+                constructor(dep) {
+                    this.dep = dep;
+                }
+            }
+            container.registerSingleton('Dependency', Dependency);
+            container.registerSingleton('Service', Service, ['Dependency']);
+            const service = container.get('Service');
+            expect(service.dep).toBeInstanceOf(Dependency);
+            expect(service.dep.value).toBe('dependency');
+        });
+        it('should resolve multiple dependencies', () => {
+            class Dep1 {
+                value = 1;
+            }
+            class Dep2 {
+                value = 2;
+            }
+            class Service {
+                dep1;
+                dep2;
+                constructor(dep1, dep2) {
+                    this.dep1 = dep1;
+                    this.dep2 = dep2;
+                }
+            }
+            container.registerSingleton('Dep1', Dep1);
+            container.registerSingleton('Dep2', Dep2);
+            container.registerSingleton('Service', Service, ['Dep1', 'Dep2']);
+            const service = container.get('Service');
+            expect(service.dep1.value).toBe(1);
+            expect(service.dep2.value).toBe(2);
+        });
+    });
+    describe('Error Handling', () => {
+        it('should throw error for unregistered service', () => {
+            expect(() => {
+                container.get('NonExistent');
+            }).toThrow('Service not found: NonExistent');
+        });
+    });
+    describe('Container Management', () => {
+        it('should clear all services', () => {
+            container.registerSingleton('Service1', class {
+            });
+            container.registerSingleton('Service2', class {
+            });
+            expect(container.has('Service1')).toBe(true);
+            expect(container.has('Service2')).toBe(true);
+            container.clear();
+            expect(container.has('Service1')).toBe(false);
+            expect(container.has('Service2')).toBe(false);
+        });
+        it('should remove specific service', () => {
+            container.registerSingleton('Service1', class {
+            });
+            container.registerSingleton('Service2', class {
+            });
+            expect(container.remove('Service1')).toBe(true);
+            expect(container.has('Service1')).toBe(false);
+            expect(container.has('Service2')).toBe(true);
+        });
+    });
+});

package/lib/__tests__/errors.test.d.ts

@@ -0,0 +1,4 @@
+/**
+ * 错误处理系统测试
+ */
+export {};

package/lib/__tests__/errors.test.js

@@ -0,0 +1,111 @@
+/**
+ * 错误处理系统测试
+ */
+import { describe, it, expect } from 'vitest';
+import { OneBotsError, NetworkError, ConfigError, ValidationError, ErrorHandler, ErrorCategory, ErrorSeverity, } from '../errors.js';
+describe('Error Handling System', () => {
+    describe('OneBotsError', () => {
+        it('should create error with default values', () => {
+            const error = new OneBotsError('Test error');
+            expect(error.message).toBe('Test error');
+            expect(error.category).toBe(ErrorCategory.UNKNOWN);
+            expect(error.severity).toBe(ErrorSeverity.MEDIUM);
+            expect(error.code).toBe('UNKNOWN_ERROR');
+        });
+        it('should create error with custom options', () => {
+            const error = new OneBotsError('Test error', {
+                category: ErrorCategory.NETWORK,
+                severity: ErrorSeverity.HIGH,
+                code: 'CUSTOM_ERROR',
+                context: { key: 'value' },
+            });
+            expect(error.category).toBe(ErrorCategory.NETWORK);
+            expect(error.severity).toBe(ErrorSeverity.HIGH);
+            expect(error.code).toBe('CUSTOM_ERROR');
+            expect(error.context).toEqual({ key: 'value' });
+        });
+        it('should serialize to JSON', () => {
+            const error = new OneBotsError('Test error', {
+                category: ErrorCategory.CONFIG,
+                context: { test: 'value' },
+            });
+            const json = error.toJSON();
+            expect(json.message).toBe('Test error');
+            expect(json.category).toBe(ErrorCategory.CONFIG);
+            expect(json.context).toEqual({ test: 'value' });
+            expect(json.timestamp).toBeDefined();
+        });
+        it('should convert to string', () => {
+            const error = new OneBotsError('Test error', {
+                category: ErrorCategory.NETWORK,
+                code: 'NET_ERROR',
+            });
+            expect(error.toString()).toBe('[NETWORK:NET_ERROR] Test error');
+        });
+    });
+    describe('Specific Error Types', () => {
+        it('should create NetworkError', () => {
+            const error = new NetworkError('Connection failed');
+            expect(error.category).toBe(ErrorCategory.NETWORK);
+            expect(error.severity).toBe(ErrorSeverity.MEDIUM);
+            expect(error.name).toBe('NetworkError');
+        });
+        it('should create ConfigError', () => {
+            const error = new ConfigError('Invalid config');
+            expect(error.category).toBe(ErrorCategory.CONFIG);
+            expect(error.severity).toBe(ErrorSeverity.HIGH);
+            expect(error.name).toBe('ConfigError');
+        });
+        it('should create ValidationError', () => {
+            const error = new ValidationError('Validation failed');
+            expect(error.category).toBe(ErrorCategory.VALIDATION);
+            expect(error.severity).toBe(ErrorSeverity.MEDIUM);
+            expect(error.name).toBe('ValidationError');
+        });
+    });
+    describe('ErrorHandler', () => {
+        it('should wrap Error instance', () => {
+            const originalError = new Error('Original error');
+            const wrapped = ErrorHandler.wrap(originalError);
+            expect(wrapped).toBeInstanceOf(OneBotsError);
+            expect(wrapped.message).toBe('Original error');
+            expect(wrapped.cause).toBe(originalError);
+        });
+        it('should wrap OneBotsError without modification', () => {
+            const error = new NetworkError('Network error');
+            const wrapped = ErrorHandler.wrap(error);
+            expect(wrapped).toBe(error);
+        });
+        it('should wrap unknown error types', () => {
+            const wrapped = ErrorHandler.wrap('String error');
+            expect(wrapped).toBeInstanceOf(OneBotsError);
+            expect(wrapped.message).toBe('String error');
+        });
+        it('should infer error category from message', () => {
+            const networkError = ErrorHandler.wrap(new Error('Network timeout'));
+            expect(networkError.category).toBe(ErrorCategory.NETWORK);
+            const configError = ErrorHandler.wrap(new Error('Invalid configuration'));
+            expect(configError.category).toBe(ErrorCategory.CONFIG);
+        });
+        it('should check if error is recoverable', () => {
+            const recoverable = new OneBotsError('Test', {
+                severity: ErrorSeverity.LOW,
+            });
+            expect(ErrorHandler.isRecoverable(recoverable)).toBe(true);
+            const fatal = new OneBotsError('Test', {
+                severity: ErrorSeverity.CRITICAL,
+            });
+            expect(ErrorHandler.isRecoverable(fatal)).toBe(false);
+        });
+        it('should check if error is fatal', () => {
+            const fatal = new OneBotsError('Test', {
+                severity: ErrorSeverity.CRITICAL,
+            });
+            expect(ErrorHandler.isFatal(fatal)).toBe(true);
+            const nonFatal = new OneBotsError('Test', {
+                severity: ErrorSeverity.LOW,
+            });
+            expect(ErrorHandler.isFatal(nonFatal)).toBe(false);
+        });
+    });
+});

package/lib/__tests__/integration.test.d.ts

@@ -0,0 +1,5 @@
+/**
+ * 集成测试示例
+ * 测试多个模块协同工作
+ */
+export {};

package/lib/__tests__/integration.test.js

@@ -0,0 +1,112 @@
+/**
+ * 集成测试示例
+ * 测试多个模块协同工作
+ */
+import { describe, it, expect } from 'vitest';
+import { ConfigValidator, BaseAppConfigSchema } from '../config-validator.js';
+import { LifecycleManager } from '../lifecycle.js';
+import { Container } from '../di-container.js';
+import { ErrorHandler } from '../errors.js';
+import { createLogger } from '../logger.js';
+describe('Integration Tests', () => {
+    describe('Config Validation Integration', () => {
+        it('should validate and apply defaults to BaseApp config', () => {
+            const config = {};
+            const validated = ConfigValidator.validateWithDefaults(config, BaseAppConfigSchema);
+            expect(validated.port).toBe(6727);
+            expect(validated.database).toBe('onebots.db');
+            expect(validated.username).toBe('admin');
+            expect(validated.password).toBe('123456');
+            expect(validated.log_level).toBe('info');
+        });
+        it('should throw ValidationError on invalid config', () => {
+            const invalidConfig = {
+                port: 'invalid', // 应该是数字
+            };
+            expect(() => {
+                ConfigValidator.validate(invalidConfig, BaseAppConfigSchema);
+            }).toThrow();
+        });
+    });
+    describe('Error Handling Integration', () => {
+        it('should handle errors with proper categorization', () => {
+            const networkError = new Error('Network timeout');
+            const wrapped = ErrorHandler.wrap(networkError);
+            expect(wrapped.category).toBe('NETWORK');
+            expect(ErrorHandler.isRecoverable(wrapped)).toBe(true);
+        });
+        it('should log errors with context', () => {
+            const logger = createLogger('test');
+            const error = new Error('Test error');
+            const wrapped = ErrorHandler.wrap(error, { userId: '123' });
+            // 验证错误可以被序列化
+            const json = wrapped.toJSON();
+            expect(json.context).toEqual({ userId: '123' });
+        });
+    });
+    describe('Lifecycle Management Integration', () => {
+        it('should manage resources through lifecycle', async () => {
+            const lifecycle = new LifecycleManager();
+            let cleaned = false;
+            lifecycle.register('test-resource', () => {
+                cleaned = true;
+            });
+            lifecycle.addHook({
+                onInit: () => {
+                    // 初始化逻辑
+                },
+                onStart: () => {
+                    // 启动逻辑
+                },
+                onStop: () => {
+                    // 停止逻辑
+                },
+                onCleanup: () => {
+                    // 清理逻辑
+                },
+            });
+            await lifecycle.init();
+            await lifecycle.start();
+            await lifecycle.stop();
+            await lifecycle.cleanup();
+            expect(cleaned).toBe(true);
+        });
+    });
+    describe('Dependency Injection Integration', () => {
+        it('should resolve dependencies correctly', () => {
+            const container = new Container();
+            class Database {
+                connect() {
+                    return 'connected';
+                }
+            }
+            class Service {
+                db;
+                constructor(db) {
+                    this.db = db;
+                }
+            }
+            container.registerSingleton('Database', Database);
+            container.registerSingleton('Service', Service, ['Database']);
+            const service = container.get('Service');
+            expect(service.db).toBeInstanceOf(Database);
+            expect(service.db.connect()).toBe('connected');
+        });
+    });
+    describe('Logger Integration', () => {
+        it('should log with context', () => {
+            const logger = createLogger('test');
+            const contextLogger = logger.withContext({ userId: '123' });
+            // 验证上下文被正确设置
+            expect(contextLogger).toBeInstanceOf(Object);
+        });
+        it('should measure performance', () => {
+            const logger = createLogger('test');
+            const stopTimer = logger.start('test-operation');
+            // 模拟操作
+            const duration = 100;
+            logger.performance('test-operation', duration);
+            stopTimer();
+        });
+    });
+});

package/lib/__tests__/lifecycle.test.d.ts

@@ -0,0 +1,4 @@
+/**
+ * 生命周期管理测试
+ */
+export {};