metal-orm 1.0.8 → 1.0.9

package/src/{builder → query-builder}/select.ts

@@ -1,6 +1,6 @@
-import { TableDef } from '../schema/table';
-import { ColumnDef } from '../schema/column';
-import { SelectQueryNode, HydrationPlan } from '../ast/query';
+import { TableDef } from '../schema/table.js';
+import { ColumnDef } from '../schema/column.js';
+import { SelectQueryNode, HydrationPlan } from '../core/ast/query.js';
 import {
   ColumnNode,
   ExpressionNode,
@@ -11,27 +11,25 @@ import {
   WindowFunctionNode,
   exists,
   notExists
-} from '../ast/expression';
-import { CompiledQuery, Dialect } from '../dialect/abstract';
-import { SelectQueryState } from './select-query-state';
-import { HydrationManager } from './hydration-manager';
+} from '../core/ast/expression.js';
+import { CompiledQuery, Dialect } from '../core/dialect/abstract.js';
+import { SelectQueryState } from './select-query-state.js';
+import { HydrationManager } from './hydration-manager.js';
 import {
-  defaultSelectQueryBuilderDependencies,
+  resolveSelectQueryBuilderDependencies,
   SelectQueryBuilderContext,
   SelectQueryBuilderDependencies,
   SelectQueryBuilderEnvironment
-} from './select-query-builder-deps';
-import { ColumnSelector } from './operations/column-selector';
-import { CteManager } from './operations/cte-manager';
-import { JoinManager } from './operations/join-manager';
-import { FilterManager } from './operations/filter-manager';
-import { PaginationManager } from './operations/pagination-manager';
-import { RelationManager } from './operations/relation-manager';
-import { RelationIncludeOptions } from './relation-types';
-import { JOIN_KINDS, JoinKind, ORDER_DIRECTIONS, OrderDirection } from '../constants/sql';
-import { Entity, RelationMap } from '../schema/types';
-import { OrmContext } from '../runtime/orm-context';
-import { executeHydrated } from '../runtime/execute';
+} from './select-query-builder-deps.js';
+import { QueryAstService } from './query-ast-service.js';
+import { ColumnSelector } from './column-selector.js';
+import { RelationManager } from './relation-manager.js';
+import { RelationIncludeOptions } from './relation-types.js';
+import { JOIN_KINDS, JoinKind, ORDER_DIRECTIONS, OrderDirection } from '../core/sql/sql.js';
+import { Entity, RelationMap } from '../schema/types.js';
+import { OrmContext } from '../orm/orm-context.js';
+import { executeHydrated } from '../orm/execute.js';
+import { createJoinNode } from '../core/ast/join-node.js';
 
 /**
  * Main query builder class for constructing SQL SELECT queries
@@ -42,10 +40,6 @@ export class SelectQueryBuilder<T = any, TTable extends TableDef = TableDef> {
   private readonly env: SelectQueryBuilderEnvironment;
   private readonly context: SelectQueryBuilderContext;
   private readonly columnSelector: ColumnSelector;
-  private readonly cteManager: CteManager;
-  private readonly joinManager: JoinManager;
-  private readonly filterManager: FilterManager;
-  private readonly paginationManager: PaginationManager;
   private readonly relationManager: RelationManager;
   private readonly lazyRelations: Set<string>;
 
@@ -60,10 +54,10 @@ export class SelectQueryBuilder<T = any, TTable extends TableDef = TableDef> {
     table: TTable,
     state?: SelectQueryState,
     hydration?: HydrationManager,
-    dependencies?: SelectQueryBuilderDependencies,
+    dependencies?: Partial<SelectQueryBuilderDependencies>,
     lazyRelations?: Set<string>
   ) {
-    const deps = dependencies ?? defaultSelectQueryBuilderDependencies;
+    const deps = resolveSelectQueryBuilderDependencies(dependencies);
     this.env = { table, deps };
     const initialState = state ?? deps.createState(table);
     const initialHydration = hydration ?? deps.createHydration(table);
@@ -73,10 +67,6 @@ export class SelectQueryBuilder<T = any, TTable extends TableDef = TableDef> {
     };
     this.lazyRelations = new Set(lazyRelations ?? []);
     this.columnSelector = new ColumnSelector(this.env);
-    this.cteManager = new CteManager(this.env);
-    this.joinManager = new JoinManager(this.env);
-    this.filterManager = new FilterManager(this.env);
-    this.paginationManager = new PaginationManager(this.env);
     this.relationManager = new RelationManager(this.env);
   }
 
@@ -87,15 +77,34 @@ export class SelectQueryBuilder<T = any, TTable extends TableDef = TableDef> {
     return new SelectQueryBuilder(this.env.table as TTable, context.state, context.hydration, this.env.deps, lazyRelations);
   }
 
-  private resolveQueryNode(query: SelectQueryBuilder<any, TableDef<any>> | SelectQueryNode): SelectQueryNode {
-    return typeof (query as any).getAST === 'function'
-      ? (query as SelectQueryBuilder<any, TableDef<any>>).getAST()
-      : (query as SelectQueryNode);
-  }
+  private resolveQueryNode(query: SelectQueryBuilder<any, TableDef<any>> | SelectQueryNode): SelectQueryNode {
+    return typeof (query as any).getAST === 'function'
+      ? (query as SelectQueryBuilder<any, TableDef<any>>).getAST()
+      : (query as SelectQueryNode);
+  }
+
+  private createChildBuilder<R, TChild extends TableDef>(table: TChild): SelectQueryBuilder<R, TChild> {
+    return new SelectQueryBuilder(table, undefined, undefined, this.env.deps);
+  }
+
+  private applyAst(
+    context: SelectQueryBuilderContext,
+    mutator: (service: QueryAstService) => SelectQueryState
+  ): SelectQueryBuilderContext {
+    const astService = this.env.deps.createQueryAstService(this.env.table, context.state);
+    const nextState = mutator(astService);
+    return { state: nextState, hydration: context.hydration };
+  }
 
-  private createChildBuilder<R, TChild extends TableDef>(table: TChild): SelectQueryBuilder<R, TChild> {
-    return new SelectQueryBuilder(table, undefined, undefined, this.env.deps);
-  }
+  private applyJoin(
+    context: SelectQueryBuilderContext,
+    table: TableDef,
+    condition: BinaryExpressionNode,
+    kind: JoinKind
+  ): SelectQueryBuilderContext {
+    const joinNode = createJoinNode(kind, table.name, condition);
+    return this.applyAst(context, service => service.withJoin(joinNode));
+  }
 
   /**
    * Selects specific columns for the query
@@ -122,9 +131,9 @@ export class SelectQueryBuilder<T = any, TTable extends TableDef = TableDef> {
    * @param columns - Optional column names for the CTE
    * @returns New query builder instance with the CTE
    */
