@onebots/core 0.5.0 → 1.0.0

package/lib/config-validator.d.ts

@@ -0,0 +1,45 @@
+/**
+ * 配置验证系统
+ * 提供配置schema验证和默认值处理
+ */
+import { ValidationError } from './errors.js';
+export { ValidationError };
+export interface ValidationRule<T = any> {
+    required?: boolean;
+    type?: 'string' | 'number' | 'boolean' | 'object' | 'array';
+    min?: number;
+    max?: number;
+    pattern?: RegExp;
+    enum?: any[];
+    validator?: (value: T) => boolean | string;
+    default?: T | (() => T);
+    transform?: (value: any) => T;
+}
+export interface Schema {
+    [key: string]: ValidationRule | Schema;
+}
+/**
+ * 配置验证器
+ */
+export declare class ConfigValidator {
+    /**
+     * 验证配置对象
+     */
+    static validate<T extends Record<string, any>>(config: T, schema: Schema, path?: string): T;
+    /**
+     * 检查类型
+     */
+    private static checkType;
+    /**
+     * 判断是否为嵌套schema
+     */
+    private static isSchema;
+    /**
+     * 验证并应用默认值
+     */
+    static validateWithDefaults<T extends Record<string, any>>(config: Partial<T>, schema: Schema): T;
+}
+/**
+ * BaseApp 配置 Schema
+ */
+export declare const BaseAppConfigSchema: Schema;

package/lib/config-validator.js

@@ -0,0 +1,173 @@
+/**
+ * 配置验证系统
+ * 提供配置schema验证和默认值处理
+ */
+import { ValidationError } from './errors.js';
+export { ValidationError };
+/**
+ * 配置验证器
+ */
+export class ConfigValidator {
+    /**
+     * 验证配置对象
+     */
+    static validate(config, schema, path = '') {
+        const result = { ...config };
+        const errors = [];
+        for (const [key, rule] of Object.entries(schema)) {
+            const currentPath = path ? `${path}.${key}` : key;
+            const value = config[key];
+            // 如果是嵌套schema，递归验证
+            if (this.isSchema(rule)) {
+                if (value !== undefined) {
+                    result[key] = this.validate(value || {}, rule, currentPath);
+                }
+                continue;
+            }
+            const validationRule = rule;
+            // 检查必填字段
+            if (validationRule.required && (value === undefined || value === null)) {
+                if (validationRule.default !== undefined) {
+                    result[key] = typeof validationRule.default === 'function'
+                        ? validationRule.default()
+                        : validationRule.default;
+                    continue;
+                }
+                errors.push(`${currentPath} is required`);
+                continue;
+            }
+            // 如果值为undefined且有默认值，使用默认值
+            if (value === undefined && validationRule.default !== undefined) {
+                result[key] = typeof validationRule.default === 'function'
+                    ? validationRule.default()
+                    : validationRule.default;
+                continue;
+            }
+            // 如果值为undefined，跳过验证
+            if (value === undefined) {
+                continue;
+            }
+            // 类型转换
+            if (validationRule.transform) {
+                try {
+                    result[key] = validationRule.transform(value);
+                }
+                catch (error) {
+                    errors.push(`${currentPath} transform failed: ${error.message}`);
+                    continue;
+                }
+            }
+            const finalValue = result[key];
+            // 类型检查
+            if (validationRule.type) {
+                const typeError = this.checkType(finalValue, validationRule.type, currentPath);
+                if (typeError) {
+                    errors.push(typeError);
+                    continue;
+                }
+            }
+            // 数值范围检查
+            if (validationRule.type === 'number') {
+                if (validationRule.min !== undefined && finalValue < validationRule.min) {
+                    errors.push(`${currentPath} must be >= ${validationRule.min}`);
+                }
+                if (validationRule.max !== undefined && finalValue > validationRule.max) {
+                    errors.push(`${currentPath} must be <= ${validationRule.max}`);
+                }
+            }
+            // 字符串长度检查
+            if (validationRule.type === 'string') {
+                if (validationRule.min !== undefined && finalValue.length < validationRule.min) {
+                    errors.push(`${currentPath} length must be >= ${validationRule.min}`);
+                }
+                if (validationRule.max !== undefined && finalValue.length > validationRule.max) {
+                    errors.push(`${currentPath} length must be <= ${validationRule.max}`);
+                }
+                if (validationRule.pattern && !validationRule.pattern.test(finalValue)) {
+                    errors.push(`${currentPath} does not match pattern ${validationRule.pattern}`);
+                }
+            }
+            // 枚举检查
+            if (validationRule.enum && !validationRule.enum.includes(finalValue)) {
+                errors.push(`${currentPath} must be one of: ${validationRule.enum.join(', ')}`);
+            }
+            // 自定义验证器
+            if (validationRule.validator) {
+                const validationResult = validationRule.validator(finalValue);
+                if (validationResult !== true) {
+                    errors.push(`${currentPath}: ${validationResult || 'validation failed'}`);
+                }
+            }
+        }
+        if (errors.length > 0) {
+            throw new ValidationError('Configuration validation failed', {
+                context: {
+                    errors,
+                    path,
+                },
+            });
+        }
+        return result;
+    }
+    /**
+     * 检查类型
+     */
+    static checkType(value, expectedType, path) {
+        const actualType = Array.isArray(value) ? 'array' : typeof value;
+        if (actualType !== expectedType) {
+            return `${path} must be ${expectedType}, got ${actualType}`;
+        }
+        return null;
+    }
+    /**
+     * 判断是否为嵌套schema
+     */
+    static isSchema(rule) {
+        return !('required' in rule) && !('type' in rule) && typeof rule === 'object';
+    }
+    /**
+     * 验证并应用默认值
+     */
+    static validateWithDefaults(config, schema) {
+        return this.validate(config, schema);
+    }
+}
+/**
+ * BaseApp 配置 Schema
+ */
+export const BaseAppConfigSchema = {
+    port: {
+        type: 'number',
+        min: 1,
+        max: 65535,
+        default: 6727,
+    },
+    path: {
+        type: 'string',
+        default: '',
+    },
+    database: {
+        type: 'string',
+        default: 'onebots.db',
+    },
+    timeout: {
+        type: 'number',
+        min: 1,
+        default: 30,
+    },
+    username: {
+        type: 'string',
+        min: 1,
+        default: 'admin',
+    },
+    password: {
+        type: 'string',
+        min: 1,
+        default: '123456',
+    },
+    log_level: {
+        type: 'string',
+        enum: ['trace', 'debug', 'info', 'warn', 'error', 'fatal', 'mark', 'off'],
+        default: 'info',
+    },
+};

