metal-orm 1.0.42 → 1.0.44

package/src/orm/entity.ts

@@ -13,7 +13,7 @@ import { findPrimaryKey } from '../query-builder/hydration-planner.js';
 /**
  * Type representing an array of database rows.
  */
-type Rows = Record<string, any>[];
+type Rows = Record<string, unknown>[];
 
 /**
  * Caches relation loader results across entities of the same type.
@@ -23,8 +23,8 @@ type Rows = Record<string, any>[];
  * @param factory - The factory function to create the cache
  * @returns Promise with the cached relation data
  */
-const relationLoaderCache = <T extends Map<string, any>>(
-  meta: EntityMeta<any>,
+const relationLoaderCache = <T extends Map<string, unknown>>(
+  meta: EntityMeta<TableDef>,
   relationName: string,
   factory: () => Promise<T>
 ): Promise<T> => {
@@ -68,10 +68,10 @@ export const createEntityProxy = <
 >(
   ctx: EntityContext,
   table: TTable,
-  row: Record<string, any>,
+  row: Record<string, unknown>,
   lazyRelations: TLazy[] = [] as TLazy[]
 ): EntityInstance<TTable> => {
-  const target: Record<string, any> = { ...row };
+  const target: Record<string, unknown> = { ...row };
   const meta: EntityMeta<TTable> = {
     ctx,
     table,
@@ -87,8 +87,7 @@ export const createEntityProxy = <
     writable: false
   });
 
-  let proxy: EntityInstance<TTable>;
-  const handler: ProxyHandler<any> = {
+  const handler: ProxyHandler<object> = {
     get(targetObj, prop, receiver) {
       if (prop === ENTITY_META) {
         return meta;
@@ -96,7 +95,7 @@ export const createEntityProxy = <
 
       if (prop === '$load') {
         return async (relationName: keyof RelationMap<TTable>) => {
-          const wrapper = getRelationWrapper(meta, relationName as string, proxy);
+          const wrapper = getRelationWrapper(meta as unknown as EntityMeta<TableDef>, relationName as string, receiver);
           if (wrapper && typeof wrapper.load === 'function') {
             return wrapper.load();
           }
@@ -105,7 +104,7 @@ export const createEntityProxy = <
       }
 
       if (typeof prop === 'string' && table.relations[prop]) {
-        return getRelationWrapper(meta, prop, proxy);
+        return getRelationWrapper(meta as unknown as EntityMeta<TableDef>, prop, receiver);
       }
 
       return Reflect.get(targetObj, prop, receiver);
@@ -114,13 +113,13 @@ export const createEntityProxy = <
     set(targetObj, prop, value, receiver) {
       const result = Reflect.set(targetObj, prop, value, receiver);
       if (typeof prop === 'string' && table.columns[prop]) {
-        ctx.markDirty(proxy);
+        ctx.markDirty(receiver);
       }
       return result;
     }
   };
 
-  proxy = new Proxy(target, handler) as EntityInstance<TTable>;
+  const proxy = new Proxy(target, handler) as EntityInstance<TTable>;
   populateHydrationCache(proxy, row, meta);
   return proxy;
 };
@@ -141,7 +140,7 @@ export const createEntityFromRow = <
 >(
   ctx: EntityContext,
   table: TTable,
-  row: Record<string, any>,
+  row: Record<string, unknown>,
   lazyRelations: (keyof RelationMap<TTable>)[] = []
 ): TResult => {
   const pkName = findPrimaryKey(table);
@@ -176,8 +175,8 @@ const toKey = (value: unknown): string => (value === null || value === undefined
  * @param meta - The entity metadata
  */
 const populateHydrationCache = <TTable extends TableDef>(
-  entity: any,
-  row: Record<string, any>,
+  entity: Record<string, unknown>,
+  row: Record<string, unknown>,
   meta: EntityMeta<TTable>
 ): void => {
   for (const relationName of Object.keys(meta.table.relations)) {
@@ -188,8 +187,8 @@ const populateHydrationCache = <TTable extends TableDef>(
       const rootValue = entity[localKey];
       if (rootValue === undefined || rootValue === null) continue;
       if (!data || typeof data !== 'object') continue;
-      const cache = new Map<string, Record<string, any>>();
-      cache.set(toKey(rootValue), data as Record<string, any>);
+      const cache = new Map<string, Record<string, unknown>>();
+      cache.set(toKey(rootValue), data as Record<string, unknown>);
       meta.relationHydration.set(relationName, cache);
       meta.relationCache.set(relationName, Promise.resolve(cache));
       continue;
@@ -210,7 +209,7 @@ const populateHydrationCache = <TTable extends TableDef>(
 
     if (relation.type === RelationKinds.BelongsTo) {
       const targetKey = relation.localKey || findPrimaryKey(relation.target);
-      const cache = new Map<string, Record<string, any>>();
+      const cache = new Map<string, Record<string, unknown>>();
       for (const item of data) {
         const pkValue = item[targetKey];
         if (pkValue === undefined || pkValue === null) continue;
@@ -232,18 +231,18 @@ const populateHydrationCache = <TTable extends TableDef>(
  * @returns The relation wrapper or undefined
  */
 const getRelationWrapper = (
-  meta: EntityMeta<any>,
+  meta: EntityMeta<TableDef>,
   relationName: string,
-  owner: any
-): HasManyCollection<any> | HasOneReference<any> | BelongsToReference<any> | ManyToManyCollection<any> | undefined => {
+  owner: unknown
+): HasManyCollection<unknown> | HasOneReference<unknown> | BelongsToReference<unknown> | ManyToManyCollection<unknown> | undefined => {
   if (meta.relationWrappers.has(relationName)) {
-    return meta.relationWrappers.get(relationName) as HasManyCollection<any>;
+    return meta.relationWrappers.get(relationName) as HasManyCollection<unknown>;
   }
 
   const relation = meta.table.relations[relationName];
   if (!relation) return undefined;
 
-  const wrapper = instantiateWrapper(meta, relationName, relation as any, owner);
+  const wrapper = instantiateWrapper(meta, relationName, relation, owner);
   if (wrapper) {
     meta.relationWrappers.set(relationName, wrapper);
   }
@@ -260,11 +259,11 @@ const getRelationWrapper = (
  * @returns The relation wrapper or undefined
  */
 const instantiateWrapper = (
-  meta: EntityMeta<any>,
+  meta: EntityMeta<TableDef>,
   relationName: string,
   relation: HasManyRelation | HasOneRelation | BelongsToRelation | BelongsToManyRelation,
-  owner: any
-): HasManyCollection<any> | HasOneReference<any> | BelongsToReference<any> | ManyToManyCollection<any> | undefined => {
+  owner: unknown
+): HasManyCollection<unknown> | HasOneReference<unknown> | BelongsToReference<unknown> | ManyToManyCollection<unknown> | undefined => {
   switch (relation.type) {
     case RelationKinds.HasOne: {
       const hasOne = relation as HasOneRelation;
@@ -280,7 +279,7 @@ const instantiateWrapper = (
         hasOne,
         meta.table,
         loader,
-        (row: Record<string, any>) => createEntityFromRow(meta.ctx, hasOne.target, row),
+        (row: Record<string, unknown>) => createEntityFromRow(meta.ctx, hasOne.target, row),
         localKey
       );
     }
@@ -298,7 +297,7 @@ const instantiateWrapper = (
         hasMany,
         meta.table,
         loader,
-        (row: Record<string, any>) => createEntityFromRow(meta.ctx, relation.target, row),
+        (row: Record<string, unknown>) => createEntityFromRow(meta.ctx, relation.target, row),
         localKey
       );
     }
@@ -316,7 +315,7 @@ const instantiateWrapper = (
         belongsTo,
         meta.table,
         loader,
-        (row: Record<string, any>) => createEntityFromRow(meta.ctx, relation.target, row),
+        (row: Record<string, unknown>) => createEntityFromRow(meta.ctx, relation.target, row),
         targetKey
       );
     }
@@ -334,7 +333,7 @@ const instantiateWrapper = (
         many,
         meta.table,
         loader,
-        (row: Record<string, any>) => createEntityFromRow(meta.ctx, relation.target, row),
+        (row: Record<string, unknown>) => createEntityFromRow(meta.ctx, relation.target, row),
         localKey
       );
     }

package/src/orm/execute.ts

@@ -8,7 +8,7 @@ import { EntityContext } from './entity-context.js';
 import { ExecutionContext } from './execution-context.js';
 import { HydrationContext } from './hydration-context.js';
 
-type Row = Record<string, any>;
+type Row = Record<string, unknown>;
 
 const flattenResults = (results: { columns: string[]; values: unknown[][] }[]): Row[] => {
   const rows: Row[] = [];
@@ -27,7 +27,7 @@ const flattenResults = (results: { columns: string[]; values: unknown[][] }[]):
 
 const executeWithEntityContext = async <TTable extends TableDef>(
   entityCtx: EntityContext,
-  qb: SelectQueryBuilder<any, TTable>
+  qb: SelectQueryBuilder<unknown, TTable>
 ): Promise<EntityInstance<TTable>[]> => {
   const ast = qb.getAST();
   const compiled = entityCtx.dialect.compileSelect(ast);
@@ -42,17 +42,32 @@ const executeWithEntityContext = async <TTable extends TableDef>(
   return hydrated.map(row => createEntityFromRow(entityCtx, qb.getTable(), row, qb.getLazyRelations()));
 };
 
+/**
+ * Executes a hydrated query using the ORM session.
+ * @template TTable - The table type
+ * @param session - The ORM session
+ * @param qb - The select query builder
+ * @returns Promise resolving to array of entity instances
+ */
 export async function executeHydrated<TTable extends TableDef>(
   session: OrmSession,
-  qb: SelectQueryBuilder<any, TTable>
+  qb: SelectQueryBuilder<unknown, TTable>
 ): Promise<EntityInstance<TTable>[]> {
   return executeWithEntityContext(session, qb);
 }
 
+/**
+ * Executes a hydrated query using execution and hydration contexts.
+ * @template TTable - The table type
+ * @param _execCtx - The execution context (unused)
+ * @param hydCtx - The hydration context
+ * @param qb - The select query builder
+ * @returns Promise resolving to array of entity instances
+ */
 export async function executeHydratedWithContexts<TTable extends TableDef>(
   _execCtx: ExecutionContext,
   hydCtx: HydrationContext,
-  qb: SelectQueryBuilder<any, TTable>
+  qb: SelectQueryBuilder<unknown, TTable>
 ): Promise<EntityInstance<TTable>[]> {
   const entityCtx = hydCtx.entityContext;
   if (!entityCtx) {

package/src/orm/hydration.ts

@@ -1,6 +1,10 @@
-import { HydrationPlan, HydrationRelationPlan } from '../core/hydration/types.js';
-import { RelationKinds } from '../schema/relation.js';
-import { isRelationAlias, makeRelationAlias } from '../query-builder/relation-alias.js';
+import { HydrationPlan, HydrationRelationPlan } from '../core/hydration/types.js';
+import { RelationKinds } from '../schema/relation.js';
+import { isRelationAlias, makeRelationAlias } from '../query-builder/relation-alias.js';
+
+/**
+ * Hydrates query results according to a hydration plan
+ * @param rows - Raw database rows
 
 /**
  * Hydrates query results according to a hydration plan
@@ -8,13 +12,13 @@ import { isRelationAlias, makeRelationAlias } from '../query-builder/relation-al
  * @param plan - Hydration plan
  * @returns Hydrated result objects with nested relations
  */
-export const hydrateRows = (rows: Record<string, any>[], plan?: HydrationPlan): Record<string, any>[] => {
+export const hydrateRows = (rows: Record<string, unknown>[], plan?: HydrationPlan): Record<string, unknown>[] => {
   if (!plan || !rows.length) return rows;
 
-  const rootMap = new Map<any, Record<string, any>>();
-  const relationIndex = new Map<any, Record<string, Set<any>>>();
+  const rootMap = new Map<unknown, Record<string, unknown>>();
+  const relationIndex = new Map<unknown, Record<string, Set<unknown>>>();
 
-  const getOrCreateParent = (row: Record<string, any>) => {
+  const getOrCreateParent = (row: Record<string, unknown>) => {
     const rootId = row[plan.rootPrimaryKey];
     if (rootId === undefined) return undefined;
 
@@ -25,7 +29,7 @@ export const hydrateRows = (rows: Record<string, any>[], plan?: HydrationPlan):
     return rootMap.get(rootId);
   };
 
-  const getRelationSeenSet = (rootId: any, relationName: string): Set<any> => {
+  const getRelationSeenSet = (rootId: unknown, relationName: string): Set<unknown> => {
     let byRelation = relationIndex.get(rootId);
     if (!byRelation) {
       byRelation = {};
@@ -34,7 +38,7 @@ export const hydrateRows = (rows: Record<string, any>[], plan?: HydrationPlan):
 
     let seen = byRelation[relationName];
     if (!seen) {
-      seen = new Set<any>();
+      seen = new Set<unknown>();
       byRelation[relationName] = seen;
     }
 
@@ -48,32 +52,32 @@ export const hydrateRows = (rows: Record<string, any>[], plan?: HydrationPlan):
     const parent = getOrCreateParent(row);
     if (!parent) continue;
 
-    for (const rel of plan.relations) {
-      const childPkKey = makeRelationAlias(rel.aliasPrefix, rel.targetPrimaryKey);
-      const childPk = row[childPkKey];
-      if (childPk === null || childPk === undefined) continue;
-
-      const seen = getRelationSeenSet(rootId, rel.name);
-      if (seen.has(childPk)) continue;
-      seen.add(childPk);
-
-      if (rel.type === RelationKinds.HasOne) {
-        if (!parent[rel.name]) {
-          parent[rel.name] = buildChild(row, rel);
-        }
-        continue;
-      }
-
-      const bucket = parent[rel.name] as any[];
-      bucket.push(buildChild(row, rel));
-    }
+    for (const rel of plan.relations) {
+      const childPkKey = makeRelationAlias(rel.aliasPrefix, rel.targetPrimaryKey);
+      const childPk = row[childPkKey];
+      if (childPk === null || childPk === undefined) continue;
+
+      const seen = getRelationSeenSet(rootId, rel.name);
+      if (seen.has(childPk)) continue;
+      seen.add(childPk);
+
+      if (rel.type === RelationKinds.HasOne) {
+        if (!parent[rel.name]) {
+          parent[rel.name] = buildChild(row, rel);
+        }
+        continue;
+      }
+
+      const bucket = parent[rel.name] as unknown[];
+      bucket.push(buildChild(row, rel));
+    }
   }
 
   return Array.from(rootMap.values());
 };
 
-const createBaseRow = (row: Record<string, any>, plan: HydrationPlan): Record<string, any> => {
-  const base: Record<string, any> = {};
+const createBaseRow = (row: Record<string, unknown>, plan: HydrationPlan): Record<string, unknown> => {
+  const base: Record<string, unknown> = {};
   const baseKeys = plan.rootColumns.length
     ? plan.rootColumns
     : Object.keys(row).filter(k => !isRelationAlias(k));
@@ -82,15 +86,14 @@ const createBaseRow = (row: Record<string, any>, plan: HydrationPlan): Record<st
     base[key] = row[key];
   }
 
-  for (const rel of plan.relations) {
-    base[rel.name] = rel.type === RelationKinds.HasOne ? null : [];
-  }
-
+  for (const rel of plan.relations) {
+    base[rel.name] = rel.type === RelationKinds.HasOne ? null : [];
+  }
   return base;
 };
 
-const buildChild = (row: Record<string, any>, rel: HydrationRelationPlan): Record<string, any> => {
-  const child: Record<string, any> = {};
+const buildChild = (row: Record<string, unknown>, rel: HydrationRelationPlan): Record<string, unknown> => {
+  const child: Record<string, unknown> = {};
   for (const col of rel.columns) {
     const key = makeRelationAlias(rel.aliasPrefix, col);
     child[col] = row[key];
@@ -98,16 +101,16 @@ const buildChild = (row: Record<string, any>, rel: HydrationRelationPlan): Recor
 
   const pivot = buildPivot(row, rel);
   if (pivot) {
-    (child as any)._pivot = pivot;
+    (child as { _pivot: unknown })._pivot = pivot;
   }
 
   return child;
 };
 
-const buildPivot = (row: Record<string, any>, rel: HydrationRelationPlan): Record<string, any> | undefined => {
+const buildPivot = (row: Record<string, unknown>, rel: HydrationRelationPlan): Record<string, unknown> | undefined => {
   if (!rel.pivot) return undefined;
 
-  const pivot: Record<string, any> = {};
+  const pivot: Record<string, unknown> = {};
   for (const col of rel.pivot.columns) {
     const key = makeRelationAlias(rel.pivot.aliasPrefix, col);
     pivot[col] = row[key];

package/src/orm/identity-map.ts

@@ -8,7 +8,7 @@ export class IdentityMap {
     return this.buckets;
   }
 
-  getEntity(table: TableDef, pk: string | number): any | undefined {
+  getEntity(table: TableDef, pk: string | number): unknown | undefined {
     const bucket = this.buckets.get(table.name);
     return bucket?.get(this.toIdentityKey(pk))?.entity;
   }

package/src/orm/lazy-batch.ts

@@ -7,7 +7,9 @@ import type { QueryResult } from '../core/execution/db-executor.js';
 import { ColumnDef } from '../schema/column.js';
 import { findPrimaryKey } from '../query-builder/hydration-planner.js';
 
-type Rows = Record<string, any>[];
+type Rows = Record<string, unknown>[];
+
+type EntityTracker = ReturnType<EntityContext['getEntitiesForTable']>[number];
 
 const selectAllColumns = (table: TableDef): Record<string, ColumnDef> =>
   Object.entries(table.columns).reduce((acc, [name, def]) => {
@@ -20,7 +22,7 @@ const rowsFromResults = (results: QueryResult[]): Rows => {
   for (const result of results) {
     const { columns, values } = result;
     for (const valueRow of values) {
-      const row: Record<string, any> = {};
+      const row: Record<string, unknown> = {};
       columns.forEach((column, idx) => {
         row[column] = valueRow[idx];
       });
@@ -30,7 +32,7 @@ const rowsFromResults = (results: QueryResult[]): Rows => {
   return rows;
 };
 
-const executeQuery = async (ctx: EntityContext, qb: SelectQueryBuilder<any, TableDef<any>>): Promise<Rows> => {
+const executeQuery = async (ctx: EntityContext, qb: SelectQueryBuilder<unknown, TableDef>): Promise<Rows> => {
   const compiled = ctx.dialect.compileSelect(qb.getAST());
   const results = await ctx.executor.executeSql(compiled.sql, compiled.params);
   return rowsFromResults(results);
@@ -38,90 +40,97 @@ const executeQuery = async (ctx: EntityContext, qb: SelectQueryBuilder<any, Tabl
 
 const toKey = (value: unknown): string => (value === null || value === undefined ? '' : String(value));
 
-export const loadHasManyRelation = async (
-  ctx: EntityContext,
-  rootTable: TableDef,
-  _relationName: string,
-  relation: HasManyRelation
-): Promise<Map<string, Rows>> => {
-  const localKey = relation.localKey || findPrimaryKey(rootTable);
-  const roots = ctx.getEntitiesForTable(rootTable);
-  const keys = new Set<unknown>();
-
+const collectKeysFromRoots = (roots: EntityTracker[], key: string): Set<unknown> => {
+  const collected = new Set<unknown>();
   for (const tracked of roots) {
-    const value = tracked.entity[localKey];
+    const value = tracked.entity[key];
     if (value !== null && value !== undefined) {
-      keys.add(value);
+      collected.add(value);
     }
   }
+  return collected;
+};
 
-  if (!keys.size) {
-    return new Map();
-  }
+const buildInListValues = (keys: Set<unknown>): (string | number | LiteralNode)[] =>
+  Array.from(keys) as (string | number | LiteralNode)[];
 
-  const selectMap = selectAllColumns(relation.target);
-  const fb = new SelectQueryBuilder(relation.target).select(selectMap);
-  const fkColumn = relation.target.columns[relation.foreignKey];
-  if (!fkColumn) return new Map();
-
-  fb.where(inList(fkColumn, Array.from(keys) as (string | number | LiteralNode)[]));
+const fetchRowsForKeys = async (
+  ctx: EntityContext,
+  table: TableDef,
+  column: ColumnDef,
+  keys: Set<unknown>
+): Promise<Rows> => {
+  const qb = new SelectQueryBuilder(table).select(selectAllColumns(table));
+  qb.where(inList(column, buildInListValues(keys)));
+  return executeQuery(ctx, qb);
+};
 
-  const rows = await executeQuery(ctx, fb);
+const groupRowsByMany = (rows: Rows, keyColumn: string): Map<string, Rows> => {
   const grouped = new Map<string, Rows>();
-
   for (const row of rows) {
-    const fkValue = row[relation.foreignKey];
-    if (fkValue === null || fkValue === undefined) continue;
-    const key = toKey(fkValue);
+    const value = row[keyColumn];
+    if (value === null || value === undefined) continue;
+    const key = toKey(value);
     const bucket = grouped.get(key) ?? [];
     bucket.push(row);
     grouped.set(key, bucket);
   }
-
   return grouped;
 };
 
-export const loadHasOneRelation = async (
+const groupRowsByUnique = (rows: Rows, keyColumn: string): Map<string, Record<string, unknown>> => {
+  const lookup = new Map<string, Record<string, unknown>>();
+  for (const row of rows) {
+    const value = row[keyColumn];
+    if (value === null || value === undefined) continue;
+    const key = toKey(value);
+    if (!lookup.has(key)) {
+      lookup.set(key, row);
+    }
+  }
+  return lookup;
+};
+
+export const loadHasManyRelation = async (
   ctx: EntityContext,
   rootTable: TableDef,
   _relationName: string,
-  relation: HasOneRelation
-): Promise<Map<string, Record<string, any>>> => {
+  relation: HasManyRelation
+): Promise<Map<string, Rows>> => {
   const localKey = relation.localKey || findPrimaryKey(rootTable);
   const roots = ctx.getEntitiesForTable(rootTable);
-  const keys = new Set<unknown>();
-
-  for (const tracked of roots) {
-    const value = tracked.entity[localKey];
-    if (value !== null && value !== undefined) {
-      keys.add(value);
-    }
-  }
+  const keys = collectKeysFromRoots(roots, localKey);
 
   if (!keys.size) {
     return new Map();
   }
 
-  const selectMap = selectAllColumns(relation.target);
-  const qb = new SelectQueryBuilder(relation.target).select(selectMap);
   const fkColumn = relation.target.columns[relation.foreignKey];
   if (!fkColumn) return new Map();
 
-  qb.where(inList(fkColumn, Array.from(keys) as (string | number | LiteralNode)[]));
+  const rows = await fetchRowsForKeys(ctx, relation.target, fkColumn, keys);
+  return groupRowsByMany(rows, relation.foreignKey);
+};
 
-  const rows = await executeQuery(ctx, qb);
-  const lookup = new Map<string, Record<string, any>>();
+export const loadHasOneRelation = async (
+  ctx: EntityContext,
+  rootTable: TableDef,
+  _relationName: string,
+  relation: HasOneRelation
+): Promise<Map<string, Record<string, unknown>>> => {
+  const localKey = relation.localKey || findPrimaryKey(rootTable);
+  const roots = ctx.getEntitiesForTable(rootTable);
+  const keys = collectKeysFromRoots(roots, localKey);
 
-  for (const row of rows) {
-    const fkValue = row[relation.foreignKey];
-    if (fkValue === null || fkValue === undefined) continue;
-    const key = toKey(fkValue);
-    if (!lookup.has(key)) {
-      lookup.set(key, row);
-    }
+  if (!keys.size) {
+    return new Map();
   }
 
-  return lookup;
+  const fkColumn = relation.target.columns[relation.foreignKey];
+  if (!fkColumn) return new Map();
+
+  const rows = await fetchRowsForKeys(ctx, relation.target, fkColumn, keys);
+  return groupRowsByUnique(rows, relation.foreignKey);
 };
 
 export const loadBelongsToRelation = async (
@@ -129,38 +138,20 @@ export const loadBelongsToRelation = async (
   rootTable: TableDef,
   _relationName: string,
   relation: BelongsToRelation
-): Promise<Map<string, Record<string, any>>> => {
+): Promise<Map<string, Record<string, unknown>>> => {
   const roots = ctx.getEntitiesForTable(rootTable);
-  const foreignKeys = new Set<unknown>();
-
-  for (const tracked of roots) {
-    const value = tracked.entity[relation.foreignKey];
-    if (value !== null && value !== undefined) {
-      foreignKeys.add(value);
-    }
-  }
+  const foreignKeys = collectKeysFromRoots(roots, relation.foreignKey);
 
   if (!foreignKeys.size) {
     return new Map();
   }
 
-  const selectMap = selectAllColumns(relation.target);
-  const qb = new SelectQueryBuilder(relation.target).select(selectMap);
   const targetKey = relation.localKey || findPrimaryKey(relation.target);
   const pkColumn = relation.target.columns[targetKey];
   if (!pkColumn) return new Map();
 
-  qb.where(inList(pkColumn, Array.from(foreignKeys) as (string | number | LiteralNode)[]));
-  const rows = await executeQuery(ctx, qb);
-  const map = new Map<string, Record<string, any>>();
-
-  for (const row of rows) {
-    const keyValue = row[targetKey];
-    if (keyValue === null || keyValue === undefined) continue;
-    map.set(toKey(keyValue), row);
-  }
-
-  return map;
+  const rows = await fetchRowsForKeys(ctx, relation.target, pkColumn, foreignKeys);
+  return groupRowsByUnique(rows, targetKey);
 };
 
 export const loadBelongsToManyRelation = async (
@@ -171,28 +162,17 @@ export const loadBelongsToManyRelation = async (
 ): Promise<Map<string, Rows>> => {
   const rootKey = relation.localKey || findPrimaryKey(rootTable);
   const roots = ctx.getEntitiesForTable(rootTable);
-  const rootIds = new Set<unknown>();
-
-  for (const tracked of roots) {
-    const value = tracked.entity[rootKey];
-    if (value !== null && value !== undefined) {
-      rootIds.add(value);
-    }
-  }
+  const rootIds = collectKeysFromRoots(roots, rootKey);
 
   if (!rootIds.size) {
     return new Map();
   }
 
-  const pivotSelect = selectAllColumns(relation.pivotTable);
-  const pivotQb = new SelectQueryBuilder(relation.pivotTable).select(pivotSelect);
-  const pivotFkCol = relation.pivotTable.columns[relation.pivotForeignKeyToRoot];
-  if (!pivotFkCol) return new Map();
+  const pivotColumn = relation.pivotTable.columns[relation.pivotForeignKeyToRoot];
+  if (!pivotColumn) return new Map();
 
-  pivotQb.where(inList(pivotFkCol, Array.from(rootIds) as (string | number | LiteralNode)[]));
-  const pivotRows = await executeQuery(ctx, pivotQb);
-
-  const rootLookup = new Map<string, { targetId: unknown; pivot: Record<string, any> }[]>();
+  const pivotRows = await fetchRowsForKeys(ctx, relation.pivotTable, pivotColumn, rootIds);
+  const rootLookup = new Map<string, { targetId: unknown; pivot: Record<string, unknown> }[]>();
   const targetIds = new Set<unknown>();
 
   for (const pivot of pivotRows) {
@@ -214,22 +194,12 @@ export const loadBelongsToManyRelation = async (
     return new Map();
   }
 
-  const targetSelect = selectAllColumns(relation.target);
   const targetKey = relation.targetKey || findPrimaryKey(relation.target);
   const targetPkColumn = relation.target.columns[targetKey];
   if (!targetPkColumn) return new Map();
 
-  const targetQb = new SelectQueryBuilder(relation.target).select(targetSelect);
-  targetQb.where(inList(targetPkColumn, Array.from(targetIds) as (string | number | LiteralNode)[]));
-  const targetRows = await executeQuery(ctx, targetQb);
-  const targetMap = new Map<string, Record<string, any>>();
-
-  for (const row of targetRows) {
-    const pkValue = row[targetKey];
-    if (pkValue === null || pkValue === undefined) continue;
-    targetMap.set(toKey(pkValue), row);
-  }
-
+  const targetRows = await fetchRowsForKeys(ctx, relation.target, targetPkColumn, targetIds);
+  const targetMap = groupRowsByUnique(targetRows, targetKey);
   const result = new Map<string, Rows>();
 
   for (const [rootId, entries] of rootLookup.entries()) {