metal-orm 1.0.8 → 1.0.9

package/src/{builder → query-builder}/relation-conditions.ts

@@ -1,112 +1,112 @@
-import { TableDef } from '../schema/table';
-import { RelationDef, RelationKinds, BelongsToManyRelation } from '../schema/relation';
-import { ExpressionNode, eq, and } from '../ast/expression';
-import { findPrimaryKey } from './hydration-planner';
-import { JoinNode } from '../ast/join';
-import { JoinKind } from '../constants/sql';
-import { createJoinNode } from '../utils/join-node';
-
-/**
- * Utility function to handle unreachable code paths
- * @param value - Value that should never occur
- * @throws Error indicating unhandled relation type
- */
-const assertNever = (value: never): never => {
-  throw new Error(`Unhandled relation type: ${JSON.stringify(value)}`);
-};
-
-/**
- * Builds the base condition for a relation join
- * @param root - Root table definition
- * @param relation - Relation definition
- * @returns Expression node representing the join condition
- */
-const baseRelationCondition = (root: TableDef, relation: RelationDef): ExpressionNode => {
-  const defaultLocalKey =
-    relation.type === RelationKinds.HasMany
-      ? findPrimaryKey(root)
-      : findPrimaryKey(relation.target);
-  const localKey = relation.localKey || defaultLocalKey;
-
-  switch (relation.type) {
-    case RelationKinds.HasMany:
-      return eq(
-        { type: 'Column', table: relation.target.name, name: relation.foreignKey },
-        { type: 'Column', table: root.name, name: localKey }
-      );
-    case RelationKinds.BelongsTo:
-      return eq(
-        { type: 'Column', table: relation.target.name, name: localKey },
-        { type: 'Column', table: root.name, name: relation.foreignKey }
-      );
-    case RelationKinds.BelongsToMany:
-      throw new Error('BelongsToMany relations do not support the standard join condition builder');
-    default:
-      return assertNever(relation);
-  }
-};
-
-/**
- * Builds the join nodes required to include a BelongsToMany relation.
- */
-export const buildBelongsToManyJoins = (
-  root: TableDef,
-  relationName: string,
-  relation: BelongsToManyRelation,
-  joinKind: JoinKind,
-  extra?: ExpressionNode
-): JoinNode[] => {
-  const rootKey = relation.localKey || findPrimaryKey(root);
-  const targetKey = relation.targetKey || findPrimaryKey(relation.target);
-
-  const pivotCondition = eq(
-    { type: 'Column', table: relation.pivotTable.name, name: relation.pivotForeignKeyToRoot },
-    { type: 'Column', table: root.name, name: rootKey }
-  );
-
-  const pivotJoin = createJoinNode(joinKind, relation.pivotTable.name, pivotCondition);
-
-  let targetCondition: ExpressionNode = eq(
-    { type: 'Column', table: relation.target.name, name: targetKey },
-    { type: 'Column', table: relation.pivotTable.name, name: relation.pivotForeignKeyToTarget }
-  );
-
-  if (extra) {
-    targetCondition = and(targetCondition, extra);
-  }
-
-  const targetJoin = createJoinNode(
-    joinKind,
-    relation.target.name,
-    targetCondition,
-    relationName
-  );
-
-  return [pivotJoin, targetJoin];
-};
-
-/**
- * Builds a relation join condition with optional extra conditions
- * @param root - Root table definition
- * @param relation - Relation definition
- * @param extra - Optional additional expression to combine with AND
- * @returns Expression node representing the complete join condition
- */
-export const buildRelationJoinCondition = (
-  root: TableDef,
-  relation: RelationDef,
-  extra?: ExpressionNode
-): ExpressionNode => {
-  const base = baseRelationCondition(root, relation);
-  return extra ? and(base, extra) : base;
-};
-
-/**
- * Builds a relation correlation condition for subqueries
- * @param root - Root table definition
- * @param relation - Relation definition
- * @returns Expression node representing the correlation condition
- */
-export const buildRelationCorrelation = (root: TableDef, relation: RelationDef): ExpressionNode => {
-  return baseRelationCondition(root, relation);
-};
+import { TableDef } from '../schema/table.js';
+import { RelationDef, RelationKinds, BelongsToManyRelation } from '../schema/relation.js';
+import { ExpressionNode, eq, and } from '../core/ast/expression.js';
+import { findPrimaryKey } from './hydration-planner.js';
+import { JoinNode } from '../core/ast/join.js';
+import { JoinKind } from '../core/sql/sql.js';
+import { createJoinNode } from '../core/ast/join-node.js';
+
+/**
+ * Utility function to handle unreachable code paths
+ * @param value - Value that should never occur
+ * @throws Error indicating unhandled relation type
+ */
+const assertNever = (value: never): never => {
+  throw new Error(`Unhandled relation type: ${JSON.stringify(value)}`);
+};
+
+/**
+ * Builds the base condition for a relation join
+ * @param root - Root table definition
+ * @param relation - Relation definition
+ * @returns Expression node representing the join condition
+ */
+const baseRelationCondition = (root: TableDef, relation: RelationDef): ExpressionNode => {
+  const defaultLocalKey =
+    relation.type === RelationKinds.HasMany
+      ? findPrimaryKey(root)
+      : findPrimaryKey(relation.target);
+  const localKey = relation.localKey || defaultLocalKey;
+
+  switch (relation.type) {
+    case RelationKinds.HasMany:
+      return eq(
+        { type: 'Column', table: relation.target.name, name: relation.foreignKey },
+        { type: 'Column', table: root.name, name: localKey }
+      );
+    case RelationKinds.BelongsTo:
+      return eq(
+        { type: 'Column', table: relation.target.name, name: localKey },
+        { type: 'Column', table: root.name, name: relation.foreignKey }
+      );
+    case RelationKinds.BelongsToMany:
+      throw new Error('BelongsToMany relations do not support the standard join condition builder');
+    default:
+      return assertNever(relation);
+  }
+};
+
+/**
+ * Builds the join nodes required to include a BelongsToMany relation.
+ */
+export const buildBelongsToManyJoins = (
+  root: TableDef,
+  relationName: string,
+  relation: BelongsToManyRelation,
+  joinKind: JoinKind,
+  extra?: ExpressionNode
+): JoinNode[] => {
+  const rootKey = relation.localKey || findPrimaryKey(root);
+  const targetKey = relation.targetKey || findPrimaryKey(relation.target);
+
+  const pivotCondition = eq(
+    { type: 'Column', table: relation.pivotTable.name, name: relation.pivotForeignKeyToRoot },
+    { type: 'Column', table: root.name, name: rootKey }
+  );
+
+  const pivotJoin = createJoinNode(joinKind, relation.pivotTable.name, pivotCondition);
+
+  let targetCondition: ExpressionNode = eq(
+    { type: 'Column', table: relation.target.name, name: targetKey },
+    { type: 'Column', table: relation.pivotTable.name, name: relation.pivotForeignKeyToTarget }
+  );
+
+  if (extra) {
+    targetCondition = and(targetCondition, extra);
+  }
+
+  const targetJoin = createJoinNode(
+    joinKind,
+    relation.target.name,
+    targetCondition,
+    relationName
+  );
+
+  return [pivotJoin, targetJoin];
+};
+
+/**
+ * Builds a relation join condition with optional extra conditions
+ * @param root - Root table definition
+ * @param relation - Relation definition
+ * @param extra - Optional additional expression to combine with AND
+ * @returns Expression node representing the complete join condition
+ */
+export const buildRelationJoinCondition = (
+  root: TableDef,
+  relation: RelationDef,
+  extra?: ExpressionNode
+): ExpressionNode => {
+  const base = baseRelationCondition(root, relation);
+  return extra ? and(base, extra) : base;
+};
+
+/**
+ * Builds a relation correlation condition for subqueries
+ * @param root - Root table definition
+ * @param relation - Relation definition
+ * @returns Expression node representing the correlation condition
+ */
+export const buildRelationCorrelation = (root: TableDef, relation: RelationDef): ExpressionNode => {
+  return baseRelationCondition(root, relation);
+};

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

