metal-orm 1.1.21 → 1.1.23

package/src/core/dialect/capabilities/procedure-compiler.ts

@@ -0,0 +1,30 @@
+import type { ProcedureCallNode } from '../../ast/procedure.js';
+import type { CompiledQuery } from '../abstract.js';
+
+export interface CompiledProcedureCall extends CompiledQuery {
+  outParams: {
+    source: 'none' | 'firstResultSet' | 'lastResultSet';
+    names: string[];
+  };
+}
+
+/**
+ * Optional dialect capability for stored-procedure compilation.
+ *
+ * Dialects that do not support procedures simply do not implement this
+ * interface; unsupported behavior is resolved at the capability boundary
+ * rather than through mandatory methods that only throw.
+ */
+export interface ProcedureCompiler {
+  compileProcedureCall(ast: ProcedureCallNode): CompiledProcedureCall;
+}
+
+export const isProcedureCompiler = (value: unknown): value is ProcedureCompiler =>
+  typeof (value as { compileProcedureCall?: unknown } | null)?.compileProcedureCall === 'function';
+
+export const requireProcedureCompiler = (value: unknown): ProcedureCompiler => {
+  if (!isProcedureCompiler(value)) {
+    throw new Error('Stored procedures are not supported by this dialect.');
+  }
+  return value;
+};

package/src/core/dialect/dialect-factory.ts

@@ -1,7 +1,7 @@
 // Dialect factory for the SQL DSL.
 // Centralizes how we go from a symbolic name ("sqlite") to a concrete Dialect instance.
 
-import { Dialect } from './abstract.js';
+import type { Dialect } from './abstract.js';
 import { PostgresDialect } from './postgres/index.js';
 import { MySqlDialect } from './mysql/index.js';
 import { SqliteDialect } from './sqlite/index.js';
