metal-orm 1.0.7 → 1.0.9

package/src/{runtime → orm}/hydration.ts

@@ -1,5 +1,5 @@
-import { HydrationPlan, HydrationRelationPlan } from '../ast/query';
-import { isRelationAlias, makeRelationAlias } from '../utils/relation-alias';
+import { HydrationPlan, HydrationRelationPlan } from '../core/ast/query.js';
+import { isRelationAlias, makeRelationAlias } from '../query-builder/relation-alias.js';
 
 /**
  * Hydrates query results according to a hydration plan
@@ -7,104 +7,104 @@ import { isRelationAlias, makeRelationAlias } from '../utils/relation-alias';
  * @param plan - Hydration plan
  * @returns Hydrated result objects with nested relations
  */
-export const hydrateRows = (rows: Record<string, any>[], plan?: HydrationPlan): Record<string, any>[] => {
-  if (!plan || !rows.length) return rows;
-
-  const rootMap = new Map<any, Record<string, any>>();
-  const relationIndex = new Map<any, Record<string, Set<any>>>();
-
-  const getOrCreateParent = (row: Record<string, any>) => {
-    const rootId = row[plan.rootPrimaryKey];
-    if (rootId === undefined) return undefined;
-
-    if (!rootMap.has(rootId)) {
-      rootMap.set(rootId, createBaseRow(row, plan));
-    }
-
-    return rootMap.get(rootId);
-  };
-
-  const getRelationSeenSet = (rootId: any, relationName: string): Set<any> => {
-    let byRelation = relationIndex.get(rootId);
-    if (!byRelation) {
-      byRelation = {};
-      relationIndex.set(rootId, byRelation);
-    }
-
-    let seen = byRelation[relationName];
-    if (!seen) {
-      seen = new Set<any>();
-      byRelation[relationName] = seen;
-    }
-
-    return seen;
-  };
-
-  for (const row of rows) {
-    const rootId = row[plan.rootPrimaryKey];
-    if (rootId === undefined) continue;
-
-    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);
-
-      const bucket = parent[rel.name] as any[];
-      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 baseKeys = plan.rootColumns.length
-    ? plan.rootColumns
-    : Object.keys(row).filter(k => !isRelationAlias(k));
-
-  for (const key of baseKeys) {
-    base[key] = row[key];
-  }
-
-  for (const rel of plan.relations) {
-    base[rel.name] = [];
-  }
-
-  return base;
-};
-
-const buildChild = (row: Record<string, any>, rel: HydrationRelationPlan): Record<string, any> => {
-  const child: Record<string, any> = {};
-  for (const col of rel.columns) {
-    const key = makeRelationAlias(rel.aliasPrefix, col);
-    child[col] = row[key];
-  }
-
-  const pivot = buildPivot(row, rel);
-  if (pivot) {
-    (child as any)._pivot = pivot;
-  }
-
-  return child;
-};
-
-const buildPivot = (row: Record<string, any>, rel: HydrationRelationPlan): Record<string, any> | undefined => {
-  if (!rel.pivot) return undefined;
-
-  const pivot: Record<string, any> = {};
-  for (const col of rel.pivot.columns) {
-    const key = makeRelationAlias(rel.pivot.aliasPrefix, col);
-    pivot[col] = row[key];
-  }
-
-  const hasValue = Object.values(pivot).some(v => v !== null && v !== undefined);
-  return hasValue ? pivot : undefined;
-};
+export const hydrateRows = (rows: Record<string, any>[], plan?: HydrationPlan): Record<string, any>[] => {
+  if (!plan || !rows.length) return rows;
+
+  const rootMap = new Map<any, Record<string, any>>();
+  const relationIndex = new Map<any, Record<string, Set<any>>>();
+
+  const getOrCreateParent = (row: Record<string, any>) => {
+    const rootId = row[plan.rootPrimaryKey];
+    if (rootId === undefined) return undefined;
+
+    if (!rootMap.has(rootId)) {
+      rootMap.set(rootId, createBaseRow(row, plan));
+    }
+
+    return rootMap.get(rootId);
+  };
+
+  const getRelationSeenSet = (rootId: any, relationName: string): Set<any> => {
+    let byRelation = relationIndex.get(rootId);
+    if (!byRelation) {
+      byRelation = {};
+      relationIndex.set(rootId, byRelation);
+    }
+
+    let seen = byRelation[relationName];
+    if (!seen) {
+      seen = new Set<any>();
+      byRelation[relationName] = seen;
+    }
+
+    return seen;
+  };
+
+  for (const row of rows) {
+    const rootId = row[plan.rootPrimaryKey];
+    if (rootId === undefined) continue;
+
+    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);
+
+      const bucket = parent[rel.name] as any[];
+      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 baseKeys = plan.rootColumns.length
+    ? plan.rootColumns
+    : Object.keys(row).filter(k => !isRelationAlias(k));
+
+  for (const key of baseKeys) {
+    base[key] = row[key];
+  }
+
+  for (const rel of plan.relations) {
+    base[rel.name] = [];
+  }
+
+  return base;
+};
+
+const buildChild = (row: Record<string, any>, rel: HydrationRelationPlan): Record<string, any> => {
+  const child: Record<string, any> = {};
+  for (const col of rel.columns) {
+    const key = makeRelationAlias(rel.aliasPrefix, col);
+    child[col] = row[key];
+  }
+
+  const pivot = buildPivot(row, rel);
+  if (pivot) {
+    (child as any)._pivot = pivot;
+  }
+
+  return child;
+};
+
+const buildPivot = (row: Record<string, any>, rel: HydrationRelationPlan): Record<string, any> | undefined => {
+  if (!rel.pivot) return undefined;
+
+  const pivot: Record<string, any> = {};
+  for (const col of rel.pivot.columns) {
+    const key = makeRelationAlias(rel.pivot.aliasPrefix, col);
+    pivot[col] = row[key];
+  }
+
+  const hasValue = Object.values(pivot).some(v => v !== null && v !== undefined);
+  return hasValue ? pivot : undefined;
+};

