@zhin.js/core 1.0.24 → 1.0.26

package/src/built/cron.ts

@@ -1,9 +1,10 @@
 /**
- * Cron Context
- * 管理所有插件注册的定时任务
+ * CronFeature
+ * 管理所有插件注册的定时任务，继承自 Feature 抽象类
  */
+import { Feature, FeatureJSON } from "../feature.js";
 import { Cron } from "../cron.js";
-import { Context, Plugin, getPlugin } from "../plugin.js";
+import { Plugin, getPlugin } from "../plugin.js";
 
 /**
  * CronContext 扩展方法类型
@@ -18,123 +19,138 @@ declare module "../plugin.js" {
   namespace Plugin {
     interface Extensions extends CronContextExtensions {}
     interface Contexts {
-      cron: CronService;
+      cron: CronFeature;
     }
   }
 }
 
 /**
- * 定时任务服务数据
+ * 定时任务服务 Feature
  */
-export interface CronService {
-  /** 任务列表 */
-  readonly items: Cron[];
+export class CronFeature extends Feature<Cron> {
+  readonly name = 'cron' as const;
+  readonly icon = 'Clock';
+  readonly desc = '定时任务';
+
   /** 按 ID/表达式 索引 */
-  readonly byName: Map<string, Cron>;
-  /** 添加任务 */
-  add(cron: Cron, pluginName: string): () => void;
-  /** 移除任务 */
-  remove(cron: Cron): boolean;
-  /** 按名称获取 */
-  get(id: string): Cron | undefined;
-  /** 停止所有任务 */
-  stopAll(): void;
-  /** 启动所有任务 */
-  startAll(): void;
-  /** 获取状态 */
+  readonly byName = new Map<string, Cron>();
+
+  /**
+   * 添加定时任务，自动启动
+   */
+  add(cron: Cron, pluginName: string): () => void {
+    this.byName.set(cron.id || cron.cronExpression, cron);
+    // 自动启动
+    if (!cron.running) {
+      cron.run();
+    }
+    return super.add(cron, pluginName);
+  }
+
+  /**
+   * 移除定时任务，自动停止
+   */
+  remove(cron: Cron): boolean {
+    if (cron.running) {
+      cron.stop();
+    }
+    this.byName.delete(cron.id || cron.cronExpression);
+    return super.remove(cron);
+  }
+
+  /**
+   * 按 ID/表达式 获取
+   */
+  get(id: string): Cron | undefined {
+    return this.byName.get(id);
+  }
+
+  /**
+   * 停止所有任务
+   */
+  stopAll(): void {
+    for (const cron of this.items) {
+      if (cron.running) {
+        cron.stop();
+      }
+    }
+  }
+
+  /**
+   * 启动所有任务
+   */
+  startAll(): void {
+    for (const cron of this.items) {
+      if (!cron.running && !cron.disposed) {
+        cron.run();
+      }
+    }
+  }
+
+  /**
+   * 获取所有任务状态
+   */
   getStatus(): Array<{
     expression: string;
     running: boolean;
     nextExecution: Date | null;
     plugin: string;
-  }>;
-}
-
-/**
- * 创建定时任务 Context
- */
-export function createCronService(): Context<'cron', CronContextExtensions> {
-  const items: Cron[] = [];
-  const byName = new Map<string, Cron>();
-  const pluginMap = new Map<Cron, string>();
-  
-  const value: CronService = {
-    items,
-    byName,
-    
-    add(cron, pluginName) {
-      items.push(cron);
-      byName.set(cron.id || cron.cronExpression, cron);
-      pluginMap.set(cron, pluginName);
-      // 自动启动
-      if (!cron.running) {
-        cron.run();
-      }
-      return () => value.remove(cron);
-    },
-    
-    remove(cron) {
-      const index = items.indexOf(cron);
-      if (index !== -1) {
-        // 自动停止
-        if (cron.running) {
-          cron.stop();
+  }> {
+    return this.items.map(cron => {
+      // 从 pluginItems 中找到对应的插件名
+      let pluginName = 'unknown';
+      for (const [name, items] of this.pluginItems) {
+        if (items.includes(cron)) {
+          pluginName = name;
+          break;
         }
-        items.splice(index, 1);
-        byName.delete(cron.id || cron.cronExpression);
-        pluginMap.delete(cron);
-        return true;
       }
-      return false;
-    },
-    
-    get(id) {
-      return byName.get(id);
-    },
-    
-    stopAll() {
-      for (const cron of items) {
-        if (cron.running) {
-          cron.stop();
-        }
-      }
-    },
-    
-    startAll() {
-      for (const cron of items) {
-        if (!cron.running && !cron.disposed) {
-          cron.run();
-        }
-      }
-    },
-    
-    getStatus() {
-      return items.map(cron => ({
+      return {
         expression: cron.cronExpression,
         running: cron.running,
         nextExecution: cron.running ? cron.getNextExecutionTime() : null,
-        plugin: pluginMap.get(cron) || 'unknown',
-      }));
-    }
-  };
-  
-  return {
-    name: 'cron',
-    description: '定时任务服务',
-    value,
-    
-    dispose() {
-      value.stopAll();
-    },
-    
-    extensions: {
+        plugin: pluginName,
+      };
+    });
+  }
+
+  /**
+   * 生命周期: 销毁时停止所有任务
+   */
+  dispose(): void {
+    this.stopAll();
+  }
+
+  /**
+   * 序列化为 JSON
+   */
+  toJSON(pluginName?: string): FeatureJSON {
+    const list = pluginName ? this.getByPlugin(pluginName) : this.items;
+    return {
+      name: this.name,
+      icon: this.icon,
+      desc: this.desc,
+      count: list.length,
+      items: list.map(c => ({
+        expression: c.cronExpression,
+        running: c.running,
+      })),
+    };
+  }
+
+  /**
+   * 提供给 Plugin.prototype 的扩展方法
+   */
+  get extensions() {
+    const feature = this;
+    return {
       addCron(cron: Cron) {
         const plugin = getPlugin();
-        const dispose = value.add(cron, plugin.name);
+        const dispose = feature.add(cron, plugin.name);
+        plugin.recordFeatureContribution(feature.name, cron.id || cron.cronExpression);
         plugin.onDispose(dispose);
         return dispose;
-      }
-    }
-  };
+      },
+    };
+  }
 }
-

package/src/built/database.ts

@@ -1,38 +1,133 @@
-import { Registry,Definition,Databases,Database } from "@zhin.js/database";
-import { DatabaseConfig,Models } from "../types.js";
-import { defineContext,Plugin } from "../plugin.js";
+/**
+ * DatabaseFeature
+ * 数据库服务，管理数据模型定义，继承自 Feature 抽象类
+ */
+import { Registry, Definition, Databases, Database } from "@zhin.js/database";
+import { DatabaseConfig, Models } from "../types.js";
+import { Feature, FeatureJSON } from "../feature.js";
+import { Plugin, getPlugin } from "../plugin.js";
 import { SystemLogDefinition } from "../models/system-log.js";
 import { UserDefinition } from "../models/user.js";
-declare module "../plugin" {
-    namespace Plugin {
-        interface Extensions {
-            defineModel<K extends keyof Models>(name: K, definition: Definition<Models[K]>): void;
-        }
-        interface Contexts {
-            database: Database<any,Models,any>;
-        }
+
+/**
+ * 模型定义记录
+ */
+export interface ModelRecord {
+  name: string;
+  definition: Definition<any>;
+}
+
+declare module "../plugin.js" {
+  namespace Plugin {
+    interface Extensions {
+      defineModel<K extends keyof Models>(name: K, definition: Definition<Models[K]>): void;
+    }
+    interface Contexts {
+      database: DatabaseFeature;
     }
+  }
 }
-export function defineDatabaseService<K extends keyof Databases>(config: DatabaseConfig<K>) {
-    const db = Registry.create<Models,K>(config.dialect, config,{
-        SystemLog: SystemLogDefinition,
-        User: UserDefinition,
+
+export class DatabaseFeature extends Feature<ModelRecord> {
+  readonly name = 'database' as const;
+  readonly icon = 'Database';
+  readonly desc = '数据模型';
+
+  /** 内部数据库实例 */
+  readonly db: Database<any, Models, any>;
+
+  /** 按模型名索引 */
+  readonly byName = new Map<string, ModelRecord>();
+
+  constructor(config: DatabaseConfig) {
+    super();
+    this.db = Registry.create<Models, keyof Databases>(config.dialect, config, {
+      SystemLog: SystemLogDefinition,
+      User: UserDefinition,
     });
-    return defineContext({
-        name: 'database',
-        description: '数据库服务',
-        mounted: async () => {
-            await db.start();
-            return db;
-        },
-        dispose: async () => {
-            await db.stop();
-        },
-        extensions: {
-            defineModel<K extends keyof Models>(this:Plugin,name: K, definition: Definition<Models[K]>) {
-                db.define(name, definition);
-                this.logger.debug(`Model "${String(name)}" defined by plugin "${this.name}"`);
-            }
-        },
-    });
-}
+  }
+
+  // ====================================================================
+  // 向后兼容代理：旧代码 inject('database').xxx 可直接使用
+  // ====================================================================
+
+  get models() {
+    return this.db.models;
+  }
+
+  define<K extends keyof Models>(name: K, definition: Definition<Models[K]>) {
+    return this.db.define(name, definition);
+  }
+
+  start() {
+    return this.db.start();
+  }
+
+  stop() {
+    return this.db.stop();
+  }
+
+  /**
+   * 添加模型定义
+   */
+  add(record: ModelRecord, pluginName: string): () => void {
+    this.db.define(record.name as keyof Models, record.definition);
+    this.byName.set(record.name, record);
+    return super.add(record, pluginName);
+  }
+
+  /**
+   * 移除模型定义
+   */
+  remove(record: ModelRecord): boolean {
+    this.byName.delete(record.name);
+    return super.remove(record);
+  }
+
+  /**
+   * 生命周期: 启动数据库
+   */
+  async mounted(plugin: Plugin): Promise<void> {
+    plugin.logger.info('Database service started');
+    await this.db.start();
+  }
+
+  /**
+   * 生命周期: 停止数据库
+   */
+  async dispose(): Promise<void> {
+    await this.db.stop();
+  }
+
+  /**
+   * 序列化为 JSON
+   */
+  toJSON(pluginName?: string): FeatureJSON {
+    const list = pluginName ? this.getByPlugin(pluginName) : this.items;
+    return {
+      name: this.name,
+      icon: this.icon,
+      desc: this.desc,
+      count: list.length,
+      items: list.map(r => ({
+        name: r.name,
+      })),
+    };
+  }
+
+  /**
+   * 提供给 Plugin.prototype 的扩展方法
+   */
+  get extensions() {
+    const feature = this;
+    return {
+      defineModel<K extends keyof Models>(name: K, definition: Definition<Models[K]>) {
+        const plugin = getPlugin();
+        const record: ModelRecord = { name: name as string, definition };
+        const dispose = feature.add(record, plugin.name);
+        plugin.recordFeatureContribution(feature.name, name as string);
+        plugin.onDispose(dispose);
+      },
+    };
+  }
+}