metal-orm 1.1.10 → 1.1.16

package/src/orm/hydration.ts

@@ -1,105 +1,105 @@
-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
- * @param rows - Raw database rows
- * @param plan - Hydration plan
- * @returns Hydrated result objects with nested relations
- */
-export const hydrateRows = (rows: Record<string, unknown>[], plan?: HydrationPlan): Record<string, unknown>[] => {
-  if (!plan || !rows.length) return rows;
-
-  const rootMap = new Map<unknown, Record<string, unknown>>();
-  const relationIndex = new Map<unknown, Record<string, Set<unknown>>>();
-
-  const getOrCreateParent = (row: Record<string, unknown>) => {
-    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: unknown, relationName: string): Set<unknown> => {
-    let byRelation = relationIndex.get(rootId);
-    if (!byRelation) {
-      byRelation = {};
-      relationIndex.set(rootId, byRelation);
-    }
-
-    let seen = byRelation[relationName];
-    if (!seen) {
-      seen = new Set<unknown>();
-      byRelation[relationName] = seen;
-    }
-
-    return seen;
-  };
-
-  const hasRelations = plan.relations.length > 0;
-
-  for (const row of rows) {
-    const rootId = row[plan.rootPrimaryKey];
-
-    if (rootId === undefined || rootId === null) {
-      if (!hasRelations) {
-        rootMap.set(Symbol(), createBaseRow(row, plan));
-      }
-      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);
-
-      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, 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));
-
-  for (const key of baseKeys) {
-    base[key] = row[key];
-  }
-
-  for (const rel of plan.relations) {
-    base[rel.name] = rel.type === RelationKinds.HasOne ? null : [];
-  }
-  return base;
-};
-
+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
+ * @param rows - Raw database rows
+ * @param plan - Hydration plan
+ * @returns Hydrated result objects with nested relations
+ */
+export const hydrateRows = (rows: Record<string, unknown>[], plan?: HydrationPlan): Record<string, unknown>[] => {
+  if (!plan || !rows.length) return rows;
+
+  const rootMap = new Map<unknown, Record<string, unknown>>();
+  const relationIndex = new Map<unknown, Record<string, Set<unknown>>>();
+
+  const getOrCreateParent = (row: Record<string, unknown>) => {
+    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: unknown, relationName: string): Set<unknown> => {
+    let byRelation = relationIndex.get(rootId);
+    if (!byRelation) {
+      byRelation = {};
+      relationIndex.set(rootId, byRelation);
+    }
+
+    let seen = byRelation[relationName];
+    if (!seen) {
+      seen = new Set<unknown>();
+      byRelation[relationName] = seen;
+    }
+
+    return seen;
+  };
+
+  const hasRelations = plan.relations.length > 0;
+
+  for (const row of rows) {
+    const rootId = row[plan.rootPrimaryKey];
+
+    if (rootId === undefined || rootId === null) {
+      if (!hasRelations) {
+        rootMap.set(Symbol(), createBaseRow(row, plan));
+      }
+      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);
+
+      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, 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));
+
+  for (const key of baseKeys) {
+    base[key] = row[key];
+  }
+
+  for (const rel of plan.relations) {
+    base[rel.name] = rel.type === RelationKinds.HasOne ? null : [];
+  }
+  return base;
+};
+
 const buildChild = (row: Record<string, unknown>, rel: HydrationRelationPlan): Record<string, unknown> => {
   const child: Record<string, unknown> = {};
   for (const col of rel.columns) {
@@ -127,13 +127,13 @@ const mergePivotIntoChild = (child: Record<string, unknown>, pivot: Record<strin
 
 const buildPivot = (row: Record<string, unknown>, rel: HydrationRelationPlan): Record<string, unknown> | undefined => {
   if (!rel.pivot) return undefined;
-
-  const pivot: Record<string, unknown> = {};
-  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;
-};
+
+  const pivot: Record<string, unknown> = {};
+  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

@@ -1,61 +1,61 @@
-import type { TableDef } from '../schema/table.js';
-import type { TrackedEntity } from './runtime-types.js';
-import type { PrimaryKey } from './entity-context.js';
-
-/**
- * Simple identity map for tracking entities within a session.
- * Ensures that the same database record is represented by a single entity instance.
- */
-export class IdentityMap {
-  private readonly buckets = new Map<string, Map<string, TrackedEntity>>();
-
-  get bucketsMap(): Map<string, Map<string, TrackedEntity>> {
-    return this.buckets;
-  }
-
-  /**
-   * Retrieves an entity from the identity map if it exists.
-   * @param table The table definition of the entity.
-   * @param pk The primary key value.
-   * @returns The entity instance if found, undefined otherwise.
-   */
-  getEntity(table: TableDef, pk: PrimaryKey): object | undefined {
-    const bucket = this.buckets.get(table.name);
-    return bucket?.get(this.toIdentityKey(pk))?.entity;
-  }
-
-  /**
-   * Registers a tracked entity in the identity map.
-   * @param tracked The tracked entity metadata and instance.
-   */
-  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));
-  }
-
-  /**
-   * Returns all tracked entities for a specific table.
-   * @param table The table definition.
-   * @returns Array of tracked entities.
-   */
-  getEntitiesForTable(table: TableDef): TrackedEntity[] {
-    const bucket = this.buckets.get(table.name);
-    return bucket ? Array.from(bucket.values()) : [];
-  }
-
-  clear(): void {
-    this.buckets.clear();
-  }
-
-  private toIdentityKey(pk: PrimaryKey): string {
-    return String(pk);
-  }
-}
+import type { TableDef } from '../schema/table.js';
+import type { TrackedEntity } from './runtime-types.js';
+import type { PrimaryKey } from './entity-context.js';
+
+/**
+ * Simple identity map for tracking entities within a session.
+ * Ensures that the same database record is represented by a single entity instance.
+ */
+export class IdentityMap {
+  private readonly buckets = new Map<string, Map<string, TrackedEntity>>();
+
+  get bucketsMap(): Map<string, Map<string, TrackedEntity>> {
+    return this.buckets;
+  }
+
+  /**
+   * Retrieves an entity from the identity map if it exists.
+   * @param table The table definition of the entity.
+   * @param pk The primary key value.
+   * @returns The entity instance if found, undefined otherwise.
+   */
+  getEntity(table: TableDef, pk: PrimaryKey): object | undefined {
+    const bucket = this.buckets.get(table.name);
+    return bucket?.get(this.toIdentityKey(pk))?.entity;
+  }
+
+  /**
+   * Registers a tracked entity in the identity map.
+   * @param tracked The tracked entity metadata and instance.
+   */
+  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));
+  }
+
+  /**
+   * Returns all tracked entities for a specific table.
+   * @param table The table definition.
+   * @returns Array of tracked entities.
+   */
+  getEntitiesForTable(table: TableDef): TrackedEntity[] {
+    const bucket = this.buckets.get(table.name);
+    return bucket ? Array.from(bucket.values()) : [];
+  }
+
+  clear(): void {
+    this.buckets.clear();
+  }
+
+  private toIdentityKey(pk: PrimaryKey): string {
+    return String(pk);
+  }
+}