@@ -42,9 +42,8 @@ export class DialectFactory {
   /**
    * Register (or override) a dialect factory for a key.
    *
-   * Examples:
-   *   DialectFactory.register('sqlite', () => new SqliteDialect());
-   *   DialectFactory.register('my-tenant-dialect', () => new CustomDialect());
+   * Implementations are structural: extending DialectBase/SqlDialectBase is
+   * optional. A composed object satisfying Dialect is a valid registration.
    */
   public static register(key: DialectKey, factory: DialectFactoryFn): void {
     this.registry.set(key, factory);

package/src/core/dialect/mssql/index.ts

@@ -1,4 +1,5 @@
-import { CompilerContext, CompiledProcedureCall } from '../abstract.js';
+import { CompilerContext } from '../abstract.js';
+import type { CompiledProcedureCall, ProcedureCompiler } from '../capabilities/procedure-compiler.js';
 import {
   SelectQueryNode,
   InsertQueryNode,
@@ -21,7 +22,7 @@ const toProcedureParamReference = (value: string): string =>
 /**
  * Microsoft SQL Server dialect implementation
  */
-export class SqlServerDialect extends SqlDialectBase {
+export class SqlServerDialect extends SqlDialectBase implements ProcedureCompiler {
   protected readonly dialect = 'mssql';
   /**
    * Creates a new SqlServerDialect instance

package/src/core/dialect/mysql/index.ts

@@ -1,4 +1,5 @@
-import { CompilerContext, CompiledProcedureCall } from '../abstract.js';
+import { CompilerContext } from '../abstract.js';
+import type { CompiledProcedureCall, ProcedureCompiler } from '../capabilities/procedure-compiler.js';
 import { JsonPathNode, IsDistinctExpressionNode } from '../../ast/expression.js';
 import { InsertQueryNode } from '../../ast/query.js';
 import { SqlDialectBase } from '../base/sql-dialect.js';
@@ -11,7 +12,7 @@ const sanitizeVariableSuffix = (value: string): string =>
 /**
  * MySQL dialect implementation
  */
-export class MySqlDialect extends SqlDialectBase {
+export class MySqlDialect extends SqlDialectBase implements ProcedureCompiler {
   protected readonly dialect = 'mysql';
   /**
    * Creates a new MySqlDialect instance

package/src/core/dialect/postgres/index.ts

@@ -1,4 +1,5 @@
-import { CompilerContext, CompiledProcedureCall } from '../abstract.js';
+import { CompilerContext } from '../abstract.js';
+import type { CompiledProcedureCall, ProcedureCompiler } from '../capabilities/procedure-compiler.js';
 import { JsonPathNode, ColumnNode, BitwiseExpressionNode } from '../../ast/expression.js';
 import { InsertQueryNode, TableNode } from '../../ast/query.js';
 import { SqlDialectBase } from '../base/sql-dialect.js';
@@ -9,7 +10,7 @@ import { ProcedureCallNode } from '../../ast/procedure.js';
 /**
  * PostgreSQL dialect implementation
  */
-export class PostgresDialect extends SqlDialectBase {
+export class PostgresDialect extends SqlDialectBase implements ProcedureCompiler {
   protected readonly dialect = 'postgres';
   /**
    * Creates a new PostgresDialect instance

package/src/core/dialect/sqlite/index.ts

@@ -1,9 +1,8 @@
-import { CompilerContext, CompiledProcedureCall } from '../abstract.js';
+import { CompilerContext } from '../abstract.js';
 import { JsonPathNode, ColumnNode, BitwiseExpressionNode } from '../../ast/expression.js';
 import { InsertQueryNode, TableNode } from '../../ast/query.js';
 import { SqlDialectBase } from '../base/sql-dialect.js';
 import { SqliteFunctionStrategy } from './functions.js';
-import { ProcedureCallNode } from '../../ast/procedure.js';
 
 /**
  * SQLite dialect implementation
@@ -104,9 +103,4 @@ export class SqliteDialect extends SqlDialectBase {
   supportsDmlReturningClause(): boolean {
     return true;
   }
-
-  compileProcedureCall(_ast: ProcedureCallNode): CompiledProcedureCall {
-    void _ast;
-    throw new Error('Stored procedures are not supported by the SQLite dialect.');
-  }
 }

package/src/decorators/entity.ts

@@ -1,4 +1,3 @@
-import { TableHooks } from '../schema/table.js';
 import { RelationKinds } from '../schema/relation.js';
 import {
   addColumnMetadata,
@@ -15,7 +14,6 @@ import { syncTreeEntityMetadata } from '../tree/tree-decorator.js';
  */
 export interface EntityOptions {
   tableName?: string;
-  hooks?: TableHooks;
   /** Entity type: 'table' (default) or 'view'. Views are read-only. */
   type?: 'table' | 'view';
 }
@@ -42,6 +40,7 @@ const deriveTableNameFromConstructor = (ctor: EntityConstructor<unknown>): strin
 
 /**
  * Class decorator to mark a class as an entity and configure its table mapping.
+ * Runtime lifecycle hooks are registered on OrmSession, not entity metadata.
  * @param options - Configuration options for the entity.
  * @returns A class decorator that registers the entity metadata.
  */
@@ -52,7 +51,7 @@ export function Entity(options: EntityOptions = {}) {
   ): T {
     const ctor = value;
     const tableName = options.tableName ?? deriveTableNameFromConstructor(ctor);
-    setEntityTableName(ctor, tableName, options.hooks, options.type);
+    setEntityTableName(ctor, tableName, options.type);
 
     const bag = context ? readMetadataBag(context) : readMetadataBagFromConstructor(ctor);
     if (bag) {

package/src/index.ts

@@ -17,6 +17,9 @@ export * from './core/ast/expression.js';
 export * from './core/ast/procedure.js';
 export * from './core/ast/window-functions.js';
 export * from './core/hydration/types.js';
+export * from './core/dialect/abstract.js';
+export * from './core/dialect/dialect-factory.js';
+export * from './core/dialect/capabilities/procedure-compiler.js';
 export * from './core/dialect/mysql/index.js';
 export * from './core/dialect/mssql/index.js';
 export * from './core/dialect/sqlite/index.js';
@@ -38,6 +41,7 @@ export * from './orm/hydration.js';
 export * from './codegen/typescript.js';
 export * from './orm/orm-session.js';
 export * from './orm/orm.js';
+export * from './orm/lifecycle.js';
 export * from './orm/column-introspection.js';
 export * from './orm/entity.js';
 export * from './orm/lazy-batch.js';

package/src/orm/entity-metadata.ts

@@ -1,5 +1,5 @@
 import { ColumnDef } from '../schema/column-types.js';
-import { defineTable, TableDef, TableHooks } from '../schema/table.js';
+import { defineTable, TableDef } from '../schema/table.js';
 import { CascadeMode, RelationKinds } from '../schema/relation.js';
 import type { TransformerMetadata } from '../decorators/transformers/transformer-metadata.js';
 
@@ -153,7 +153,7 @@ export interface MorphManyRelationMetadata {
 }
 
 /**
- * Union type for all relation metadata.
+ * Union type for all relation metadata types.
  */
 export type RelationMetadata =
   | HasManyRelationMetadata
@@ -169,6 +169,7 @@ export type EntityType = 'table' | 'view';
 
 /**
  * Metadata for entities.
+ * Runtime lifecycle hooks intentionally live on OrmSession rather than here.
  * @template TColumns - The columns type
  */
 export interface EntityMetadata<TColumns extends Record<string, ColumnDefLike> = Record<string, ColumnDefLike>> {
@@ -184,8 +185,6 @@ export interface EntityMetadata<TColumns extends Record<string, ColumnDefLike> =
   relations: Record<string, RelationMetadata>;
   /** The transformers */
   transformers: Record<string, TransformerMetadata>;
-  /** Optional hooks */
-  hooks?: TableHooks;
   /** Optional table definition */
   table?: TableDef<MaterializeColumns<TColumns>>;
 }
@@ -295,25 +294,21 @@ export const addTransformerMetadata = (
 };
 
 /**
- * Sets the table name, hooks, and type for an entity.
+ * Sets the table name and type for an entity.
+ * Lifecycle policy is session-bound and is not persisted in metadata.
  * @param target - The entity constructor
  * @param tableName - The table name
- * @param hooks - Optional table hooks
  * @param type - Entity type: 'table' or 'view'
  */
 export const setEntityTableName = (
   target: EntityConstructor,
   tableName: string,
-  hooks?: TableHooks,
   type?: EntityType
 ): void => {
   const meta = ensureEntityMetadata(target);
   if (tableName && tableName.length > 0) {
     meta.tableName = tableName;
   }
-  if (hooks) {
-    meta.hooks = hooks;
-  }
   if (type) {
     meta.type = type;
   }
@@ -340,7 +335,7 @@ export const buildTableDef = <TColumns extends Record<string, ColumnDefLike>>(me
     } as ColumnDef;
   }
 
-  const table = defineTable(meta.tableName, columns as MaterializeColumns<TColumns>, {}, meta.hooks);
+  const table = defineTable(meta.tableName, columns as MaterializeColumns<TColumns>);
   meta.table = table;
   return table;
 };

package/src/orm/execute-procedure.ts

@@ -1,7 +1,8 @@
 import type { ProcedureCallNode } from '../core/ast/procedure.js';
 import type { QueryResult } from '../core/execution/db-executor.js';
 import { payloadResultSets } from '../core/execution/db-executor.js';
-import type { CompiledProcedureCall } from '../core/dialect/abstract.js';
+import type { CompiledProcedureCall } from '../core/dialect/capabilities/procedure-compiler.js';
+import { requireProcedureCompiler } from '../core/dialect/capabilities/procedure-compiler.js';
 import type { OrmSession } from './orm-session.js';
 
 export interface ProcedureExecutionResult {
@@ -63,7 +64,7 @@ export const executeProcedureAst = async (
   ast: ProcedureCallNode
 ): Promise<ProcedureExecutionResult> => {
   const execCtx = session.getExecutionContext();
-  const compiled = execCtx.dialect.compileProcedureCall(ast);
+  const compiled = requireProcedureCompiler(execCtx.dialect).compileProcedureCall(ast);
   const payload = await execCtx.interceptors.run(
     { sql: compiled.sql, params: compiled.params },
     execCtx.executor

package/src/orm/lifecycle.ts

@@ -0,0 +1,20 @@
+import type { TableDef } from '../schema/table.js';
+
+/**
+ * Entity lifecycle hooks executed by the Unit of Work.
+ *
+ * Hooks are runtime/session configuration. They are intentionally not stored on
+ * TableDef so the same mapping can be used by independent sessions with
+ * different lifecycle policies.
+ */
+export interface TableHooks<TEntity = unknown, TContext = unknown> {
+  beforeInsert?(ctx: TContext, entity: TEntity): Promise<void> | void;
+  afterInsert?(ctx: TContext, entity: TEntity): Promise<void> | void;
+  beforeUpdate?(ctx: TContext, entity: TEntity): Promise<void> | void;
+  afterUpdate?(ctx: TContext, entity: TEntity): Promise<void> | void;
+  beforeDelete?(ctx: TContext, entity: TEntity): Promise<void> | void;
+  afterDelete?(ctx: TContext, entity: TEntity): Promise<void> | void;
+}
+
+/** @internal */
+export type TableHookResolver = (table: TableDef) => TableHooks | undefined;

package/src/orm/orm-session.ts

@@ -13,6 +13,7 @@ import type { EntityConstructor } from './entity-metadata.js';
 import { Orm } from './orm.js';
 import { IdentityMap } from './identity-map.js';
 import { UnitOfWork } from './unit-of-work.js';
+import type { TableHooks } from './lifecycle.js';
 import { DomainEventBus, DomainEventHandler, InitialHandlers } from './domain-event-bus.js';
 import { RelationChangeProcessor } from './relation-change-processor.js';
 import { createQueryLoggingExecutor, QueryLogger } from './query-logger.js';
@@ -38,6 +39,12 @@ const NESTED_TRANSACTIONS_REQUIRE_SAVEPOINTS =
 const ROLLBACK_ONLY_TRANSACTION =
   'Cannot commit transaction because an inner transaction failed';
 
+type LifecycleHookTarget = TableDef | EntityConstructor<object>;
+type LifecycleHookEntity<TTarget extends LifecycleHookTarget> =
+  TTarget extends TableDef ? EntityInstance<TTarget> :
+  TTarget extends EntityConstructor<object> ? InstanceType<TTarget> :
+  never;
+
 /**
  * Interface for ORM interceptors that allow hooking into the flush lifecycle.
  */
@@ -106,6 +113,7 @@ export class OrmSession<E extends DomainEvent = OrmDomainEvent> implements Entit
   readonly tenantId?: string | number;
 
   private readonly interceptors: OrmInterceptor[];
+  private readonly tableHooks = new WeakMap<TableDef, TableHooks>();
   private saveGraphDefaults?: SaveGraphSessionOptions;
   private transactionDepth = 0;
   private savepointCounter = 0;
@@ -121,7 +129,13 @@ export class OrmSession<E extends DomainEvent = OrmDomainEvent> implements Entit
     this.interceptors = [...(opts.interceptors ?? [])];
 
     this.identityMap = new IdentityMap();
-    this.unitOfWork = new UnitOfWork(this.orm.dialect, this.executor, this.identityMap, () => this);
+    this.unitOfWork = new UnitOfWork(
+      this.orm.dialect,
+      this.executor,
+      this.identityMap,
+      () => this,
+      table => this.tableHooks.get(table)
+    );
     this.relationChanges = new RelationChangeProcessor(this.unitOfWork, this.orm.dialect, this.executor);
     this.domainEvents = new DomainEventBus<E, OrmSession<E>>(opts.domainEventHandlers);
     this.cacheManager = opts.cacheManager;
@@ -250,6 +264,24 @@ export class OrmSession<E extends DomainEvent = OrmDomainEvent> implements Entit
     return this.unitOfWork.getEntitiesForTable(table);
   }
 
+  /**
+   * Registers INSERT/UPDATE/DELETE lifecycle hooks for this Session only.
+   * The target can be a TableDef or a decorated entity constructor.
+   * Registering again for the same table replaces the previous hook set.
+   */
+  registerTableHooks<TTarget extends LifecycleHookTarget>(
+    target: TTarget,
+    hooks: TableHooks<LifecycleHookEntity<TTarget>, OrmSession<E>>
+  ): void {
+    const table = typeof target === 'function'
+      ? getTableDefFromEntity(target as EntityConstructor<object>)
+      : target;
+    if (!table) {
+      throw new Error('Entity metadata has not been bootstrapped');
+    }
+    this.tableHooks.set(table as TableDef, hooks as unknown as TableHooks);
+  }
+
   /**
    * Registers an interceptor for flush lifecycle hooks.
    * @param interceptor - The interceptor to register
@@ -261,7 +293,7 @@ export class OrmSession<E extends DomainEvent = OrmDomainEvent> implements Entit
   /**
    * Registers a domain event handler.
    * @param type - The event type
-   * @param handler - The event handler
+   * @param handler - The domain event handler
    */
   registerDomainEventHandler<TType extends E['type']>(
     type: TType,
@@ -500,7 +532,9 @@ export class OrmSession<E extends DomainEvent = OrmDomainEvent> implements Entit
   }
 
   /**
-   * Flushes pending changes to the database without session hooks, relation processing, or domain events.
+   * Flushes pending changes to the database without session interceptors,
+   * relation processing, or domain events. Table lifecycle hooks still run
+   * because they are part of the Unit of Work.
    */
   async flush(): Promise<void> {
     await this.unitOfWork.flush();

package/src/orm/unit-of-work.ts

@@ -5,13 +5,14 @@ import { InsertQueryBuilder } from '../query-builder/insert.js';
 import { UpdateQueryBuilder } from '../query-builder/update.js';
 import { DeleteQueryBuilder } from '../query-builder/delete.js';
 import { findPrimaryKey } from '../query-builder/hydration-planner.js';
-import type { TableDef, TableHooks } from '../schema/table.js';
+import type { TableDef } from '../schema/table.js';
 import { payloadResultSets } from '../core/execution/db-executor.js';
 import type { DbExecutor, QueryResult } from '../core/execution/db-executor.js';
 import { IdentityMap } from './identity-map.js';
 import { EntityStatus } from './runtime-types.js';
 import type { TrackedEntity } from './runtime-types.js';
 import type { PrimaryKey } from './entity-context.js';
+import type { TableHookResolver, TableHooks } from './lifecycle.js';
 
 /**
  * Unit of Work pattern implementation for tracking entity changes.
@@ -25,12 +26,14 @@ export class UnitOfWork {
    * @param executor - The database executor
    * @param identityMap - The identity map
    * @param hookContext - Function to get the hook context
+   * @param resolveTableHooks - Session/runtime lifecycle hook resolver
    */
   constructor(
     private readonly dialect: Dialect,
     private readonly executor: DbExecutor,
     private readonly identityMap: IdentityMap,
-    private readonly hookContext: () => unknown
+    private readonly hookContext: () => unknown,
+    private readonly resolveTableHooks: TableHookResolver = () => undefined
   ) { }
 
   /**
@@ -195,7 +198,8 @@ export class UnitOfWork {
    * @param tracked - The tracked entity to insert
    */
   private async flushInsert(tracked: TrackedEntity): Promise<void> {
-    await this.runHook(tracked.table.hooks?.beforeInsert, tracked);
+    const hooks = this.resolveTableHooks(tracked.table);
+    await this.runHook(hooks?.beforeInsert, tracked);
 
     const payload = this.extractColumns(tracked.table, tracked.entity as Record<string, unknown>);
     let builder = new InsertQueryBuilder(tracked.table).values(payload as Record<string, ValueOperandInput>);
@@ -212,7 +216,7 @@ export class UnitOfWork {
     tracked.pk = this.getPrimaryKeyValue(tracked);
     this.registerIdentity(tracked);
 
-    await this.runHook(tracked.table.hooks?.afterInsert, tracked);
+    await this.runHook(hooks?.afterInsert, tracked);
   }
 
   /**
@@ -227,7 +231,8 @@ export class UnitOfWork {
       return;
     }
 
-    await this.runHook(tracked.table.hooks?.beforeUpdate, tracked);
+    const hooks = this.resolveTableHooks(tracked.table);
+    await this.runHook(hooks?.beforeUpdate, tracked);
 
     const pkColumn = tracked.table.columns[findPrimaryKey(tracked.table)];
     if (!pkColumn) return;
@@ -248,7 +253,7 @@ export class UnitOfWork {
     tracked.original = this.createSnapshot(tracked.table, tracked.entity as Record<string, unknown>);
     this.registerIdentity(tracked);
 
-    await this.runHook(tracked.table.hooks?.afterUpdate, tracked);
+    await this.runHook(hooks?.afterUpdate, tracked);
   }
 
   /**
@@ -257,7 +262,8 @@ export class UnitOfWork {
    */
   private async flushDelete(tracked: TrackedEntity): Promise<void> {
     if (tracked.pk == null) return;
-    await this.runHook(tracked.table.hooks?.beforeDelete, tracked);
+    const hooks = this.resolveTableHooks(tracked.table);
+    await this.runHook(hooks?.beforeDelete, tracked);
 
     const pkColumn = tracked.table.columns[findPrimaryKey(tracked.table)];
     if (!pkColumn) return;
@@ -270,11 +276,11 @@ export class UnitOfWork {
     this.trackedEntities.delete(tracked.entity);
     this.identityMap.remove(tracked);
 
-    await this.runHook(tracked.table.hooks?.afterDelete, tracked);
+    await this.runHook(hooks?.afterDelete, tracked);
   }
 
   /**
-   * Runs a table hook if defined.
+   * Runs a lifecycle hook if defined.
    * @param hook - The hook function
    * @param tracked - The tracked entity
    */

package/src/query-builder/procedure-call.ts

@@ -1,5 +1,7 @@
 import type { ProcedureCallNode, ProcedureParamNode } from '../core/ast/procedure.js';
-import type { CompiledProcedureCall, Dialect } from '../core/dialect/abstract.js';
+import type { Dialect } from '../core/dialect/abstract.js';
+import type { CompiledProcedureCall } from '../core/dialect/capabilities/procedure-compiler.js';
+import { requireProcedureCompiler } from '../core/dialect/capabilities/procedure-compiler.js';
 import { DialectKey, resolveDialectInput } from '../core/dialect/dialect-factory.js';
 import { valueToOperand, ValueOperandInput } from '../core/ast/expression-builders.js';
 import type { OrmSession } from '../orm/orm-session.js';
@@ -82,8 +84,7 @@ export class ProcedureCallBuilder {
 
   compile(dialect: ProcedureDialectInput): CompiledProcedureCall {
     const resolved = resolveDialectInput(dialect);
-    this.validateMssqlOutDbType(resolved);
-    return resolved.compileProcedureCall(this.getAST());
+    return requireProcedureCompiler(resolved).compileProcedureCall(this.getAST());
   }
 
   toSql(dialect: ProcedureDialectInput): string {
@@ -99,23 +100,8 @@ export class ProcedureCallBuilder {
   }
 
   async execute(session: OrmSession): Promise<ProcedureExecutionResult> {
-    this.validateMssqlOutDbType(session.getExecutionContext().dialect);
     return executeProcedureAst(session, this.getAST());
   }
-
-  private validateMssqlOutDbType(dialect: Dialect): void {
-    const isMssqlDialect = dialect.constructor.name === 'SqlServerDialect';
-    if (!isMssqlDialect) return;
-
-    for (const param of this.ast.params) {
-      const needsDbType = param.direction === 'out' || param.direction === 'inout';
-      if (needsDbType && !param.dbType) {
-        throw new Error(
-          `MSSQL requires "dbType" for procedure parameter "${param.name}" with direction "${param.direction}".`
-        );
-      }
-    }
-  }
 }
 
 export const callProcedure = (name: string, options?: CallProcedureOptions): ProcedureCallBuilder =>

package/src/schema/table.ts

@@ -36,23 +36,15 @@ export interface TableOptions {
   collation?: string;
 }
 
-export interface TableHooks<TEntity = unknown, TContext = unknown> {
-  beforeInsert?(ctx: TContext, entity: TEntity): Promise<void> | void;
-  afterInsert?(ctx: TContext, entity: TEntity): Promise<void> | void;
-  beforeUpdate?(ctx: TContext, entity: TEntity): Promise<void> | void;
-  afterUpdate?(ctx: TContext, entity: TEntity): Promise<void> | void;
-  beforeDelete?(ctx: TContext, entity: TEntity): Promise<void> | void;
-  afterDelete?(ctx: TContext, entity: TEntity): Promise<void> | void;
-}
-
 /**
- * Definition of a database table with its columns and relationships
+ * Definition of a database table with its columns and relationships.
+ *
+ * Runtime lifecycle policy intentionally does not live here. TableDef is
+ * mapping/schema metadata and can be shared by multiple OrmSession instances.
  * @typeParam T - Type of the columns record
  */
 export interface TableDef<
-  T extends Record<string, ColumnDef> = Record<string, ColumnDef>,
-  TEntity = unknown,
-  TContext = unknown
+  T extends Record<string, ColumnDef> = Record<string, ColumnDef>
 > {
   /** Name of the table */
   name: string;
@@ -62,8 +54,6 @@ export interface TableDef<
   columns: T;
   /** Record of relationship definitions keyed by relation name */
   relations: Record<string, RelationDef>;
-  /** Optional lifecycle hooks */
-  hooks?: TableHooks<TEntity, TContext>;
   /** Composite primary key definition (falls back to column.primary flags) */
   primaryKey?: string[];
   /** Secondary indexes */
@@ -79,11 +69,12 @@ export interface TableDef<
 }
 
 /**
- * Creates a table definition with columns and relationships
+ * Creates a table definition with columns and relationships.
  * @typeParam T - Type of the columns record
  * @param name - Name of the table
- * @param columns - Record of column definitions
+ * @param columns - Record of column definitions keyed by property name
  * @param relations - Record of relationship definitions (optional)
+ * @param options - Schema/table options (optional)
  * @returns Complete table definition with runtime-filled column metadata
  *
  * @example
@@ -95,17 +86,12 @@ export interface TableDef<
  * });
  * ```
  */
-export const defineTable = <
-  T extends Record<string, ColumnDef>,
-  TEntity = unknown,
-  TContext = unknown
->(
+export const defineTable = <T extends Record<string, ColumnDef>>(
   name: string,
   columns: T,
   relations: Record<string, RelationDef> = {},
-  hooks?: TableHooks<TEntity, TContext>,
   options: TableOptions = {}
-): TableDef<T, TEntity, TContext> => {
+): TableDef<T> => {
   // Runtime mutability to assign names to column definitions for convenience
   const colsWithNames = Object.entries(columns).reduce((acc, [key, def]) => {
     const colDef = { ...def, name: key, table: name };
@@ -118,7 +104,6 @@ export const defineTable = <
     schema: options.schema,
     columns: colsWithNames,
     relations,
-    hooks,
     primaryKey: options.primaryKey,
     indexes: options.indexes,
     checks: options.checks,