@zhin.js/core 1.0.0 → 1.0.2

package/src/schema.ts

@@ -0,0 +1,273 @@
+import { isEmpty } from './utils.js';
+
+export class Schema<S = any, T = S> {
+    public [Symbol.toStringTag] = 'Schema';
+    constructor(
+        public meta: Schema.Meta<S, T>,
+        public options: Schema.Options = {},
+    ) {
+        const _this = this;
+        const schema = function (value?: S) {
+            const formatter = Schema.resolve(_this.meta.type);
+            if (!formatter) throw new Error(`type ${_this.meta.type} not found`);
+            return formatter.call(_this, value);
+        } as Schema<S, T>;
+        return new Proxy(schema, {
+            get(target, p: string | symbol, receiver: any): any {
+                return Reflect.get(_this, p, receiver);
+            },
+            set(target, p: string | symbol, value: any, receiver: any): boolean {
+                return Reflect.set(_this, p, value, receiver);
+            },
+        });
+    }
+    static fromJSON<S, T>(json: Schema.JSON<S, T>) {
+        const { object, inner, list, ...meta } = json;
+        const options: Schema.Options = {};
+        if (object)
+            options.object = Object.fromEntries(Object.entries(object).map(([key, value]) => [key, Schema.fromJSON(value)]));
+        if (inner) options.inner = Schema.fromJSON(inner);
+        return new Schema<S, T>(meta, options);
+    }
+    toJSON(): Record<string, any> {
+        return Object.fromEntries(
+            Object.entries({
+                ...this.meta,
+                default: typeof this.meta.default === 'function' ? this.meta.default() : this.meta.default,
+                inner: this.options.inner?.toJSON(),
+                dict: this.options.object
+                    ? Object.fromEntries(Object.entries(this.options.object || {}).map(([key, value]) => [key, value.toJSON()]))
+                    : undefined,
+            }).filter(([key, value]) => typeof value !== 'undefined'),
+        );
+    }
+    [Symbol.unscopables]() {
+        return {
+            options: true,
+            meta: true,
+        };
+    }
+    /** 设置是否必填 */
+    required(): this {
+        this.meta.required = true;
+        return this;
+    }
+    /** 是否隐藏 */
+    hidden(): this {
+        this.meta.hidden = true;
+        return this;
+    }
+    /** 设置描述 */
+    description(description: string): this {
+        this.meta.description = description;
+        return this;
+    }
+    /** 设置默认值 */
+    default(defaultValue: T): this {
+        this.meta.default = defaultValue;
+        return this;
+    }
+    /** 设置选项列表 */
+    option(list: (T | Schema.Option<T>)[]): this {
+        this.meta.options = Schema.formatOptionList(list);
+        return this;
+    }
+    /** 设置是否允许多选 */
+    multiple(): this {
+        if (this.meta.type !== 'list') throw new Error('multiple only support list type');
+        this.meta.multiple = true;
+        return this;
+    }
+    /** 声明一个数字类型 */
+    static number(description: string): Schema<number> {
+        return new Schema<number>({ type: 'number', description });
+    }
+    /** 声明一个字符串类型 */
+    static string(description: string): Schema<string> {
+        return new Schema<string>({ type: 'string', description });
+    }
+    /** 声明一个布尔类型 */
+    static boolean(description: string): Schema<boolean> {
+        return new Schema<boolean>({ type: 'boolean', description });
+    }
+    /** 声明一个正则类型 */
+    static regexp(description: string) {
+        return new Schema<RegExp | string, RegExp>({ type: 'regexp', description });
+    }
+    /** 声明一个日期类型 */
+    static date(description: string) {
+        return new Schema<Date | number, Date>({ type: 'date', description });
+    }
+    /** 声明一个字典类型 */
+    static dict<X extends Schema>(input: X, description: string) {
+        return new Schema<Record<string, Schema.Types<X>>>({ type: 'dict', description }, { inner: input });
+    }
+    static object<X extends Record<string, Schema>>(input: X, description: string = '') {
+        return new Schema<Schema.RecordTypes<X>>({ type: 'object', description }, { object: input });
+    }
+    /** 声明一个列表类型 */
+    static list<X extends Schema>(inner: X, description: string) {
+        return new Schema<Schema.Types<X>[]>({ type: 'list', description }, { inner });
+    }
+    /** 声明一个常量 */
+    static const<X extends string | number | boolean>(value: X, description: string) {
+        return new Schema<X>({ type: 'const', default: value as any, description });
+    }
+    static resolve<T extends string>(type: T): Schema.Formatter {
+        return Schema.formatters.get(type)!;
+    }
+    static extend<T extends string>(type: T, formatter: Schema.Formatter) {
+        Schema.formatters.set(type, formatter);
+    }
+}
+export interface Schema<S = any> {
+    (value?: S): S;
+}
+export namespace Schema {
+    export const formatters: Map<string, Formatter> = new Map<string, Formatter>();
+    export type Formatter<S = any, T = S> = (this: Schema, value: S) => T;
+    export type JSON<S = any, T = S> = Meta<S, T> & {
+        object?: Record<string, JSON>;
+        inner?: JSON;
+        list?: JSON[];
+    };
+    export interface Meta<S = any, T = S> {
+        hidden?: boolean;
+        type: string;
+        default?: T;
+        required?: boolean;
+        options?: Option<T>[];
+        multiple?: boolean;
+        description: string;
+        component?: string;
+        min?: number;
+        max?: number;
+        step?: number;
+    }
+    export interface Options {
+        object?: Record<string, Schema>;
+        inner?: Schema;
+    }
+    export type Types<T> = T extends Schema<infer S> ? S : never;
+    export type RecordTypes<T> = T extends Record<string, Schema>
+        ? {
+            [K in keyof T]?: Types<T[K]>;
+        }
+        : unknown;
+    export function checkDefault<T>(schema: Schema, value: T, fallback: T = value) {
+        if (isEmpty(value)) {
+            value = schema.meta.default || fallback;
+        }
+        const validateType = (schema: Schema, value: any) => {
+            switch (schema.meta.type) {
+                case 'string':
+                    if (!['string', 'undefined'].includes(typeof value)) throw new TypeError(`value is not a string`);
+                    break;
+                case 'number':
+                    if (!['number', 'undefined'].includes(typeof value)) throw new TypeError(`value is not a number`);
+                    break;
+                case 'boolean':
+                    if (!['boolean', 'undefined'].includes(typeof value)) throw new TypeError(`value is not a boolean`);
+                    break;
+                case 'regexp':
+                    if (!['string', 'undefined'].includes(typeof value) && !(value instanceof RegExp))
+                        throw new TypeError(`value is not a RegExp|string`);
+                    break;
+                case 'date':
+                    if (!['number', 'undefined'].includes(typeof value) && !(value instanceof Date))
+                        throw new TypeError(`value is not a Date|number`);
+                    if (value instanceof Date && isNaN(value.getTime())) throw new TypeError(`value is not a valid Date`);
+                    break;
+                case 'dict':
+                    if (!['object', 'undefined', 'null'].includes(typeof value)) throw new TypeError(`value is not a object`);
+                    break;
+                case 'object':
+                    if (!['object', 'undefined', 'null'].includes(typeof value)) throw new TypeError(`value is not a object`);
+                    break;
+                case 'list':
+                    if (typeof value !== 'undefined' && !Array.isArray(value)) throw new TypeError(`value is not a list`);
+                    break;
+                case 'const':
+                    if (typeof value !== 'undefined' && value !== schema.meta.default) throw new TypeError(`value is not const`);
+                    break;
+                default:
+                    throw new TypeError(`value is not a valid type`);
+            }
+        };
+        if (schema.meta.required && typeof value === 'undefined') throw new Error(`value is required`);
+        validateType(schema, value);
+        return value;
+    }
+    export type Option<T = any> = {
+        label: string;
+        value: T;
+    };
+    export function formatOptionList<T extends (any | Schema.Option)[]>(list: T): Schema.Option[] {
+        return list.map(item => {
+            if (typeof item === 'string') {
+                return {
+                    label: `${item}`,
+                    value: item,
+                } as Schema.Option;
+            }
+            return item as unknown as Schema.Option;
+        });
+    }
+}
+Schema.extend('number', function (this: Schema, value: any) {
+    value = Schema.checkDefault(this, value);
+    return value;
+});
+Schema.extend('string', function (this: Schema, value: any) {
+    value = Schema.checkDefault(this, value);
+    return value;
+});
+Schema.extend('boolean', function (this: Schema, value: any) {
+    return Schema.checkDefault(this, value);
+});
+Schema.extend('dict', function (this: Schema, value: any) {
+    value = Schema.checkDefault(this, value, {});
+    return Object.fromEntries(
+        Object.entries(value).map(([key, schema]) => {
+            return [key, this.options.inner!(schema)];
+        }),
+    );
+});
+
+Schema.extend('object', function (this: Schema, value: any) {
+    const getDefault = (schema: Schema) => {
+        const result = Object.create(null);
+        for (const key in schema.options.object) {
+            result[key] = getDefault(schema.options.object[key]);
+        }
+        return result;
+    };
+    value = Schema.checkDefault(this, value, getDefault(this));
+    return Object.fromEntries(
+        Object.entries(value).map(([key, schema]) => {
+            return [key, this.options.object![key](schema)];
+        }),
+    );
+});
+Schema.extend('list', function (this: Schema, value: any) {
+    value = Schema.checkDefault(this, value, []);
+    return value.map((item: any) => this.options.inner!(item));
+});
+Schema.extend('regexp', function (this: Schema, value: any) {
+    value = Schema.checkDefault(this, value);
+    if (typeof value === 'string') {
+        return new RegExp(value);
+    }
+    return value;
+});
+Schema.extend('date', function (this: Schema, value: any) {
+    value = Schema.checkDefault(this, value);
+    return new Date(value);
+});
+Schema.extend('const', function (this: Schema, value: any) {
+    value = Schema.checkDefault(this, value);
+    if (value !== this.meta.default) {
+        throw new Error('const value not match');
+    }
+    return value;
+});

