@zhin.js/core 1.0.17 → 1.0.18

package/src/built/cron.ts

@@ -0,0 +1,140 @@
+/**
+ * Cron Context
+ * 管理所有插件注册的定时任务
+ */
+import { Cron } from "../cron.js";
+import { Context, Plugin, getPlugin } from "../plugin.js";
+
+/**
+ * CronContext 扩展方法类型
+ */
+export interface CronContextExtensions {
+  /** 添加定时任务 */
+  addCron(cron: Cron): () => void;
+}
+
+// 扩展 Plugin 接口
+declare module "../plugin.js" {
+  namespace Plugin {
+    interface Extensions extends CronContextExtensions {}
+    interface Contexts {
+      cron: CronService;
+    }
+  }
+}
+
+/**
+ * 定时任务服务数据
+ */
+export interface CronService {
+  /** 任务列表 */
+  readonly items: Cron[];
+  /** 按 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;
+  /** 获取状态 */
+  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();
+        }
+        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 => ({
+        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: {
+      addCron(cron: Cron) {
+        const plugin = getPlugin();
+        const dispose = value.add(cron, plugin.name);
+        plugin.onDispose(dispose);
+        return dispose;
+      }
+    }
+  };
+}
+

package/src/built/database.ts

@@ -0,0 +1,38 @@
+import { Registry,Definition,Databases,Database } from "@zhin.js/database";
+import { DatabaseConfig,Models } from "../types.js";
+import { defineContext,Plugin } 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 function defineDatabaseService<K extends keyof Databases>(config: DatabaseConfig<K>) {
+    const db = Registry.create<Models,K>(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}"`);
+            }
+        },
+    });
+}

package/src/{permissions.ts → built/permission.ts}

@@ -1,15 +1,11 @@
-import { MaybePromise } from "@zhin.js/types";
-import { RegisteredAdapter } from "./types.js";
-import { Message } from "./message.js";
-import { AdapterMessage } from "./types.js";
-import { App } from "./app.js";
+import { MaybePromise, RegisteredAdapter, Message, AdapterMessage } from "@zhin.js/core";
 export type PermissionItem<T extends RegisteredAdapter = RegisteredAdapter> = {
     name: string | RegExp
     check: PermissionChecker<T>
 }
 export type PermissionChecker<T extends RegisteredAdapter = RegisteredAdapter> = (name: string, message: Message<AdapterMessage<T>>) => MaybePromise<boolean>
