metal-orm 1.1.8 → 1.1.10

package/src/orm/entity.ts

@@ -1,199 +1,199 @@
-import { TableDef } from '../schema/table.js';
-import { EntityInstance } from '../schema/types.js';
-import type { EntityContext, PrimaryKey } from './entity-context.js';
-import { ENTITY_META, EntityMeta, RelationKey } from './entity-meta.js';
-import { findPrimaryKey } from '../query-builder/hydration-planner.js';
-import { RelationIncludeOptions } from '../query-builder/relation-types.js';
-import { populateHydrationCache } from './entity-hydration.js';
-import { getRelationWrapper, RelationEntityFactory } from './entity-relations.js';
-import { RelationKinds } from '../schema/relation.js';
-
-export { relationLoaderCache } from './entity-relation-cache.js';
-
-/**
- * Options for toJSON serialization.
- */
-export interface ToJsonOptions {
-  /**
-   * If true (default), includes all relations defined in the schema (empty arrays/null for unloaded).
-   * If false, only includes relations that were loaded.
-   */
-  includeAllRelations?: boolean;
-}
-
-const isRelationWrapperLoaded = (value: unknown): boolean => {
-  if (!value || typeof value !== 'object') return false;
-  return Boolean((value as { loaded?: boolean }).loaded);
-};
-
-type JsonSource<TTable extends TableDef> = EntityInstance<TTable> & Record<string, unknown>;
-
-/**
- * Creates an entity proxy with lazy loading capabilities.
- * @template TTable - The table type
- * @template TLazy - The lazy relation keys
- * @param ctx - The entity context
- * @param table - The table definition
- * @param row - The database row
- * @param lazyRelations - Optional lazy relations
- * @returns The entity instance
- */
-export const createEntityProxy = <
-  TTable extends TableDef,
-  TLazy extends RelationKey<TTable> = RelationKey<TTable>
->(
-  ctx: EntityContext,
-  table: TTable,
-  row: Record<string, unknown>,
-  lazyRelations: TLazy[] = [] as TLazy[],
-  lazyRelationOptions: Map<string, RelationIncludeOptions> = new Map()
-): EntityInstance<TTable> => {
-  const target: Record<string, unknown> = { ...row };
-  const meta: EntityMeta<TTable> = {
-    ctx,
-    table,
-    lazyRelations: [...lazyRelations],
-    lazyRelationOptions: new Map(lazyRelationOptions),
-    relationCache: new Map(),
-    relationHydration: new Map(),
-    relationWrappers: new Map()
-  };
-  const createRelationEntity: RelationEntityFactory = (relationTable, relationRow) =>
-    createEntityFromRow(meta.ctx, relationTable, relationRow);
-
-  const isCollectionRelation = (relationName: string): boolean => {
-    const rel = table.relations[relationName];
-    if (!rel) return false;
-    return rel.type === RelationKinds.HasMany || rel.type === RelationKinds.BelongsToMany;
-  };
-
-  const buildJson = (self: JsonSource<TTable>, options?: ToJsonOptions): Record<string, unknown> => {
-    const json: Record<string, unknown> = {};
-    const includeAll = options?.includeAllRelations ?? true;
-
-    // Add non-relation columns
-    for (const key of Object.keys(target)) {
-      if (!table.relations[key]) {
-        json[key] = self[key];
-      }
-    }
-
-    // Add relations
-    if (includeAll) {
-      // Include ALL relations from schema
-      for (const relationName of Object.keys(table.relations)) {
-        const wrapper = self[relationName];
-        if (wrapper && isRelationWrapperLoaded(wrapper)) {
-          const wrapperWithToJSON = wrapper as { toJSON?: () => unknown };
-          json[relationName] = typeof wrapperWithToJSON.toJSON === 'function'
-            ? wrapperWithToJSON.toJSON()
-            : wrapper;
-        } else {
-          // Unloaded: use empty array for collections, null for single relations
-          json[relationName] = isCollectionRelation(relationName) ? [] : null;
-        }
-      }
-    } else {
-      // Only include loaded relations that exist in target
-      for (const key of Object.keys(target)) {
-        if (table.relations[key]) {
-          const wrapper = self[key];
-          if (wrapper && isRelationWrapperLoaded(wrapper)) {
-            const wrapperWithToJSON = wrapper as { toJSON?: () => unknown };
-            json[key] = typeof wrapperWithToJSON.toJSON === 'function'
-              ? wrapperWithToJSON.toJSON()
-              : wrapper;
-          }
-        }
-      }
-    }
-
-    return json;
-  };
-
-  Object.defineProperty(target, ENTITY_META, {
-    value: meta,
-    enumerable: false,
-    writable: false
-  });
-
-  const handler: ProxyHandler<object> = {
-    get(targetObj, prop, receiver) {
-      if (prop === ENTITY_META) {
-        return meta;
-      }
-
-      if (prop === '$load') {
-        return async (relationName: RelationKey<TTable>) => {
-          const wrapper = getRelationWrapper(meta, relationName, receiver, createRelationEntity);
-          if (wrapper && typeof wrapper.load === 'function') {
-            return wrapper.load();
-          }
-          return undefined;
-        };
-      }
-
-      if (prop === 'toJSON') {
-        if (prop in targetObj) {
-          return Reflect.get(targetObj, prop, receiver);
-        }
-        return (options?: ToJsonOptions) => buildJson(receiver as JsonSource<TTable>, options);
-      }
-
-      if (typeof prop === 'string' && table.relations[prop]) {
-        return getRelationWrapper(meta, prop as RelationKey<TTable>, receiver, createRelationEntity);
-      }
-
-      return Reflect.get(targetObj, prop, receiver);
-    },
-
-    set(targetObj, prop, value, receiver) {
-      const result = Reflect.set(targetObj, prop, value, receiver);
-      if (typeof prop === 'string' && table.columns[prop]) {
-        ctx.markDirty(receiver);
-      }
-      return result;
-    }
-  };
-
-  const proxy = new Proxy(target, handler) as EntityInstance<TTable>;
-  populateHydrationCache(proxy, row, meta);
-  return proxy;
-};
-
-/**
- * Creates an entity instance from a database row.
- * @template TTable - The table type
- * @template TResult - The result type
- * @param ctx - The entity context
- * @param table - The table definition
- * @param row - The database row
- * @param lazyRelations - Optional lazy relations
- * @returns The entity instance
- */
-export const createEntityFromRow = <
-  TTable extends TableDef,
-  TResult extends EntityInstance<TTable> = EntityInstance<TTable>
->(
-  ctx: EntityContext,
-  table: TTable,
-  row: Record<string, unknown>,
-  lazyRelations: RelationKey<TTable>[] = [],
-  lazyRelationOptions: Map<string, RelationIncludeOptions> = new Map()
-): TResult => {
-  const pkName = findPrimaryKey(table);
-  const pkValue = row[pkName];
-  if (pkValue !== undefined && pkValue !== null) {
-    const tracked = ctx.getEntity(table, pkValue as PrimaryKey);
-    if (tracked) return tracked as TResult;
-  }
-
-  const entity = createEntityProxy(ctx, table, row, lazyRelations, lazyRelationOptions);
-  if (pkValue !== undefined && pkValue !== null) {
-    ctx.trackManaged(table, pkValue as PrimaryKey, entity);
-  } else {
-    ctx.trackNew(table, entity);
-  }
-
-  return entity as TResult;
-};
+import { TableDef } from '../schema/table.js';
+import { EntityInstance } from '../schema/types.js';
+import type { EntityContext, PrimaryKey } from './entity-context.js';
+import { ENTITY_META, EntityMeta, RelationKey } from './entity-meta.js';
+import { findPrimaryKey } from '../query-builder/hydration-planner.js';
+import { RelationIncludeOptions } from '../query-builder/relation-types.js';
+import { populateHydrationCache } from './entity-hydration.js';
+import { getRelationWrapper, RelationEntityFactory } from './entity-relations.js';
+import { RelationKinds } from '../schema/relation.js';
+
+export { relationLoaderCache } from './entity-relation-cache.js';
+
+/**
+ * Options for toJSON serialization.
+ */
+export interface ToJsonOptions {
+  /**
+   * If true (default), includes all relations defined in the schema (empty arrays/null for unloaded).
+   * If false, only includes relations that were loaded.
+   */
+  includeAllRelations?: boolean;
+}
+
+const isRelationWrapperLoaded = (value: unknown): boolean => {
+  if (!value || typeof value !== 'object') return false;
+  return Boolean((value as { loaded?: boolean }).loaded);
+};
+
+type JsonSource<TTable extends TableDef> = EntityInstance<TTable> & Record<string, unknown>;
+
+/**
+ * Creates an entity proxy with lazy loading capabilities.
+ * @template TTable - The table type
+ * @template TLazy - The lazy relation keys
+ * @param ctx - The entity context
+ * @param table - The table definition
+ * @param row - The database row
+ * @param lazyRelations - Optional lazy relations
+ * @returns The entity instance
+ */
+export const createEntityProxy = <
+  TTable extends TableDef,
+  TLazy extends RelationKey<TTable> = RelationKey<TTable>
+>(
+  ctx: EntityContext,
+  table: TTable,
+  row: Record<string, unknown>,
+  lazyRelations: TLazy[] = [] as TLazy[],
+  lazyRelationOptions: Map<string, RelationIncludeOptions> = new Map()
+): EntityInstance<TTable> => {
+  const target: Record<string, unknown> = { ...row };
+  const meta: EntityMeta<TTable> = {
+    ctx,
+    table,
+    lazyRelations: [...lazyRelations],
+    lazyRelationOptions: new Map(lazyRelationOptions),
+    relationCache: new Map(),
+    relationHydration: new Map(),
+    relationWrappers: new Map()
+  };
+  const createRelationEntity: RelationEntityFactory = (relationTable, relationRow) =>
+    createEntityFromRow(meta.ctx, relationTable, relationRow);
+
+  const isCollectionRelation = (relationName: string): boolean => {
+    const rel = table.relations[relationName];
+    if (!rel) return false;
+    return rel.type === RelationKinds.HasMany || rel.type === RelationKinds.BelongsToMany || rel.type === RelationKinds.MorphMany;
+  };
+
+  const buildJson = (self: JsonSource<TTable>, options?: ToJsonOptions): Record<string, unknown> => {
+    const json: Record<string, unknown> = {};
+    const includeAll = options?.includeAllRelations ?? true;
+
+    // Add non-relation columns
+    for (const key of Object.keys(target)) {
+      if (!table.relations[key]) {
+        json[key] = self[key];
+      }
+    }
+
+    // Add relations
+    if (includeAll) {
+      // Include ALL relations from schema
+      for (const relationName of Object.keys(table.relations)) {
+        const wrapper = self[relationName];
+        if (wrapper && isRelationWrapperLoaded(wrapper)) {
+          const wrapperWithToJSON = wrapper as { toJSON?: () => unknown };
+          json[relationName] = typeof wrapperWithToJSON.toJSON === 'function'
+            ? wrapperWithToJSON.toJSON()
+            : wrapper;
+        } else {
+          // Unloaded: use empty array for collections, null for single relations
+          json[relationName] = isCollectionRelation(relationName) ? [] : null;
+        }
+      }
+    } else {
+      // Only include loaded relations that exist in target
+      for (const key of Object.keys(target)) {
+        if (table.relations[key]) {
+          const wrapper = self[key];
+          if (wrapper && isRelationWrapperLoaded(wrapper)) {
+            const wrapperWithToJSON = wrapper as { toJSON?: () => unknown };
+            json[key] = typeof wrapperWithToJSON.toJSON === 'function'
+              ? wrapperWithToJSON.toJSON()
+              : wrapper;
+          }
+        }
+      }
+    }
+
+    return json;
+  };
+
+  Object.defineProperty(target, ENTITY_META, {
+    value: meta,
+    enumerable: false,
+    writable: false
+  });
+
+  const handler: ProxyHandler<object> = {
+    get(targetObj, prop, receiver) {
+      if (prop === ENTITY_META) {
+        return meta;
+      }
+
+      if (prop === '$load') {
+        return async (relationName: RelationKey<TTable>) => {
+          const wrapper = getRelationWrapper(meta, relationName, receiver, createRelationEntity);
+          if (wrapper && typeof wrapper.load === 'function') {
+            return wrapper.load();
+          }
+          return undefined;
+        };
+      }
+
+      if (prop === 'toJSON') {
+        if (prop in targetObj) {
+          return Reflect.get(targetObj, prop, receiver);
+        }
+        return (options?: ToJsonOptions) => buildJson(receiver as JsonSource<TTable>, options);
+      }
+
+      if (typeof prop === 'string' && table.relations[prop]) {
+        return getRelationWrapper(meta, prop as RelationKey<TTable>, receiver, createRelationEntity);
+      }
+
+      return Reflect.get(targetObj, prop, receiver);
+    },
+
+    set(targetObj, prop, value, receiver) {
+      const result = Reflect.set(targetObj, prop, value, receiver);
+      if (typeof prop === 'string' && table.columns[prop]) {
+        ctx.markDirty(receiver);
+      }
+      return result;
+    }
+  };
+
+  const proxy = new Proxy(target, handler) as EntityInstance<TTable>;
+  populateHydrationCache(proxy, row, meta);
+  return proxy;
+};
+
+/**
+ * Creates an entity instance from a database row.
+ * @template TTable - The table type
+ * @template TResult - The result type
+ * @param ctx - The entity context
+ * @param table - The table definition
+ * @param row - The database row
+ * @param lazyRelations - Optional lazy relations
+ * @returns The entity instance
+ */
+export const createEntityFromRow = <
+  TTable extends TableDef,
+  TResult extends EntityInstance<TTable> = EntityInstance<TTable>
+>(
+  ctx: EntityContext,
+  table: TTable,
+  row: Record<string, unknown>,
+  lazyRelations: RelationKey<TTable>[] = [],
+  lazyRelationOptions: Map<string, RelationIncludeOptions> = new Map()
+): TResult => {
+  const pkName = findPrimaryKey(table);
+  const pkValue = row[pkName];
+  if (pkValue !== undefined && pkValue !== null) {
+    const tracked = ctx.getEntity(table, pkValue as PrimaryKey);
+    if (tracked) return tracked as TResult;
+  }
+
+  const entity = createEntityProxy(ctx, table, row, lazyRelations, lazyRelationOptions);
+  if (pkValue !== undefined && pkValue !== null) {
+    ctx.trackManaged(table, pkValue as PrimaryKey, entity);
+  } else {
+    ctx.trackNew(table, entity);
+  }
+
+  return entity as TResult;
+};

