@zhin.js/core 1.0.1 → 1.0.3

package/src/jsx-dev-runtime.ts

@@ -0,0 +1,2 @@
+export * from './jsx-runtime.js'
+export {jsx as jsxDEV} from './jsx.js'

package/src/jsx-runtime.ts

@@ -0,0 +1,12 @@
+// JSX 运行时入口文件
+import { jsx, jsxs, Fragment, renderJSX } from './jsx.js';
+
+export { jsx, jsxs, Fragment, renderJSX };
+
+// 默认导出 JSX 运行时
+export default {
+    jsx,
+    jsxs,
+    Fragment,
+    renderJSX
+};

package/src/jsx.d.ts

@@ -0,0 +1,52 @@
+import { SendContent } from './types.js';
+import { Component,ComponentContext } from './component.js';
+import { MessageElement } from './types.js';
+
+declare global {
+    namespace JSX {
+        interface Element {
+            type: string | Component<any>;
+            data: Record<string, any>;
+            children?: JSXChildren;
+        }
+
+        interface ElementClass {
+            render(props: any, context?: ComponentContext): MaybePromise<SendContent>;
+        }
+
+        interface ElementAttributesProperty {
+            data: {};
+        }
+
+        interface ElementChildrenAttribute {
+            children: {};
+        }
+
+        interface IntrinsicElements {
+            // 简化的组件元素
+            fetch: JSXFetchElement;
+        }
+    }
+}
+
+// 简化的组件属性接口
+interface JSXBaseElement {
+    children?: JSXChildren;
+}
+
+interface JSXFetchElement extends JSXBaseElement {
+    url?: string;
+}
+
+// JSX 子元素类型
+type JSXChildren = MessageElement | string | number | boolean | null | undefined | JSXChildren[];
+
+// JSX 元素类型
+type JSXElement = {
+    type: string | Component<any>;
+    data: Record<string, any>;
+    children?: JSXChildren;
+};
+
+// 类型辅助
+type MaybePromise<T> = T | Promise<T>;

package/src/jsx.ts

@@ -0,0 +1,92 @@
+import { MaybePromise } from '@zhin.js/types';
+import { SendContent,MessageElement } from './types.js';
+import { MessageComponent } from './message.js';
+import { Component, ComponentContext } from './component.js';
+
+
+// JSX 子元素类型
+export type JSXChildren = MessageElement | string | number | boolean | null | undefined | JSXChildren[];
+
+// JSX 元素类型
+export type JSXElementType = string | Component<any> ;
+
+// JSX 属性类型
+export type JSXProps = Record<string, any> & {
+    children?: JSXChildren;
+};
+export {Fragment} from './component.js'
+// 全局 JSX 命名空间
+declare global {
+    namespace JSX {
+        interface Element extends MessageComponent<any> {}
+        interface ElementClass {
+            render(props: any, context?: ComponentContext): MaybePromise<SendContent>;
+        }
+        interface ElementAttributesProperty {
+            data: {};
+        }
+        interface ElementChildrenAttribute {
+            children: {};
+        }
+        interface IntrinsicElements {
+            [elemName: string]: any;
+        }
+    }
+}
+
+// JSX 运行时函数
+export function jsx(type: JSXElementType, data: JSXProps): MessageElement {
+    return {
+        type,
+        data,
+    } as MessageElement;
+}
+
+// JSX Fragment 支持
+export function jsxs(type: JSXElementType, props: JSXProps): MessageElement {
+    return jsx(type, props);
+}
+
+
+// JSX 渲染函数
+export async function renderJSX(element: MessageComponent<any>, context?: ComponentContext): Promise<SendContent> {
+    if (typeof element.type === 'string') {
+        if (element.type === 'Fragment') {
+            return await renderChildren(element.data.children, context);
+        }
+        // 其他内置组件处理
+        return await renderChildren(element.data.children, context);
+    } else if (typeof element.type === 'function') {
+        // 函数组件
+        const component = element.type as Component<any>;
+        return await component(element.data, context || {} as ComponentContext);
+    } else {
+        // 类组件或其他类型
+        const component = element.type as Component<any>;
+        return await component(element.data, context || {} as ComponentContext);
+    }
+}
+
+// 渲染子元素
+async function renderChildren(children: JSXChildren, context?: ComponentContext): Promise<SendContent> {
+    if (children == null) return '';
+    if (typeof children === 'string' || typeof children === 'number' || typeof children === 'boolean') {
+        return String(children);
+    }
+    if (Array.isArray(children)) {
+        const results = await Promise.all(children.map(async child => {
+            if (typeof child === 'string' || typeof child === 'number' || typeof child === 'boolean') {
+                return String(child);
+            }
+            if (child && typeof child === 'object' && 'type' in child) {
+                return await renderJSX(child as MessageComponent<any>, context);
+            }
+            return '';
+        }));
+        return results.join('');
+    }
+    if (children && typeof children === 'object' && 'type' in children) {
+        return await renderJSX(children as MessageComponent<any>, context);
+    }
+    return '';
+}