-  with(name: string, query: SelectQueryBuilder<any, TableDef<any>> | SelectQueryNode, columns?: string[]): SelectQueryBuilder<T, TTable> {
+  with(name: string, query: SelectQueryBuilder<any, TableDef<any>> | SelectQueryNode, columns?: string[]): SelectQueryBuilder<T, TTable> {
     const subAst = this.resolveQueryNode(query);
-    const nextContext = this.cteManager.withCte(this.context, name, subAst, columns, false);
+    const nextContext = this.applyAst(this.context, service => service.withCte(name, subAst, columns, false));
     return this.clone(nextContext);
   }
 
@@ -135,9 +144,9 @@ export class SelectQueryBuilder<T = any, TTable extends TableDef = TableDef> {
    * @param columns - Optional column names for the CTE
    * @returns New query builder instance with the recursive CTE
    */
-  withRecursive(name: string, query: SelectQueryBuilder<any, TableDef<any>> | SelectQueryNode, columns?: string[]): SelectQueryBuilder<T, TTable> {
+  withRecursive(name: string, query: SelectQueryBuilder<any, TableDef<any>> | SelectQueryNode, columns?: string[]): SelectQueryBuilder<T, TTable> {
     const subAst = this.resolveQueryNode(query);
-    const nextContext = this.cteManager.withCte(this.context, name, subAst, columns, true);
+    const nextContext = this.applyAst(this.context, service => service.withCte(name, subAst, columns, true));
     return this.clone(nextContext);
   }
 
@@ -147,7 +156,7 @@ export class SelectQueryBuilder<T = any, TTable extends TableDef = TableDef> {
    * @param sub - Query builder or query node for the subquery
    * @returns New query builder instance with the subquery selection
    */
-  selectSubquery(alias: string, sub: SelectQueryBuilder<any, TableDef<any>> | SelectQueryNode): SelectQueryBuilder<T, TTable> {
+  selectSubquery(alias: string, sub: SelectQueryBuilder<any, TableDef<any>> | SelectQueryNode): SelectQueryBuilder<T, TTable> {
     const query = this.resolveQueryNode(sub);
     return this.clone(this.columnSelector.selectSubquery(this.context, alias, query));
   }
@@ -159,7 +168,7 @@ export class SelectQueryBuilder<T = any, TTable extends TableDef = TableDef> {
    * @returns New query builder instance with the INNER JOIN
    */
   innerJoin(table: TableDef, condition: BinaryExpressionNode): SelectQueryBuilder<T, TTable> {
-    const nextContext = this.joinManager.join(this.context, table, condition, JOIN_KINDS.INNER);
+    const nextContext = this.applyJoin(this.context, table, condition, JOIN_KINDS.INNER);
     return this.clone(nextContext);
   }
 
@@ -170,7 +179,7 @@ export class SelectQueryBuilder<T = any, TTable extends TableDef = TableDef> {
    * @returns New query builder instance with the LEFT JOIN
    */
   leftJoin(table: TableDef, condition: BinaryExpressionNode): SelectQueryBuilder<T, TTable> {
-    const nextContext = this.joinManager.join(this.context, table, condition, JOIN_KINDS.LEFT);
+    const nextContext = this.applyJoin(this.context, table, condition, JOIN_KINDS.LEFT);
     return this.clone(nextContext);
   }
 
@@ -181,7 +190,7 @@ export class SelectQueryBuilder<T = any, TTable extends TableDef = TableDef> {
    * @returns New query builder instance with the RIGHT JOIN
    */
   rightJoin(table: TableDef, condition: BinaryExpressionNode): SelectQueryBuilder<T, TTable> {
-    const nextContext = this.joinManager.join(this.context, table, condition, JOIN_KINDS.RIGHT);
+    const nextContext = this.applyJoin(this.context, table, condition, JOIN_KINDS.RIGHT);
     return this.clone(nextContext);
   }
 
@@ -223,7 +232,7 @@ export class SelectQueryBuilder<T = any, TTable extends TableDef = TableDef> {
     return this.clone(nextContext);
   }
 
-  includeLazy<K extends keyof RelationMap<TTable>>(relationName: K): SelectQueryBuilder<T, TTable> {
+  includeLazy<K extends keyof RelationMap<TTable>>(relationName: K): SelectQueryBuilder<T, TTable> {
     const nextLazy = new Set(this.lazyRelations);
     nextLazy.add(relationName as string);
     return this.clone(this.context, nextLazy);
@@ -247,7 +256,7 @@ export class SelectQueryBuilder<T = any, TTable extends TableDef = TableDef> {
    * @returns New query builder instance with the WHERE condition
    */
   where(expr: ExpressionNode): SelectQueryBuilder<T, TTable> {
-    const nextContext = this.filterManager.where(this.context, expr);
+    const nextContext = this.applyAst(this.context, service => service.withWhere(expr));
     return this.clone(nextContext);
   }
 
@@ -257,7 +266,7 @@ export class SelectQueryBuilder<T = any, TTable extends TableDef = TableDef> {
    * @returns New query builder instance with the GROUP BY clause
    */
   groupBy(col: ColumnDef | ColumnNode): SelectQueryBuilder<T, TTable> {
-    const nextContext = this.filterManager.groupBy(this.context, col);
+    const nextContext = this.applyAst(this.context, service => service.withGroupBy(col));
     return this.clone(nextContext);
   }
 
@@ -267,7 +276,7 @@ export class SelectQueryBuilder<T = any, TTable extends TableDef = TableDef> {
    * @returns New query builder instance with the HAVING condition
    */
   having(expr: ExpressionNode): SelectQueryBuilder<T, TTable> {
-    const nextContext = this.filterManager.having(this.context, expr);
+    const nextContext = this.applyAst(this.context, service => service.withHaving(expr));
     return this.clone(nextContext);
   }
 
@@ -278,7 +287,7 @@ export class SelectQueryBuilder<T = any, TTable extends TableDef = TableDef> {
    * @returns New query builder instance with the ORDER BY clause
    */
   orderBy(col: ColumnDef | ColumnNode, direction: OrderDirection = ORDER_DIRECTIONS.ASC): SelectQueryBuilder<T, TTable> {
-    const nextContext = this.filterManager.orderBy(this.context, col, direction);
+    const nextContext = this.applyAst(this.context, service => service.withOrderBy(col, direction));
     return this.clone(nextContext);
   }
 
@@ -297,7 +306,7 @@ export class SelectQueryBuilder<T = any, TTable extends TableDef = TableDef> {
    * @returns New query builder instance with the LIMIT clause
    */
   limit(n: number): SelectQueryBuilder<T, TTable> {
-    const nextContext = this.paginationManager.limit(this.context, n);
+    const nextContext = this.applyAst(this.context, service => service.withLimit(n));
     return this.clone(nextContext);
   }
 
@@ -307,7 +316,7 @@ export class SelectQueryBuilder<T = any, TTable extends TableDef = TableDef> {
    * @returns New query builder instance with the OFFSET clause
    */
   offset(n: number): SelectQueryBuilder<T, TTable> {
-    const nextContext = this.paginationManager.offset(this.context, n);
+    const nextContext = this.applyAst(this.context, service => service.withOffset(n));
     return this.clone(nextContext);
   }
 
@@ -316,7 +325,7 @@ export class SelectQueryBuilder<T = any, TTable extends TableDef = TableDef> {
    * @param subquery - Subquery to check for existence
    * @returns New query builder instance with the WHERE EXISTS condition
    */
-  whereExists(subquery: SelectQueryBuilder<any, TableDef<any>> | SelectQueryNode): SelectQueryBuilder<T, TTable> {
+  whereExists(subquery: SelectQueryBuilder<any, TableDef<any>> | SelectQueryNode): SelectQueryBuilder<T, TTable> {
     const subAst = this.resolveQueryNode(subquery);
     return this.where(exists(subAst));
   }
@@ -326,7 +335,7 @@ export class SelectQueryBuilder<T = any, TTable extends TableDef = TableDef> {
    * @param subquery - Subquery to check for non-existence
    * @returns New query builder instance with the WHERE NOT EXISTS condition
    */
-  whereNotExists(subquery: SelectQueryBuilder<any, TableDef<any>> | SelectQueryNode): SelectQueryBuilder<T, TTable> {
+  whereNotExists(subquery: SelectQueryBuilder<any, TableDef<any>> | SelectQueryNode): SelectQueryBuilder<T, TTable> {
     const subAst = this.resolveQueryNode(subquery);
     return this.where(notExists(subAst));
   }
@@ -337,18 +346,18 @@ export class SelectQueryBuilder<T = any, TTable extends TableDef = TableDef> {
    * @param callback - Optional callback to modify the relationship query
    * @returns New query builder instance with the relationship existence check
    */
-  whereHas(
-    relationName: string,
-    callback?: <TChildTable extends TableDef>(
-      qb: SelectQueryBuilder<any, TChildTable>
-    ) => SelectQueryBuilder<any, TChildTable>
-  ): SelectQueryBuilder<T, TTable> {
+  whereHas(
+    relationName: string,
+    callback?: <TChildTable extends TableDef>(
+      qb: SelectQueryBuilder<any, TChildTable>
+    ) => SelectQueryBuilder<any, TChildTable>
+  ): SelectQueryBuilder<T, TTable> {
     const relation = this.env.table.relations[relationName];
     if (!relation) {
       throw new Error(`Relation '${relationName}' not found on table '${this.env.table.name}'`);
     }
 
-    let subQb = this.createChildBuilder<any, typeof relation.target>(relation.target);
+    let subQb = this.createChildBuilder<any, typeof relation.target>(relation.target);
     if (callback) {
       subQb = callback(subQb);
     }
@@ -364,18 +373,18 @@ export class SelectQueryBuilder<T = any, TTable extends TableDef = TableDef> {
    * @param callback - Optional callback to modify the relationship query
    * @returns New query builder instance with the relationship non-existence check
    */
-  whereHasNot(
-    relationName: string,
-    callback?: <TChildTable extends TableDef>(
-      qb: SelectQueryBuilder<any, TChildTable>
-    ) => SelectQueryBuilder<any, TChildTable>
-  ): SelectQueryBuilder<T, TTable> {
+  whereHasNot(
+    relationName: string,
+    callback?: <TChildTable extends TableDef>(
+      qb: SelectQueryBuilder<any, TChildTable>
+    ) => SelectQueryBuilder<any, TChildTable>
+  ): SelectQueryBuilder<T, TTable> {
     const relation = this.env.table.relations[relationName];
     if (!relation) {
       throw new Error(`Relation '${relationName}' not found on table '${this.env.table.name}'`);
     }
 
-    let subQb = this.createChildBuilder<any, typeof relation.target>(relation.target);
+    let subQb = this.createChildBuilder<any, typeof relation.target>(relation.target);
     if (callback) {
       subQb = callback(subQb);
     }

package/src/{builder → query-builder}/update-query-state.ts

@@ -1,59 +1,55 @@
-import { TableDef } from '../schema/table';
-import { ColumnNode, ExpressionNode, valueToOperand } from '../ast/expression';
-import { TableNode, UpdateQueryNode, UpdateAssignmentNode } from '../ast/query';
-
-const createTableNode = (table: TableDef): TableNode => ({
-  type: 'Table',
-  name: table.name
-});
-
-/**
- * Immutable state for UPDATE queries
- */
-export class UpdateQueryState {
-  public readonly table: TableDef;
-  public readonly ast: UpdateQueryNode;
-
-  constructor(table: TableDef, ast?: UpdateQueryNode) {
-    this.table = table;
-    this.ast = ast ?? {
-      type: 'UpdateQuery',
-      table: createTableNode(table),
-      set: []
-    };
-  }
-
-  private clone(nextAst: UpdateQueryNode): UpdateQueryState {
-    return new UpdateQueryState(this.table, nextAst);
-  }
-
-  withSet(values: Record<string, unknown>): UpdateQueryState {
-    const assignments: UpdateAssignmentNode[] = Object.entries(values).map(([column, value]) => ({
-      column: {
-        type: 'Column',
-        table: this.table.name,
-        name: column
-      },
-      value: valueToOperand(value)
-    }));
-
-    return this.clone({
-      ...this.ast,
-      set: assignments
-    });
-  }
-
-  withWhere(expr: ExpressionNode): UpdateQueryState {
-    return this.clone({
-      ...this.ast,
-      where: expr
-    });
-  }
-
-  withReturning(columns: ColumnNode[]): UpdateQueryState {
-    return this.clone({
-      ...this.ast,
-      returning: [...columns]
-    });
-  }
-}
+import { TableDef } from '../schema/table.js';
+import { ColumnNode, ExpressionNode, valueToOperand } from '../core/ast/expression.js';
+import { TableNode, UpdateQueryNode, UpdateAssignmentNode } from '../core/ast/query.js';
+import { createTableNode } from '../core/ast/builders.js';
+
+/**
+ * Immutable state for UPDATE queries
+ */
+export class UpdateQueryState {
+  public readonly table: TableDef;
+  public readonly ast: UpdateQueryNode;
+
+  constructor(table: TableDef, ast?: UpdateQueryNode) {
+    this.table = table;
+    this.ast = ast ?? {
+      type: 'UpdateQuery',
+      table: createTableNode(table),
+      set: []
+    };
+  }
+
+  private clone(nextAst: UpdateQueryNode): UpdateQueryState {
+    return new UpdateQueryState(this.table, nextAst);
+  }
+
+  withSet(values: Record<string, unknown>): UpdateQueryState {
+    const assignments: UpdateAssignmentNode[] = Object.entries(values).map(([column, value]) => ({
+      column: {
+        type: 'Column',
+        table: this.table.name,
+        name: column
+      },
+      value: valueToOperand(value)
+    }));
+
+    return this.clone({
+      ...this.ast,
+      set: assignments
+    });
+  }
+
+  withWhere(expr: ExpressionNode): UpdateQueryState {
+    return this.clone({
+      ...this.ast,
+      where: expr
+    });
+  }
+
+  withReturning(columns: ColumnNode[]): UpdateQueryState {
+    return this.clone({
+      ...this.ast,
+      returning: [...columns]
+    });
+  }
+}

package/src/{builder → query-builder}/update.ts

@@ -1,61 +1,50 @@
-import { TableDef } from '../schema/table';
-import { ColumnDef } from '../schema/column';
-import { ColumnNode, ExpressionNode } from '../ast/expression';
-import { CompiledQuery, UpdateCompiler } from '../dialect/abstract';
-import { UpdateQueryNode } from '../ast/query';
-import { UpdateQueryState } from './update-query-state';
-
-const buildColumnNode = (table: TableDef, column: ColumnDef | ColumnNode): ColumnNode => {
-  if ((column as ColumnNode).type === 'Column') {
-    return column as ColumnNode;
-  }
-  const def = column as ColumnDef;
-  return {
-    type: 'Column',
-    table: def.table || table.name,
-    name: def.name
-  };
-};
-
-/**
- * Builder for UPDATE queries
- */
-export class UpdateQueryBuilder<T> {
-  private readonly table: TableDef;
-  private readonly state: UpdateQueryState;
-
-  constructor(table: TableDef, state?: UpdateQueryState) {
-    this.table = table;
-    this.state = state ?? new UpdateQueryState(table);
-  }
-
-  private clone(state: UpdateQueryState): UpdateQueryBuilder<T> {
-    return new UpdateQueryBuilder(this.table, state);
-  }
-
-  set(values: Record<string, unknown>): UpdateQueryBuilder<T> {
-    return this.clone(this.state.withSet(values));
-  }
-
-  where(expr: ExpressionNode): UpdateQueryBuilder<T> {
-    return this.clone(this.state.withWhere(expr));
-  }
-
-  returning(...columns: (ColumnDef | ColumnNode)[]): UpdateQueryBuilder<T> {
-    if (!columns.length) return this;
-    const nodes = columns.map(column => buildColumnNode(this.table, column));
-    return this.clone(this.state.withReturning(nodes));
-  }
-
-  compile(compiler: UpdateCompiler): CompiledQuery {
-    return compiler.compileUpdate(this.state.ast);
-  }
-
-  toSql(compiler: UpdateCompiler): string {
-    return this.compile(compiler).sql;
-  }
-
-  getAST(): UpdateQueryNode {
-    return this.state.ast;
-  }
-}
+import { TableDef } from '../schema/table.js';
+import { ColumnDef } from '../schema/column.js';
+import { ColumnNode, ExpressionNode } from '../core/ast/expression.js';
+import { CompiledQuery, UpdateCompiler } from '../core/dialect/abstract.js';
+import { UpdateQueryNode } from '../core/ast/query.js';
+import { UpdateQueryState } from './update-query-state.js';
+import { buildColumnNode } from '../core/ast/builders.js';
+
+/**
+ * Builder for UPDATE queries
+ */
+export class UpdateQueryBuilder<T> {
+  private readonly table: TableDef;
+  private readonly state: UpdateQueryState;
+
+  constructor(table: TableDef, state?: UpdateQueryState) {
+    this.table = table;
+    this.state = state ?? new UpdateQueryState(table);
+  }
+
+  private clone(state: UpdateQueryState): UpdateQueryBuilder<T> {
+    return new UpdateQueryBuilder(this.table, state);
+  }
+
+  set(values: Record<string, unknown>): UpdateQueryBuilder<T> {
+    return this.clone(this.state.withSet(values));
+  }
+
+  where(expr: ExpressionNode): UpdateQueryBuilder<T> {
+    return this.clone(this.state.withWhere(expr));
+  }
+
+  returning(...columns: (ColumnDef | ColumnNode)[]): UpdateQueryBuilder<T> {
+    if (!columns.length) return this;
+    const nodes = columns.map(column => buildColumnNode(this.table, column));
+    return this.clone(this.state.withReturning(nodes));
+  }
+
+  compile(compiler: UpdateCompiler): CompiledQuery {
+    return compiler.compileUpdate(this.state.ast);
+  }
+
+  toSql(compiler: UpdateCompiler): string {
+    return this.compile(compiler).sql;
+  }
+
+  getAST(): UpdateQueryNode {
+    return this.state.ast;
+  }
+}

package/src/schema/column.ts

@@ -20,54 +20,54 @@ export type ColumnType =
 /**
  * Definition of a database column
  */
-export interface ColumnDef {
-  /** Column name (filled at runtime by defineTable) */
-  name: string;
-  /** Data type of the column */
-  type: ColumnType;
-  /** Whether this column is a primary key */
-  primary?: boolean;
-  /** Whether this column cannot be null */
-  notNull?: boolean;
-  /** Additional arguments for the column type (e.g., VARCHAR length) */
-  args?: any[];
-  /** Table name this column belongs to (filled at runtime by defineTable) */
-  table?: string;
-}
+export interface ColumnDef<T extends ColumnType = ColumnType> {
+  /** Column name (filled at runtime by defineTable) */
+  name: string;
+  /** Data type of the column */
+  type: T;
+  /** Whether this column is a primary key */
+  primary?: boolean;
+  /** Whether this column cannot be null */
+  notNull?: boolean;
+  /** Additional arguments for the column type (e.g., VARCHAR length) */
+  args?: any[];
+  /** Table name this column belongs to (filled at runtime by defineTable) */
+  table?: string;
+}
 
 /**
  * Factory for creating column definitions with common data types
  */
-export const col = {
-  /**
-   * Creates an integer column definition
-   * @returns ColumnDef with INT type
-   */
-  int: (): ColumnDef => ({ name: '', type: 'INT' }),
+export const col = {
+  /**
+   * Creates an integer column definition
+   * @returns ColumnDef with INT type
+   */
+  int: (): ColumnDef<'INT'> => ({ name: '', type: 'INT' }),
 
   /**
    * Creates a variable character column definition
    * @param length - Maximum length of the string
    * @returns ColumnDef with VARCHAR type
    */
-  varchar: (length: number): ColumnDef => ({ name: '', type: 'VARCHAR', args: [length] }),
+  varchar: (length: number): ColumnDef<'VARCHAR'> => ({ name: '', type: 'VARCHAR', args: [length] }),
 
   /**
    * Creates a JSON column definition
    * @returns ColumnDef with JSON type
    */
-  json: (): ColumnDef => ({ name: '', type: 'JSON' }),
+  json: (): ColumnDef<'JSON'> => ({ name: '', type: 'JSON' }),
 
   /**
    * Creates a boolean column definition
    * @returns ColumnDef with BOOLEAN type
    */
-  boolean: (): ColumnDef => ({ name: '', type: 'BOOLEAN' }),
+  boolean: (): ColumnDef<'BOOLEAN'> => ({ name: '', type: 'BOOLEAN' }),
 
   /**
    * Marks a column definition as a primary key
    * @param def - Column definition to modify
    * @returns Modified ColumnDef with primary: true
    */
-  primaryKey: (def: ColumnDef): ColumnDef => ({ ...def, primary: true })
-};
+  primaryKey: <T extends ColumnType>(def: ColumnDef<T>): ColumnDef<T> => ({ ...def, primary: true })
+};