metal-orm 1.0.97 → 1.0.99

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "metal-orm",
-  "version": "1.0.97",
+  "version": "1.0.99",
   "type": "module",
   "types": "./dist/index.d.ts",
   "engines": {

package/src/core/hydration/types.ts

@@ -1,57 +1,57 @@
-import { RelationType } from '../../schema/relation.js';
-
-/**
- * Plan describing pivot columns needed for hydration
- */
-export interface HydrationPivotPlan {
-  table: string;
-  primaryKey: string;
-  aliasPrefix: string;
-  columns: string[];
-}
-
-/**
- * Plan for hydrating relationship data
- */
-export interface HydrationRelationPlan {
-  /** Name of the relationship */
-  name: string;
-  /** Alias prefix for the relationship */
-  aliasPrefix: string;
-  /** Type of relationship */
-  type: RelationType;
-  /** Target table name */
-  targetTable: string;
-  /** Target table primary key */
-  targetPrimaryKey: string;
-  /** Foreign key column */
-  foreignKey: string;
-  /** Local key column */
-  localKey: string;
-  /** Columns to include */
-  columns: string[];
-  /** Optional pivot plan for many-to-many relationships */
-  pivot?: HydrationPivotPlan;
-}
-
-/**
- * Complete hydration plan for a query
- */
-export interface HydrationPlan {
-  /** Root table name */
-  rootTable: string;
-  /** Root table primary key */
-  rootPrimaryKey: string;
-  /** Root table columns */
-  rootColumns: string[];
-  /** Relationship hydration plans */
-  relations: HydrationRelationPlan[];
-}
-
-/**
- * Metadata bag for attaching hydration to query ASTs without coupling AST types.
- */
-export interface HydrationMetadata {
-  hydration?: HydrationPlan;
-  [key: string]: unknown;
-}
+import { RelationType } from '../../schema/relation.js';
+
+/**
+ * Plan describing pivot columns needed for hydration
+ */
+export interface HydrationPivotPlan {
+  table: string;
+  primaryKey: string;
+  aliasPrefix: string;
+  columns: string[];
+}
+
+/**
+ * Plan for hydrating relationship data
+ */
+export interface HydrationRelationPlan {
+  /** Name of the relationship */
+  name: string;
+  /** Alias prefix for the relationship */
+  aliasPrefix: string;
+  /** Type of relationship */
+  type: RelationType;
+  /** Target table name */
+  targetTable: string;
+  /** Target table primary key */
+  targetPrimaryKey: string;
+  /** Foreign key column */
+  foreignKey: string;
+  /** Local key column */
+  localKey: string;
+  /** Columns to include */
+  columns: string[];
+  /** Optional pivot plan for many-to-many relationships */
+  pivot?: HydrationPivotPlan;
+}
+
+/**
+ * Complete hydration plan for a query
+ */
+export interface HydrationPlan {
+  /** Root table name */
+  rootTable: string;
+  /** Root table primary key */
+  rootPrimaryKey: string;
+  /** Root table columns */
+  rootColumns: string[];
+  /** Relationship hydration plans */
+  relations: HydrationRelationPlan[];
+}
+
+/**
+ * Metadata bag for attaching hydration to query ASTs without coupling AST types.
+ */
+export interface HydrationMetadata {
+  hydration?: HydrationPlan;
+  [key: string]: unknown;
+}

package/src/orm/entity-relations.ts

@@ -125,16 +125,16 @@ const instantiateWrapper = <TTable extends TableDef>(
   createEntity: RelationEntityFactory
 ): HasManyCollection<unknown> | HasOneReference<object> | BelongsToReference<object> | ManyToManyCollection<unknown> | undefined => {
   const metaBase = meta as unknown as EntityMeta<TableDef>;
-  const loadCached = <T extends Map<string, unknown>>(factory: () => Promise<T>) =>
-    relationLoaderCache(metaBase, relationName, factory);
-  const resolveOptions = () => meta.lazyRelationOptions.get(relationName);
+  const loadCached = <T extends Map<string, unknown>>(factory: () => Promise<T>) =>
+    relationLoaderCache(metaBase, relationName, factory);
+  const resolveOptions = () => meta.lazyRelationOptions.get(relationName);
   switch (relation.type) {
     case RelationKinds.HasOne: {
       const hasOne = relation as HasOneRelation;
-      const localKey = hasOne.localKey || findPrimaryKey(meta.table);
-      const loader = () => loadCached(() =>
-        loadHasOneRelation(meta.ctx, meta.table, relationName, hasOne, resolveOptions())
-      );
+      const localKey = hasOne.localKey || findPrimaryKey(meta.table);
+      const loader = () => loadCached(() =>
+        loadHasOneRelation(meta.ctx, meta.table, relationName, hasOne, resolveOptions())
+      );
       return new DefaultHasOneReference(
         meta.ctx,
         metaBase,
@@ -149,10 +149,10 @@ const instantiateWrapper = <TTable extends TableDef>(
     }
     case RelationKinds.HasMany: {
       const hasMany = relation as HasManyRelation;
-      const localKey = hasMany.localKey || findPrimaryKey(meta.table);
-      const loader = () => loadCached(() =>
-        loadHasManyRelation(meta.ctx, meta.table, relationName, hasMany, resolveOptions())
-      );
+      const localKey = hasMany.localKey || findPrimaryKey(meta.table);
+      const loader = () => loadCached(() =>
+        loadHasManyRelation(meta.ctx, meta.table, relationName, hasMany, resolveOptions())
+      );
       return new DefaultHasManyCollection(
         meta.ctx,
         metaBase,
@@ -167,10 +167,10 @@ const instantiateWrapper = <TTable extends TableDef>(
     }
     case RelationKinds.BelongsTo: {
       const belongsTo = relation as BelongsToRelation;
-      const targetKey = belongsTo.localKey || findPrimaryKey(belongsTo.target);
-      const loader = () => loadCached(() =>
-        loadBelongsToRelation(meta.ctx, meta.table, relationName, belongsTo, resolveOptions())
-      );
+      const targetKey = belongsTo.localKey || findPrimaryKey(belongsTo.target);
+      const loader = () => loadCached(() =>
+        loadBelongsToRelation(meta.ctx, meta.table, relationName, belongsTo, resolveOptions())
+      );
       return new DefaultBelongsToReference(
         meta.ctx,
         metaBase,
@@ -185,10 +185,10 @@ const instantiateWrapper = <TTable extends TableDef>(
     }
     case RelationKinds.BelongsToMany: {
       const many = relation as BelongsToManyRelation;
-      const localKey = many.localKey || findPrimaryKey(meta.table);
-      const loader = () => loadCached(() =>
-        loadBelongsToManyRelation(meta.ctx, meta.table, relationName, many, resolveOptions())
-      );
+      const localKey = many.localKey || findPrimaryKey(meta.table);
+      const loader = () => loadCached(() =>
+        loadBelongsToManyRelation(meta.ctx, meta.table, relationName, many, resolveOptions())
+      );
       return new DefaultManyToManyCollection(
         meta.ctx,
         metaBase,

package/src/orm/lazy-batch/belongs-to-many.ts

@@ -1,134 +1,134 @@
-import { TableDef } from '../../schema/table.js';
-import { BelongsToManyRelation } from '../../schema/relation.js';
-import { findPrimaryKey } from '../../query-builder/hydration-planner.js';
-import { RelationIncludeOptions } from '../../query-builder/relation-types.js';
-import { buildDefaultPivotColumns } from '../../query-builder/relation-utils.js';
-import { EntityContext } from '../entity-context.js';
-import {
-  buildColumnSelection,
-  collectKeysFromRoots,
-  fetchRowsForKeys,
-  filterRow,
-  groupRowsByUnique,
-  hasColumns,
-  toKey,
-  Rows
-} from './shared.js';
-
-/**
- * Loads related entities for a belongs-to-many relation in batch, including pivot data.
- * @param ctx - The entity context.
- * @param rootTable - The root table of the relation.
- * @param _relationName - The name of the relation (unused).
- * @param relation - The belongs-to-many relation definition.
- * @returns A promise resolving to a map of root keys to arrays of related rows with pivot data.
- */
-export const loadBelongsToManyRelation = async (
-  ctx: EntityContext,
-  rootTable: TableDef,
-  relationName: string,
-  relation: BelongsToManyRelation,
-  options?: RelationIncludeOptions
-): Promise<Map<string, Rows>> => {
-  const rootKey = relation.localKey || findPrimaryKey(rootTable);
-  const roots = ctx.getEntitiesForTable(rootTable);
-  const rootIds = collectKeysFromRoots(roots, rootKey);
-
-  if (!rootIds.size) {
-    return new Map();
-  }
-
-  const pivotColumn = relation.pivotTable.columns[relation.pivotForeignKeyToRoot];
-  if (!pivotColumn) return new Map();
-
-  const pivotColumnsRequested = hasColumns(options?.pivot?.columns) ? [...options!.pivot!.columns] : undefined;
-  const useIncludeDefaults = options !== undefined;
-  let pivotSelectedColumns: string[];
-  if (pivotColumnsRequested) {
-    pivotSelectedColumns = [...pivotColumnsRequested];
-  } else if (useIncludeDefaults) {
-    const pivotPk = relation.pivotPrimaryKey || findPrimaryKey(relation.pivotTable);
-    pivotSelectedColumns = relation.defaultPivotColumns ?? buildDefaultPivotColumns(relation, pivotPk);
-  } else {
-    pivotSelectedColumns = Object.keys(relation.pivotTable.columns);
-  }
-
-  const pivotQueryColumns = new Set(pivotSelectedColumns);
-  pivotQueryColumns.add(relation.pivotForeignKeyToRoot);
-  pivotQueryColumns.add(relation.pivotForeignKeyToTarget);
-
-  const pivotSelection = buildColumnSelection(
-    relation.pivotTable,
-    Array.from(pivotQueryColumns),
-    column => `Column '${column}' not found on pivot table '${relation.pivotTable.name}'`
-  );
-
-  const pivotRows = await fetchRowsForKeys(ctx, relation.pivotTable, pivotColumn, rootIds, pivotSelection);
-  const rootLookup = new Map<string, { targetId: unknown; pivot: Record<string, unknown> }[]>();
-  const targetIds = new Set<unknown>();
-  const pivotVisibleColumns = new Set(pivotSelectedColumns);
-
-  for (const pivot of pivotRows) {
-    const rootValue = pivot[relation.pivotForeignKeyToRoot];
-    const targetValue = pivot[relation.pivotForeignKeyToTarget];
-    if (rootValue === null || rootValue === undefined || targetValue === null || targetValue === undefined) {
-      continue;
-    }
-    const bucket = rootLookup.get(toKey(rootValue)) ?? [];
-    bucket.push({
-      targetId: targetValue,
-      pivot: pivotVisibleColumns.size ? filterRow(pivot, pivotVisibleColumns) : {}
-    });
-    rootLookup.set(toKey(rootValue), bucket);
-    targetIds.add(targetValue);
-  }
-
-  if (!targetIds.size) {
-    return new Map();
-  }
-
-  const targetKey = relation.targetKey || findPrimaryKey(relation.target);
-  const targetPkColumn = relation.target.columns[targetKey];
-  if (!targetPkColumn) return new Map();
-
-  const targetRequestedColumns = hasColumns(options?.columns) ? [...options!.columns] : undefined;
-  const targetSelectedColumns = targetRequestedColumns
-    ? [...targetRequestedColumns]
-    : Object.keys(relation.target.columns);
-  if (!targetSelectedColumns.includes(targetKey)) {
-    targetSelectedColumns.push(targetKey);
-  }
-
-  const targetSelection = buildColumnSelection(
-    relation.target,
-    targetSelectedColumns,
-    column => `Column '${column}' not found on relation '${relationName}'`
-  );
-
-  const targetRows = await fetchRowsForKeys(
-    ctx,
-    relation.target,
-    targetPkColumn,
-    targetIds,
-    targetSelection,
-    options?.filter
-  );
-  const targetMap = groupRowsByUnique(targetRows, targetKey);
-  const targetVisibleColumns = new Set(targetSelectedColumns);
-  const result = new Map<string, Rows>();
-
-  for (const [rootId, entries] of rootLookup.entries()) {
-    const bucket: Rows = [];
-    for (const entry of entries) {
-      const targetRow = targetMap.get(toKey(entry.targetId));
-      if (!targetRow) continue;
-      bucket.push({
-        ...(targetRequestedColumns ? filterRow(targetRow, targetVisibleColumns) : targetRow),
-        _pivot: entry.pivot
-      });
-    }
-    result.set(rootId, bucket);
-  }
-
-  return result;
-};
+import { TableDef } from '../../schema/table.js';
+import { BelongsToManyRelation } from '../../schema/relation.js';
+import { findPrimaryKey } from '../../query-builder/hydration-planner.js';
+import { RelationIncludeOptions } from '../../query-builder/relation-types.js';
+import { buildDefaultPivotColumns } from '../../query-builder/relation-utils.js';
+import { EntityContext } from '../entity-context.js';
+import {
+  buildColumnSelection,
+  collectKeysFromRoots,
+  fetchRowsForKeys,
+  filterRow,
+  groupRowsByUnique,
+  hasColumns,
+  toKey,
+  Rows
+} from './shared.js';
+
+/**
+ * Loads related entities for a belongs-to-many relation in batch, including pivot data.
+ * @param ctx - The entity context.
+ * @param rootTable - The root table of the relation.
+ * @param _relationName - The name of the relation (unused).
+ * @param relation - The belongs-to-many relation definition.
+ * @returns A promise resolving to a map of root keys to arrays of related rows with pivot data.
+ */
+export const loadBelongsToManyRelation = async (
+  ctx: EntityContext,
+  rootTable: TableDef,
+  relationName: string,
+  relation: BelongsToManyRelation,
+  options?: RelationIncludeOptions
+): Promise<Map<string, Rows>> => {
+  const rootKey = relation.localKey || findPrimaryKey(rootTable);
+  const roots = ctx.getEntitiesForTable(rootTable);
+  const rootIds = collectKeysFromRoots(roots, rootKey);
+
+  if (!rootIds.size) {
+    return new Map();
+  }
+
+  const pivotColumn = relation.pivotTable.columns[relation.pivotForeignKeyToRoot];
+  if (!pivotColumn) return new Map();
+
+  const pivotColumnsRequested = hasColumns(options?.pivot?.columns) ? [...options!.pivot!.columns] : undefined;
+  const useIncludeDefaults = options !== undefined;
+  let pivotSelectedColumns: string[];
+  if (pivotColumnsRequested) {
+    pivotSelectedColumns = [...pivotColumnsRequested];
+  } else if (useIncludeDefaults) {
+    const pivotPk = relation.pivotPrimaryKey || findPrimaryKey(relation.pivotTable);
+    pivotSelectedColumns = relation.defaultPivotColumns ?? buildDefaultPivotColumns(relation, pivotPk);
+  } else {
+    pivotSelectedColumns = Object.keys(relation.pivotTable.columns);
+  }
+
+  const pivotQueryColumns = new Set(pivotSelectedColumns);
+  pivotQueryColumns.add(relation.pivotForeignKeyToRoot);
+  pivotQueryColumns.add(relation.pivotForeignKeyToTarget);
+
+  const pivotSelection = buildColumnSelection(
+    relation.pivotTable,
+    Array.from(pivotQueryColumns),
+    column => `Column '${column}' not found on pivot table '${relation.pivotTable.name}'`
+  );
+
+  const pivotRows = await fetchRowsForKeys(ctx, relation.pivotTable, pivotColumn, rootIds, pivotSelection);
+  const rootLookup = new Map<string, { targetId: unknown; pivot: Record<string, unknown> }[]>();
+  const targetIds = new Set<unknown>();
+  const pivotVisibleColumns = new Set(pivotSelectedColumns);
+
+  for (const pivot of pivotRows) {
+    const rootValue = pivot[relation.pivotForeignKeyToRoot];
+    const targetValue = pivot[relation.pivotForeignKeyToTarget];
+    if (rootValue === null || rootValue === undefined || targetValue === null || targetValue === undefined) {
+      continue;
+    }
+    const bucket = rootLookup.get(toKey(rootValue)) ?? [];
+    bucket.push({
+      targetId: targetValue,
+      pivot: pivotVisibleColumns.size ? filterRow(pivot, pivotVisibleColumns) : {}
+    });
+    rootLookup.set(toKey(rootValue), bucket);
+    targetIds.add(targetValue);
+  }
+
+  if (!targetIds.size) {
+    return new Map();
+  }
+
+  const targetKey = relation.targetKey || findPrimaryKey(relation.target);
+  const targetPkColumn = relation.target.columns[targetKey];
+  if (!targetPkColumn) return new Map();
+
+  const targetRequestedColumns = hasColumns(options?.columns) ? [...options!.columns] : undefined;
+  const targetSelectedColumns = targetRequestedColumns
+    ? [...targetRequestedColumns]
+    : Object.keys(relation.target.columns);
+  if (!targetSelectedColumns.includes(targetKey)) {
+    targetSelectedColumns.push(targetKey);
+  }
+
+  const targetSelection = buildColumnSelection(
+    relation.target,
+    targetSelectedColumns,
+    column => `Column '${column}' not found on relation '${relationName}'`
+  );
+
+  const targetRows = await fetchRowsForKeys(
+    ctx,
+    relation.target,
+    targetPkColumn,
+    targetIds,
+    targetSelection,
+    options?.filter
+  );
+  const targetMap = groupRowsByUnique(targetRows, targetKey);
+  const targetVisibleColumns = new Set(targetSelectedColumns);
+  const result = new Map<string, Rows>();
+
+  for (const [rootId, entries] of rootLookup.entries()) {
+    const bucket: Rows = [];
+    for (const entry of entries) {
+      const targetRow = targetMap.get(toKey(entry.targetId));
+      if (!targetRow) continue;
+      bucket.push({
+        ...(targetRequestedColumns ? filterRow(targetRow, targetVisibleColumns) : targetRow),
+        _pivot: entry.pivot
+      });
+    }
+    result.set(rootId, bucket);
+  }
+
+  return result;
+};