@onebots/core 0.5.0 → 1.0.4

package/lib/db.d.ts

@@ -34,6 +34,7 @@ export declare namespace SqliteDB {
     };
     function Column(type: ColumnType, options?: Omit<Column, "type">): Column;
     function Column(column: Column): Column;
+    /** 将值格式化为 SQL 字面量（字符串加单引号并转义，数字等直接返回，null/undefined 返回 NULL） */
     function formatValue(value: any): string;
     type QueryCondition<T extends {} = {}> = T & {
         $and?: QueryCondition<T>;
@@ -62,7 +63,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/db.js

@@ -88,8 +88,17 @@ export class SqliteDB {
         }
     }
     SqliteDB.Column = Column;
+    /** 将值格式化为 SQL 字面量（字符串加单引号并转义，数字等直接返回，null/undefined 返回 NULL） */
     function formatValue(value) {
-        return JSON.stringify(value).replace(/"/g, "'");
+        if (value === undefined || value === null)
+            return 'NULL';
+        if (typeof value === 'number')
+            return String(value);
+        const s = typeof value === 'string' ? value : JSON.stringify(value);
+        if (typeof s !== 'string')
+            return 'NULL';
+        // 字符串必须用单引号包裹，否则 SQL 会将其解析为列名（如 "no such column: zhin"）
+        return "'" + s.replace(/'/g, "''") + "'";
     }
     SqliteDB.formatValue = formatValue;
     function generateWhereClause(conditions, logic = "AND") {
@@ -128,7 +137,7 @@ export class SqliteDB {
                 else if (key === "$between" && Array.isArray(value) && value.length === 2) {
                     subClauses.push(`BETWEEN ${value[0]} AND ${value[1]}`);
                 }
-                else if (typeof value === 'object' && value === null) {
+                else if (value === undefined || value === null) {
                     subClauses.push(`${key} IS NULL`);
                 }
                 else {

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;
+}

package/lib/errors.js

@@ -0,0 +1,257 @@
+/**
+ * 错误处理和分类系统
+ * 提供统一的错误类型和处理机制
+ */
+/**
+ * 错误分类枚举
+ */
+export var ErrorCategory;
+(function (ErrorCategory) {
+    /** 网络相关错误 */
+    ErrorCategory["NETWORK"] = "NETWORK";
+    /** 配置相关错误 */
+    ErrorCategory["CONFIG"] = "CONFIG";
+    /** 运行时错误 */
+    ErrorCategory["RUNTIME"] = "RUNTIME";
+    /** 验证错误 */
+    ErrorCategory["VALIDATION"] = "VALIDATION";
+    /** 资源错误 */
+    ErrorCategory["RESOURCE"] = "RESOURCE";
+    /** 协议错误 */
+    ErrorCategory["PROTOCOL"] = "PROTOCOL";
+    /** 适配器错误 */
+    ErrorCategory["ADAPTER"] = "ADAPTER";
+    /** 未知错误 */
+    ErrorCategory["UNKNOWN"] = "UNKNOWN";
+})(ErrorCategory || (ErrorCategory = {}));
+/**
+ * 错误严重程度
+ */
+export var ErrorSeverity;
+(function (ErrorSeverity) {
+    /** 低 - 可以忽略或自动恢复 */
+    ErrorSeverity["LOW"] = "LOW";
+    /** 中 - 需要记录但可以继续运行 */
+    ErrorSeverity["MEDIUM"] = "MEDIUM";
+    /** 高 - 影响功能，需要处理 */
+    ErrorSeverity["HIGH"] = "HIGH";
+    /** 严重 - 可能导致服务停止 */
+    ErrorSeverity["CRITICAL"] = "CRITICAL";
+})(ErrorSeverity || (ErrorSeverity = {}));
+/**
+ * 基础错误类
+ */
+export class OneBotsError extends Error {
+    category;
+    severity;
+    code;
+    context;
+    timestamp;
+    cause;
+    constructor(message, options = {}) {
+        super(message);
+        this.name = 'OneBotsError';
+        this.category = options.category || ErrorCategory.UNKNOWN;
+        this.severity = options.severity || ErrorSeverity.MEDIUM;
+        this.code = options.code || 'UNKNOWN_ERROR';
+        this.context = options.context;
+        this.cause = options.cause;
+        this.timestamp = new Date();
+        // 保持错误堆栈
+        if (Error.captureStackTrace) {
+            Error.captureStackTrace(this, OneBotsError);
+        }
+    }
+    /**
+     * 转换为可序列化的对象
+     */
+    toJSON() {
+        return {
+            name: this.name,
+            message: this.message,
+            category: this.category,
+            severity: this.severity,
+            code: this.code,
+            context: this.context,
+            timestamp: this.timestamp.toISOString(),
+            stack: this.stack,
+            cause: this.cause ? {
+                message: this.cause.message,
+                stack: this.cause.stack,
+            } : undefined,
+        };
+    }
+    /**
+     * 转换为字符串
+     */
+    toString() {
+        return `[${this.category}:${this.code}] ${this.message}`;
+    }
+}
+/**
+ * 网络错误
+ */
+export class NetworkError extends OneBotsError {
+    constructor(message, options) {
+        super(message, {
+            category: ErrorCategory.NETWORK,
+            severity: ErrorSeverity.MEDIUM,
+            code: 'NETWORK_ERROR',
+            ...options,
+        });
+        this.name = 'NetworkError';
+    }
+}
+/**
+ * 配置错误
+ */
+export class ConfigError extends OneBotsError {
+    constructor(message, options) {
+        super(message, {
+            category: ErrorCategory.CONFIG,
+            severity: ErrorSeverity.HIGH,
+            code: 'CONFIG_ERROR',
+            ...options,
+        });
+        this.name = 'ConfigError';
+    }
+}
+/**
+ * 验证错误
+ */
+export class ValidationError extends OneBotsError {
+    constructor(message, options) {
+        super(message, {
+            category: ErrorCategory.VALIDATION,
+            severity: ErrorSeverity.MEDIUM,
+            code: 'VALIDATION_ERROR',
+            ...options,
+        });
+        this.name = 'ValidationError';
+    }
+}
+/**
+ * 资源错误
+ */
+export class ResourceError extends OneBotsError {
+    constructor(message, options) {
+        super(message, {
+            category: ErrorCategory.RESOURCE,
+            severity: ErrorSeverity.HIGH,
+            code: 'RESOURCE_ERROR',
+            ...options,
+        });
+        this.name = 'ResourceError';
+    }
+}
+/**
+ * 协议错误
+ */
+export class ProtocolError extends OneBotsError {
+    constructor(message, options) {
+        super(message, {
+            category: ErrorCategory.PROTOCOL,
+            severity: ErrorSeverity.MEDIUM,
+            code: 'PROTOCOL_ERROR',
+            ...options,
+        });
+        this.name = 'ProtocolError';
+    }
+}
+/**
+ * 适配器错误
+ */
+export class AdapterError extends OneBotsError {
+    constructor(message, options) {
+        super(message, {
+            category: ErrorCategory.ADAPTER,
+            severity: ErrorSeverity.HIGH,
+            code: 'ADAPTER_ERROR',
+            ...options,
+        });
+        this.name = 'AdapterError';
+    }
+}
+/**
+ * 运行时错误
+ */
+export class RuntimeError extends OneBotsError {
+    constructor(message, options) {
+        super(message, {
+            category: ErrorCategory.RUNTIME,
+            severity: ErrorSeverity.HIGH,
+            code: 'RUNTIME_ERROR',
+            ...options,
+        });
+        this.name = 'RuntimeError';
+    }
+}
+/**
+ * 错误处理工具函数
+ */
+export class ErrorHandler {
+    /**
+     * 包装错误，转换为 OneBotsError
+     */
+    static wrap(error, context) {
+        if (error instanceof OneBotsError) {
+            if (context) {
+                return new OneBotsError(error.message, {
+                    category: error.category,
+                    severity: error.severity,
+                    code: error.code,
+                    context: { ...error.context, ...context },
+                    cause: error.cause || error,
+                });
+            }
+            return error;
+        }
+        if (error instanceof Error) {
+            // 尝试从错误消息推断错误类型
+            const message = error.message.toLowerCase();
+            let category = ErrorCategory.UNKNOWN;
+            let code = 'UNKNOWN_ERROR';
+            if (message.includes('network') || message.includes('connection') || message.includes('timeout')) {
+                category = ErrorCategory.NETWORK;
+                code = 'NETWORK_ERROR';
+            }
+            else if (message.includes('config') || message.includes('configuration')) {
+                category = ErrorCategory.CONFIG;
+                code = 'CONFIG_ERROR';
+            }
+            else if (message.includes('validation') || message.includes('invalid')) {
+                category = ErrorCategory.VALIDATION;
+                code = 'VALIDATION_ERROR';
+            }
+            else if (message.includes('not found') || message.includes('missing')) {
+                category = ErrorCategory.RESOURCE;
+                code = 'RESOURCE_NOT_FOUND';
+            }
+            return new OneBotsError(error.message, {
+                category,
+                severity: ErrorSeverity.MEDIUM,
+                code,
+                context,
+                cause: error,
+            });
+        }
+        return new OneBotsError(String(error), {
+            category: ErrorCategory.UNKNOWN,
+            severity: ErrorSeverity.MEDIUM,
+            code: 'UNKNOWN_ERROR',
+            context,
+        });
+    }
+    /**
+     * 判断错误是否可恢复
+     */
+    static isRecoverable(error) {
+        return error.severity === ErrorSeverity.LOW || error.severity === ErrorSeverity.MEDIUM;
+    }
+    /**
+     * 判断错误是否致命
+     */
+    static isFatal(error) {
+        return error.severity === ErrorSeverity.CRITICAL;
+    }
+}

package/lib/index.d.ts

@@ -1,13 +1,22 @@
-export type {} from 'koa-bodyparser';
 export * from "./account.js";
 export * from "./adapter.js";
 export * from "./base-app.js";
-export * from './router.js';
-export * from "./types.js";
 export * from "./router.js";
+export * from "./types.js";
 export * from "./utils.js";
+export * from "./timestamp.js";
 export * from "./message-utils.js";
 export * from "./protocol.js";
 export * from "./registry.js";
-export * from "./registry.js";
 export * from "./db.js";
+export * from "./errors.js";
+export * from "./logger.js";
+export * from "./config-validator.js";
+export * from "./di-container.js";
+export * from "./lifecycle.js";
+export * from "./retry.js";
+export * from "./rate-limiter.js";
+export * from "./circuit-breaker.js";
+export * from "./metrics.js";
+export * from "./connection-pool.js";
+export * from "./middleware/index.js";

package/lib/index.js

@@ -1,12 +1,26 @@
+// Core modules
 export * from "./account.js";
 export * from "./adapter.js";
 export * from "./base-app.js";
-export * from './router.js';
-export * from "./types.js";
 export * from "./router.js";
+export * from "./types.js";
 export * from "./utils.js";
+export * from "./timestamp.js";
 export * from "./message-utils.js";
 export * from "./protocol.js";
 export * from "./registry.js";
-export * from "./registry.js";
 export * from "./db.js";
+// Enhanced modules
+export * from "./errors.js";
+export * from "./logger.js";
+export * from "./config-validator.js";
+export * from "./di-container.js";
+export * from "./lifecycle.js";
+// Utilities
+export * from "./retry.js";
+export * from "./rate-limiter.js";
+export * from "./circuit-breaker.js";
+export * from "./metrics.js";
+export * from "./connection-pool.js";
+// Middleware
+export * from "./middleware/index.js";