package/src/types-generator.ts

@@ -1,6 +1,8 @@
 import fs from 'node:fs';
 import path from 'node:path';
-import { logger } from './logger.js';
+import { getLogger } from '@zhin.js/logger';
+
+const logger = getLogger('TypesGenerator');
 
 /**
  * 更新 tsconfig.json 的类型声明
@@ -48,7 +50,7 @@ export async function generateEnvTypes(cwd: string): Promise<void> {
             try {
                 tsconfig = JSON.parse(fs.readFileSync(tsconfigPath, 'utf-8'));
             } catch (err) {
-                console.error(err)
+                // console.error 已替换为注释
                 logger.warn('⚠️ Failed to parse tsconfig.json, creating new one');
             }
         }
@@ -69,6 +71,8 @@ export async function generateEnvTypes(cwd: string): Promise<void> {
         fs.writeFileSync(tsconfigPath, JSON.stringify(tsconfig, null, 2), 'utf-8');
         logger.info('✅ Updated TypeScript types configuration');
     } catch (error) {
-        logger.warn('⚠️ Failed to update TypeScript types:', error);
+        logger.warn('⚠️ Failed to update TypeScript types', { 
+            error: error instanceof Error ? error.message : String(error) 
+        });
     }
 }

package/src/types.ts

@@ -1,36 +1,81 @@
 import {MaybePromise}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";
 
-export interface MessageSegment<T extends keyof Segment=keyof Segment> {
-  type: T;
-  data: Segment[T];
+/**
+ * 类型定义文件：包含适配器、消息、数据库、配置等核心类型声明。
+ * 协作者可通过本文件了解各主要数据结构的用途与关系。
+ */
+declare module '@zhin.js/types'{
+  interface GlobalContext extends RegisteredAdapters{}
 }