package/src/orm/interceptor-pipeline.ts

@@ -1,28 +1,28 @@
 import type { DbExecutor, ExecutionPayload } from '../core/execution/db-executor.js';
 import { toExecutionPayload } from '../core/execution/db-executor.js';
-
+
 export interface QueryContext {
-  sql: string;
-  params: unknown[];
-  // maybe metadata like entity type, operation type, etc.
+  sql: string;
+  params: unknown[];
+  // maybe metadata like entity type, operation type, etc.
 }
 
 export type QueryInterceptor = (
   ctx: QueryContext,
   next: () => Promise<ExecutionPayload>
 ) => Promise<ExecutionPayload>;
-
-/**
- * Pipeline for query interceptors.
- * Interceptors can wrap query execution to add logging, tracing, caching, etc.
- */
-export class InterceptorPipeline {
-  private interceptors: QueryInterceptor[] = [];
-
-  use(interceptor: QueryInterceptor) {
-    this.interceptors.push(interceptor);
-  }
-
+
+/**
+ * Pipeline for query interceptors.
+ * Interceptors can wrap query execution to add logging, tracing, caching, etc.
+ */
+export class InterceptorPipeline {
+  private interceptors: QueryInterceptor[] = [];
+
+  use(interceptor: QueryInterceptor) {
+    this.interceptors.push(interceptor);
+  }
+
   async run(ctx: QueryContext, executor: DbExecutor): Promise<ExecutionPayload> {
     let i = 0;
     const dispatch = async (): Promise<ExecutionPayload> => {

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

@@ -1,122 +1,122 @@
-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>();
-
+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) {