package/src/orm/identity-map.ts

@@ -0,0 +1,37 @@
+import type { TableDef } from '../schema/table.js';
+import type { TrackedEntity } from './runtime-types.js';
+
+export class IdentityMap {
+  private readonly buckets = new Map<string, Map<string, TrackedEntity>>();
+
+  get bucketsMap(): Map<string, Map<string, TrackedEntity>> {
+    return this.buckets;
+  }
+
+  getEntity(table: TableDef, pk: string | number): any | undefined {
+    const bucket = this.buckets.get(table.name);
+    return bucket?.get(this.toIdentityKey(pk))?.entity;
+  }
+
+  register(tracked: TrackedEntity): void {
+    if (tracked.pk == null) return;
+    const bucket = this.buckets.get(tracked.table.name) ?? new Map<string, TrackedEntity>();
+    bucket.set(this.toIdentityKey(tracked.pk), tracked);
+    this.buckets.set(tracked.table.name, bucket);
+  }
+
+  remove(tracked: TrackedEntity): void {
+    if (tracked.pk == null) return;
+    const bucket = this.buckets.get(tracked.table.name);
+    bucket?.delete(this.toIdentityKey(tracked.pk));
+  }
+
+  getEntitiesForTable(table: TableDef): TrackedEntity[] {
+    const bucket = this.buckets.get(table.name);
+    return bucket ? Array.from(bucket.values()) : [];
+  }
+
+  private toIdentityKey(pk: string | number): string {
+    return String(pk);
+  }
+}

package/src/{runtime → orm}/lazy-batch.ts