@@ -1,82 +1,82 @@
-import { ExpressionNode } from '../../ast/expression';
-import { SelectQueryNode } from '../../ast/query';
-import { SelectQueryBuilderContext, SelectQueryBuilderEnvironment } from '../select-query-builder-deps';
-import { JoinKind } from '../../constants/sql';
-import { RelationIncludeOptions } from '../relation-types';
-
-/**
- * Manages relation operations (joins, includes, etc.) for query building
- */
-export class RelationManager {
-  /**
-   * Creates a new RelationManager instance
-   * @param env - Query builder environment
-   */
-  constructor(private readonly env: SelectQueryBuilderEnvironment) {}
-
-  /**
-   * Matches records based on a relation with an optional predicate
-   * @param context - Current query context
-   * @param relationName - Name of the relation to match
-   * @param predicate - Optional predicate expression
-   * @returns Updated query context with relation match
-   */
-  match(context: SelectQueryBuilderContext, relationName: string, predicate?: ExpressionNode): SelectQueryBuilderContext {
-    const result = this.createService(context).match(relationName, predicate);
-    return { state: result.state, hydration: result.hydration };
-  }
-
-  /**
-   * Joins a relation to the query
-   * @param context - Current query context
-   * @param relationName - Name of the relation to join
-   * @param joinKind - Type of join to use
-   * @param extraCondition - Additional join condition
-   * @returns Updated query context with relation join
-   */
-  joinRelation(
-    context: SelectQueryBuilderContext,
-    relationName: string,
-    joinKind: JoinKind,
-    extraCondition?: ExpressionNode
-  ): SelectQueryBuilderContext {
-    const result = this.createService(context).joinRelation(relationName, joinKind, extraCondition);
-    return { state: result.state, hydration: result.hydration };
-  }
-
-  /**
-   * Includes a relation in the query result
-   * @param context - Current query context
-   * @param relationName - Name of the relation to include
-   * @param options - Options for relation inclusion
-   * @returns Updated query context with included relation
-   */
-  include(
-    context: SelectQueryBuilderContext,
-    relationName: string,
-    options?: RelationIncludeOptions
-  ): SelectQueryBuilderContext {
-    const result = this.createService(context).include(relationName, options);
-    return { state: result.state, hydration: result.hydration };
-  }
-
-  /**
-   * Applies relation correlation to a query AST
-   * @param context - Current query context
-   * @param relationName - Name of the relation
-   * @param ast - Query AST to modify
-   * @returns Modified query AST with relation correlation
-   */
-  applyRelationCorrelation(context: SelectQueryBuilderContext, relationName: string, ast: SelectQueryNode): SelectQueryNode {
-    return this.createService(context).applyRelationCorrelation(relationName, ast);
-  }
-
-  /**
-   * Creates a relation service instance
-   * @param context - Current query context
-   * @returns Relation service instance
-   */
-  private createService(context: SelectQueryBuilderContext) {
-    return this.env.deps.createRelationService(this.env.table, context.state, context.hydration);
-  }
-}
+import { ExpressionNode } from '../core/ast/expression.js';
+import { SelectQueryNode } from '../core/ast/query.js';
+import { SelectQueryBuilderContext, SelectQueryBuilderEnvironment } from './select-query-builder-deps.js';
+import { JoinKind } from '../core/sql/sql.js';
+import { RelationIncludeOptions } from './relation-types.js';
+
+/**
+ * Manages relation operations (joins, includes, etc.) for query building
+ */
+export class RelationManager {
+  /**
+   * Creates a new RelationManager instance
+   * @param env - Query builder environment
+   */
+  constructor(private readonly env: SelectQueryBuilderEnvironment) {}
+
+  /**
+   * Matches records based on a relation with an optional predicate
+   * @param context - Current query context
+   * @param relationName - Name of the relation to match
+   * @param predicate - Optional predicate expression
+   * @returns Updated query context with relation match
+   */
+  match(context: SelectQueryBuilderContext, relationName: string, predicate?: ExpressionNode): SelectQueryBuilderContext {
+    const result = this.createService(context).match(relationName, predicate);
+    return { state: result.state, hydration: result.hydration };
+  }
+
+  /**
+   * Joins a relation to the query
+   * @param context - Current query context
+   * @param relationName - Name of the relation to join
+   * @param joinKind - Type of join to use
+   * @param extraCondition - Additional join condition
+   * @returns Updated query context with relation join
+   */
+  joinRelation(
+    context: SelectQueryBuilderContext,
+    relationName: string,
+    joinKind: JoinKind,
+    extraCondition?: ExpressionNode
+  ): SelectQueryBuilderContext {
+    const result = this.createService(context).joinRelation(relationName, joinKind, extraCondition);
+    return { state: result.state, hydration: result.hydration };
+  }
+
+  /**
+   * Includes a relation in the query result
+   * @param context - Current query context
+   * @param relationName - Name of the relation to include
+   * @param options - Options for relation inclusion
+   * @returns Updated query context with included relation
+   */
+  include(
+    context: SelectQueryBuilderContext,
+    relationName: string,
+    options?: RelationIncludeOptions
+  ): SelectQueryBuilderContext {
+    const result = this.createService(context).include(relationName, options);
+    return { state: result.state, hydration: result.hydration };
+  }
+
+  /**
+   * Applies relation correlation to a query AST
+   * @param context - Current query context
+   * @param relationName - Name of the relation
+   * @param ast - Query AST to modify
+   * @returns Modified query AST with relation correlation
+   */
+  applyRelationCorrelation(context: SelectQueryBuilderContext, relationName: string, ast: SelectQueryNode): SelectQueryNode {
+    return this.createService(context).applyRelationCorrelation(relationName, ast);
+  }
+
+  /**
+   * Creates a relation service instance
+   * @param context - Current query context
+   * @returns Relation service instance
+   */
+  private createService(context: SelectQueryBuilderContext) {
+    return this.env.deps.createRelationService(this.env.table, context.state, context.hydration);
+  }
+}

