metal-orm 1.0.8 → 1.0.9

package/src/{builder → query-builder}/hydration-manager.ts

@@ -1,87 +1,87 @@
-import { TableDef } from '../schema/table';
-import { RelationDef } from '../schema/relation';
-import { SelectQueryNode, HydrationPlan } from '../ast/query';
-import { HydrationPlanner } from './hydration-planner';
-import { SelectQueryState, ProjectionNode } from './select-query-state';
-
-/**
- * Manages hydration planning for query results
- */
-export class HydrationManager {
-  /**
-   * Creates a new HydrationManager instance
-   * @param table - Table definition
-   * @param planner - Hydration planner
-   */
-  constructor(
-    private readonly table: TableDef,
-    private readonly planner: HydrationPlanner
-  ) {}
-
-  /**
-   * Creates a new HydrationManager with updated planner
-   * @param nextPlanner - Updated hydration planner
-   * @returns New HydrationManager instance
-   */
-  private clone(nextPlanner: HydrationPlanner): HydrationManager {
-    return new HydrationManager(this.table, nextPlanner);
-  }
-
-  /**
-   * Handles column selection for hydration planning
-   * @param state - Current query state
-   * @param newColumns - Newly selected columns
-   * @returns Updated HydrationManager with captured columns
-   */
-  onColumnsSelected(state: SelectQueryState, newColumns: ProjectionNode[]): HydrationManager {
-    const updated = this.planner.captureRootColumns(newColumns);
-    return this.clone(updated);
-  }
-
-  /**
-   * Handles relation inclusion for hydration planning
-   * @param state - Current query state
-   * @param relation - Relation definition
-   * @param relationName - Name of the relation
-   * @param aliasPrefix - Alias prefix for the relation
-   * @param targetColumns - Target columns to include
-   * @returns Updated HydrationManager with included relation
-   */
-  onRelationIncluded(
-    state: SelectQueryState,
-    relation: RelationDef,
-    relationName: string,
-    aliasPrefix: string,
-    targetColumns: string[],
-    pivot?: { aliasPrefix: string; columns: string[] }
-  ): HydrationManager {
-    const withRoots = this.planner.captureRootColumns(state.ast.columns);
-    const next = withRoots.includeRelation(relation, relationName, aliasPrefix, targetColumns, pivot);
-    return this.clone(next);
-  }
-
-  /**
-   * Applies hydration plan to the AST
-   * @param ast - Query AST to modify
-   * @returns AST with hydration metadata
-   */
-  applyToAst(ast: SelectQueryNode): SelectQueryNode {
-    const plan = this.planner.getPlan();
-    if (!plan) return ast;
-    return {
-      ...ast,
-      meta: {
-        ...(ast.meta || {}),
-        hydration: plan
-      }
-    };
-  }
-
-  /**
-   * Gets the current hydration plan
-   * @returns Hydration plan or undefined if none exists
-   */
-  getPlan(): HydrationPlan | undefined {
-    return this.planner.getPlan();
-  }
-}
+import { TableDef } from '../schema/table.js';
+import { RelationDef } from '../schema/relation.js';
+import { SelectQueryNode, HydrationPlan } from '../core/ast/query.js';
+import { HydrationPlanner } from './hydration-planner.js';
+import { SelectQueryState, ProjectionNode } from './select-query-state.js';
+
+/**
+ * Manages hydration planning for query results
+ */
+export class HydrationManager {
+  /**
+   * Creates a new HydrationManager instance
+   * @param table - Table definition
+   * @param planner - Hydration planner
+   */
+  constructor(
+    private readonly table: TableDef,
+    private readonly planner: HydrationPlanner
+  ) {}
+
+  /**
+   * Creates a new HydrationManager with updated planner
+   * @param nextPlanner - Updated hydration planner
+   * @returns New HydrationManager instance
+   */
+  private clone(nextPlanner: HydrationPlanner): HydrationManager {
+    return new HydrationManager(this.table, nextPlanner);
+  }
+
+  /**
+   * Handles column selection for hydration planning
+   * @param state - Current query state
+   * @param newColumns - Newly selected columns
+   * @returns Updated HydrationManager with captured columns
+   */
+  onColumnsSelected(state: SelectQueryState, newColumns: ProjectionNode[]): HydrationManager {
+    const updated = this.planner.captureRootColumns(newColumns);
+    return this.clone(updated);
+  }
+
+  /**
+   * Handles relation inclusion for hydration planning
+   * @param state - Current query state
+   * @param relation - Relation definition
+   * @param relationName - Name of the relation
+   * @param aliasPrefix - Alias prefix for the relation
+   * @param targetColumns - Target columns to include
+   * @returns Updated HydrationManager with included relation
+   */
+  onRelationIncluded(
+    state: SelectQueryState,
+    relation: RelationDef,
+    relationName: string,
+    aliasPrefix: string,
+    targetColumns: string[],
+    pivot?: { aliasPrefix: string; columns: string[] }
+  ): HydrationManager {
+    const withRoots = this.planner.captureRootColumns(state.ast.columns);
+    const next = withRoots.includeRelation(relation, relationName, aliasPrefix, targetColumns, pivot);
+    return this.clone(next);
+  }
+
+  /**
+   * Applies hydration plan to the AST
+   * @param ast - Query AST to modify
+   * @returns AST with hydration metadata
+   */
+  applyToAst(ast: SelectQueryNode): SelectQueryNode {
+    const plan = this.planner.getPlan();
+    if (!plan) return ast;
+    return {
+      ...ast,
+      meta: {
+        ...(ast.meta || {}),
+        hydration: plan
+      }
+    };
+  }
+
+  /**
+   * Gets the current hydration plan
+   * @returns Hydration plan or undefined if none exists
+   */
+  getPlan(): HydrationPlan | undefined {
+    return this.planner.getPlan();
+  }
+}

