metal-orm 1.0.42 → 1.0.44

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

@@ -20,7 +20,7 @@ export class HydrationManager {
   constructor(
     private readonly table: TableDef,
     private readonly planner: HydrationPlanner
-  ) {}
+  ) { }
 
   /**
    * Creates a new HydrationManager with updated planner
@@ -113,6 +113,11 @@ export class HydrationManager {
     return hasPagination && this.hasMultiplyingRelations(plan);
   }
 
+  /**
+   * Checks if the hydration plan contains relations that multiply rows
+   * @param plan - Hydration plan to check
+   * @returns True if plan has HasMany or BelongsToMany relations
+   */
   private hasMultiplyingRelations(plan: HydrationPlan): boolean {
     return plan.relations.some(
       rel => rel.type === RelationKinds.HasMany || rel.type === RelationKinds.BelongsToMany
@@ -203,6 +208,12 @@ export class HydrationManager {
     };
   }
 
+  /**
+   * Generates a unique CTE name by appending a suffix if needed
+   * @param existing - Existing CTE nodes
+   * @param baseName - Base name for the CTE
+   * @returns Unique CTE name
+   */
   private nextCteName(existing: CommonTableExpressionNode[] | undefined, baseName: string): string {
     const names = new Set((existing ?? []).map(cte => cte.name));
     let candidate = baseName;
@@ -216,16 +227,27 @@ export class HydrationManager {
     return candidate;
   }
 
+  /**
+   * Extracts projection names from column nodes
+   * @param columns - Projection nodes
+   * @returns Array of names or undefined if any column lacks name/alias
+   */
   private getProjectionNames(columns: ProjectionNode[]): string[] | undefined {
     const names: string[] = [];
     for (const col of columns) {
-      const alias = (col as any).alias ?? (col as any).name;
+      const node = col as { alias?: string; name?: string };
+      const alias = node.alias ?? node.name;
       if (!alias) return undefined;
       names.push(alias);
     }
     return names;
   }
 
+  /**
+   * Builds a map of column keys to their aliases from projection nodes
+   * @param columns - Projection nodes
+   * @returns Map of 'table.name' to alias
+   */
   private buildProjectionAliasMap(columns: ProjectionNode[]): Map<string, string> {
     const map = new Map<string, string>();
     for (const col of columns) {
@@ -237,6 +259,15 @@ export class HydrationManager {
     return map;
   }
 
+  /**
+   * Maps order by nodes to use base CTE alias
+   * @param orderBy - Original order by nodes
+   * @param plan - Hydration plan
+   * @param projectionAliases - Map of column aliases
+   * @param baseAlias - Base CTE alias
+   * @param availableColumns - Set of available column names
+   * @returns Mapped order by nodes, null if cannot map
+   */
   private mapOrderBy(
     orderBy: OrderByNode[] | undefined,
     plan: HydrationPlan,
@@ -260,6 +291,15 @@ export class HydrationManager {
     return mapped;
   }
 
+  /**
+   * Maps a single ordering term to use base CTE alias
+   * @param term - Ordering term to map
+   * @param plan - Hydration plan
+   * @param projectionAliases - Map of column aliases
+   * @param baseAlias - Base CTE alias
+   * @param availableColumns - Set of available column names
+   * @returns Mapped term or null if cannot map
+   */
   private mapOrderingTerm(
     term: OrderByNode['term'],
     plan: HydrationPlan,
@@ -267,7 +307,7 @@ export class HydrationManager {
     baseAlias: string,
     availableColumns: Set<string>
   ): OrderByNode['term'] | null {
-    if ((term as any).type === 'Column') {
+    if (term.type === 'Column') {
       const col = term as ColumnNode;
       if (col.table !== plan.rootTable) return null;
       const alias = projectionAliases.get(`${col.table}.${col.name}`) ?? col.name;
@@ -275,8 +315,8 @@ export class HydrationManager {
       return { type: 'Column', table: baseAlias, name: alias };
     }
 
-    if ((term as any).type === 'AliasRef') {
-      const aliasName = (term as any).name;
+    if (term.type === 'AliasRef') {
+      const aliasName = term.name;
       if (!availableColumns.has(aliasName)) return null;
       return { type: 'Column', table: baseAlias, name: aliasName };
     }
@@ -284,6 +324,13 @@ export class HydrationManager {
     return null;
   }
 
+  /**
+   * Builds column nodes for paging CTE
+   * @param primaryKey - Primary key name
+   * @param orderBy - Order by nodes
+   * @param tableAlias - Table alias for columns
+   * @returns Array of column nodes for paging
+   */
   private buildPagingColumns(primaryKey: string, orderBy: OrderByNode[] | undefined, tableAlias: string): ColumnNode[] {
     const columns: ColumnNode[] = [{ type: 'Column', table: tableAlias, name: primaryKey, alias: primaryKey }];
 

package/src/query-builder/insert-query-state.ts

@@ -20,6 +20,11 @@ export class InsertQueryState {
   public readonly table: TableDef;
   public readonly ast: InsertQueryNode;
 
+  /**
+   * Creates a new InsertQueryState instance
+   * @param table - The table definition for the INSERT query
+   * @param ast - Optional initial AST node, defaults to a basic INSERT query
+   */
   constructor(table: TableDef, ast?: InsertQueryNode) {
     this.table = table;
     this.ast = ast ?? {
@@ -55,6 +60,13 @@ export class InsertQueryState {
     return buildColumnNodes(this.table, names);
   }
 
+  /**
+   * Adds VALUES clause to the INSERT query
+   * @param rows - Array of row objects to insert
+   * @returns A new InsertQueryState with the VALUES clause added
+   * @throws Error if mixing VALUES with SELECT source
+   * @throws Error if invalid values are provided
+   */
   withValues(rows: Record<string, unknown>[]): InsertQueryState {
     if (!rows.length) return this;
 
@@ -88,6 +100,11 @@ export class InsertQueryState {
     });
   }
 
+  /**
+   * Sets the columns for the INSERT query
+   * @param columns - Column nodes to insert into
+   * @returns A new InsertQueryState with the specified columns
+   */
   withColumns(columns: ColumnNode[]): InsertQueryState {
     if (!columns.length) return this;
     return this.clone({
@@ -96,6 +113,14 @@ export class InsertQueryState {
     });
   }
 
+  /**
+   * Adds SELECT source to the INSERT query
+   * @param query - The SELECT query to use as source
+   * @param columns - Target columns for the INSERT
+   * @returns A new InsertQueryState with the SELECT source
+   * @throws Error if mixing SELECT with VALUES source
+   * @throws Error if no destination columns specified
+   */
   withSelect(query: SelectQueryNode, columns: ColumnNode[]): InsertQueryState {
     const targetColumns =
       columns.length
@@ -122,6 +147,11 @@ export class InsertQueryState {
     });
   }
 
+  /**
+   * Adds a RETURNING clause to the INSERT query
+   * @param columns - Columns to return after insertion
+   * @returns A new InsertQueryState with the RETURNING clause added
+   */
   withReturning(columns: ColumnNode[]): InsertQueryState {
     return this.clone({
       ...this.ast,

package/src/query-builder/insert.ts

@@ -17,6 +17,11 @@ export class InsertQueryBuilder<T> {
   private readonly table: TableDef;
   private readonly state: InsertQueryState;
 
+  /**
+   * Creates a new InsertQueryBuilder instance
+   * @param table - The table definition for the INSERT query
+   * @param state - Optional initial query state, defaults to a new InsertQueryState
+   */
   constructor(table: TableDef, state?: InsertQueryState) {
     this.table = table;
     this.state = state ?? new InsertQueryState(table);
@@ -26,19 +31,36 @@ export class InsertQueryBuilder<T> {
     return new InsertQueryBuilder(this.table, state);
   }
 
+  /**
+   * Adds VALUES to the INSERT query
+   * @param rowOrRows - Single row object or array of row objects to insert
+   * @returns A new InsertQueryBuilder with the VALUES clause added
+   */
   values(rowOrRows: Record<string, unknown> | Record<string, unknown>[]): InsertQueryBuilder<T> {
     const rows = Array.isArray(rowOrRows) ? rowOrRows : [rowOrRows];
     if (!rows.length) return this;
     return this.clone(this.state.withValues(rows));
   }
 
+  /**
+   * Specifies the columns for the INSERT query
+   * @param columns - Column definitions or nodes to insert into
+   * @returns A new InsertQueryBuilder with the specified columns
+   */
   columns(...columns: (ColumnDef | ColumnNode)[]): InsertQueryBuilder<T> {
     if (!columns.length) return this;
     return this.clone(this.state.withColumns(this.resolveColumnNodes(columns)));
   }
 
-  fromSelect(
-    query: SelectQueryNode | SelectQueryBuilder<any, TableDef<any>>,
+  /**
+   * Sets the source of the INSERT query to a SELECT query
+   * @template TSource - The source table type
+   * @param query - The SELECT query or query builder to use as source
+   * @param columns - Optional target columns for the INSERT
+   * @returns A new InsertQueryBuilder with the SELECT source
+   */
+  fromSelect<TSource extends TableDef>(
+    query: SelectQueryNode | SelectQueryBuilder<unknown, TSource>,
     columns: (ColumnDef | ColumnNode)[] = []
   ): InsertQueryBuilder<T> {
     const ast = this.resolveSelectQuery(query);
@@ -46,6 +68,11 @@ export class InsertQueryBuilder<T> {
     return this.clone(this.state.withSelect(ast, nodes));
   }
 
+  /**
+   * Adds a RETURNING clause to the INSERT query
+   * @param columns - Columns to return after insertion
+   * @returns A new InsertQueryBuilder with the RETURNING clause added
+   */
   returning(...columns: (ColumnDef | ColumnNode)[]): InsertQueryBuilder<T> {
     if (!columns.length) return this;
     const nodes = columns.map(column => buildColumnNode(this.table, column));
@@ -57,23 +84,35 @@ export class InsertQueryBuilder<T> {
     return columns.map(column => buildColumnNode(this.table, column));
   }
 
-  private resolveSelectQuery(query: SelectQueryNode | SelectQueryBuilder<any>): SelectQueryNode {
-    return typeof (query as any).getAST === 'function'
-      ? (query as SelectQueryBuilder<any>).getAST()
+  private resolveSelectQuery<TSource extends TableDef>(
+    query: SelectQueryNode | SelectQueryBuilder<unknown, TSource>
+  ): SelectQueryNode {
+    const candidate = query as { getAST?: () => SelectQueryNode };
+    return typeof candidate.getAST === 'function' && candidate.getAST
+      ? candidate.getAST()
       : (query as SelectQueryNode);
   }
 
   // Existing compiler-based compile stays, but we add a new overload.
 
-  // 1) Keep the old behavior (used internally / tests, if any):
+  /**
+   * Compiles the INSERT query
+   * @param compiler - The INSERT compiler to use
+   * @returns The compiled query with SQL and parameters
+   */
   compile(compiler: InsertCompiler): CompiledQuery;
-  // 2) New ergonomic overload:
+  /**
+   * Compiles the INSERT query for the specified dialect
+   * @param dialect - The SQL dialect to compile for
+   * @returns The compiled query with SQL and parameters
+   */
   compile(dialect: InsertDialectInput): CompiledQuery;
 
   compile(arg: InsertCompiler | InsertDialectInput): CompiledQuery {
-    if (typeof (arg as any).compileInsert === 'function') {
+    const candidate = arg as { compileInsert?: (ast: InsertQueryNode) => CompiledQuery };
+    if (typeof candidate.compileInsert === 'function') {
       // InsertCompiler path – old behavior
-      return (arg as InsertCompiler).compileInsert(this.state.ast);
+      return candidate.compileInsert(this.state.ast);
     }
 
     // Dialect | string path – new behavior
@@ -81,10 +120,19 @@ export class InsertQueryBuilder<T> {
     return dialect.compileInsert(this.state.ast);
   }
 
+  /**
+   * Returns the SQL string for the INSERT query
+   * @param arg - The compiler or dialect to generate SQL for
+   * @returns The SQL string representation of the query
+   */
   toSql(arg: InsertCompiler | InsertDialectInput): string {
-    return this.compile(arg as any).sql;
+    return this.compile(arg as InsertCompiler).sql;
   }
 
+  /**
+   * Returns the Abstract Syntax Tree (AST) representation of the query
+   * @returns The AST node for the INSERT query
+   */
   getAST(): InsertQueryNode {
     return this.state.ast;
   }

package/src/query-builder/query-ast-service.ts

@@ -49,7 +49,7 @@ export class QueryAstService {
    * @param table - Table definition
    * @param state - Current query state
    */
-  constructor(private readonly table: TableDef, private readonly state: SelectQueryState) {}
+  constructor(private readonly table: TableDef, private readonly state: SelectQueryState) { }
 
   /**
    * Selects columns for the query
@@ -251,10 +251,15 @@ export class QueryAstService {
     return existing ? and(existing, next) : next;
   }
 
+  /**
+   * Normalizes an ordering term to a standard OrderingTerm
+   * @param term - Column definition or ordering term to normalize
+   * @returns Normalized ordering term
+   */
   private normalizeOrderingTerm(term: ColumnDef | OrderingTerm): OrderingTerm {
     const from = this.state.ast.from;
     const tableRef = from.type === 'Table' && from.alias ? { ...this.table, alias: from.alias } : this.table;
-    const termType = (term as any)?.type;
+    const termType = (term as { type?: string }).type;
     if (termType === 'Column') {
       return term as ColumnNode;
     }

package/src/query-builder/query-resolution.ts

@@ -0,0 +1,78 @@
+import { SelectQueryNode, UpdateQueryNode, DeleteQueryNode, TableSourceNode } from '../core/ast/query.js';
+import { TableDef } from '../schema/table.js';
+import type { SelectQueryBuilder } from './select.js';
+import type { UpdateQueryBuilder } from './update.js';
+import type { DeleteQueryBuilder } from './delete.js';
+
+/**
+ * Resolves a SelectQueryBuilder or SelectQueryNode to a SelectQueryNode AST
+ * @param query - Query builder or AST node
+ * @returns SelectQueryNode AST
+ */
+export function resolveSelectQuery<TSub extends TableDef>(
+    query: SelectQueryBuilder<unknown, TSub> | SelectQueryNode
+): SelectQueryNode {
+    const candidate = query as { getAST?: () => SelectQueryNode };
+    return typeof candidate.getAST === 'function' && candidate.getAST
+        ? candidate.getAST()
+        : (query as SelectQueryNode);
+}
+
+/**
+ * Resolves a UpdateQueryBuilder or UpdateQueryNode to a UpdateQueryNode AST
+ * @param query - Query builder or AST node
+ * @returns UpdateQueryNode AST
+ */
+export function resolveUpdateQuery<T>(
+    query: UpdateQueryBuilder<T> | UpdateQueryNode
+): UpdateQueryNode {
+    const candidate = query as { getAST?: () => UpdateQueryNode };
+    return typeof candidate.getAST === 'function' && candidate.getAST
+        ? candidate.getAST()
+        : (query as UpdateQueryNode);
+}
+
+/**
+ * Resolves a DeleteQueryBuilder or DeleteQueryNode to a DeleteQueryNode AST
+ * @param query - Query builder or AST node
+ * @returns DeleteQueryNode AST
+ */
+export function resolveDeleteQuery<T>(
+    query: DeleteQueryBuilder<T> | DeleteQueryNode
+): DeleteQueryNode {
+    const candidate = query as { getAST?: () => DeleteQueryNode };
+    return typeof candidate.getAST === 'function' && candidate.getAST
+        ? candidate.getAST()
+        : (query as DeleteQueryNode);
+}
+
+/**
+ * Resolves a TableDef or TableSourceNode to a TableSourceNode
+ * @param source - Table definition or source node
+ * @returns TableSourceNode
+ */
+export function resolveTableSource(source: TableDef | TableSourceNode): TableSourceNode {
+    if (isTableSourceNode(source)) {
+        return source;
+    }
+    return { type: 'Table', name: source.name, schema: source.schema };
+}
+
+/**
+ * Resolves a join target (TableDef, TableSourceNode, or string relation name)
+ * @param table - Join target
+ * @returns TableSourceNode or string
+ */
+export function resolveJoinTarget(table: TableDef | TableSourceNode | string): TableSourceNode | string {
+    if (typeof table === 'string') return table;
+    return resolveTableSource(table);
+}
+
+/**
+ * Type guard to check if a value is a TableSourceNode
+ * @param source - Value to check
+ * @returns True if value is a TableSourceNode
+ */
+function isTableSourceNode(source: TableDef | TableSourceNode): source is TableSourceNode {
+    return typeof (source as TableSourceNode).type === 'string';
+}

package/src/query-builder/raw-column-parser.ts

@@ -4,6 +4,11 @@ import { CommonTableExpressionNode } from '../core/ast/query.js';
 /**
  * Best-effort helper that tries to convert a raw column expression into a `ColumnNode`.
  * This parser is intentionally limited; use it only for simple references or function calls.
+ *
+ * @param col - Raw column expression string (e.g., "column", "table.column", "COUNT(column)")
+ * @param tableName - Default table name to use when no table is specified
+ * @param ctes - Optional array of CTEs for context when parsing column references
+ * @returns A ColumnNode representing the parsed column expression
  */
 export const parseRawColumn = (
   col: string,
@@ -11,7 +16,8 @@ export const parseRawColumn = (
   ctes?: CommonTableExpressionNode[]
 ): ColumnNode => {
   if (col.includes('(')) {
-    const [fn, rest] = col.split('(');
+    const [_fn, rest] = col.split('(');
+    void _fn;
     const colName = rest.replace(')', '');
     const [table, name] = colName.includes('.') ? colName.split('.') : [tableName, colName];
     return { type: 'Column', table, name, alias: col };

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

@@ -19,6 +19,9 @@ export interface RelationAliasParts {
 
 /**
  * Builds a relation alias from the relation name and column name components.
+ * @param relationName - The name of the relation
+ * @param columnName - The name of the column within the relation
+ * @returns A relation alias string in the format "relationName__columnName"
  */
 export const makeRelationAlias = (relationName: string, columnName: string): string =>
   `${relationName}${RELATION_SEPARATOR}${columnName}`;
@@ -26,6 +29,8 @@ export const makeRelationAlias = (relationName: string, columnName: string): str
 /**
  * Parses a relation alias into its relation/column components.
  * Returns `null` when the alias does not follow the `relation__column` pattern.
+ * @param alias - The relation alias string to parse
+ * @returns Parsed relation alias parts or null if not a valid relation alias
  */
 export const parseRelationAlias = (alias: string): RelationAliasParts | null => {
   const idx = alias.indexOf(RELATION_SEPARATOR);
@@ -38,6 +43,8 @@ export const parseRelationAlias = (alias: string): RelationAliasParts | null =>
 
 /**
  * Determines whether an alias represents a relation column by checking the `__` convention.
+ * @param alias - The alias string to check
+ * @returns True if the alias follows the relation alias pattern
  */
 export const isRelationAlias = (alias?: string): boolean =>
   !!alias && alias.includes(RELATION_SEPARATOR);

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

@@ -21,26 +21,26 @@ const assertNever = (value: never): never => {
  * @param relation - Relation definition
  * @returns Expression node representing the join condition
  */
-const baseRelationCondition = (root: TableDef, relation: RelationDef, rootAlias?: string): ExpressionNode => {
-  const rootTable = rootAlias || root.name;
-  const defaultLocalKey =
-  relation.type === RelationKinds.HasMany || relation.type === RelationKinds.HasOne
-    ? findPrimaryKey(root)
-    : findPrimaryKey(relation.target);
-  const localKey = relation.localKey || defaultLocalKey;
+const baseRelationCondition = (root: TableDef, relation: RelationDef, rootAlias?: string): ExpressionNode => {
+  const rootTable = rootAlias || root.name;
+  const defaultLocalKey =
+    relation.type === RelationKinds.HasMany || relation.type === RelationKinds.HasOne
+      ? findPrimaryKey(root)
+      : findPrimaryKey(relation.target);
+  const localKey = relation.localKey || defaultLocalKey;
 
   switch (relation.type) {
-    case RelationKinds.HasMany:
-    case RelationKinds.HasOne:
-      return eq(
-        { type: 'Column', table: relation.target.name, name: relation.foreignKey },
-        { type: 'Column', table: rootTable, name: localKey }
-      );
-    case RelationKinds.BelongsTo:
-      return eq(
-        { type: 'Column', table: relation.target.name, name: localKey },
-        { type: 'Column', table: rootTable, name: relation.foreignKey }
-      );
+    case RelationKinds.HasMany:
+    case RelationKinds.HasOne:
+      return eq(
+        { type: 'Column', table: relation.target.name, name: relation.foreignKey },
+        { type: 'Column', table: rootTable, name: localKey }
+      );
+    case RelationKinds.BelongsTo:
+      return eq(
+        { type: 'Column', table: relation.target.name, name: localKey },
+        { type: 'Column', table: rootTable, name: relation.foreignKey }
+      );
     case RelationKinds.BelongsToMany:
       throw new Error('BelongsToMany relations do not support the standard join condition builder');
     default:
@@ -50,25 +50,36 @@ const baseRelationCondition = (root: TableDef, relation: RelationDef, rootAlias?
 
 /**
  * Builds the join nodes required to include a BelongsToMany relation.
+ * @param root - The root table definition
+ * @param relationName - Name of the relation being joined
+ * @param relation - The BelongsToMany relation definition
+ * @param joinKind - The type of join to perform
+ * @param extra - Optional additional conditions for the target join
+ * @param rootAlias - Optional alias for the root table
+ * @returns Array of join nodes for the pivot and target tables
  */
-export const buildBelongsToManyJoins = (
-  root: TableDef,
-  relationName: string,
-  relation: BelongsToManyRelation,
-  joinKind: JoinKind,
-  extra?: ExpressionNode,
-  rootAlias?: string
-): JoinNode[] => {
-  const rootKey = relation.localKey || findPrimaryKey(root);
-  const targetKey = relation.targetKey || findPrimaryKey(relation.target);
-  const rootTable = rootAlias || root.name;
-
-  const pivotCondition = eq(
-    { type: 'Column', table: relation.pivotTable.name, name: relation.pivotForeignKeyToRoot },
-    { type: 'Column', table: rootTable, name: rootKey }
-  );
+export const buildBelongsToManyJoins = (
+  root: TableDef,
+  relationName: string,
+  relation: BelongsToManyRelation,
+  joinKind: JoinKind,
+  extra?: ExpressionNode,
+  rootAlias?: string
+): JoinNode[] => {
+  const rootKey = relation.localKey || findPrimaryKey(root);
+  const targetKey = relation.targetKey || findPrimaryKey(relation.target);
+  const rootTable = rootAlias || root.name;
 
-  const pivotJoin = createJoinNode(joinKind, relation.pivotTable.name, pivotCondition);
+  const pivotCondition = eq(
+    { type: 'Column', table: relation.pivotTable.name, name: relation.pivotForeignKeyToRoot },
+    { type: 'Column', table: rootTable, name: rootKey }
+  );
+
+  const pivotJoin = createJoinNode(
+    joinKind,
+    { type: 'Table', name: relation.pivotTable.name, schema: relation.pivotTable.schema },
+    pivotCondition
+  );
 
   let targetCondition: ExpressionNode = eq(
     { type: 'Column', table: relation.target.name, name: targetKey },
@@ -81,7 +92,7 @@ export const buildBelongsToManyJoins = (
 
   const targetJoin = createJoinNode(
     joinKind,
-    relation.target.name,
+    { type: 'Table', name: relation.target.name, schema: relation.target.schema },
     targetCondition,
     relationName
   );
@@ -94,24 +105,26 @@ export const buildBelongsToManyJoins = (
  * @param root - Root table definition
  * @param relation - Relation definition
  * @param extra - Optional additional expression to combine with AND
+ * @param rootAlias - Optional alias for the root table
  * @returns Expression node representing the complete join condition
  */
-export const buildRelationJoinCondition = (
-  root: TableDef,
-  relation: RelationDef,
-  extra?: ExpressionNode,
-  rootAlias?: string
-): ExpressionNode => {
-  const base = baseRelationCondition(root, relation, rootAlias);
-  return extra ? and(base, extra) : base;
-};
+export const buildRelationJoinCondition = (
+  root: TableDef,
+  relation: RelationDef,
+  extra?: ExpressionNode,
+  rootAlias?: string
+): ExpressionNode => {
+  const base = baseRelationCondition(root, relation, rootAlias);
+  return extra ? and(base, extra) : base;
+};
 
 /**
  * Builds a relation correlation condition for subqueries
  * @param root - Root table definition
  * @param relation - Relation definition
+ * @param rootAlias - Optional alias for the root table
  * @returns Expression node representing the correlation condition
  */
-export const buildRelationCorrelation = (root: TableDef, relation: RelationDef, rootAlias?: string): ExpressionNode => {
-  return baseRelationCondition(root, relation, rootAlias);
-};
+export const buildRelationCorrelation = (root: TableDef, relation: RelationDef, rootAlias?: string): ExpressionNode => {
+  return baseRelationCondition(root, relation, rootAlias);
+};