package/lib/db.d.ts

@@ -62,7 +62,7 @@ export declare class Selection {
     groupBy(field: string): this;
     orderBy(field: string, order?: "ASC" | "DESC"): this;
     get sql(): string;
-    run(): unknown[];
+    run(): Record<string, import("node:sqlite").SQLOutputValue>[];
 }
 export declare class Insertion {
     #private;

package/lib/di-container.d.ts

@@ -0,0 +1,60 @@
+/**
+ * 依赖注入容器
+ * 提供依赖注入和生命周期管理
+ */
+import type { Class } from './utils.js';
+export type Token<T = any> = string | symbol | Class<T>;
+export type Factory<T = any> = (container: Container) => T;
+export type Provider<T = any> = Class<T> | Factory<T>;
+export interface ServiceOptions {
+    /** 是否单例 */
+    singleton?: boolean;
+    /** 依赖的token列表 */
+    deps?: Token[];
+}
+/**
+ * 依赖注入容器
+ */
+export declare class Container {
+    private services;
+    /**
+     * 注册服务
+     */
+    register<T>(token: Token<T>, provider: Provider<T>, options?: ServiceOptions): void;
+    /**
+     * 注册单例服务
+     */
+    registerSingleton<T>(token: Token<T>, provider: Provider<T>, deps?: Token[]): void;
+    /**
+     * 注册瞬态服务（每次获取都创建新实例）
+     */
+    registerTransient<T>(token: Token<T>, provider: Provider<T>, deps?: Token[]): void;
+    /**
+     * 获取服务实例
+     */
+    get<T>(token: Token<T>): T;
+    /**
+     * 检查服务是否已注册
+     */
+    has(token: Token): boolean;
+    /**
+     * 解析依赖
+     */
+    private resolveDependencies;
+    /**
+     * 判断是否为类
+     */
+    private isClass;
+    /**
+     * 清除所有服务
+     */
+    clear(): void;
+    /**
+     * 移除服务
+     */
+    remove(token: Token): boolean;
+}
+/**
+ * 全局容器实例
+ */
+export declare const container: Container;

package/lib/di-container.js

@@ -0,0 +1,103 @@
+/**
+ * 依赖注入容器
+ * 提供依赖注入和生命周期管理
+ */
+/**
+ * 依赖注入容器
+ */
+export class Container {
+    services = new Map();
+    /**
+     * 注册服务
+     */
+    register(token, provider, options = {}) {
+        this.services.set(token, {
+            provider,
+            options: {
+                singleton: true,
+                ...options,
+            },
+        });
+    }
+    /**
+     * 注册单例服务
+     */
+    registerSingleton(token, provider, deps) {
+        this.register(token, provider, {
+            singleton: true,
+            deps,
+        });
+    }
+    /**
+     * 注册瞬态服务（每次获取都创建新实例）
+     */
+    registerTransient(token, provider, deps) {
+        this.register(token, provider, {
+            singleton: false,
+            deps,
+        });
+    }
+    /**
+     * 获取服务实例
+     */
+    get(token) {
+        const service = this.services.get(token);
+        if (!service) {
+            throw new Error(`Service not found: ${String(token)}`);
+        }
+        // 如果是单例且已有实例，直接返回
+        if (service.options.singleton && service.instance !== undefined) {
+            return service.instance;
+        }
+        // 创建实例
+        let instance;
+        if (this.isClass(service.provider)) {
+            // 类构造函数
+            const deps = this.resolveDependencies(service.options.deps || []);
+            instance = new service.provider(...deps);
+        }
+        else {
+            // 工厂函数
+            instance = service.provider(this);
+        }
+        // 如果是单例，保存实例
+        if (service.options.singleton) {
+            service.instance = instance;
+        }
+        return instance;
+    }
+    /**
+     * 检查服务是否已注册
+     */
+    has(token) {
+        return this.services.has(token);
+    }
+    /**
+     * 解析依赖
+     */
+    resolveDependencies(tokens) {
+        return tokens.map(token => this.get(token));
+    }
+    /**
+     * 判断是否为类
+     */
+    isClass(provider) {
+        return typeof provider === 'function' && provider.prototype && provider.prototype.constructor === provider;
+    }
+    /**
+     * 清除所有服务
+     */
+    clear() {
+        this.services.clear();
+    }
+    /**
+     * 移除服务
+     */
+    remove(token) {
+        return this.services.delete(token);
+    }
+}
+/**
+ * 全局容器实例
+ */
+export const container = new Container();

package/lib/errors.d.ts

@@ -0,0 +1,157 @@
+/**
+ * 错误处理和分类系统
+ * 提供统一的错误类型和处理机制
+ */
+/**
+ * 错误分类枚举
+ */
+export declare enum ErrorCategory {
+    /** 网络相关错误 */
+    NETWORK = "NETWORK",
+    /** 配置相关错误 */
+    CONFIG = "CONFIG",
+    /** 运行时错误 */
+    RUNTIME = "RUNTIME",
+    /** 验证错误 */
+    VALIDATION = "VALIDATION",
+    /** 资源错误 */
+    RESOURCE = "RESOURCE",
+    /** 协议错误 */
+    PROTOCOL = "PROTOCOL",
+    /** 适配器错误 */
+    ADAPTER = "ADAPTER",
+    /** 未知错误 */
+    UNKNOWN = "UNKNOWN"
+}
+/**
+ * 错误严重程度
+ */
+export declare enum ErrorSeverity {
+    /** 低 - 可以忽略或自动恢复 */
+    LOW = "LOW",
+    /** 中 - 需要记录但可以继续运行 */
+    MEDIUM = "MEDIUM",
+    /** 高 - 影响功能，需要处理 */
+    HIGH = "HIGH",
+    /** 严重 - 可能导致服务停止 */
+    CRITICAL = "CRITICAL"
+}
+/**
+ * 基础错误类
+ */
+export declare class OneBotsError extends Error {
+    readonly category: ErrorCategory;
+    readonly severity: ErrorSeverity;
+    readonly code: string;
+    readonly context?: Record<string, any>;
+    readonly timestamp: Date;
+    readonly cause?: Error;
+    constructor(message: string, options?: {
+        category?: ErrorCategory;
+        severity?: ErrorSeverity;
+        code?: string;
+        context?: Record<string, any>;
+        cause?: Error;
+    });
+    /**
+     * 转换为可序列化的对象
+     */
+    toJSON(): {
+        name: string;
+        message: string;
+        category: ErrorCategory;
+        severity: ErrorSeverity;
+        code: string;
+        context: Record<string, any>;
+        timestamp: string;
+        stack: string;
+        cause: {
+            message: string;
+            stack: string;
+        };
+    };
+    /**
+     * 转换为字符串
+     */
+    toString(): string;
+}
+/**
+ * 网络错误
+ */
+export declare class NetworkError extends OneBotsError {
+    constructor(message: string, options?: {
+        context?: Record<string, any>;
+        cause?: Error;
+    });
+}
+/**
+ * 配置错误
+ */
+export declare class ConfigError extends OneBotsError {
+    constructor(message: string, options?: {
+        context?: Record<string, any>;
+        cause?: Error;
+    });
+}
+/**
+ * 验证错误
+ */
+export declare class ValidationError extends OneBotsError {
+    constructor(message: string, options?: {
+        context?: Record<string, any>;
+        cause?: Error;
+    });
+}
+/**
+ * 资源错误
+ */
+export declare class ResourceError extends OneBotsError {
+    constructor(message: string, options?: {
+        context?: Record<string, any>;
+        cause?: Error;
+    });
+}
+/**
+ * 协议错误
+ */
+export declare class ProtocolError extends OneBotsError {
+    constructor(message: string, options?: {
+        context?: Record<string, any>;
+        cause?: Error;
+    });
+}
+/**
+ * 适配器错误
+ */
+export declare class AdapterError extends OneBotsError {
+    constructor(message: string, options?: {
+        context?: Record<string, any>;
+        cause?: Error;
+    });
+}
+/**
+ * 运行时错误
+ */
+export declare class RuntimeError extends OneBotsError {
+    constructor(message: string, options?: {
+        context?: Record<string, any>;
+        cause?: Error;
+    });
+}
+/**
+ * 错误处理工具函数
+ */
+export declare class ErrorHandler {
+    /**
+     * 包装错误，转换为 OneBotsError
+     */
+    static wrap(error: unknown, context?: Record<string, any>): OneBotsError;
+    /**
+     * 判断错误是否可恢复
+     */
+    static isRecoverable(error: OneBotsError): boolean;
+    /**
+     * 判断错误是否致命
+     */
+    static isFatal(error: OneBotsError): boolean;
+}