package/src/{builder → query-builder}/hydration-planner.ts

@@ -1,182 +1,182 @@
-import { TableDef } from '../schema/table';
-import { RelationDef, RelationKinds, BelongsToManyRelation } from '../schema/relation';
-import { ProjectionNode } from './select-query-state';
-import { HydrationPlan, HydrationRelationPlan } from '../ast/query';
-import { isRelationAlias } from '../utils/relation-alias';
-import { buildDefaultPivotColumns } from './relation-utils';
-
-/**
- * Finds the primary key column name for a table
- * @param table - Table definition
- * @returns Name of the primary key column, defaults to 'id'
- */
-export const findPrimaryKey = (table: TableDef): string => {
-  const pk = Object.values(table.columns).find(c => c.primary);
-  return pk?.name || 'id';
-};
-
-/**
- * Manages hydration planning for query results
- */
-export class HydrationPlanner {
-  /**
-   * Creates a new HydrationPlanner instance
-   * @param table - Table definition
-   * @param plan - Optional existing hydration plan
-   */
-  constructor(private readonly table: TableDef, private readonly plan?: HydrationPlan) { }
-
-  /**
-   * Captures root table columns for hydration planning
-   * @param columns - Columns to capture
-   * @returns Updated HydrationPlanner with captured columns
-   */
-  captureRootColumns(columns: ProjectionNode[]): HydrationPlanner {
-    const currentPlan = this.getPlanOrDefault();
-    const rootCols = new Set(currentPlan.rootColumns);
-    let changed = false;
-
-    columns.forEach(node => {
-      if (node.type !== 'Column') return;
-      if (node.table !== this.table.name) return;
-
-      const alias = node.alias || node.name;
-      if (isRelationAlias(alias)) return;
-      if (!rootCols.has(alias)) {
-        rootCols.add(alias);
-        changed = true;
-      }
-    });
-
-    if (!changed) return this;
-    return new HydrationPlanner(this.table, {
-      ...currentPlan,
-      rootColumns: Array.from(rootCols)
-    });
-  }
-
-  /**
-   * Includes a relation in the hydration plan
-   * @param rel - Relation definition
-   * @param relationName - Name of the relation
-   * @param aliasPrefix - Alias prefix for relation columns
-   * @param columns - Columns to include from the relation
-   * @returns Updated HydrationPlanner with included relation
-   */
-  includeRelation(
-    rel: RelationDef,
-    relationName: string,
-    aliasPrefix: string,
-    columns: string[],
-    pivot?: { aliasPrefix: string; columns: string[] }
-  ): HydrationPlanner {
-    const currentPlan = this.getPlanOrDefault();
-    const relations = currentPlan.relations.filter(r => r.name !== relationName);
-    relations.push(this.buildRelationPlan(rel, relationName, aliasPrefix, columns, pivot));
-    return new HydrationPlanner(this.table, {
-      ...currentPlan,
-      relations
-    });
-  }
-
-  /**
-   * Gets the current hydration plan
-   * @returns Current hydration plan or undefined
-   */
-  getPlan(): HydrationPlan | undefined {
-    return this.plan;
-  }
-
-  /**
-   * Gets the current hydration plan or creates a default one
-   * @returns Current hydration plan or default plan
-   */
-  private getPlanOrDefault(): HydrationPlan {
-    return this.plan ?? buildDefaultHydrationPlan(this.table);
-  }
-
-  /**
-   * Builds a relation plan for hydration
-   * @param rel - Relation definition
-   * @param relationName - Name of the relation
-   * @param aliasPrefix - Alias prefix for relation columns
-   * @param columns - Columns to include from the relation
-   * @returns Hydration relation plan
-   */
-  private buildRelationPlan(
-    rel: RelationDef,
-    relationName: string,
-    aliasPrefix: string,
-    columns: string[],
-    pivot?: { aliasPrefix: string; columns: string[] }
-  ): HydrationRelationPlan {
-    switch (rel.type) {
-      case RelationKinds.HasMany: {
-        const localKey = rel.localKey || findPrimaryKey(this.table);
-        return {
-          name: relationName,
-          aliasPrefix,
-          type: rel.type,
-          targetTable: rel.target.name,
-          targetPrimaryKey: findPrimaryKey(rel.target),
-          foreignKey: rel.foreignKey,
-          localKey,
-          columns
-        };
-      }
-      case RelationKinds.BelongsTo: {
-        const localKey = rel.localKey || findPrimaryKey(rel.target);
-        return {
-          name: relationName,
-          aliasPrefix,
-          type: rel.type,
-          targetTable: rel.target.name,
-          targetPrimaryKey: findPrimaryKey(rel.target),
-          foreignKey: rel.foreignKey,
-          localKey,
-          columns
-        };
-      }
-      case RelationKinds.BelongsToMany: {
-        const many = rel as BelongsToManyRelation;
-        const localKey = many.localKey || findPrimaryKey(this.table);
-        const targetPk = many.targetKey || findPrimaryKey(many.target);
-        const pivotPk = many.pivotPrimaryKey || findPrimaryKey(many.pivotTable);
-        const pivotAliasPrefix = pivot?.aliasPrefix ?? `${aliasPrefix}_pivot`;
-        const pivotColumns =
-          pivot?.columns ??
-          many.defaultPivotColumns ??
-          buildDefaultPivotColumns(many, pivotPk);
-
-        return {
-          name: relationName,
-          aliasPrefix,
-          type: rel.type,
-          targetTable: many.target.name,
-          targetPrimaryKey: targetPk,
-          foreignKey: many.pivotForeignKeyToRoot,
-          localKey,
-          columns,
-          pivot: {
-            table: many.pivotTable.name,
-            primaryKey: pivotPk,
-            aliasPrefix: pivotAliasPrefix,
-            columns: pivotColumns
-          }
-        };
-      }
-    }
-  }
-}
-
-/**
- * Builds a default hydration plan for a table
- * @param table - Table definition
- * @returns Default hydration plan
- */
-const buildDefaultHydrationPlan = (table: TableDef): HydrationPlan => ({
-  rootTable: table.name,
-  rootPrimaryKey: findPrimaryKey(table),
-  rootColumns: [],
-  relations: []
-});
+import { TableDef } from '../schema/table.js';
+import { RelationDef, RelationKinds, BelongsToManyRelation } from '../schema/relation.js';
+import { ProjectionNode } from './select-query-state.js';
+import { HydrationPlan, HydrationRelationPlan } from '../core/ast/query.js';
+import { isRelationAlias } from './relation-alias.js';
+import { buildDefaultPivotColumns } from './relation-utils.js';
+
+/**
+ * Finds the primary key column name for a table
+ * @param table - Table definition
+ * @returns Name of the primary key column, defaults to 'id'
+ */
+export const findPrimaryKey = (table: TableDef): string => {
+  const pk = Object.values(table.columns).find(c => c.primary);
+  return pk?.name || 'id';
+};
+
+/**
+ * Manages hydration planning for query results
+ */
+export class HydrationPlanner {
+  /**
+   * Creates a new HydrationPlanner instance
+   * @param table - Table definition
+   * @param plan - Optional existing hydration plan
+   */
+  constructor(private readonly table: TableDef, private readonly plan?: HydrationPlan) { }
+
+  /**
+   * Captures root table columns for hydration planning
+   * @param columns - Columns to capture
+   * @returns Updated HydrationPlanner with captured columns
+   */
+  captureRootColumns(columns: ProjectionNode[]): HydrationPlanner {
+    const currentPlan = this.getPlanOrDefault();
+    const rootCols = new Set(currentPlan.rootColumns);
+    let changed = false;
+
+    columns.forEach(node => {
+      if (node.type !== 'Column') return;
+      if (node.table !== this.table.name) return;
+
+      const alias = node.alias || node.name;
+      if (isRelationAlias(alias)) return;
+      if (!rootCols.has(alias)) {
+        rootCols.add(alias);
+        changed = true;
+      }
+    });
+
+    if (!changed) return this;
+    return new HydrationPlanner(this.table, {
+      ...currentPlan,
+      rootColumns: Array.from(rootCols)
+    });
+  }
+
+  /**
+   * Includes a relation in the hydration plan
+   * @param rel - Relation definition
+   * @param relationName - Name of the relation
+   * @param aliasPrefix - Alias prefix for relation columns
+   * @param columns - Columns to include from the relation
+   * @returns Updated HydrationPlanner with included relation
+   */
+  includeRelation(
+    rel: RelationDef,
+    relationName: string,
+    aliasPrefix: string,
+    columns: string[],
+    pivot?: { aliasPrefix: string; columns: string[] }
+  ): HydrationPlanner {
+    const currentPlan = this.getPlanOrDefault();
+    const relations = currentPlan.relations.filter(r => r.name !== relationName);
+    relations.push(this.buildRelationPlan(rel, relationName, aliasPrefix, columns, pivot));
+    return new HydrationPlanner(this.table, {
+      ...currentPlan,
+      relations
+    });
+  }
+
+  /**
+   * Gets the current hydration plan
+   * @returns Current hydration plan or undefined
+   */
+  getPlan(): HydrationPlan | undefined {
+    return this.plan;
+  }
+
+  /**
+   * Gets the current hydration plan or creates a default one
+   * @returns Current hydration plan or default plan
+   */
+  private getPlanOrDefault(): HydrationPlan {
+    return this.plan ?? buildDefaultHydrationPlan(this.table);
+  }
+
+  /**
+   * Builds a relation plan for hydration
+   * @param rel - Relation definition
+   * @param relationName - Name of the relation
+   * @param aliasPrefix - Alias prefix for relation columns
+   * @param columns - Columns to include from the relation
+   * @returns Hydration relation plan
+   */
+  private buildRelationPlan(
+    rel: RelationDef,
+    relationName: string,
+    aliasPrefix: string,
+    columns: string[],
+    pivot?: { aliasPrefix: string; columns: string[] }
+  ): HydrationRelationPlan {
+    switch (rel.type) {
+      case RelationKinds.HasMany: {
+        const localKey = rel.localKey || findPrimaryKey(this.table);
+        return {
+          name: relationName,
+          aliasPrefix,
+          type: rel.type,
+          targetTable: rel.target.name,
+          targetPrimaryKey: findPrimaryKey(rel.target),
+          foreignKey: rel.foreignKey,
+          localKey,
+          columns
+        };
+      }
+      case RelationKinds.BelongsTo: {
+        const localKey = rel.localKey || findPrimaryKey(rel.target);
+        return {
+          name: relationName,
+          aliasPrefix,
+          type: rel.type,
+          targetTable: rel.target.name,
+          targetPrimaryKey: findPrimaryKey(rel.target),
+          foreignKey: rel.foreignKey,
+          localKey,
+          columns
+        };
+      }
+      case RelationKinds.BelongsToMany: {
+        const many = rel as BelongsToManyRelation;
+        const localKey = many.localKey || findPrimaryKey(this.table);
+        const targetPk = many.targetKey || findPrimaryKey(many.target);
+        const pivotPk = many.pivotPrimaryKey || findPrimaryKey(many.pivotTable);
+        const pivotAliasPrefix = pivot?.aliasPrefix ?? `${aliasPrefix}_pivot`;
+        const pivotColumns =
+          pivot?.columns ??
+          many.defaultPivotColumns ??
+          buildDefaultPivotColumns(many, pivotPk);
+
+        return {
+          name: relationName,
+          aliasPrefix,
+          type: rel.type,
+          targetTable: many.target.name,
+          targetPrimaryKey: targetPk,
+          foreignKey: many.pivotForeignKeyToRoot,
+          localKey,
+          columns,
+          pivot: {
+            table: many.pivotTable.name,
+            primaryKey: pivotPk,
+            aliasPrefix: pivotAliasPrefix,
+            columns: pivotColumns
+          }
+        };
+      }
+    }
+  }
+}
+
+/**
+ * Builds a default hydration plan for a table
+ * @param table - Table definition
+ * @returns Default hydration plan
+ */
+const buildDefaultHydrationPlan = (table: TableDef): HydrationPlan => ({
+  rootTable: table.name,
+  rootPrimaryKey: findPrimaryKey(table),
+  rootColumns: [],
+  relations: []
+});

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