package/src/{builder → query-builder}/relation-projection-helper.ts

@@ -1,101 +1,101 @@
-import { TableDef } from '../schema/table';
-import { ColumnDef } from '../schema/column';
-import { SelectQueryState } from './select-query-state';
-import { HydrationManager } from './hydration-manager';
-import { ColumnNode } from '../ast/expression';
-import { findPrimaryKey } from './hydration-planner';
-import { isRelationAlias } from '../utils/relation-alias';
-
-/**
- * Result of a relation operation
- */
-export interface RelationResult {
-  /**
-   * Updated query state
-   */
-  state: SelectQueryState;
-  /**
-   * Updated hydration manager
-   */
-  hydration: HydrationManager;
-}
-
-/**
- * Callback function for selecting columns
- */
-type SelectColumnsCallback = (
-  state: SelectQueryState,
-  hydration: HydrationManager,
-  columns: Record<string, ColumnDef>
-) => RelationResult;
-
-/**
- * Helper class for managing relation projections in queries
- */
-export class RelationProjectionHelper {
-  /**
-   * Creates a new RelationProjectionHelper instance
-   * @param table - Table definition
-   * @param selectColumns - Callback for selecting columns
-   */
-  constructor(
-    private readonly table: TableDef,
-    private readonly selectColumns: SelectColumnsCallback
-  ) {}
-
-  /**
-   * Ensures base projection is included in the query
-   * @param state - Current query state
-   * @param hydration - Hydration manager
-   * @returns Relation result with updated state and hydration
-   */
-  ensureBaseProjection(state: SelectQueryState, hydration: HydrationManager): RelationResult {
-    const primaryKey = findPrimaryKey(this.table);
-
-    if (!this.hasBaseProjection(state)) {
-      return this.selectColumns(state, hydration, this.getBaseColumns());
-    }
-
-    if (primaryKey && !this.hasPrimarySelected(state, primaryKey) && this.table.columns[primaryKey]) {
-      return this.selectColumns(state, hydration, {
-        [primaryKey]: this.table.columns[primaryKey]
-      });
-    }
-
-    return { state, hydration };
-  }
-
-  /**
-   * Checks if base projection exists in the query
-   * @param state - Current query state
-   * @returns True if base projection exists
-   */
-  private hasBaseProjection(state: SelectQueryState): boolean {
-    return state.ast.columns.some(col => !isRelationAlias((col as ColumnNode).alias));
-  }
-
-  /**
-   * Checks if primary key is selected in the query
-   * @param state - Current query state
-   * @param primaryKey - Primary key name
-   * @returns True if primary key is selected
-   */
-  private hasPrimarySelected(state: SelectQueryState, primaryKey: string): boolean {
-    return state.ast.columns.some(col => {
-      const alias = (col as ColumnNode).alias;
-      const name = alias || (col as ColumnNode).name;
-      return !isRelationAlias(alias) && name === primaryKey;
-    });
-  }
-
-  /**
-   * Gets all base columns for the table
-   * @returns Record of all table columns
-   */
-  private getBaseColumns(): Record<string, ColumnDef> {
-    return Object.keys(this.table.columns).reduce((acc, key) => {
-      acc[key] = (this.table.columns as Record<string, ColumnDef>)[key];
-      return acc;
-    }, {} as Record<string, ColumnDef>);
-  }
-}
+import { TableDef } from '../schema/table.js';
+import { ColumnDef } from '../schema/column.js';
+import { SelectQueryState } from './select-query-state.js';
+import { HydrationManager } from './hydration-manager.js';
+import { ColumnNode } from '../core/ast/expression.js';
+import { findPrimaryKey } from './hydration-planner.js';
+import { isRelationAlias } from './relation-alias.js';
+
+/**
+ * Result of a relation operation
+ */
+export interface RelationResult {
+  /**
+   * Updated query state
+   */
+  state: SelectQueryState;
+  /**
+   * Updated hydration manager
+   */
+  hydration: HydrationManager;
+}
+
+/**
+ * Callback function for selecting columns
+ */
+type SelectColumnsCallback = (
+  state: SelectQueryState,
+  hydration: HydrationManager,
+  columns: Record<string, ColumnDef>
+) => RelationResult;
+
+/**
+ * Helper class for managing relation projections in queries
+ */
+export class RelationProjectionHelper {
+  /**
+   * Creates a new RelationProjectionHelper instance
+   * @param table - Table definition
+   * @param selectColumns - Callback for selecting columns
+   */
+  constructor(
+    private readonly table: TableDef,
+    private readonly selectColumns: SelectColumnsCallback
+  ) {}
+
+  /**
+   * Ensures base projection is included in the query
+   * @param state - Current query state
+   * @param hydration - Hydration manager
+   * @returns Relation result with updated state and hydration
+   */
+  ensureBaseProjection(state: SelectQueryState, hydration: HydrationManager): RelationResult {
+    const primaryKey = findPrimaryKey(this.table);
+
+    if (!this.hasBaseProjection(state)) {
+      return this.selectColumns(state, hydration, this.getBaseColumns());
+    }
+
+    if (primaryKey && !this.hasPrimarySelected(state, primaryKey) && this.table.columns[primaryKey]) {
+      return this.selectColumns(state, hydration, {
+        [primaryKey]: this.table.columns[primaryKey]
+      });
+    }
+
+    return { state, hydration };
+  }
+
+  /**
+   * Checks if base projection exists in the query
+   * @param state - Current query state
+   * @returns True if base projection exists
+   */
+  private hasBaseProjection(state: SelectQueryState): boolean {
+    return state.ast.columns.some(col => !isRelationAlias((col as ColumnNode).alias));
+  }
+
+  /**
+   * Checks if primary key is selected in the query
+   * @param state - Current query state
+   * @param primaryKey - Primary key name
+   * @returns True if primary key is selected
+   */
+  private hasPrimarySelected(state: SelectQueryState, primaryKey: string): boolean {
+    return state.ast.columns.some(col => {
+      const alias = (col as ColumnNode).alias;
+      const name = alias || (col as ColumnNode).name;
+      return !isRelationAlias(alias) && name === primaryKey;
+    });
+  }
+
+  /**
+   * Gets all base columns for the table
+   * @returns Record of all table columns
+   */
+  private getBaseColumns(): Record<string, ColumnDef> {
+    return Object.keys(this.table.columns).reduce((acc, key) => {
+      acc[key] = (this.table.columns as Record<string, ColumnDef>)[key];
+      return acc;
+    }, {} as Record<string, ColumnDef>);
+  }
+}