metal-orm 1.0.8 → 1.0.9

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

@@ -1,94 +1,112 @@
-import { TableDef } from '../schema/table';
-import { SelectQueryState } from './select-query-state';
-import { HydrationManager } from './hydration-manager';
-import { HydrationPlanner } from './hydration-planner';
-import { QueryAstService } from './query-ast-service';
-import { RelationService } from './relation-service';
-
-/**
- * Context for query building operations
- */
-export interface SelectQueryBuilderContext {
-  /**
-   * Current query state
-   */
-  readonly state: SelectQueryState;
-  /**
-   * Hydration manager for the query
-   */
-  readonly hydration: HydrationManager;
-}
-
-/**
- * Dependencies for query builder operations
- */
-export interface SelectQueryBuilderDependencies {
-  /**
-   * Creates a new query state
-   * @param table - Table definition
-   * @returns New query state
-   */
-  createState: (table: TableDef) => SelectQueryState;
-  /**
-   * Creates a new hydration manager
-   * @param table - Table definition
-   * @returns New hydration manager
-   */
-  createHydration: (table: TableDef) => HydrationManager;
-  /**
-   * Creates a new hydration planner
-   * @param table - Table definition
-   * @returns Hydration planner
-   */
-  createHydrationPlanner: (table: TableDef) => HydrationPlanner;
-  /**
-   * Creates a new query AST service
-   * @param table - Table definition
-   * @param state - Query state
-   * @returns New query AST service
-   */
-  createQueryAstService: (table: TableDef, state: SelectQueryState) => QueryAstService;
-  /**
-   * Creates a new relation service
-   * @param table - Table definition
-   * @param state - Query state
-   * @param hydration - Hydration manager
-   * @returns New relation service
-   */
-  createRelationService: (
-    table: TableDef,
-    state: SelectQueryState,
-    hydration: HydrationManager
-  ) => RelationService;
-}
-
-/**
- * Environment for query builder operations
- */
-export interface SelectQueryBuilderEnvironment {
-  /**
-   * Table definition
-   */
-  readonly table: TableDef;
-  /**
-   * Query builder dependencies
-   */
-  readonly deps: SelectQueryBuilderDependencies;
-}
-
-/**
- * Default implementation of query builder dependencies
- */
-const defaultCreateQueryAstService = (table: TableDef, state: SelectQueryState) => new QueryAstService(table, state);
-const defaultCreateHydrationPlanner = (table: TableDef) => new HydrationPlanner(table);
-const defaultCreateHydration = (table: TableDef) =>
-  new HydrationManager(table, defaultCreateHydrationPlanner(table));
-
-export const defaultSelectQueryBuilderDependencies: SelectQueryBuilderDependencies = {
-  createState: table => new SelectQueryState(table),
-  createHydration: defaultCreateHydration,
-  createHydrationPlanner: defaultCreateHydrationPlanner,
-  createQueryAstService: defaultCreateQueryAstService,
-  createRelationService: (table, state, hydration) =>
-    new RelationService(table, state, hydration, defaultCreateQueryAstService)
-};
+import { TableDef } from '../schema/table.js';
+import { SelectQueryState } from './select-query-state.js';
+import { HydrationManager } from './hydration-manager.js';
+import { HydrationPlanner } from './hydration-planner.js';
+import { QueryAstService } from './query-ast-service.js';
+import { RelationService } from './relation-service.js';
+
+/**
+ * Context for query building operations
+ */
+export interface SelectQueryBuilderContext {
+  /**
+   * Current query state
+   */
+  readonly state: SelectQueryState;
+  /**
+   * Hydration manager for the query
+   */
+  readonly hydration: HydrationManager;
+}
+
+/**
+ * Dependencies for query builder operations
+ */
+export interface SelectQueryBuilderDependencies {
+  /**
+   * Creates a new query state
+   * @param table - Table definition
+   * @returns New query state
+   */
+  createState: (table: TableDef) => SelectQueryState;
+  /**
+   * Creates a new hydration manager
+   * @param table - Table definition
+   * @returns New hydration manager
+   */
+  createHydration: (table: TableDef) => HydrationManager;
+  /**
+   * Creates a new hydration planner
+   * @param table - Table definition
+   * @returns Hydration planner
+   */
+  createHydrationPlanner: (table: TableDef) => HydrationPlanner;
+  /**
+   * Creates a new query AST service
+   * @param table - Table definition
+   * @param state - Query state
+   * @returns New query AST service
+   */
+  createQueryAstService: (table: TableDef, state: SelectQueryState) => QueryAstService;
+  /**
+   * Creates a new relation service
+   * @param table - Table definition
+   * @param state - Query state
+   * @param hydration - Hydration manager
+   * @returns New relation service
+   */
+  createRelationService: (
+    table: TableDef,
+    state: SelectQueryState,
+    hydration: HydrationManager
+  ) => RelationService;
+}
+
+/**
+ * Environment for query builder operations
+ */
+export interface SelectQueryBuilderEnvironment {
+  /**
+   * Table definition
+   */
+  readonly table: TableDef;
+  /**
+   * Query builder dependencies
+   */
+  readonly deps: SelectQueryBuilderDependencies;
+}
+
+/**
+ * Default implementations for query builder dependencies
+ */
+const defaultCreateQueryAstService = (table: TableDef, state: SelectQueryState) => new QueryAstService(table, state);
+const defaultCreateHydrationPlanner = (table: TableDef) => new HydrationPlanner(table);
+
+const defaultCreateHydration = (table: TableDef, plannerFactory: (table: TableDef) => HydrationPlanner) =>
+  new HydrationManager(table, plannerFactory(table));
+
+/**
+ * Resolves query builder dependencies by merging overrides with internal defaults
+ * @param overrides - Partial overrides for dependency factories
+ */
+export const resolveSelectQueryBuilderDependencies = (
+  overrides: Partial<SelectQueryBuilderDependencies> = {}
+): SelectQueryBuilderDependencies => {
+  const createQueryAstService = overrides.createQueryAstService ?? defaultCreateQueryAstService;
+  const createHydrationPlanner = overrides.createHydrationPlanner ?? defaultCreateHydrationPlanner;
+  const createHydration =
+    overrides.createHydration ?? (table => defaultCreateHydration(table, createHydrationPlanner));
+  const createRelationService =
+    overrides.createRelationService ??
+    ((table, state, hydration) => new RelationService(table, state, hydration, createQueryAstService));
+
+  return {
+    createState: overrides.createState ?? (table => new SelectQueryState(table)),
+    createHydration,
+    createHydrationPlanner,
+    createQueryAstService,
+    createRelationService
+  };
+};
+
+export const defaultSelectQueryBuilderDependencies = resolveSelectQueryBuilderDependencies();

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