@@ -1,205 +1,205 @@
-import { TableDef } from '../schema/table';
-import { BelongsToManyRelation, HasManyRelation, BelongsToRelation } from '../schema/relation';
-import { SelectQueryBuilder } from '../builder/select';
-import { inList, LiteralNode } from '../ast/expression';
-import { OrmContext, QueryResult } from './orm-context';
-import { ColumnDef } from '../schema/column';
-import { findPrimaryKey } from '../builder/hydration-planner';
-
-type Rows = Record<string, any>[];
-
-const selectAllColumns = (table: TableDef): Record<string, ColumnDef> =>
-  Object.entries(table.columns).reduce((acc, [name, def]) => {
-    acc[name] = def;
-    return acc;
-  }, {} as Record<string, ColumnDef>);
-
-const rowsFromResults = (results: QueryResult[]): Rows => {
-  const rows: Rows = [];
-  for (const result of results) {
-    const { columns, values } = result;
-    for (const valueRow of values) {
-      const row: Record<string, any> = {};
-      columns.forEach((column, idx) => {
-        row[column] = valueRow[idx];
-      });
-      rows.push(row);
-    }
-  }
-  return rows;
-};
-
-const executeQuery = async (ctx: OrmContext, qb: SelectQueryBuilder<any, TableDef<any>>): Promise<Rows> => {
-  const compiled = ctx.dialect.compileSelect(qb.getAST());
-  const results = await ctx.executor.executeSql(compiled.sql, compiled.params);
-  return rowsFromResults(results);
-};
-
-const toKey = (value: unknown): string => (value === null || value === undefined ? '' : String(value));
-
-export const loadHasManyRelation = async (
-  ctx: OrmContext,
-  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>();
-
-  for (const tracked of roots) {
-    const value = tracked.entity[localKey];
-    if (value !== null && value !== undefined) {
-      keys.add(value);
-    }
-  }
-
-  if (!keys.size) {
-    return new Map();
-  }
-
-  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 rows = await executeQuery(ctx, fb);
-  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 bucket = grouped.get(key) ?? [];
-    bucket.push(row);
-    grouped.set(key, bucket);
-  }
-
-  return grouped;
-};
-
-export const loadBelongsToRelation = async (
-  ctx: OrmContext,
-  rootTable: TableDef,
-  _relationName: string,
-  relation: BelongsToRelation
-): Promise<Map<string, Record<string, any>>> => {
-  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);
-    }
-  }
-
-  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;
-};
-
-export const loadBelongsToManyRelation = async (
-  ctx: OrmContext,
-  rootTable: TableDef,
-  _relationName: string,
-  relation: BelongsToManyRelation
-): 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);
-    }
-  }
-
-  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();
-
-  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 targetIds = new Set<unknown>();
-
-  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: { ...pivot }
-    });
-    rootLookup.set(toKey(rootValue), bucket);
-    targetIds.add(targetValue);
-  }
-
-  if (!targetIds.size) {
-    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 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({
-        ...targetRow,
-        _pivot: entry.pivot
-      });
-    }
-    result.set(rootId, bucket);
-  }
-
-  return result;
-};
+import { TableDef } from '../schema/table.js';
+import { BelongsToManyRelation, HasManyRelation, BelongsToRelation } from '../schema/relation.js';
+import { SelectQueryBuilder } from '../query-builder/select.js';
+import { inList, LiteralNode } from '../core/ast/expression.js';
+import { OrmContext, QueryResult } from './orm-context.js';
+import { ColumnDef } from '../schema/column.js';
+import { findPrimaryKey } from '../query-builder/hydration-planner.js';
+
+type Rows = Record<string, any>[];
+
+const selectAllColumns = (table: TableDef): Record<string, ColumnDef> =>
+  Object.entries(table.columns).reduce((acc, [name, def]) => {
+    acc[name] = def;
+    return acc;
+  }, {} as Record<string, ColumnDef>);
+
+const rowsFromResults = (results: QueryResult[]): Rows => {
+  const rows: Rows = [];
+  for (const result of results) {
+    const { columns, values } = result;
+    for (const valueRow of values) {
+      const row: Record<string, any> = {};
+      columns.forEach((column, idx) => {
+        row[column] = valueRow[idx];
+      });
+      rows.push(row);
+    }
+  }
+  return rows;
+};
+
+const executeQuery = async (ctx: OrmContext, qb: SelectQueryBuilder<any, TableDef<any>>): Promise<Rows> => {
+  const compiled = ctx.dialect.compileSelect(qb.getAST());
+  const results = await ctx.executor.executeSql(compiled.sql, compiled.params);
+  return rowsFromResults(results);
+};
+
+const toKey = (value: unknown): string => (value === null || value === undefined ? '' : String(value));
+
+export const loadHasManyRelation = async (
+  ctx: OrmContext,
+  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>();
+
+  for (const tracked of roots) {
+    const value = tracked.entity[localKey];
+    if (value !== null && value !== undefined) {
+      keys.add(value);
+    }
+  }
+
+  if (!keys.size) {
+    return new Map();
+  }
+
+  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 rows = await executeQuery(ctx, fb);
+  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 bucket = grouped.get(key) ?? [];
+    bucket.push(row);
+    grouped.set(key, bucket);
+  }
+
+  return grouped;
+};
+
+export const loadBelongsToRelation = async (
+  ctx: OrmContext,
+  rootTable: TableDef,
+  _relationName: string,
+  relation: BelongsToRelation
+): Promise<Map<string, Record<string, any>>> => {
+  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);
+    }
+  }
+
+  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;
+};
+
+export const loadBelongsToManyRelation = async (
+  ctx: OrmContext,
+  rootTable: TableDef,
+  _relationName: string,
+  relation: BelongsToManyRelation
+): 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);
+    }
+  }
+
+  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();
+
+  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 targetIds = new Set<unknown>();
+
+  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: { ...pivot }
+    });
+    rootLookup.set(toKey(rootValue), bucket);
+    targetIds.add(targetValue);
+  }
+
+  if (!targetIds.size) {
+    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 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({
+        ...targetRow,
+        _pivot: entry.pivot
+      });
+    }
+    result.set(rootId, bucket);
+  }
+
+  return result;
+};