-export interface Segment{
-  [key:string]:Record<string, any>
-  any:Record<string, any>
+/**
+ * 所有已注册适配器的类型映射（key为适配器名，value为Adapter实例）
+ */
+export interface RegisteredAdapters extends Record<string, Adapter>{}
+/**
+ * 数据库配置类型，支持多种数据库驱动
+ */
+export type DatabaseConfig<T extends keyof Databases=keyof Databases>={
+  dialect:T
+} & Registry.Config<Databases[T]>
+/**
+ * 获取对象所有value类型
+ */
+export type ObjectItem<T extends object>=T[keyof T]
+/**
+ * 已注册适配器名类型
+ */
+export type RegisteredAdapter=keyof RegisteredAdapters
+/**
+ * 指定适配器的消息类型
+ */
+export type AdapterMessage<T extends keyof RegisteredAdapters=keyof RegisteredAdapters>=RegisteredAdapters[T] extends Adapter<infer R>?BotMessage<R>:{}
+/**
+ * 指定适配器的配置类型
+ */
+export type AdapterConfig<T extends keyof RegisteredAdapters=keyof RegisteredAdapters>=RegisteredAdapters[T] extends Adapter<infer R>?PlatformConfig<R>:BotConfig
+/**
+ * Bot实例的配置类型
+ */
+export type PlatformConfig<T>=T extends Bot<infer L,infer R>?R:BotConfig
+/**
+ * Bot实例的消息类型
+ */
+export type BotMessage<T extends Bot>=T extends Bot<infer R>?R:{}
+/**
+ * 消息段结构，支持 text/image/at/face 等类型
+ */
+export interface MessageSegment {
+  type: string;
+  data: Record<string, any>;
 }
+export type MessageElement=MessageSegment|MessageComponent<any>
+/**
+ * 单个或数组类型
+ */
 export type MaybeArray<T>=T|T[]
-export type SendContent=MaybeArray<string|MessageSegment>
+/**
+ * 消息发送内容类型
+ */
+export type SendContent=MaybeArray<string|MessageElement>
+/**
+ * 消息发送者信息
+ */
 export interface MessageSender{
   id: string;
   name?: string;
 }
-export type MessageComponent<T extends object>=(props:T&{children:SendContent})=>MaybePromise<SendContent>
-export interface MessageChannel{
-  id: string;
-  type: 'group' | 'private' | 'channel';
-}
-export interface Message {
-  id: string;
-  adapter:string
-  bot:string
-  content: MessageSegment[];
-  sender: MessageSender;
-  reply(content:SendContent,quote?:boolean|string):Promise<void>
-  channel: MessageChannel;
-  timestamp: number;
-  raw: string;
-}
-
+/**
+ * 通用字典类型
+ */
+export type Dict<V=any,K extends string|symbol=string>=Record<K, V>;
+/**
+ * 用户信息结构
+ */
 export interface User {
   user_id: string;
   nickname: string;
@@ -38,23 +83,24 @@ export interface User {
   role?: string;
 }
 
+/**
+ * 群组信息结构
+ */
 export interface Group {
   group_id: string;
   group_name: string;
   member_count: number;
 }
 
-export interface BotConfig {
-  name: string;
-  context: string;
-  [key: string]: any;
-}
-
-
 
+/**
+ * App配置类型，涵盖机器人、数据库、插件、调试等
+ */
 export interface AppConfig {
   /** 机器人配置列表 */
   bots?: BotConfig[];
+  /** 数据库配置列表 */
+  database?: DatabaseConfig;
   /** 插件目录列表，默认为 ['./plugins', 'node_modules'] */
   plugin_dirs?: string[];
   /** 需要加载的插件列表 */
@@ -64,6 +110,9 @@ export interface AppConfig {
   /** 是否启用调试模式 */
   debug?: boolean;
 }
+/**
+ * defineConfig辅助类型，支持函数式/对象式配置
+ */
 export type DefineConfig<T> = T | ((env:Record<string,string>)=>MaybePromise<T>);
 
 export interface SendOptions extends MessageChannel{