package/src/log-transport.ts

@@ -0,0 +1,163 @@
+import { LogTransport } from '@zhin.js/logger'
+import { App } from './app.js'
+
+/**
+ * 数据库日志传输器
+ * 将日志存储到数据库，并自动清理旧日志
+ */
+export class DatabaseLogTransport implements LogTransport {
+  private app: App
+  private stripAnsiRegex = /\x1b\[[0-9;]*m/g
+  private cleanupTimer?: NodeJS.Timeout
+  private maxDays: number
+  private maxRecords: number
+  private cleanupInterval: number
+
+  constructor(app: App) {
+    this.app = app
+    
+    // 从配置读取日志清理策略
+    const logConfig = app['config']?.log || {}
+    this.maxDays = logConfig.maxDays || 7 // 默认保留 7 天
+    this.maxRecords = logConfig.maxRecords || 10000 // 默认最多 10000 条
+    this.cleanupInterval = logConfig.cleanupInterval || 24 // 默认 24 小时清理一次
+    
+    // 启动定时清理
+    this.startCleanup()
+  }
+
+  /**
+   * 启动定时清理任务
+   */
+  private startCleanup(): void {
+    // 立即执行一次清理
+    this.cleanupOldLogs().catch(err => {
+      this.app.logger.error('[DatabaseLogTransport] Initial cleanup failed:', err.message)
+    })
+
+    // 设置定时任务
+    this.cleanupTimer = setInterval(() => {
+      this.cleanupOldLogs().catch(err => {
+        this.app.logger.error('[DatabaseLogTransport] Scheduled cleanup failed:', err.message)
+      })
+    }, this.cleanupInterval * 60 * 60 * 1000) // 转换为毫秒
+  }
+
+  /**
+   * 清理旧日志
+   */
+  private async cleanupOldLogs(): Promise<void> {
+    if (!this.app.database) {
+      return
+    }
+
+    try {
+      const LogModel = this.app.database.model('SystemLog')
+      if (!LogModel) {
+        return
+      }
+
+      // 1. 按时间清理：删除超过 maxDays 天的日志
+      const cutoffDate = new Date()
+      cutoffDate.setDate(cutoffDate.getDate() - this.maxDays)
+      
+      const deletedByDate = await LogModel
+        .delete({ timestamp: { $lt: cutoffDate } })
+      
+      // 2. 按数量清理：如果日志总数超过 maxRecords，删除最旧的
+      const total = await LogModel.select()
+      const totalCount = total.length
+      
+      if (totalCount > this.maxRecords) {
+        const excessCount = totalCount - this.maxRecords
+        
+        // 查找最旧的 excessCount 条日志的 ID
+        const oldestLogs = await LogModel
+          .select('id','timestamp')
+          .orderBy('timestamp', 'ASC')
+          .limit(excessCount)
+        
+        const idsToDelete = oldestLogs.map((log: any) => log.id)
+        
+        if (idsToDelete.length > 0) {
+          await LogModel
+            .delete({ id: { $in: idsToDelete } })
+        }
+      }
+
+      this.app.logger.info(
+        `[DatabaseLogTransport] Log cleanup completed. ` +
+        `Deleted ${deletedByDate || 0} logs older than ${this.maxDays} days. ` +
+        `Current total: ${Math.max(0, totalCount - (deletedByDate || 0))} logs.`
+      )
+    } catch (error) {
+      // 静默处理错误
+      this.app.logger.error('[DatabaseLogTransport] Cleanup error:', (error as Error).message)
+    }
+  }
+
+  /**
+   * 停止清理任务
+   */
+  public stopCleanup(): void {
+    if (this.cleanupTimer) {
+      clearInterval(this.cleanupTimer)
+      this.cleanupTimer = undefined
+    }
+  }
+
+  /**
+   * 移除 ANSI 颜色代码
+   */
+  private stripAnsi(str: string): string {
+    return str.replace(this.stripAnsiRegex, '')
+  }
+
+  write(message: string): void {
+    // 移除 ANSI 颜色代码
+    const cleanMessage = this.stripAnsi(message)
+    
+    // 解析日志消息
+    // 格式: [09-08 04:07:55.852] [INFO] [MyApp]: message
+    const logRegex = /\[[\d-]+ [\d:.]+\] \[(\w+)\] \[([^\]]+)\]: ([\s\S]+)/
+    const match = cleanMessage.match(logRegex)
+    
+    if (match) {
+      const [, level, name, msg] = match
+      const source = name.split(':')[0] // 取第一部分作为 source
+      
+      // 异步存储到数据库，不阻塞日志输出
+      this.saveToDatabase(level.toLowerCase(), name, msg.trim(), source).catch(err => {
+        // 避免日志存储失败导致应用崩溃
+        console.error('[DatabaseLogTransport] Failed to save log:', err.message)
+      })
+    }
+  }
+
+  /**
+   * 保存日志到数据库
+   */
+  private async saveToDatabase(level: string, name: string, message: string, source: string): Promise<void> {
+    if (!this.app.database) {
+      return // 没有数据库则跳过
+    }
+
+    try {
+      const LogModel = this.app.database.model('SystemLog')
+      if (!LogModel) {
+        return // 模型不存在则跳过
+      }
+
+      await LogModel.create({
+        level,
+        name,
+        message,
+        source,
+        timestamp: new Date()
+      })
+    } catch (error) {
+      // 静默处理错误，避免干扰主流程
+    }
+  }
+}
+