@@ -1,179 +1,179 @@
-import { TableDef } from '../schema/table';
-import { SelectQueryNode, CommonTableExpressionNode, OrderByNode } from '../ast/query';
-import {
-  ColumnNode,
-  ExpressionNode,
-  FunctionNode,
-  ScalarSubqueryNode,
-  CaseExpressionNode,
-  WindowFunctionNode
-} from '../ast/expression';
-import { JoinNode } from '../ast/join';
-
-/**
- * Node types that can be used in query projections
- */
-export type ProjectionNode =
-  | ColumnNode
-  | FunctionNode
-  | ScalarSubqueryNode
-  | CaseExpressionNode
-  | WindowFunctionNode;
-
-/**
- * Manages the state of a SELECT query being built
- */
-export class SelectQueryState {
-  /**
-   * Table definition for the query
-   */
-  public readonly table: TableDef;
-  /**
-   * Abstract Syntax Tree (AST) representation of the query
-   */
-  public readonly ast: SelectQueryNode;
-
-  /**
-   * Creates a new SelectQueryState instance
-   * @param table - Table definition
-   * @param ast - Optional existing AST
-   */
-  constructor(table: TableDef, ast?: SelectQueryNode) {
-    this.table = table;
-    this.ast = ast ?? {
-      type: 'SelectQuery',
-      from: { type: 'Table', name: table.name },
-      columns: [],
-      joins: []
-    };
-  }
-
-  /**
-   * Creates a new SelectQueryState with updated AST
-   * @param nextAst - Updated AST
-   * @returns New SelectQueryState instance
-   */
-  private clone(nextAst: SelectQueryNode): SelectQueryState {
-    return new SelectQueryState(this.table, nextAst);
-  }
-
-  /**
-   * Adds columns to the query
-   * @param newCols - Columns to add
-   * @returns New SelectQueryState with added columns
-   */
-  withColumns(newCols: ProjectionNode[]): SelectQueryState {
-    return this.clone({
-      ...this.ast,
-      columns: [...(this.ast.columns ?? []), ...newCols]
-    });
-  }
-
-  /**
-   * Adds a join to the query
-   * @param join - Join node to add
-   * @returns New SelectQueryState with added join
-   */
-  withJoin(join: JoinNode): SelectQueryState {
-    return this.clone({
-      ...this.ast,
-      joins: [...(this.ast.joins ?? []), join]
-    });
-  }
-
-  /**
-   * Adds a WHERE clause to the query
-   * @param predicate - WHERE predicate expression
-   * @returns New SelectQueryState with WHERE clause
-   */
-  withWhere(predicate: ExpressionNode): SelectQueryState {
-    return this.clone({
-      ...this.ast,
-      where: predicate
-    });
-  }
-
-  /**
-   * Adds a HAVING clause to the query
-   * @param predicate - HAVING predicate expression
-   * @returns New SelectQueryState with HAVING clause
-   */
-  withHaving(predicate: ExpressionNode): SelectQueryState {
-    return this.clone({
-      ...this.ast,
-      having: predicate
-    });
-  }
-
-  /**
-   * Adds GROUP BY columns to the query
-   * @param columns - Columns to group by
-   * @returns New SelectQueryState with GROUP BY clause
-   */
-  withGroupBy(columns: ColumnNode[]): SelectQueryState {
-    return this.clone({
-      ...this.ast,
-      groupBy: [...(this.ast.groupBy ?? []), ...columns]
-    });
-  }
-
-  /**
-   * Adds ORDER BY clauses to the query
-   * @param orderBy - ORDER BY nodes
-   * @returns New SelectQueryState with ORDER BY clause
-   */
-  withOrderBy(orderBy: OrderByNode[]): SelectQueryState {
-    return this.clone({
-      ...this.ast,
-      orderBy: [...(this.ast.orderBy ?? []), ...orderBy]
-    });
-  }
-
-  /**
-   * Adds DISTINCT columns to the query
-   * @param columns - Columns to make distinct
-   * @returns New SelectQueryState with DISTINCT clause
-   */
-  withDistinct(columns: ColumnNode[]): SelectQueryState {
-    return this.clone({
-      ...this.ast,
-      distinct: [...(this.ast.distinct ?? []), ...columns]
-    });
-  }
-
-  /**
-   * Adds a LIMIT clause to the query
-   * @param limit - Maximum number of rows to return
-   * @returns New SelectQueryState with LIMIT clause
-   */
-  withLimit(limit: number): SelectQueryState {
-    return this.clone({
-      ...this.ast,
-      limit
-    });
-  }
-
-  /**
-   * Adds an OFFSET clause to the query
-   * @param offset - Number of rows to skip
-   * @returns New SelectQueryState with OFFSET clause
-   */
-  withOffset(offset: number): SelectQueryState {
-    return this.clone({
-      ...this.ast,
-      offset
-    });
-  }
-
-  /**
-   * Adds a Common Table Expression (CTE) to the query
-   * @param cte - CTE node to add
-   * @returns New SelectQueryState with CTE
-   */
-  withCte(cte: CommonTableExpressionNode): SelectQueryState {
-    return this.clone({
-      ...this.ast,
-      ctes: [...(this.ast.ctes ?? []), cte]
-    });
-  }
-}
+import { TableDef } from '../schema/table.js';
+import { SelectQueryNode, CommonTableExpressionNode, OrderByNode } from '../core/ast/query.js';
+import {
+  ColumnNode,
+  ExpressionNode,
+  FunctionNode,
+  ScalarSubqueryNode,
+  CaseExpressionNode,
+  WindowFunctionNode
+} from '../core/ast/expression.js';
+import { JoinNode } from '../core/ast/join.js';
+
+/**
+ * Node types that can be used in query projections
+ */
+export type ProjectionNode =
+  | ColumnNode
+  | FunctionNode
+  | ScalarSubqueryNode
+  | CaseExpressionNode
+  | WindowFunctionNode;
+
+/**
+ * Manages the state of a SELECT query being built
+ */
+export class SelectQueryState {
+  /**
+   * Table definition for the query
+   */
+  public readonly table: TableDef;
+  /**
+   * Abstract Syntax Tree (AST) representation of the query
+   */
+  public readonly ast: SelectQueryNode;
+
+  /**
+   * Creates a new SelectQueryState instance
+   * @param table - Table definition
+   * @param ast - Optional existing AST
+   */
+  constructor(table: TableDef, ast?: SelectQueryNode) {
+    this.table = table;
+    this.ast = ast ?? {
+      type: 'SelectQuery',
+      from: { type: 'Table', name: table.name },
+      columns: [],
+      joins: []
+    };
+  }
+
+  /**
+   * Creates a new SelectQueryState with updated AST
+   * @param nextAst - Updated AST
+   * @returns New SelectQueryState instance
+   */
+  private clone(nextAst: SelectQueryNode): SelectQueryState {
+    return new SelectQueryState(this.table, nextAst);
+  }
+
+  /**
+   * Adds columns to the query
+   * @param newCols - Columns to add
+   * @returns New SelectQueryState with added columns
+   */
+  withColumns(newCols: ProjectionNode[]): SelectQueryState {
+    return this.clone({
+      ...this.ast,
+      columns: [...(this.ast.columns ?? []), ...newCols]
+    });
+  }
+
+  /**
+   * Adds a join to the query
+   * @param join - Join node to add
+   * @returns New SelectQueryState with added join
+   */
+  withJoin(join: JoinNode): SelectQueryState {
+    return this.clone({
+      ...this.ast,
+      joins: [...(this.ast.joins ?? []), join]
+    });
+  }
+
+  /**
+   * Adds a WHERE clause to the query
+   * @param predicate - WHERE predicate expression
+   * @returns New SelectQueryState with WHERE clause
+   */
+  withWhere(predicate: ExpressionNode): SelectQueryState {
+    return this.clone({
+      ...this.ast,
+      where: predicate
+    });
+  }
+
+  /**
+   * Adds a HAVING clause to the query
+   * @param predicate - HAVING predicate expression
+   * @returns New SelectQueryState with HAVING clause
+   */
+  withHaving(predicate: ExpressionNode): SelectQueryState {
+    return this.clone({
+      ...this.ast,
+      having: predicate
+    });
+  }
+
+  /**
+   * Adds GROUP BY columns to the query
+   * @param columns - Columns to group by
+   * @returns New SelectQueryState with GROUP BY clause
+   */
+  withGroupBy(columns: ColumnNode[]): SelectQueryState {
+    return this.clone({
+      ...this.ast,
+      groupBy: [...(this.ast.groupBy ?? []), ...columns]
+    });
+  }
+
+  /**
+   * Adds ORDER BY clauses to the query
+   * @param orderBy - ORDER BY nodes
+   * @returns New SelectQueryState with ORDER BY clause
+   */
+  withOrderBy(orderBy: OrderByNode[]): SelectQueryState {
+    return this.clone({
+      ...this.ast,
+      orderBy: [...(this.ast.orderBy ?? []), ...orderBy]
+    });
+  }
+
+  /**
+   * Adds DISTINCT columns to the query
+   * @param columns - Columns to make distinct
+   * @returns New SelectQueryState with DISTINCT clause
+   */
+  withDistinct(columns: ColumnNode[]): SelectQueryState {
+    return this.clone({
+      ...this.ast,
+      distinct: [...(this.ast.distinct ?? []), ...columns]
+    });
+  }
+
+  /**
+   * Adds a LIMIT clause to the query
+   * @param limit - Maximum number of rows to return
+   * @returns New SelectQueryState with LIMIT clause
+   */
+  withLimit(limit: number): SelectQueryState {
+    return this.clone({
+      ...this.ast,
+      limit
+    });
+  }
+
+  /**
+   * Adds an OFFSET clause to the query
+   * @param offset - Number of rows to skip
+   * @returns New SelectQueryState with OFFSET clause
+   */
+  withOffset(offset: number): SelectQueryState {
+    return this.clone({
+      ...this.ast,
+      offset
+    });
+  }
+
+  /**
+   * Adds a Common Table Expression (CTE) to the query
+   * @param cte - CTE node to add
+   * @returns New SelectQueryState with CTE
+   */
+  withCte(cte: CommonTableExpressionNode): SelectQueryState {
+    return this.clone({
+      ...this.ast,
+      ctes: [...(this.ast.ctes ?? []), cte]
+    });
+  }
+}