metal-orm 1.1.11 → 1.1.18

package/src/query-builder/relation-manager.ts

@@ -1,87 +1,87 @@
-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,
-    additionalCorrelation?: ExpressionNode
-  ): SelectQueryNode {
-    return this.createService(context).applyRelationCorrelation(relationName, ast, additionalCorrelation);
-  }
-
-  /**
-   * 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,
+    additionalCorrelation?: ExpressionNode
+  ): SelectQueryNode {
+    return this.createService(context).applyRelationCorrelation(relationName, ast, additionalCorrelation);
+  }
+
+  /**
+   * 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/query-builder/relation-projection-helper.ts

@@ -1,102 +1,102 @@
-import { TableDef } from '../schema/table.js';
-import { ColumnDef } from '../schema/column-types.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>);
-  }
-}
-
+import { TableDef } from '../schema/table.js';
+import { ColumnDef } from '../schema/column-types.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>);
+  }
+}
+

package/src/query-builder/relation-types.ts

@@ -3,15 +3,15 @@ import { JOIN_KINDS } from '../core/sql/sql.js';
 import { TableDef } from '../schema/table.js';
 import { BelongsToManyRelation, RelationDef } from '../schema/relation.js';
 import { RelationTargetTable } from '../schema/types.js';
-
-/**
- * Join kinds allowed when including a relation using `.include(...)`.
- */
-export type RelationIncludeJoinKind = typeof JOIN_KINDS.LEFT | typeof JOIN_KINDS.INNER;
-
-/**
- * Options for including a relation in a query
- */
+
+/**
+ * Join kinds allowed when including a relation using `.include(...)`.
+ */
+export type RelationIncludeJoinKind = typeof JOIN_KINDS.LEFT | typeof JOIN_KINDS.INNER;
+
+/**
+ * Options for including a relation in a query
+ */
 export interface RelationIncludeOptions {
   columns?: readonly string[];
   aliasPrefix?: string;

package/src/query-builder/relation-utils.ts

@@ -1,15 +1,15 @@
-import { BelongsToManyRelation } from '../schema/relation.js';
-
-/**
- * Builds a default set of pivot columns, excluding keys used for joins.
- * @param rel - The BelongsToMany relation definition
- * @param pivotPk - The primary key column name of the pivot table
- * @returns Array of column names that can be included in pivot table selections
- */
-export const buildDefaultPivotColumns = (
-  rel: BelongsToManyRelation,
-  pivotPk: string
-): string[] => {
-  const excluded = new Set([pivotPk, rel.pivotForeignKeyToRoot, rel.pivotForeignKeyToTarget]);
-  return Object.keys(rel.pivotTable.columns).filter(col => !excluded.has(col));
-};
+import { BelongsToManyRelation } from '../schema/relation.js';
+
+/**
+ * Builds a default set of pivot columns, excluding keys used for joins.
+ * @param rel - The BelongsToMany relation definition
+ * @param pivotPk - The primary key column name of the pivot table
+ * @returns Array of column names that can be included in pivot table selections
+ */
+export const buildDefaultPivotColumns = (
+  rel: BelongsToManyRelation,
+  pivotPk: string
+): string[] => {
+  const excluded = new Set([pivotPk, rel.pivotForeignKeyToRoot, rel.pivotForeignKeyToTarget]);
+  return Object.keys(rel.pivotTable.columns).filter(col => !excluded.has(col));
+};

package/src/query-builder/select/cte-facet.ts

@@ -1,40 +1,40 @@
-import { SelectQueryNode } from '../../core/ast/query.js';
-import { SelectQueryBuilderContext, SelectQueryBuilderEnvironment } from '../select-query-builder-deps.js';
-import { QueryAstService } from '../query-ast-service.js';
-import { SelectQueryState } from '../select-query-state.js';
-
-/**
- * Facet responsible for Common Table Expressions (WITH clauses)
- */
-export class SelectCTEFacet {
-    /**
-     * Creates a new SelectCTEFacet instance
-     * @param env - Query builder environment
-     * @param createAstService - Function to create AST service
-     */
-    constructor(
-        private readonly env: SelectQueryBuilderEnvironment,
-        private readonly createAstService: (state: SelectQueryState) => QueryAstService
-    ) { }
-
-    /**
-     * Adds a Common Table Expression to the query
-     * @param context - Current query context
-     * @param name - CTE name
-     * @param subAst - CTE query AST
-     * @param columns - Optional column names
-     * @param recursive - Whether the CTE is recursive
-     * @returns Updated query context with CTE
-     */
-    withCTE(
-        context: SelectQueryBuilderContext,
-        name: string,
-        subAst: SelectQueryNode,
-        columns: string[] | undefined,
-        recursive: boolean
-    ): SelectQueryBuilderContext {
-        const astService = this.createAstService(context.state);
-        const nextState = astService.withCte(name, subAst, columns, recursive);
-        return { state: nextState, hydration: context.hydration };
-    }
-}
+import { SelectQueryNode } from '../../core/ast/query.js';
+import { SelectQueryBuilderContext, SelectQueryBuilderEnvironment } from '../select-query-builder-deps.js';
+import { QueryAstService } from '../query-ast-service.js';
+import { SelectQueryState } from '../select-query-state.js';
+
+/**
+ * Facet responsible for Common Table Expressions (WITH clauses)
+ */
+export class SelectCTEFacet {
+    /**
+     * Creates a new SelectCTEFacet instance
+     * @param env - Query builder environment
+     * @param createAstService - Function to create AST service
+     */
+    constructor(
+        private readonly env: SelectQueryBuilderEnvironment,
+        private readonly createAstService: (state: SelectQueryState) => QueryAstService
+    ) { }
+
+    /**
+     * Adds a Common Table Expression to the query
+     * @param context - Current query context
+     * @param name - CTE name
+     * @param subAst - CTE query AST
+     * @param columns - Optional column names
+     * @param recursive - Whether the CTE is recursive
+     * @returns Updated query context with CTE
+     */
+    withCTE(
+        context: SelectQueryBuilderContext,
+        name: string,
+        subAst: SelectQueryNode,
+        columns: string[] | undefined,
+        recursive: boolean
+    ): SelectQueryBuilderContext {
+        const astService = this.createAstService(context.state);
+        const nextState = astService.withCte(name, subAst, columns, recursive);
+        return { state: nextState, hydration: context.hydration };
+    }
+}