package/src/message.ts

@@ -1,10 +1,13 @@
-import {MaybePromise} from "@zhin.js/types";
-import {MessageSegment, MessageSender, RegisteredAdapter, SendContent} from "./types";
+import {MessageElement, MessageSender, SendContent} from "./types";
+import { Component } from "./component.js";
 
 /**
  * 消息组件类型：用于自定义消息结构
  */
-export type MessageComponent<T extends object>=(props:T&{children:SendContent})=>MaybePromise<SendContent>
+export type MessageComponent<T extends object>={
+    type:Component<T&{children?:SendContent}>
+    data:T
+}
 /**
  * 消息频道信息
  */
@@ -23,9 +26,9 @@ export interface MessageBase {
     $id: string;
     $adapter:string
     $bot:string
-    $content: MessageSegment[];
+    $content: MessageElement[];
     $sender: MessageSender;
-    $reply(content:SendContent,quote?:boolean|string):Promise<void>
+    $reply(content:SendContent,quote?:boolean|string):Promise<string>
     $channel: MessageChannel;
     $timestamp: number;
     $raw: string;

package/src/models/system-log.ts

@@ -0,0 +1,20 @@
+import { Schema } from '@zhin.js/database'
+
+export interface SystemLog {
+  id?: number
+  level: string
+  name: string
+  message: string
+  source: string
+  timestamp: Date
+}
+
+export const SystemLogSchema:Schema<SystemLog>={
+  id: { type: 'integer', autoIncrement: true, primary: true },
+  level: { type: 'text', nullable: false },
+  name: { type: 'text', nullable: false },
+  message: { type: 'text', nullable: false },
+  source: { type: 'text', nullable: false },
+  timestamp: { type: 'date', nullable: false }
+}
+

package/src/plugin.ts

@@ -9,7 +9,7 @@ import {Message} from './message.js'
 import {Dependency, Logger,} from "@zhin.js/hmr";
 import {App} from "./app";
 import {MessageCommand} from "./command.js";
-import {Component} from "./component.js";
+import {Component, renderComponents} from "./component.js";
 import { PluginError, MessageError, errorManager } from './errors.js';
 import {remove} from "./utils.js";
 import {Prompt} from "./prompt.js";
@@ -29,8 +29,8 @@ export type MessageMiddleware<P extends RegisteredAdapter=RegisteredAdapter> = (
  * 支持命令注册、中间件、组件、定时任务、模型等。
  */
 export class Plugin extends Dependency<Plugin> {
-    middlewares: MessageMiddleware<any>[] = [];
-    components: Map<string, Component<any, any, any>> = new Map();
+    middlewares: MessageMiddleware<RegisteredAdapter>[] = [];
+    components: Map<string, Component<any>> = new Map();
     schemas: Map<string,Schema<any>>=new Map();
     commands:MessageCommand[]=[];
     crons:Cron[]=[];
@@ -54,7 +54,7 @@ export class Plugin extends Dependency<Plugin> {
             return next()
         });
         // 发送前渲染组件
-        this.beforeSend((options)=>Component.render(this.components,options))
+        this.beforeSend((options)=>renderComponents(this.components,options))
         // 资源清理：卸载时清空模型、定时任务等
         this.on('dispose',()=>{
             for(const name of this.schemas.keys()){
@@ -140,7 +140,7 @@ export class Plugin extends Dependency<Plugin> {
         return temp.getLogger(names.join('/'))
     }
     /** 添加组件 */
-    addComponent<T = {}, D = {}, P = Component.Props<T>>(component:Component<T,D,P>){
+    addComponent<T=any>(component:Component<T>){
         this.components.set(component.name,component);
     }
     /** 添加中间件 */
@@ -178,6 +178,20 @@ export class Plugin extends Dependency<Plugin> {
             throw messageError
         }
     }
+    recallMessage(adapter:string,bot:string,id:string){
+        try{
+            this.app.recallMessage(adapter,bot,id)
+        }catch(error){
+            const messageError = new MessageError(
+                `撤回消息失败: ${(error as Error).message}`,
+                id,
+                undefined,
+                { originalError: error }
+            )
+            errorManager.handle(messageError)
+            throw messageError
+        }
+    }
 
     /** 销毁插件 */
     dispose(): void {

package/src/prompt.ts

@@ -27,8 +27,8 @@ export class Prompt<P extends RegisteredAdapter> {
      * @param config 提问配置
      */
     private prompt<T = any>(config: Prompt.Config<T>) {
-        return new Promise<T>((resolve, reject) => {
-            this.event.$reply(config.tips);
+        return new Promise<T>(async (resolve, reject) => {
+            const id = await this.event.$reply(config.tips);
             this.middleware(
                 input => {
                     if (input instanceof Error) {
@@ -37,6 +37,7 @@ export class Prompt<P extends RegisteredAdapter> {
                         else reject(input);
                         return;
                     }
+                    this.plugin.recallMessage(this.event.$adapter,this.event.$bot,id);
                     resolve(config.format(input));
                 },
                 config.timeout,

package/src/types.ts

@@ -1,20 +1,10 @@
-import {MaybePromise}from '@zhin.js/types'
+import {MaybePromise,RegisteredAdapters}from '@zhin.js/types'
 import {MessageChannel} from "./message.js";
 import {Adapter} from "./adapter.js";
 import {Bot,BotConfig} from "./bot.js";
 import { Databases,Registry } from "@zhin.js/database";
+import { MessageComponent } from "./message.js";
 
-/**
- * 类型定义文件：包含适配器、消息、数据库、配置等核心类型声明。
- * 协作者可通过本文件了解各主要数据结构的用途与关系。
- */
-declare module '@zhin.js/types'{
-  interface GlobalContext extends RegisteredAdapters{}
-}
-/**
- * 所有已注册适配器的类型映射（key为适配器名，value为Adapter实例）
- */
-export interface RegisteredAdapters extends Record<string, Adapter>{}
 /**
  * 数据库配置类型，支持多种数据库驱动
  */
@@ -52,6 +42,7 @@ export interface MessageSegment {
   type: string;
   data: Record<string, any>;
 }
+export type MessageElement=MessageSegment|MessageComponent<any>
 /**
  * 单个或数组类型
  */
@@ -59,7 +50,7 @@ export type MaybeArray<T>=T|T[]
 /**
  * 消息发送内容类型
  */
-export type SendContent=MaybeArray<string|MessageSegment>
+export type SendContent=MaybeArray<string|MessageElement>
 /**
  * 消息发送者信息
  */
@@ -107,6 +98,15 @@ export interface AppConfig {
   disable_dependencies?: string[];
   /** 是否启用调试模式 */
   debug?: boolean;
+  /** 日志配置 */
+  log?: {
+    /** 最大日志保留天数，默认 7 天 */
+    maxDays?: number;
+    /** 最大日志条数，默认 10000 条 */
+    maxRecords?: number;
+    /** 自动清理间隔（小时），默认 24 小时 */
+    cleanupInterval?: number;
+  };
 }
 /**
  * defineConfig辅助类型，支持函数式/对象式配置

package/src/utils.ts

@@ -1,4 +1,4 @@
-import {Dict, MessageSegment, SendContent} from "./types";
+import {Dict, MessageElement, MessageSegment, SendContent} from "./types";
 
 export function getValueWithRuntime(template: string, ctx: Dict) {
     const result = evaluate(template, ctx);
@@ -79,10 +79,10 @@ export namespace segment{
     }
     export function from(content: SendContent): SendContent {
         if (!Array.isArray(content)) content=[content];
-        const toString=(template:string|MessageSegment)=>{
+        const toString=(template:string|MessageElement)=>{
             if(typeof template!=='string') return [template]
             template=unescape(template);
-            const result: MessageSegment[] = [];
+            const result: MessageElement[] = [];
             const closingReg = /<(\S+)(\s[^>]+)?\/>/;
             const twinningReg = /<(\S+)(\s[^>]+)?>([\s\S]*?)<\/\1>/;
             while (template.length) {
@@ -132,7 +132,7 @@ export namespace segment{
         return content.reduce((result,item)=>{
             result.push(...toString(item))
             return result;
-        },[] as MessageSegment[])
+        },[] as MessageElement[])
     }
     export function raw(content:SendContent){
         if(!Array.isArray(content)) content=[content]
@@ -147,7 +147,8 @@ export namespace segment{
         if(!Array.isArray(content)) content=[content]
         return content.map(item=>{
             if(typeof item==='string') return item
-            const {type,data}=item
+            let {type,data}=item
+            if(typeof type==='function') type=type.name
             if(type==='text') return data.text
             return `<${type} ${Object.keys(data).map(key=>`${key}='${escape(JSON.stringify(data[key]))}'`).join(' ')}/>`
         }).join('')