imodel 0.5.1 → 0.6.0

package/index.d.mts

@@ -1,5 +1,5 @@
 /*!
- * imodel v0.5.1
+ * imodel v0.6.0
  * (c) 2019-2025 undefined
  * @license undefined
  */
@@ -686,7 +686,17 @@ interface IndexInfo extends IndexOptions {
 interface Index extends IndexInfo {
     name: string;
 }
-interface TableDefine<T extends Fields = Fields, TT extends string | VirtualTable | void = string | VirtualTable | void> {
+interface Hooks<T extends Record<string, any> = Record<string, any>> {
+    beforeCreateMany(conn: Connection, records: Record<string, any>[]): PromiseLike<void | Record<string, any>[]> | void | Record<string, any>[];
+    afterCreateMany(conn: Connection, records: Record<string, any>[]): PromiseLike<void> | void;
+    beforeCreate(conn: Connection, record: Record<string, any>): PromiseLike<void | Record<string, any>> | void | Record<string, any>;
+    afterCreate(conn: Connection, record: Record<string, any>): PromiseLike<void> | void;
+    beforeUpdate(conn: Connection, record: Record<string, any>, set: Record<string, any>): PromiseLike<void | Record<string, any>> | void | Record<string, any>;
+    afterUpdate(conn: Connection, record: Record<string, any>, oldRecord: Record<string, any>): PromiseLike<void> | void;
+    beforeDelete(conn: Connection, record: T, update: Record<string, any> | null): PromiseLike<void> | void;
+    afterDelete(conn: Connection, record: T, update: Record<string, any> | null): PromiseLike<void> | void;
+}
+interface TableDefine<T extends Fields = Fields, TT extends string | VirtualTable | undefined = string | VirtualTable | undefined> {
     /** 字段信息 */
     readonly fields: T;
     /** 表名 */
@@ -695,6 +705,8 @@ interface TableDefine<T extends Fields = Fields, TT extends string | VirtualTabl
     readonly pseudo?: string;
     /** 索引信息 */
     readonly indexes?: readonly IndexInfo[];
+    /** 钩子 */
+    readonly hooks?: Partial<Hooks>;
 }
 
 type deleted = typeof deleted;
@@ -863,7 +875,7 @@ interface Save {
 }
 declare const Create: unique symbol;
 interface Create<T = unknown> {
-    [Create](connection: Connection, data: object, run: (data: any) => Promise<object>, table: TableDefine): PromiseLike<T>;
+    [Create](connection: Connection, data: object, run: (data: any, that: any) => Promise<object>, table: TableDefine): PromiseLike<T>;
 }
 declare const Build: unique symbol;
 interface Build<T = unknown> {
@@ -1549,7 +1561,7 @@ declare function defaultValue<T>(value: T): FieldDecorator<T>;
  * @param {string} table
  * @returns {ClassDecorator}
  */
-declare function submodel(table: string): ClassDecorator;
+declare function model(table: string): ClassDecorator;
 /**
  * @template {Record<string, any>} T
  * @overload
@@ -1559,7 +1571,7 @@ declare function submodel(table: string): ClassDecorator;
  * @param {FieldDefineOption} [options]
  * @returns {FieldDecorator<T[]>}
  */
-declare function submodel<T extends Record<string, any>>(type: TableDefine & {
+declare function model<T extends Record<string, any>>(type: TableDefine & {
     new (...a: any): T;
 }, constraints: Record<string, Constraint>, array: true, options?: FieldDefineOption | undefined): FieldDecorator<T[]>;
 /**
@@ -1571,7 +1583,7 @@ declare function submodel<T extends Record<string, any>>(type: TableDefine & {
  * @param {FieldDefineOption} [options]
  * @returns {FieldDecorator<T>}
  */
-declare function submodel<T extends Record<string, any>>(type: TableDefine & {
+declare function model<T extends Record<string, any>>(type: TableDefine & {
     new (...a: any): T;
 }, constraints: Record<string, Constraint>, array?: false | undefined, options?: FieldDefineOption | undefined): FieldDecorator<T>;
 /**
@@ -1582,7 +1594,7 @@ declare function submodel<T extends Record<string, any>>(type: TableDefine & {
  * @param {FieldDefineOption} [options]
  * @returns {FieldDecorator<T>}
  */
-declare function submodel<T extends Record<string, any>>(type: TableDefine & {
+declare function model<T extends Record<string, any>>(type: TableDefine & {
     new (...a: any): T;
 }, constraints: Record<string, Constraint>, options?: FieldDefineOption | undefined): FieldDecorator<T>;
 /**
@@ -1595,7 +1607,7 @@ declare function submodel<T extends Record<string, any>>(type: TableDefine & {
  * @param {FieldDefineOption} [options]
  * @returns {FieldDecorator<A extends false ? T : A extends true ? T[] : T | T[]>}
  */
-declare function submodel<T extends Record<string, any>, A extends boolean = boolean>(type: TableDefine & {
+declare function model<T extends Record<string, any>, A extends boolean = boolean>(type: TableDefine & {
     new (...a: any): T;
 }, constraints: Record<string, Constraint>, array: A, options?: FieldDefineOption | undefined): FieldDecorator<A extends false ? T : A extends true ? T[] : T | T[]>;
 /**
@@ -1607,7 +1619,7 @@ declare function submodel<T extends Record<string, any>, A extends boolean = boo
  * @param {FieldDefineOption} [options]
  * @returns {FieldDecorator<T[]>}
  */
-declare function submodel<T extends Record<string, any>>(type: TableDefine, constraints: Record<string, Constraint>, array: true, options?: FieldDefineOption | undefined): FieldDecorator<T[]>;
+declare function model<T extends Record<string, any>>(type: TableDefine, constraints: Record<string, Constraint>, array: true, options?: FieldDefineOption | undefined): FieldDecorator<T[]>;
 /**
  * @template {object} T
  * @overload
@@ -1617,7 +1629,7 @@ declare function submodel<T extends Record<string, any>>(type: TableDefine, cons
  * @param {FieldDefineOption} [options]
  * @returns {FieldDecorator<T>}
  */
-declare function submodel<T extends Record<string, any>>(type: TableDefine, constraints: Record<string, Constraint>, array?: false | undefined, options?: FieldDefineOption | undefined): FieldDecorator<T>;
+declare function model<T extends Record<string, any>>(type: TableDefine, constraints: Record<string, Constraint>, array?: false | undefined, options?: FieldDefineOption | undefined): FieldDecorator<T>;
 /**
  * @template {object} T
  * @overload
@@ -1626,7 +1638,7 @@ declare function submodel<T extends Record<string, any>>(type: TableDefine, cons
  * @param {FieldDefineOption} [options]
  * @returns {FieldDecorator<T>}
  */
-declare function submodel<T extends Record<string, any>>(type: TableDefine, constraints: Record<string, Constraint>, options?: FieldDefineOption | undefined): FieldDecorator<T>;
+declare function model<T extends Record<string, any>>(type: TableDefine, constraints: Record<string, Constraint>, options?: FieldDefineOption | undefined): FieldDecorator<T>;
 /**
  * @template {object} T
  * @template {boolean} [A=boolean]
@@ -1637,7 +1649,7 @@ declare function submodel<T extends Record<string, any>>(type: TableDefine, cons
  * @param {FieldDefineOption} [options]
  * @returns {FieldDecorator<A extends false ? T :A extends true ? T[] : T | T[]>}
  */
-declare function submodel<T extends Record<string, any>, A extends boolean = boolean>(type: TableDefine, constraints: Record<string, Constraint>, array: A, options?: FieldDefineOption | undefined): FieldDecorator<A extends false ? T : A extends true ? T[] : T | T[]>;
+declare function model<T extends Record<string, any>, A extends boolean = boolean>(type: TableDefine, constraints: Record<string, Constraint>, array: A, options?: FieldDefineOption | undefined): FieldDecorator<A extends false ? T : A extends true ? T[] : T | T[]>;
 
 /**
  * @param {number} [size]
@@ -1655,11 +1667,29 @@ declare function updating(size?: number): FieldDecorator<Date | null>;
  */
 declare function deleting(size?: number): FieldDecorator<Date | null>;
 
+/** @type {(insert?: boolean) => MethodDecorator<Hooks['beforeCreateMany']>} */
+declare const beforeCreateMany: (insert?: boolean) => MethodDecorator<Hooks["beforeCreateMany"]>;
+/** @type {(insert?: boolean) => MethodDecorator<Hooks['afterCreateMany']>} */
+declare const afterCreateMany: (insert?: boolean) => MethodDecorator<Hooks["afterCreateMany"]>;
+/** @type {(insert?: boolean) => MethodDecorator<Hooks['beforeCreate']>} */
+declare const beforeCreate: (insert?: boolean) => MethodDecorator<Hooks["beforeCreate"]>;
+/** @type {(insert?: boolean) => MethodDecorator<Hooks['afterCreate']>} */
+declare const afterCreate: (insert?: boolean) => MethodDecorator<Hooks["afterCreate"]>;
+/** @type {(insert?: boolean) => MethodDecorator<Hooks['beforeUpdate']>} */
+declare const beforeUpdate: (insert?: boolean) => MethodDecorator<Hooks["beforeUpdate"]>;
+/** @type {(insert?: boolean) => MethodDecorator<Hooks['afterUpdate']>} */
+declare const afterUpdate: (insert?: boolean) => MethodDecorator<Hooks["afterUpdate"]>;
+/** @type {(insert?: boolean) => MethodDecorator<Hooks['beforeDelete']>} */
+declare const beforeDelete: (insert?: boolean) => MethodDecorator<Hooks["beforeDelete"]>;
+/** @type {(insert?: boolean) => MethodDecorator<Hooks['afterDelete']>} */
+declare const afterDelete: (insert?: boolean) => MethodDecorator<Hooks["afterDelete"]>;
+
 type ClassDecorator = (val: Function, ctx: ClassDecoratorContext) => any;
 type FieldDecorator<T> = (val: {
     get(): T;
     set(v: T): void;
 }, ctx: ClassAccessorDecoratorContext) => any;
+type MethodDecorator<T extends Function> = (val: T, ctx: ClassMethodDecoratorContext<any, T>) => any;
 
 type QueryOptions<T extends Fields, TB extends unknown = any> = {
     table?: string | VirtualTable<object> | undefined;
@@ -1694,8 +1724,9 @@ declare class Query<T extends Fields, TB extends unknown = any> implements Query
     static table<F extends Fields, T_1 extends new (o: QueryOptions<F>) => Query<F>>(this: T_1, table: string, fields: F, pseudo?: string): InstanceType<T_1>;
     /**
      * @param {QueryOptions<T, TB> | Query<T, TB>} options
+     * @param {boolean} [noBuild]
      */
-    constructor(options: QueryOptions<T, TB> | Query<T, TB>);
+    constructor(options: QueryOptions<T, TB> | Query<T, TB>, noBuild?: boolean);
     /** @readonly @type {string | VirtualTable | undefined} */
     readonly table: string | VirtualTable | undefined;
     /** @readonly @type {T} */
@@ -1920,6 +1951,7 @@ declare class Model implements Save, Destroy, PseudoDestroy {
     static readonly fields: Fields;
     /** @readonly @type {readonly IndexInfo[]} */
     static readonly indexes: readonly IndexInfo[];
+    static get hooks(): Readonly<Partial<Hooks<Record<string, any>>>>;
     /**
      * @template {typeof Model} T
      * @this {T}
@@ -1940,10 +1972,10 @@ declare class Model implements Save, Destroy, PseudoDestroy {
      * @this {T}
      * @param {Connection} t
      * @param {object} p
-     * @param {(data: object) => Promise<object>} run
+     * @param {(data: object, that: any) => Promise<object>} run
      * @returns {Promise<InstanceType<T>>}
      */
-    static [Create]<T extends typeof Model>(this: T, t: Connection, p: object, run: (data: object) => Promise<object>): Promise<InstanceType<T>>;
+    static [Create]<T extends typeof Model>(this: T, t: Connection, p: object, run: (data: object, that: any) => Promise<object>): Promise<InstanceType<T>>;
     /**
      * @template {typeof Model} T
      * @this {T}
@@ -2271,4 +2303,4 @@ declare function field<T extends MainFieldType>(type: T, options: {
 declare function setDevelopment(d?: boolean): void;
 declare let isDevelopment: boolean;
 
-export { Build, type ClassDecorator, type Column, type ColumnOptions, Connection, type Constraint, Create, type DBColumn, type DBIndex, type DBTable, Destroy, type Environment, type FieldDecorator, type FieldDefine, type FieldDefineOption, type FieldDefineType, type FieldSpecific, type FieldSpecificValue, type FieldType, type FieldTypeDefine, type FieldValue, type Fields, type FindArg, type FindRange, type GetName, type IConnection, type Index, type IndexInfo, type IndexOptions, type Join, type JoinType, type MainFieldType, type MaybePromise, Model, type Options, PseudoDestroy, Query, type QueryOptions, type Queryable, Save, Scene, Select, SetValue, type Skip, Submodel, type Support, type TableDefine, type TableType, type ToFieldType, type ToType, type TransactionFn, type VirtualTable, Where, type WhereItem, type WhereLike, type WhereOr, type WhereRaw, type WhereValue, type Wheres, column, creating, decrement, defaultValue, field as define, deleted, deleting, divide, field$1 as field, getPrimaryFields, getPrimaryKeys, immutable, increment, index, isDevelopment, isPseudo, submodel as model, multiply, now, primary, prop, pseudo, setDevelopment, sort, submodel, toNot, toPrimaries, toPrimary, uncreatable, undeleted, updating, uuid, values, withDeleted };
+export { Build, type ClassDecorator, type Column, type ColumnOptions, Connection, type Constraint, Create, type DBColumn, type DBIndex, type DBTable, Destroy, type Environment, type FieldDecorator, type FieldDefine, type FieldDefineOption, type FieldDefineType, type FieldSpecific, type FieldSpecificValue, type FieldType, type FieldTypeDefine, type FieldValue, type Fields, type FindArg, type FindRange, type GetName, type Hooks, type IConnection, type Index, type IndexInfo, type IndexOptions, type Join, type JoinType, type MainFieldType, type MaybePromise, type MethodDecorator, Model, type Options, PseudoDestroy, Query, type QueryOptions, type Queryable, Save, Scene, Select, SetValue, type Skip, Submodel, type Support, type TableDefine, type TableType, type ToFieldType, type ToType, type TransactionFn, type VirtualTable, Where, type WhereItem, type WhereLike, type WhereOr, type WhereRaw, type WhereValue, type Wheres, afterCreate, afterCreateMany, afterDelete, afterUpdate, beforeCreate, beforeCreateMany, beforeDelete, beforeUpdate, column, creating, decrement, defaultValue, field as define, deleted, deleting, divide, field$1 as field, getPrimaryFields, getPrimaryKeys, immutable, increment, index, isDevelopment, isPseudo, model, multiply, now, primary, prop, pseudo, setDevelopment, sort, model as submodel, toNot, toPrimaries, toPrimary, uncreatable, undeleted, updating, uuid, values, withDeleted };

package/index.mjs

@@ -1,5 +1,5 @@
 /*!
- * imodel v0.5.1
+ * imodel v0.6.0
  * (c) 2019-2025 undefined
  * @license undefined
  */
@@ -1822,18 +1822,63 @@ class Connection {
    * @returns {Promise<object[] | (T extends Build<infer R> ? R : object)>}
    */
   async create(model, p, skip) {
-    if (Array.isArray(p) || typeof model[Create] !== 'function') {
+    const {
+      beforeCreateMany,
+      afterCreateMany,
+      beforeCreate,
+      afterCreate
+    } = model.hooks || {};
+    const isArray = Array.isArray(p);
+    const list = [p].flat(Infinity).filter(Boolean);
+    if (!list.length) {
+      // @ts-ignore
+      return isArray ? [] : null;
+    }
+    if (list.length !== 1) {
       const modelBuild = model[Build];
       const md = typeof modelBuild === 'function' ? modelBuild.bind(model) : undefined;
       const conn = await this.#getConnection();
-      return create(conn, this.#env, model, p, skip, md);
+      let setData = list;
+      if (typeof beforeCreateMany === 'function') {
+        // @ts-ignore
+        setData = (await beforeCreateMany.call(setData, this, setData)) || setData;
+      }
+      const r = await create(conn, this.#env, model, setData, skip, md);
+      if (typeof afterCreateMany === 'function') {
+        await afterCreateMany.call(r, this, r);
+      }
+      return r;
+    }
+    const [data] = list;
+    if (typeof model[Create] !== 'function') {
+      const modelBuild = model[Build];
+      const md = typeof modelBuild === 'function' ? modelBuild.bind(model) : undefined;
+      const conn = await this.#getConnection();
+      let setData = data;
+      if (typeof beforeCreate === 'function') {
+        setData = (await beforeCreate.call(setData, this, setData)) || setData;
+      }
+      const result = await create(conn, this.#env, model, setData, skip, md);
+      if (typeof afterCreate === 'function') {
+        await afterCreate.call(result, this, result);
+      }
+      return isArray ? [result] : result;
     }
     // @ts-ignore
     const m = /** @type {Create} */model;
-    return m[Create](this, p, async data => {
+    const result = m[Create](this, data, async (data, that) => {
+      let setData = data;
       const conn = await this.#getConnection();
-      return create(conn, this.#env, model, data, skip);
+      if (typeof beforeCreate === 'function') {
+        setData = (await beforeCreate.call(that ?? setData, this, setData)) || setData;
+      }
+      const r = await create(conn, this.#env, model, setData, skip);
+      if (typeof afterCreate === 'function') {
+        await afterCreate.call(that ?? r, this, r);
+      }
+      return r;
     }, model);
+    return isArray ? [result] : result;
   }
   /**
    *
@@ -1864,24 +1909,69 @@ class Connection {
    * @returns {Promise<(T extends Save ? T : object)?>}
    */
   async save(model, data, newData, skip) {
+    const {
+      beforeCreate,
+      afterCreate,
+      beforeUpdate,
+      afterUpdate
+    } = model.hooks || {};
     if (typeof data[Save] !== 'function') {
       const conn = await this.#getConnection();
       if (newData) {
-        /** @type {any} */
-        const doc = data;
+        let setData = newData;
+        if (typeof beforeUpdate === 'function') {
+          // @ts-ignore
+          setData = (await beforeUpdate.call(data, this, data, setData)) || setData;
+        }
+        // @ts-ignore
+        const r = await updateData(conn, model, data, setData, this.#env, skip);
+        if (r) {
+          if (typeof afterUpdate === 'function') {
+            // @ts-ignore
+            await afterUpdate.call(r, this, r, data);
+          }
+        }
         // @ts-ignore
-        return updateData(conn, model, doc, newData, this.#env, skip);
+        return r;
+      }
+      /** @type {Record<string, any>} */
+      // @ts-ignore
+      let setData = data;
+      if (typeof beforeCreate === 'function') {
+        setData = (await beforeCreate.call(data, this, setData)) || setData;
+      }
+      const r = await create(conn, this.#env, model, setData, skip);
+      if (typeof afterCreate === 'function') {
+        await afterCreate.call(r, this, r);
       }
-      return create(conn, this.#env, model, data, skip);
+      return r;
     }
-    const r = /** @type {Save}*/data;
+    const that = /** @type {Save}*/data;
     // @ts-ignore
-    return r[Save](this, async (doc, newData) => {
+    return that[Save](this, async (data, newData) => {
       const conn = await this.#getConnection();
       if (newData) {
-        return updateData(conn, model, doc, newData, this.#env, skip);
+        let setData = newData;
+        if (typeof beforeUpdate === 'function') {
+          setData = (await beforeUpdate.call(that, this, data, setData)) || setData;
+        }
+        const r = await updateData(conn, model, data, setData, this.#env, skip);
+        if (r) {
+          if (typeof afterUpdate === 'function') {
+            await afterUpdate.call(that, this, r, data);
+          }
+        }
+        return r;
+      }
+      let setData = data;
+      if (typeof beforeCreate === 'function') {
+        setData = (await beforeCreate.call(that, this, setData)) || setData;
+      }
+      const r = await create(conn, this.#env, model, setData, skip);
+      if (typeof afterCreate === 'function') {
+        await afterCreate.call(that, this, r);
       }
-      return create(conn, this.#env, model, doc, skip);
+      return r;
     }, newData || null, model);
   }
   /**
@@ -1892,15 +1982,35 @@ class Connection {
    * @returns {Promise<(T extends Destroy ? T : object)?>}
    */
   async completelyDestroy(tableDef, data) {
+    const {
+      beforeDelete,
+      afterDelete
+    } = tableDef.hooks || {};
     if (typeof data[Destroy] !== 'function') {
       const conn = await this.#getConnection();
-      return completelyDelete(conn, tableDef, data, this.#env);
+      if (typeof beforeDelete === 'function') {
+        // @ts-ignore
+        await beforeDelete.call(data, this, data, null);
+      }
+      const r = await completelyDelete(conn, tableDef, data, this.#env);
+      if (r && typeof afterDelete === 'function') {
+        // @ts-ignore
+        await afterDelete.call(r, this, data, null);
+      }
+      return r;
     }
-    const r = /** @type {Destroy} */data;
+    const that = /** @type {Destroy} */data;
     // @ts-ignore
-    return r[Destroy](this, async data => {
+    return that[Destroy](this, async data => {
       const conn = await this.#getConnection();
-      return completelyDelete(conn, tableDef, data, this.#env);
+      if (typeof beforeDelete === 'function') {
+        await beforeDelete.call(that, this, data, null);
+      }
+      const r = await completelyDelete(conn, tableDef, data, this.#env);
+      if (r && typeof afterDelete === 'function') {
+        await afterDelete.call(that, this, data, null);
+      }
+      return r;
     }, tableDef);
   }
   /**
@@ -1915,19 +2025,40 @@ class Connection {
     if (!canPseudo(tableDef)) {
       return null;
     }
+    const {
+      beforeDelete,
+      afterDelete
+    } = tableDef.hooks || {};
     const update = {
       ...value
     };
     if (typeof data[PseudoDestroy] !== 'function') {
       const conn = await this.#getConnection();
+      if (typeof beforeDelete === 'function') {
+        // @ts-ignore
+        await beforeDelete.call(data, this, data, update);
+      }
+      const r = await pseudoDestroy(conn, tableDef, data, update, this.#env);
+      if (r && typeof afterDelete === 'function') {
+        // @ts-ignore
+        await afterDelete.call(r, this, data, update);
+      }
       // @ts-ignore
-      return pseudoDestroy(conn, tableDef, data, update, this.#env);
+      return r;
     }
-    const r = /** @type {PseudoDestroy} */data;
+    const that = /** @type {PseudoDestroy} */data;
     // @ts-ignore
-    return r[PseudoDestroy](this, update, async data => {
+    return that[PseudoDestroy](this, update, async data => {
       const conn = await this.#getConnection();
-      return pseudoDestroy(conn, tableDef, data, update, this.#env);
+      if (typeof beforeDelete === 'function') {
+        await beforeDelete.call(that, this, data, update);
+      }
+      const r = await pseudoDestroy(conn, tableDef, data, update, this.#env);
+      if (r && typeof afterDelete === 'function') {
+        await afterDelete.call(that, this, data, update);
+      }
+      // @ts-ignore
+      return r;
     }, tableDef);
   }
   /**
@@ -2446,6 +2577,219 @@ function check(ctx) {
   return name;
 }
 
+/** @import { Hooks } from '../types' */
+/** @import { MethodDecorator } from './index.mjs' */
+const appendHookMetaKey = Symbol();
+const insertHookMetaKey = Symbol();
+const beforeCreateManyMetaKey = Symbol();
+const afterCreateManyMetaKey = Symbol();
+const beforeCreateMetaKey = Symbol();
+const afterCreateMetaKey = Symbol();
+const beforeUpdateMetaKey = Symbol();
+const afterUpdateMetaKey = Symbol();
+const beforeDeleteMetaKey = Symbol();
+const afterDeleteMetaKey = Symbol();
+const hookMetaKeys = {
+  beforeCreateMany: beforeCreateManyMetaKey,
+  afterCreateMany: afterCreateManyMetaKey,
+  beforeCreate: beforeCreateMetaKey,
+  afterCreate: afterCreateMetaKey,
+  beforeUpdate: beforeUpdateMetaKey,
+  afterUpdate: afterUpdateMetaKey,
+  beforeDelete: beforeDeleteMetaKey,
+  afterDelete: afterDeleteMetaKey
+};
+/** @typedef {{static: boolean; hook: Function}} Hook */
+/**
+ *
+ * @template {Function} T
+ * @param {string} key
+ * @param {boolean} onlyStatic
+ * @param {boolean} [insert]
+ * @returns {MethodDecorator<T>}
+ */
+function hook(key, onlyStatic, insert = false) {
+  return (value, ctx) => {
+    if (!ctx || ctx.kind !== 'method') {
+      throw new Error('钩子属性只能是方法(method)');
+    }
+    if (onlyStatic && !ctx.static) {
+      throw new Error(`${key} 钩子只能是静态属性`);
+    }
+    const metaKey = insert ? insertHookMetaKey : appendHookMetaKey;
+    let hooks = /** @type {Record<string, Hook[]>?} */ctx.metadata[metaKey];
+    if (!hooks) {
+      hooks = {};
+      ctx.metadata[metaKey] = hooks;
+    }
+    let list = hooks[key];
+    /** @type {Hook} */
+    const item = {
+      static: ctx.static,
+      hook: value
+    };
+    if (Array.isArray(list)) {
+      list.push(item);
+    } else {
+      hooks[key] = [item];
+    }
+  };
+}
+/** @type {(insert?: boolean) => MethodDecorator<Hooks['beforeCreateMany']>} */
+const beforeCreateMany = hook.bind(null, 'beforeCreateMany', true);
+/** @type {(insert?: boolean) => MethodDecorator<Hooks['afterCreateMany']>} */
+const afterCreateMany = hook.bind(null, 'afterCreateMany', true);
+/** @type {(insert?: boolean) => MethodDecorator<Hooks['beforeCreate']>} */
+const beforeCreate = hook.bind(null, 'beforeCreate', false);
+/** @type {(insert?: boolean) => MethodDecorator<Hooks['afterCreate']>} */
+const afterCreate = hook.bind(null, 'afterCreate', false);
+/** @type {(insert?: boolean) => MethodDecorator<Hooks['beforeUpdate']>} */
+const beforeUpdate = hook.bind(null, 'beforeUpdate', false);
+/** @type {(insert?: boolean) => MethodDecorator<Hooks['afterUpdate']>} */
+const afterUpdate = hook.bind(null, 'afterUpdate', false);
+/** @type {(insert?: boolean) => MethodDecorator<Hooks['beforeDelete']>} */
+const beforeDelete = hook.bind(null, 'beforeDelete', false);
+/** @type {(insert?: boolean) => MethodDecorator<Hooks['afterDelete']>} */
+const afterDelete = hook.bind(null, 'afterDelete', false);
+/**
+ *
+ * @param {Hook[]?} hooks
+ */
+function flatHook(hooks) {
+  const list = [hooks].flat(Infinity);
+  return /** @type {Hook[]} */list.filter(Boolean);
+}
+/**
+ *
+ * @param {any} Model
+ * @returns {Readonly<Partial<Hooks>>}
+ */
+function buildHooks(Model) {
+  const metadata = Model[Symbol.metadata];
+  if (!metadata) {
+    return {};
+  }
+  /** @type {Record<symbol, Hook[]?>} */
+  const {
+    [beforeCreateManyMetaKey]: beforeCreateManyMeta,
+    [afterCreateManyMetaKey]: afterCreateManyMeta,
+    [beforeCreateMetaKey]: beforeCreateMeta,
+    [afterCreateMetaKey]: afterCreateMeta,
+    [beforeUpdateMetaKey]: beforeUpdateMeta,
+    [afterUpdateMetaKey]: afterUpdateMeta,
+    [beforeDeleteMetaKey]: beforeDeleteMeta,
+    [afterDeleteMetaKey]: afterDeleteMeta
+  } = metadata;
+  return {
+    async beforeCreateMany(conn, record) {
+      let data = record;
+      for (const {
+        static: isStatic,
+        hook
+      } of flatHook(beforeCreateManyMeta)) {
+        if (typeof hook !== 'function') {
+          continue;
+        }
+        data = (await hook.call(Model, conn, data)) || data;
+      }
+      return data;
+    },
+    async afterCreateMany(conn, record) {
+      for (const {
+        static: isStatic,
+        hook
+      } of flatHook(afterCreateManyMeta)) {
+        if (typeof hook !== 'function') {
+          continue;
+        }
+        await hook.call(Model, conn, record);
+      }
+    },
+    async beforeCreate(conn, record) {
+      let that;
+      let data = record;
+      for (const {
+        static: isStatic,
+        hook
+      } of flatHook(beforeCreateMeta)) {
+        if (typeof hook !== 'function') {
+          continue;
+        }
+        const thisArg = isStatic ? Model : that ||= this instanceof Model ? this : new Model(record);
+        data = (await hook.call(thisArg, conn, data)) || data;
+      }
+      return data;
+    },
+    async afterCreate(conn, record) {
+      let that;
+      for (const {
+        static: isStatic,
+        hook
+      } of flatHook(afterCreateMeta)) {
+        if (typeof hook !== 'function') {
+          continue;
+        }
+        const thisArg = isStatic ? Model : that ||= this instanceof Model ? this : new Model(record, true);
+        await hook.call(thisArg, conn, record);
+      }
+    },
+    async beforeUpdate(conn, record, set) {
+      let that;
+      let data = set;
+      for (const {
+        static: isStatic,
+        hook
+      } of flatHook(beforeUpdateMeta)) {
+        if (typeof hook !== 'function') {
+          continue;
+        }
+        const thisArg = isStatic ? Model : that ||= this instanceof Model ? this : new Model(record, set);
+        data = (await hook.call(thisArg, conn, record, data)) || data;
+      }
+      return data;
+    },
+    async afterUpdate(conn, record, oldRecord) {
+      let that;
+      for (const {
+        static: isStatic,
+        hook
+      } of flatHook(afterUpdateMeta)) {
+        if (typeof hook !== 'function') {
+          continue;
+        }
+        const thisArg = isStatic ? Model : that ||= this instanceof Model ? this : new Model(record, true);
+        await hook.call(thisArg, conn, record, oldRecord);
+      }
+    },
+    async beforeDelete(conn, record, update) {
+      let that;
+      for (const {
+        static: isStatic,
+        hook
+      } of flatHook(beforeDeleteMeta)) {
+        if (typeof hook !== 'function') {
+          continue;
+        }
+        const thisArg = isStatic ? Model : that ||= this instanceof Model ? this : new Model(record, true);
+        await hook.call(thisArg, conn, record, update);
+      }
+    },
+    async afterDelete(conn, record, update) {
+      let that;
+      for (const {
+        static: isStatic,
+        hook
+      } of flatHook(afterDeleteMeta)) {
+        if (typeof hook !== 'function') {
+          continue;
+        }
+        const thisArg = isStatic ? Model : that ||= this instanceof Model ? this : new Model(record, true);
+        await hook.call(thisArg, conn, record, update);
+      }
+    }
+  };
+}
+
 /** @import { ClassDecorator } from './index.mjs' */
 const fieldKey = Symbol();
 const propsKey = Symbol();
@@ -2537,7 +2881,7 @@ const typeKey = Symbol();
  * @param {*} [p1]
  * @param {*} [p2]
  */
-function submodel(type, constraints, p1, p2) {
+function model(type, constraints, p1, p2) {
   if (typeof type === 'string') {
     const table = type;
     /**
@@ -2561,6 +2905,12 @@ function submodel(type, constraints, p1, p2) {
       if (!fields && !classField) {
         throw new Error('字段未定义');
       }
+      const insertHooks = metadata[insertHookMetaKey] || {};
+      const appendHooks = metadata[appendHookMetaKey] || {};
+      const parentMetadata = Object.getPrototypeOf(ModelClass)?.[Symbol.metadata] || {};
+      for (const [name, key] of Object.entries(hookMetaKeys)) {
+        metadata[key] = [...(insertHooks[name] || []), ...(parentMetadata[key] || []), ...(appendHooks[name] || [])];
+      }
       Object.defineProperty(ModelClass, 'table', {
         value: table,
         configurable: true,
@@ -3930,13 +4280,14 @@ class Query {
   }
   /**
    * @param {QueryOptions<T, TB> | Query<T, TB>} options
+   * @param {boolean} [noBuild]
    */
-  constructor(options) {
+  constructor(options, noBuild) {
     if (options instanceof Query) {
       this.table = options.table;
       this.fields = options.fields;
       this.pseudo = options.pseudo;
-      this.#build = options.#build;
+      this.#build = noBuild ? null : options.#build;
       this.#options = {
         ...options.#options
       };
@@ -3954,7 +4305,9 @@ class Query {
       this.pseudo = typeof pseudo === 'string' ? pseudo : '';
       this.#build = typeof build === 'function' ? build : null;
       this.#primaryFields = Object.entries(fields).filter(([, v]) => v.primary).sort(([, a], [, b]) => Number(a.primary) - Number(b.primary)).map(([v]) => v);
-      if (typeof options[Build] === 'function') {
+      if (noBuild) {
+        this.#build = null;
+      } else if (typeof options[Build] === 'function') {
         this.#build = options[Build].bind(options);
       } else if (typeof build === 'function') {
         this.#build = build.bind(options);
@@ -4684,6 +5037,9 @@ class Model {
   static fields = {};
   /** @readonly @type {readonly IndexInfo[]} */
   static indexes = [];
+  static get hooks() {
+    return buildHooks(this);
+  }
   /**
    * @template {typeof Model} T
    * @this {T}
@@ -4730,7 +5086,7 @@ class Model {
    * @this {T}
    * @param {Connection} t
    * @param {object} p
-   * @param {(data: object) => Promise<object>} run
+   * @param {(data: object, that: any) => Promise<object>} run
    * @returns {Promise<InstanceType<T>>}
    */
   static async [Create](t, p, run) {
@@ -4741,7 +5097,7 @@ class Model {
     return doc.#do(() => doc.$_onBeforeSave(t, false), () => run({
       ...doc.#data,
       ...doc.#newData
-    }), () => doc.$_onAfterSave(t, false)).then(() => doc);
+    }, doc), () => doc.$_onAfterSave(t, false)).then(() => doc);
   }
   /**
    * @template {typeof Model} T
@@ -5508,4 +5864,4 @@ function field(type, {
   };
 }
 
-export { Build, Connection, Create, Destroy, Model, PseudoDestroy, Query, Save, Scene, Submodel, Where, column, creating, decrement, defaultValue, field as define, deleted, deleting, divide, field$1 as field, getPrimaryFields, getPrimaryKeys, immutable, increment, index, isDevelopment, isPseudo, submodel as model, multiply, now, primary, prop, pseudo, setDevelopment, sort, submodel, toNot, toPrimaries, toPrimary, uncreatable, undeleted, updating, uuid, values, withDeleted };
+export { Build, Connection, Create, Destroy, Model, PseudoDestroy, Query, Save, Scene, Submodel, Where, afterCreate, afterCreateMany, afterDelete, afterUpdate, beforeCreate, beforeCreateMany, beforeDelete, beforeUpdate, column, creating, decrement, defaultValue, field as define, deleted, deleting, divide, field$1 as field, getPrimaryFields, getPrimaryKeys, immutable, increment, index, isDevelopment, isPseudo, model, multiply, now, primary, prop, pseudo, setDevelopment, sort, model as submodel, toNot, toPrimaries, toPrimary, uncreatable, undeleted, updating, uuid, values, withDeleted };

package/migrate.d.mts

@@ -1,5 +1,5 @@
 /*!
- * imodel v0.5.1
+ * imodel v0.6.0
  * (c) 2019-2025 undefined
  * @license undefined
  */

package/migrate.mjs

@@ -1,5 +1,5 @@
 /*!
- * imodel v0.5.1
+ * imodel v0.6.0
  * (c) 2019-2025 undefined
  * @license undefined
  */

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "imodel",
-  "version": "0.5.1",
+  "version": "0.6.0",
   "main": "index.mjs",
   "type": "module",
   "repository": {