-export class Permissions extends Array<PermissionItem>{
-    constructor(private readonly app: App) {
+export class PermissionService extends Array<PermissionItem>{
+    constructor() {
         super();
         this.add(Permissions.define(/^adapter\([^)]+\)$/, (name, message) => {
             return message.$adapter === name.replace(/^adapter\(([^)]+)\)$/, '$1');
@@ -48,11 +44,12 @@ export class Permissions extends Array<PermissionItem>{
     add(permission: PermissionItem) {
         this.push(permission);
     }
-    get(name: string): PermissionItem | undefined {
-        return this.app.dependencyList.reduce((result,dep)=>{
-            result.push(...dep.permissions)
-            return result;
-        },[...this]).find(p => new RegExp(p.name).test(name));
+    async check(name: string, message: Message<AdapterMessage<RegisteredAdapter>>):Promise<boolean> {
+        for(const permission of this){
+            const passed=await permission.check(name,message);
+            if(passed) return true;
+        }
+        return false;
     }
 }
 export namespace Permissions{

package/src/command.ts

@@ -1,22 +1,20 @@
 import {MatchResult, SegmentMatcher} from "segment-matcher";
 import {AdapterMessage, SendContent} from "./types.js";
-import {RegisteredAdapters} from "@zhin.js/types";
+import {RegisteredAdapter} from "./types.js";
 import type {Message} from "./message.js";
-import {MaybePromise} from "@zhin.js/types";
-import { ZhinError } from "./errors.js";
-import { App } from "./app.js";
+import {MaybePromise} from "./types.js";
+import {Plugin} from "./plugin.js";
 
 /**
  * MessageCommand类：命令系统核心，基于segment-matcher实现。
  * 支持多平台命令注册、作用域限制、参数解析、异步处理等。
  */
-export class MessageCommand<T extends keyof RegisteredAdapters=keyof RegisteredAdapters> extends SegmentMatcher{
+export class MessageCommand<T extends RegisteredAdapter=RegisteredAdapter> extends SegmentMatcher{
     #callbacks:MessageCommand.Callback<T>[]=[];
     #desc:string[]=[];
     #usage:string[]=[];
     #examples:string[]=[];
     #permissions:string[]=[];
-    #checkers:MessageCommand.Checker<T>[]=[]
     get helpInfo():MessageCommand.HelpInfo{
         return {
             pattern: this.pattern,
@@ -63,18 +61,11 @@ export class MessageCommand<T extends keyof RegisteredAdapters=keyof RegisteredA
      * @param plugin 插件实例
      * @returns 命令返回内容或undefined
      */
-    async handle(message:Message<AdapterMessage<T>>,app:App):Promise<SendContent|undefined>{
-        for(const permission of this.#permissions){
-            const permit=app.permissions.get(permission)
-            if(!permit) {
-                throw new ZhinError(`权限 ${permission} 不存在`)
-            }
-            const result=await permit.check(permission,message)
-            if(!result) return;
-        }
-        for(const check of this.#checkers){
-            const result=await check(message)
-            if(!result) return;
+    async handle(message:Message<AdapterMessage<T>>,plugin:Plugin):Promise<SendContent|undefined>{
+        const auth = plugin.contextIsReady('permission') ? plugin.inject('permission') : null
+        for(const permit of this.#permissions){
+            const passed=await auth?.check(permit,message)
+            if(!passed) return;
         }
         const matched=this.match(message.$content);
         if(!matched) return
@@ -85,8 +76,8 @@ export class MessageCommand<T extends keyof RegisteredAdapters=keyof RegisteredA
     }
 }
 export namespace MessageCommand{
-    export type Callback<T extends keyof RegisteredAdapters>=(message:Message<AdapterMessage<T>>,result:MatchResult)=>SendContent|undefined|Promise<SendContent|undefined>;
-    export type Checker<T extends keyof RegisteredAdapters>=(message:Message<AdapterMessage<T>>)=>MaybePromise<boolean>
+    export type Callback<T extends RegisteredAdapter>=(message:Message<AdapterMessage<T>>,result:MatchResult)=>SendContent|undefined|Promise<SendContent|undefined>;
+    export type Checker<T extends RegisteredAdapter>=(message:Message<AdapterMessage<T>>)=>MaybePromise<boolean>
     export type HelpInfo={
         pattern:string;
         desc:string[];

package/src/component.ts

@@ -1,6 +1,5 @@
 import { getValueWithRuntime, compiler, segment } from './utils.js';
 import { Dict, SendContent, SendOptions, MessageElement } from './types.js';
-import { Message } from "./message.js";
 
 // 组件匹配符号
 export const CapWithChild = Symbol('CapWithChild');

package/src/cron.ts

@@ -6,6 +6,7 @@ import { Cron as Croner } from 'croner';
  */
 export class Cron {
   private job: Croner | null = null;
+  id:string = '';
   private callback: () => void | Promise<void>;
   private isDisposed = false;
   private _cronExpression: string;
@@ -16,6 +17,7 @@ export class Cron {
    * @param callback - 要执行的回调函数
    */
   constructor(cronExpression: string, callback: () => void | Promise<void>) {
+    this.id=Math.random().toString(36).substring(2, 10);
     try {
       this._cronExpression = cronExpression;
       this.callback = callback;

package/src/index.ts

@@ -1,18 +1,28 @@
 // Core exports
-export * from './app.js'
 export * from './bot.js'
 export * from './plugin.js'
 export * from './command.js'
 export * from './component.js'
 export * from './adapter.js'
-export * from './config.js'
 export * from './message.js'
-// Logger moved to @zhin.js/logger package
+export * from './prompt.js'
+// Models
+export * from './models/system-log.js'
+export * from './models/user.js'
+// Built-in Contexts
+export * from './built/config.js'
+export * from './built/command.js'
+export * from './built/cron.js'
+export * from './built/permission.js'
+export * from './built/adapter-process.js'
+export * from './built/component.js'
+export * from './built/database.js'
+
 export * from './types.js'
 export * from './utils.js'
 export * from './errors.js'  // 导出错误处理系统
 export * from './cron.js'
 export * from '@zhin.js/database'
 export * from '@zhin.js/logger'
-
-export { Dependency, Schema, usePerformanceMonitor } from '@zhin.js/hmr'
+// 只导出 Schema 类，避免与 utils.js 的 isEmpty 冲突
+export { Schema } from '@zhin.js/schema'

package/src/message.ts

@@ -1,4 +1,4 @@
-import {MessageElement, MessageSender, SendContent} from "./types";
+import {MessageElement, MessageSender, RegisteredAdapter, SendContent} from "./types";
 import { Component } from "./component.js";
 
 /**
@@ -24,7 +24,7 @@ export type MessageType = 'group' | 'private' | 'channel'
  */
 export interface MessageBase {
     $id: string;
-    $adapter:string
+    $adapter:RegisteredAdapter
     $bot:string
     $content: MessageElement[];
     $sender: MessageSender;