metal-orm 1.0.100 → 1.0.102

package/src/query-builder/relation-include-strategies.ts

@@ -16,6 +16,7 @@ import { RelationIncludeOptions } from './relation-types.js';
 import { makeRelationAlias } from './relation-alias.js';
 import { buildDefaultPivotColumns } from './relation-utils.js';
 import { findPrimaryKey } from './hydration-planner.js';
+import { getJoinRelationName } from '../core/ast/join-metadata.js';
 
 type RelationWithForeignKey =
   | HasManyRelation
@@ -39,18 +40,42 @@ type IncludeStrategyContext = {
 
 type IncludeStrategy = (context: IncludeStrategyContext) => RelationResult;
 
+/**
+ * Gets the correlation name (exposed name) for a join associated with a relation.
+ * This is necessary to correctly reference columns when a table has been aliased
+ * to avoid "same exposed names" errors in SQL Server.
+ */
+const getJoinCorrelationName = (
+  state: SelectQueryState,
+  relationName: string,
+  fallback: string
+): string => {
+  const join = state.ast.joins.find(j => getJoinRelationName(j) === relationName);
+  if (!join) return fallback;
+
+  const t = join.table;
+  if (t.type === 'Table') return t.alias ?? t.name;
+  if (t.type === 'DerivedTable') return t.alias;
+  if (t.type === 'FunctionTable') return t.alias ?? fallback;
+  return fallback;
+};
+
 const buildTypedSelection = (
   columns: Record<string, ColumnDef>,
   prefix: string,
   keys: string[],
-  missingMsg: (col: string) => string
+  missingMsg: (col: string) => string,
+  tableOverride?: string
 ): Record<string, ColumnDef> => {
   return keys.reduce((acc, key) => {
     const def = columns[key];
     if (!def) {
       throw new Error(missingMsg(key));
     }
-    acc[makeRelationAlias(prefix, key)] = def;
+    // Clone the column definition with the overridden table if provided
+    acc[makeRelationAlias(prefix, key)] = tableOverride
+      ? { ...def, table: tableOverride }
+      : def;
     return acc;
   }, {} as Record<string, ColumnDef>);
 };
@@ -100,11 +125,14 @@ const standardIncludeStrategy: IncludeStrategy = context => {
   hydration = fkSelectionResult.hydration;
 
   const targetColumns = resolveTargetColumns(relation, context.options);
+  // Get the actual correlation name from the JOIN (may be aliased to avoid collisions)
+  const tableOverride = getJoinCorrelationName(state, context.relationName, relation.target.name);
   const targetSelection = buildTypedSelection(
     relation.target.columns as Record<string, ColumnDef>,
     context.aliasPrefix,
     targetColumns,
-    key => `Column '${key}' not found on relation '${context.relationName}'`
+    key => `Column '${key}' not found on relation '${context.relationName}'`,
+    tableOverride
   );
 
   const relationSelectionResult = context.selectColumns(state, hydration, targetSelection);
@@ -127,11 +155,14 @@ const belongsToManyStrategy: IncludeStrategy = context => {
   let { state, hydration } = context;
 
   const targetColumns = resolveTargetColumns(relation, context.options);
+  // Get the actual correlation name from the JOIN (may be aliased to avoid collisions)
+  const tableOverride = getJoinCorrelationName(state, context.relationName, relation.target.name);
   const targetSelection = buildTypedSelection(
     relation.target.columns as Record<string, ColumnDef>,
     context.aliasPrefix,
     targetColumns,
-    key => `Column '${key}' not found on relation '${context.relationName}'`
+    key => `Column '${key}' not found on relation '${context.relationName}'`,
+    tableOverride
   );
 
   const pivotAliasPrefix = context.options?.pivot?.aliasPrefix ?? `${context.aliasPrefix}_pivot`;

package/src/query-builder/relation-join-planner.ts

@@ -8,6 +8,67 @@ import { JoinKind } from '../core/sql/sql.js';
 import { buildRelationJoinCondition, buildBelongsToManyJoins } from './relation-conditions.js';
 import { createJoinNode } from '../core/ast/join-node.js';
 
+/**
+ * Gets the exposed name from a TableSourceNode.
+ * The exposed name is the alias if present, otherwise the table name.
+ */
+const getExposedName = (ts: TableSourceNode): string | null => {
+  if (ts.type === 'Table') return ts.alias ?? ts.name;
+  if (ts.type === 'DerivedTable') return ts.alias;
+  if (ts.type === 'FunctionTable') return ts.alias ?? ts.name;
+  return null;
+};
+
+/**
+ * Collects all exposed names from the current query state (FROM + JOINs).
+ * This is used to detect naming collisions when adding new joins.
+ */
+const collectExposedNames = (state: SelectQueryState): Set<string> => {
+  const used = new Set<string>();
+  const fromName = getExposedName(state.ast.from);
+  if (fromName) used.add(fromName);
+
+  for (const j of state.ast.joins) {
+    const n = getExposedName(j.table);
+    if (n) used.add(n);
+  }
+  return used;
+};
+
+/**
+ * Creates a unique alias based on a base name, avoiding collisions with already-used names.
+ */
+const makeUniqueAlias = (base: string, used: Set<string>): string => {
+  let alias = base;
+  let i = 2;
+  while (used.has(alias)) alias = `${base}_${i++}`;
+  return alias;
+};
+
+/**
+ * Ensures a TableSourceNode has a unique correlation name (alias) to avoid SQL Server's
+ * "same exposed names" error. If the table's exposed name already exists in the query,
+ * an alias is generated using the relation name.
+ */
+const ensureCorrelationName = (
+  state: SelectQueryState,
+  relationName: string,
+  ts: TableSourceNode,
+  extraUsed?: Iterable<string>
+): TableSourceNode => {
+  if (ts.type !== 'Table') return ts;
+  if (ts.alias) return ts;
+
+  const used = collectExposedNames(state);
+  for (const x of extraUsed ?? []) used.add(x);
+
+  // Only alias if the exposed name (table name) already exists
+  if (!used.has(ts.name)) return ts;
+
+  const alias = makeUniqueAlias(relationName, used);
+  return { ...ts, alias };
+};
+
 export class RelationJoinPlanner {
   constructor(
     private readonly table: TableDef,
@@ -24,11 +85,19 @@ export class RelationJoinPlanner {
   ): SelectQueryState {
     const rootAlias = state.ast.from.type === 'Table' ? state.ast.from.alias : undefined;
     if (relation.type === RelationKinds.BelongsToMany) {
-      const targetTableSource: TableSourceNode = tableSource ?? {
+      let targetTableSource: TableSourceNode = tableSource ?? {
         type: 'Table',
         name: relation.target.name,
         schema: relation.target.schema
       };
+      // Ensure unique alias to avoid "same exposed names" error
+      // Include pivot table name in extraUsed since it will be added in this operation
+      targetTableSource = ensureCorrelationName(
+        state,
+        relationName,
+        targetTableSource,
+        [relation.pivotTable.name]
+      );
       const targetName = this.resolveTargetTableName(targetTableSource, relation);
       const joins = buildBelongsToManyJoins(
         this.table,
@@ -43,11 +112,13 @@ export class RelationJoinPlanner {
       return joins.reduce((current, join) => this.astService(current).withJoin(join), state);
     }
 
-    const targetTable: TableSourceNode = tableSource ?? {
+    let targetTable: TableSourceNode = tableSource ?? {
       type: 'Table',
       name: relation.target.name,
       schema: relation.target.schema
     };
+    // Ensure unique alias to avoid "same exposed names" error
+    targetTable = ensureCorrelationName(state, relationName, targetTable);
     const targetName = this.resolveTargetTableName(targetTable, relation);
     const condition = buildRelationJoinCondition(
       this.table,