package/src/orm/execute.ts

@@ -15,13 +15,13 @@ import { HydrationContext } from './hydration-context.js';
 import { RelationIncludeOptions } from '../query-builder/relation-types.js';
 import { getEntityMeta, RelationKey } from './entity-meta.js';
 import { preloadRelationIncludes } from './relation-preload.js';
-import {
-  loadHasManyRelation,
-  loadHasOneRelation,
-  loadBelongsToRelation,
-  loadBelongsToManyRelation
-} from './lazy-batch.js';
-import { payloadResultSets } from '../core/execution/db-executor.js';
+import {
+  loadHasManyRelation,
+  loadHasOneRelation,
+  loadBelongsToRelation,
+  loadBelongsToManyRelation
+} from './lazy-batch.js';
+import { payloadResultSets } from '../core/execution/db-executor.js';
 
 type Row = Record<string, unknown>;
 
@@ -46,9 +46,9 @@ const executeWithContexts = async <TTable extends TableDef>(
   qb: SelectQueryBuilder<unknown, TTable>
 ): Promise<EntityInstance<TTable>[]> => {
   const ast = qb.getAST();
-  const compiled = execCtx.dialect.compileSelect(ast);
-  const executed = await execCtx.interceptors.run({ sql: compiled.sql, params: compiled.params }, execCtx.executor);
-  const rows = flattenResults(payloadResultSets(executed));
+  const compiled = execCtx.dialect.compileSelect(ast);
+  const executed = await execCtx.interceptors.run({ sql: compiled.sql, params: compiled.params }, execCtx.executor);
+  const rows = flattenResults(payloadResultSets(executed));
   const lazyRelations = qb.getLazyRelations() as RelationKey<TTable>[];
   const lazyRelationOptions = qb.getLazyRelationOptions();
   const includeTree = qb.getIncludeTree();
@@ -72,9 +72,9 @@ const executePlainWithContexts = async <TTable extends TableDef>(
   qb: SelectQueryBuilder<unknown, TTable>
 ): Promise<Record<string, unknown>[]> => {
   const ast = qb.getAST();
-  const compiled = execCtx.dialect.compileSelect(ast);
-  const executed = await execCtx.interceptors.run({ sql: compiled.sql, params: compiled.params }, execCtx.executor);
-  const rows = flattenResults(payloadResultSets(executed));
+  const compiled = execCtx.dialect.compileSelect(ast);
+  const executed = await execCtx.interceptors.run({ sql: compiled.sql, params: compiled.params }, execCtx.executor);
+  const rows = flattenResults(payloadResultSets(executed));
 
   if (ast.setOps && ast.setOps.length > 0) {
     return rows;

package/src/orm/lazy-batch/morph-many.ts

@@ -0,0 +1,70 @@
+import { TableDef } from '../../schema/table.js';
+import { MorphManyRelation } from '../../schema/relation.js';
+import { findPrimaryKey } from '../../query-builder/hydration-planner.js';
+import { RelationIncludeOptions } from '../../query-builder/relation-types.js';
+import { EntityContext } from '../entity-context.js';
+import { eq, and, ExpressionNode } from '../../core/ast/expression.js';
+import {
+  buildColumnSelection,
+  collectKeysFromRoots,
+  fetchRowsForKeys,
+  filterRows,
+  groupRowsByMany,
+  hasColumns,
+  Rows
+} from './shared.js';
+
+export const loadMorphManyRelation = async (
+  ctx: EntityContext,
+  rootTable: TableDef,
+  relationName: string,
+  relation: MorphManyRelation,
+  options?: RelationIncludeOptions
+): Promise<Map<string, Rows>> => {
+  const localKey = relation.localKey || findPrimaryKey(rootTable);
+  const roots = ctx.getEntitiesForTable(rootTable);
+  const keys = collectKeysFromRoots(roots, localKey);
+
+  if (!keys.size) {
+    return new Map();
+  }
+
+  const fkColumn = relation.target.columns[relation.idField];
+  if (!fkColumn) return new Map();
+
+  const requestedColumns = hasColumns(options?.columns) ? [...options!.columns] : undefined;
+  const targetPrimaryKey = findPrimaryKey(relation.target);
+  const selectedColumns = requestedColumns ? [...requestedColumns] : Object.keys(relation.target.columns);
+  if (!selectedColumns.includes(targetPrimaryKey)) {
+    selectedColumns.push(targetPrimaryKey);
+  }
+
+  const queryColumns = new Set(selectedColumns);
+  queryColumns.add(relation.idField);
+
+  const selection = buildColumnSelection(
+    relation.target,
+    Array.from(queryColumns),
+    column => `Column '${column}' not found on relation '${relationName}'`
+  );
+
+  // Add discriminator filter
+  const typeColumn = relation.target.columns[relation.typeField];
+  const discriminatorFilter: ExpressionNode = eq(
+    typeColumn ?? { type: 'Column', table: relation.target.name, name: relation.typeField },
+    { type: 'Literal', value: relation.typeValue }
+  );
+  const combinedFilter = options?.filter ? and(options.filter, discriminatorFilter) : discriminatorFilter;
+
+  const rows = await fetchRowsForKeys(ctx, relation.target, fkColumn, keys, selection, combinedFilter);
+  const grouped = groupRowsByMany(rows, relation.idField);
+
+  if (!requestedColumns) return grouped;
+
+  const visibleColumns = new Set(selectedColumns);
+  const filtered = new Map<string, Rows>();
+  for (const [key, bucket] of grouped.entries()) {
+    filtered.set(key, filterRows(bucket, visibleColumns));
+  }
+  return filtered;
+};

package/src/orm/lazy-batch/morph-one.ts

@@ -0,0 +1,69 @@
+import { TableDef } from '../../schema/table.js';
+import { MorphOneRelation } from '../../schema/relation.js';
+import { findPrimaryKey } from '../../query-builder/hydration-planner.js';
+import { RelationIncludeOptions } from '../../query-builder/relation-types.js';
+import { EntityContext } from '../entity-context.js';
+import { eq, and, ExpressionNode } from '../../core/ast/expression.js';
+import {
+  buildColumnSelection,
+  collectKeysFromRoots,
+  fetchRowsForKeys,
+  filterRow,
+  groupRowsByUnique,
+  hasColumns
+} from './shared.js';
+
+export const loadMorphOneRelation = async (
+  ctx: EntityContext,
+  rootTable: TableDef,
+  relationName: string,
+  relation: MorphOneRelation,
+  options?: RelationIncludeOptions
+): Promise<Map<string, Record<string, unknown>>> => {
+  const localKey = relation.localKey || findPrimaryKey(rootTable);
+  const roots = ctx.getEntitiesForTable(rootTable);
+  const keys = collectKeysFromRoots(roots, localKey);
+
+  if (!keys.size) {
+    return new Map();
+  }
+
+  const fkColumn = relation.target.columns[relation.idField];
+  if (!fkColumn) return new Map();
+
+  const requestedColumns = hasColumns(options?.columns) ? [...options!.columns] : undefined;
+  const targetPrimaryKey = findPrimaryKey(relation.target);
+  const selectedColumns = requestedColumns ? [...requestedColumns] : Object.keys(relation.target.columns);
+  if (!selectedColumns.includes(targetPrimaryKey)) {
+    selectedColumns.push(targetPrimaryKey);
+  }
+
+  const queryColumns = new Set(selectedColumns);
+  queryColumns.add(relation.idField);
+
+  const selection = buildColumnSelection(
+    relation.target,
+    Array.from(queryColumns),
+    column => `Column '${column}' not found on relation '${relationName}'`
+  );
+
+  // Add discriminator filter
+  const typeColumn = relation.target.columns[relation.typeField];
+  const discriminatorFilter: ExpressionNode = eq(
+    typeColumn ?? { type: 'Column', table: relation.target.name, name: relation.typeField },
+    { type: 'Literal', value: relation.typeValue }
+  );
+  const combinedFilter = options?.filter ? and(options.filter, discriminatorFilter) : discriminatorFilter;
+
+  const rows = await fetchRowsForKeys(ctx, relation.target, fkColumn, keys, selection, combinedFilter);
+  const grouped = groupRowsByUnique(rows, relation.idField);
+
+  if (!requestedColumns) return grouped;
+
+  const visibleColumns = new Set(selectedColumns);
+  const filtered = new Map<string, Record<string, unknown>>();
+  for (const [key, row] of grouped.entries()) {
+    filtered.set(key, filterRow(row, visibleColumns));
+  }
+  return filtered;
+};

package/src/orm/lazy-batch/morph-to.ts

@@ -0,0 +1,59 @@
+import { TableDef } from '../../schema/table.js';
+import { MorphToRelation } from '../../schema/relation.js';
+import { findPrimaryKey } from '../../query-builder/hydration-planner.js';
+import { EntityContext } from '../entity-context.js';
+import {
+  buildColumnSelection,
+  fetchRowsForKeys,
+  toKey
+} from './shared.js';
+
+export const loadMorphToRelation = async (
+  ctx: EntityContext,
+  rootTable: TableDef,
+  _relationName: string,
+  relation: MorphToRelation
+): Promise<Map<string, Record<string, unknown>>> => {
+  const roots = ctx.getEntitiesForTable(rootTable);
+  const result = new Map<string, Record<string, unknown>>();
+
+  // Group root entities by type value
+  const grouped = new Map<string, Set<unknown>>();
+  for (const tracked of roots) {
+    const entity = tracked.entity as Record<string, unknown>;
+    const typeValue = entity[relation.typeField];
+    const idValue = entity[relation.idField];
+    if (!typeValue || idValue === undefined || idValue === null) continue;
+    const typeKey = toKey(typeValue);
+    const ids = grouped.get(typeKey) ?? new Set();
+    ids.add(idValue);
+    grouped.set(typeKey, ids);
+  }
+
+  // For each type, load from the corresponding target table
+  for (const [typeKey, ids] of grouped.entries()) {
+    const targetTable = relation.targets[typeKey];
+    if (!targetTable) continue;
+
+    const targetPk = relation.targetKey || findPrimaryKey(targetTable);
+    const pkColumn = targetTable.columns[targetPk];
+    if (!pkColumn) continue;
+
+    const selection = buildColumnSelection(
+      targetTable,
+      Object.keys(targetTable.columns),
+      column => `Column '${column}' not found on target '${targetTable.name}'`
+    );
+
+    const rows = await fetchRowsForKeys(ctx, targetTable, pkColumn, ids, selection);
+
+    for (const row of rows) {
+      const pkValue = row[targetPk];
+      if (pkValue === undefined || pkValue === null) continue;
+      const compositeKey = `${typeKey}:${toKey(pkValue)}`;
+      result.set(compositeKey, row);
+    }
+  }
+
+  return result;
+};

package/src/orm/lazy-batch.ts

@@ -2,4 +2,7 @@ export { loadHasManyRelation } from './lazy-batch/has-many.js';
 export { loadHasOneRelation } from './lazy-batch/has-one.js';
 export { loadBelongsToRelation } from './lazy-batch/belongs-to.js';
 export { loadBelongsToManyRelation } from './lazy-batch/belongs-to-many.js';
-
+export { loadMorphOneRelation } from './lazy-batch/morph-one.js';
+export { loadMorphManyRelation } from './lazy-batch/morph-many.js';
+export { loadMorphToRelation } from './lazy-batch/morph-to.js';
+