@@ -1,62 +1,51 @@
-import { TableDef } from '../schema/table';
-import { InsertQueryNode, TableNode } from '../ast/query';
-import { ColumnNode, OperandNode, valueToOperand } from '../ast/expression';
-
-const createTableNode = (table: TableDef): TableNode => ({
-  type: 'Table',
-  name: table.name
-});
-
-const buildColumnNodes = (table: TableDef, names: string[]): ColumnNode[] =>
-  names.map(name => ({
-    type: 'Column',
-    table: table.name,
-    name
-  }));
-
-/**
- * Maintains immutable state for building INSERT queries
- */
-export class InsertQueryState {
-  public readonly table: TableDef;
-  public readonly ast: InsertQueryNode;
-
-  constructor(table: TableDef, ast?: InsertQueryNode) {
-    this.table = table;
-    this.ast = ast ?? {
-      type: 'InsertQuery',
-      into: createTableNode(table),
-      columns: [],
-      values: []
-    };
-  }
-
-  private clone(nextAst: InsertQueryNode): InsertQueryState {
-    return new InsertQueryState(this.table, nextAst);
-  }
-
-  withValues(rows: Record<string, unknown>[]): InsertQueryState {
-    if (!rows.length) return this;
-
-    const definedColumns = this.ast.columns.length
-      ? this.ast.columns
-      : buildColumnNodes(this.table, Object.keys(rows[0]));
-
-    const newRows: OperandNode[][] = rows.map(row =>
-      definedColumns.map(column => valueToOperand(row[column.name]))
-    );
-
-    return this.clone({
-      ...this.ast,
-      columns: definedColumns,
-      values: [...this.ast.values, ...newRows]
-    });
-  }
-
-  withReturning(columns: ColumnNode[]): InsertQueryState {
-    return this.clone({
-      ...this.ast,
-      returning: [...columns]
-    });
-  }
-}
+import { TableDef } from '../schema/table.js';
+import { InsertQueryNode, TableNode } from '../core/ast/query.js';
+import { ColumnNode, OperandNode, valueToOperand } from '../core/ast/expression.js';
+import { buildColumnNodes, createTableNode } from '../core/ast/builders.js';
+
+/**
+ * Maintains immutable state for building INSERT queries
+ */
+export class InsertQueryState {
+  public readonly table: TableDef;
+  public readonly ast: InsertQueryNode;
+
+  constructor(table: TableDef, ast?: InsertQueryNode) {
+    this.table = table;
+    this.ast = ast ?? {
+      type: 'InsertQuery',
+      into: createTableNode(table),
+      columns: [],
+      values: []
+    };
+  }
+
+  private clone(nextAst: InsertQueryNode): InsertQueryState {
+    return new InsertQueryState(this.table, nextAst);
+  }
+
+  withValues(rows: Record<string, unknown>[]): InsertQueryState {
+    if (!rows.length) return this;
+
+    const definedColumns = this.ast.columns.length
+      ? this.ast.columns
+      : buildColumnNodes(this.table, Object.keys(rows[0]));
+
+    const newRows: OperandNode[][] = rows.map(row =>
+      definedColumns.map(column => valueToOperand(row[column.name]))
+    );
+
+    return this.clone({
+      ...this.ast,
+      columns: definedColumns,
+      values: [...this.ast.values, ...newRows]
+    });
+  }
+
+  withReturning(columns: ColumnNode[]): InsertQueryState {
+    return this.clone({
+      ...this.ast,
+      returning: [...columns]
+    });
+  }
+}