metal-orm 1.0.63 → 1.0.65

package/src/orm/execute.ts

@@ -1,25 +1,25 @@
-import { TableDef } from '../schema/table.js';
-import { EntityInstance } from '../schema/types.js';
-import { RelationKinds } from '../schema/relation.js';
-import { hydrateRows } from './hydration.js';
-import { OrmSession } from './orm-session.ts';
-import { SelectQueryBuilder } from '../query-builder/select.js';
-import {
-  createEntityProxy,
-  createEntityFromRow,
-  relationLoaderCache
-} from './entity.js';
-import { EntityContext } from './entity-context.js';
-import { ExecutionContext } from './execution-context.js';
-import { HydrationContext } from './hydration-context.js';
-import { RelationIncludeOptions } from '../query-builder/relation-types.js';
-import { getEntityMeta, RelationKey } from './entity-meta.js';
-import {
-  loadHasManyRelation,
-  loadHasOneRelation,
-  loadBelongsToRelation,
-  loadBelongsToManyRelation
-} from './lazy-batch.js';
+import { TableDef } from '../schema/table.js';
+import { EntityInstance } from '../schema/types.js';
+import { RelationKinds } from '../schema/relation.js';
+import { hydrateRows } from './hydration.js';
+import { OrmSession } from './orm-session.ts';
+import { SelectQueryBuilder } from '../query-builder/select.js';
+import {
+  createEntityProxy,
+  createEntityFromRow,
+  relationLoaderCache
+} from './entity.js';
+import { EntityContext } from './entity-context.js';
+import { ExecutionContext } from './execution-context.js';
+import { HydrationContext } from './hydration-context.js';
+import { RelationIncludeOptions } from '../query-builder/relation-types.js';
+import { getEntityMeta, RelationKey } from './entity-meta.js';
+import {
+  loadHasManyRelation,
+  loadHasOneRelation,
+  loadBelongsToRelation,
+  loadBelongsToManyRelation
+} from './lazy-batch.js';
 
 type Row = Record<string, unknown>;
 
@@ -38,152 +38,152 @@ const flattenResults = (results: { columns: string[]; values: unknown[][] }[]):
   return rows;
 };
 
-const executeWithContexts = async <TTable extends TableDef>(
-  execCtx: ExecutionContext,
-  entityCtx: EntityContext,
-  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(executed);
-  const lazyRelations = qb.getLazyRelations() as RelationKey<TTable>[];
-  const lazyRelationOptions = qb.getLazyRelationOptions();
-
-  if (ast.setOps && ast.setOps.length > 0) {
-    const proxies = rows.map(row => createEntityProxy(entityCtx, qb.getTable(), row, lazyRelations, lazyRelationOptions));
-    await loadLazyRelationsForTable(entityCtx, qb.getTable(), lazyRelations, lazyRelationOptions);
-    return proxies;
-  }
-
-  const hydrated = hydrateRows(rows, qb.getHydrationPlan());
-  const entities = hydrated.map(row => createEntityFromRow(entityCtx, qb.getTable(), row, lazyRelations, lazyRelationOptions));
-  await loadLazyRelationsForTable(entityCtx, qb.getTable(), lazyRelations, lazyRelationOptions);
-  return entities;
-};
-
-const executePlainWithContexts = async <TTable extends TableDef>(
-  execCtx: ExecutionContext,
-  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(executed);
-
-  if (ast.setOps && ast.setOps.length > 0) {
-    return rows;
-  }
-
-  return hydrateRows(rows, qb.getHydrationPlan());
-};
-
-/**
- * Executes a hydrated query using the ORM session.
- * @template TTable - The table type
- * @param session - The ORM session
- * @param qb - The select query builder
+const executeWithContexts = async <TTable extends TableDef>(
+  execCtx: ExecutionContext,
+  entityCtx: EntityContext,
+  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(executed);
+  const lazyRelations = qb.getLazyRelations() as RelationKey<TTable>[];
+  const lazyRelationOptions = qb.getLazyRelationOptions();
+
+  if (ast.setOps && ast.setOps.length > 0) {
+    const proxies = rows.map(row => createEntityProxy(entityCtx, qb.getTable(), row, lazyRelations, lazyRelationOptions));
+    await loadLazyRelationsForTable(entityCtx, qb.getTable(), lazyRelations, lazyRelationOptions);
+    return proxies;
+  }
+
+  const hydrated = hydrateRows(rows, qb.getHydrationPlan());
+  const entities = hydrated.map(row => createEntityFromRow(entityCtx, qb.getTable(), row, lazyRelations, lazyRelationOptions));
+  await loadLazyRelationsForTable(entityCtx, qb.getTable(), lazyRelations, lazyRelationOptions);
+  return entities;
+};
+
+const executePlainWithContexts = async <TTable extends TableDef>(
+  execCtx: ExecutionContext,
+  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(executed);
+
+  if (ast.setOps && ast.setOps.length > 0) {
+    return rows;
+  }
+
+  return hydrateRows(rows, qb.getHydrationPlan());
+};
+
+/**
+ * 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<unknown, TTable>
-): Promise<EntityInstance<TTable>[]> {
-  return executeWithContexts(session.getExecutionContext(), session, qb);
-}
-
-/**
- * Executes a hydrated query and returns plain row objects (no entity proxies).
- * @template TTable - The table type
- * @param session - The ORM session
- * @param qb - The select query builder
- * @returns Promise resolving to array of plain row objects
- */
-export async function executeHydratedPlain<TTable extends TableDef>(
-  session: OrmSession,
-  qb: SelectQueryBuilder<unknown, TTable>
-): Promise<Record<string, unknown>[]> {
-  return executePlainWithContexts(session.getExecutionContext(), 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
+export async function executeHydrated<TTable extends TableDef>(
+  session: OrmSession,
+  qb: SelectQueryBuilder<unknown, TTable>
+): Promise<EntityInstance<TTable>[]> {
+  return executeWithContexts(session.getExecutionContext(), session, qb);
+}
+
+/**
+ * Executes a hydrated query and returns plain row objects (no entity proxies).
+ * @template TTable - The table type
+ * @param session - The ORM session
+ * @param qb - The select query builder
+ * @returns Promise resolving to array of plain row objects
+ */
+export async function executeHydratedPlain<TTable extends TableDef>(
+  session: OrmSession,
+  qb: SelectQueryBuilder<unknown, TTable>
+): Promise<Record<string, unknown>[]> {
+  return executePlainWithContexts(session.getExecutionContext(), 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<unknown, TTable>
-): Promise<EntityInstance<TTable>[]> {
-  const entityCtx = hydCtx.entityContext;
-  if (!entityCtx) {
-    throw new Error('Hydration context is missing an EntityContext');
-  }
-  return executeWithContexts(execCtx, entityCtx, qb);
-}
-
-/**
- * Executes a hydrated query using execution context and returns plain row objects.
- * @template TTable - The table type
- * @param execCtx - The execution context
- * @param qb - The select query builder
- * @returns Promise resolving to array of plain row objects
- */
-export async function executeHydratedPlainWithContexts<TTable extends TableDef>(
-  execCtx: ExecutionContext,
-  qb: SelectQueryBuilder<unknown, TTable>
-): Promise<Record<string, unknown>[]> {
-  return executePlainWithContexts(execCtx, qb);
-}
-
-const loadLazyRelationsForTable = async <TTable extends TableDef>(
-  ctx: EntityContext,
-  table: TTable,
-  lazyRelations: RelationKey<TTable>[],
-  lazyRelationOptions: Map<string, RelationIncludeOptions>
-): Promise<void> => {
-  if (!lazyRelations.length) return;
-
-  const tracked = ctx.getEntitiesForTable(table);
-  if (!tracked.length) return;
-
-  const meta = getEntityMeta(tracked[0].entity);
-  if (!meta) return;
-
-  for (const relationName of lazyRelations) {
-    const relation = table.relations[relationName as string];
-    if (!relation) continue;
-    const key = relationName as string;
-    const options = lazyRelationOptions.get(key);
-    if (!options) {
-      continue;
-    }
-
-    switch (relation.type) {
-      case RelationKinds.HasOne:
-        await relationLoaderCache(meta, key, () =>
-          loadHasOneRelation(ctx, table, key, relation, options)
-        );
-        break;
-      case RelationKinds.HasMany:
-        await relationLoaderCache(meta, key, () =>
-          loadHasManyRelation(ctx, table, key, relation, options)
-        );
-        break;
-      case RelationKinds.BelongsTo:
-        await relationLoaderCache(meta, key, () =>
-          loadBelongsToRelation(ctx, table, key, relation, options)
-        );
-        break;
-      case RelationKinds.BelongsToMany:
-        await relationLoaderCache(meta, key, () =>
-          loadBelongsToManyRelation(ctx, table, key, relation, options)
-        );
-        break;
-    }
-  }
-};
+export async function executeHydratedWithContexts<TTable extends TableDef>(
+  execCtx: ExecutionContext,
+  hydCtx: HydrationContext,
+  qb: SelectQueryBuilder<unknown, TTable>
+): Promise<EntityInstance<TTable>[]> {
+  const entityCtx = hydCtx.entityContext;
+  if (!entityCtx) {
+    throw new Error('Hydration context is missing an EntityContext');
+  }
+  return executeWithContexts(execCtx, entityCtx, qb);
+}
+
+/**
+ * Executes a hydrated query using execution context and returns plain row objects.
+ * @template TTable - The table type
+ * @param execCtx - The execution context
+ * @param qb - The select query builder
+ * @returns Promise resolving to array of plain row objects
+ */
+export async function executeHydratedPlainWithContexts<TTable extends TableDef>(
+  execCtx: ExecutionContext,
+  qb: SelectQueryBuilder<unknown, TTable>
+): Promise<Record<string, unknown>[]> {
+  return executePlainWithContexts(execCtx, qb);
+}
+
+const loadLazyRelationsForTable = async <TTable extends TableDef>(
+  ctx: EntityContext,
+  table: TTable,
+  lazyRelations: RelationKey<TTable>[],
+  lazyRelationOptions: Map<string, RelationIncludeOptions>
+): Promise<void> => {
+  if (!lazyRelations.length) return;
+
+  const tracked = ctx.getEntitiesForTable(table);
+  if (!tracked.length) return;
+
+  const meta = getEntityMeta(tracked[0].entity);
+  if (!meta) return;
+
+  for (const relationName of lazyRelations) {
+    const relation = table.relations[relationName as string];
+    if (!relation) continue;
+    const key = relationName as string;
+    const options = lazyRelationOptions.get(key);
+    if (!options) {
+      continue;
+    }
+
+    switch (relation.type) {
+      case RelationKinds.HasOne:
+        await relationLoaderCache(meta, key, () =>
+          loadHasOneRelation(ctx, table, key, relation, options)
+        );
+        break;
+      case RelationKinds.HasMany:
+        await relationLoaderCache(meta, key, () =>
+          loadHasManyRelation(ctx, table, key, relation, options)
+        );
+        break;
+      case RelationKinds.BelongsTo:
+        await relationLoaderCache(meta, key, () =>
+          loadBelongsToRelation(ctx, table, key, relation, options)
+        );
+        break;
+      case RelationKinds.BelongsToMany:
+        await relationLoaderCache(meta, key, () =>
+          loadBelongsToManyRelation(ctx, table, key, relation, options)
+        );
+        break;
+    }
+  }
+};

package/src/orm/identity-map.ts

@@ -18,7 +18,7 @@ export class IdentityMap {
    * @param pk The primary key value.
    * @returns The entity instance if found, undefined otherwise.
    */
-  getEntity(table: TableDef, pk: string | number): unknown | undefined {
+  getEntity(table: TableDef, pk: string | number): object | undefined {
     const bucket = this.buckets.get(table.name);
     return bucket?.get(this.toIdentityKey(pk))?.entity;
   }

package/src/orm/lazy-batch/shared.ts

@@ -71,7 +71,7 @@ export const toKey = (value: unknown): string => (value === null || value === un
 export const collectKeysFromRoots = (roots: EntityTracker[], key: string): Set<unknown> => {
   const collected = new Set<unknown>();
   for (const tracked of roots) {
-    const value = tracked.entity[key];
+    const value = (tracked.entity as Record<string, unknown>)[key];
     if (value !== null && value !== undefined) {
       collected.add(value);
     }

package/src/orm/orm-session.ts

@@ -18,7 +18,7 @@ import { RelationChangeProcessor } from './relation-change-processor.js';
 import { createQueryLoggingExecutor, QueryLogger } from './query-logger.js';
 import { ExecutionContext } from './execution-context.js';
 import type { HydrationContext } from './hydration-context.js';
-import type { EntityContext } from './entity-context.js';
+import type { EntityContext, PrimaryKey } from './entity-context.js';
 import {
   DomainEvent,
   OrmDomainEvent,
@@ -27,10 +27,10 @@ import {
   RelationKey,
   TrackedEntity
 } from './runtime-types.js';
-import { executeHydrated } from './execute.js';
-import { runInTransaction } from './transaction-runner.js';
-import { saveGraphInternal, SaveGraphOptions } from './save-graph.js';
-import type { SaveGraphInputPayload } from './save-graph-types.js';
+import { executeHydrated } from './execute.js';
+import { runInTransaction } from './transaction-runner.js';
+import { saveGraphInternal, SaveGraphOptions } from './save-graph.js';
+import type { SaveGraphInputPayload } from './save-graph-types.js';
 
 /**
  * Interface for ORM interceptors that allow hooking into the flush lifecycle.
@@ -142,9 +142,9 @@ export class OrmSession<E extends DomainEvent = OrmDomainEvent> implements Entit
    * @param pk - The primary key value
    * @returns The entity or undefined if not found
    */
-  getEntity(table: TableDef, pk: unknown): unknown | undefined {
-    return this.unitOfWork.getEntity(table, pk as string | number);
-  }
+  getEntity(table: TableDef, pk: PrimaryKey): object | undefined {
+    return this.unitOfWork.getEntity(table, pk);
+  }
 
   /**
    * Sets an entity in the identity map.
@@ -152,9 +152,9 @@ export class OrmSession<E extends DomainEvent = OrmDomainEvent> implements Entit
    * @param pk - The primary key value
    * @param entity - The entity instance
    */
-  setEntity(table: TableDef, pk: unknown, entity: unknown): void {
-    this.unitOfWork.setEntity(table, pk as string | number, entity);
-  }
+  setEntity(table: TableDef, pk: PrimaryKey, entity: object): void {
+    this.unitOfWork.setEntity(table, pk, entity);
+  }
 
   /**
    * Tracks a new entity.
@@ -162,9 +162,9 @@ export class OrmSession<E extends DomainEvent = OrmDomainEvent> implements Entit
    * @param entity - The entity instance
    * @param pk - Optional primary key value
    */
-  trackNew(table: TableDef, entity: unknown, pk?: unknown): void {
-    this.unitOfWork.trackNew(table, entity, pk as string | number);
-  }
+  trackNew(table: TableDef, entity: object, pk?: PrimaryKey): void {
+    this.unitOfWork.trackNew(table, entity, pk);
+  }
 
   /**
    * Tracks a managed entity.
@@ -172,25 +172,25 @@ export class OrmSession<E extends DomainEvent = OrmDomainEvent> implements Entit
    * @param pk - The primary key value
    * @param entity - The entity instance
    */
-  trackManaged(table: TableDef, pk: unknown, entity: unknown): void {
-    this.unitOfWork.trackManaged(table, pk as string | number, entity);
-  }
+  trackManaged(table: TableDef, pk: PrimaryKey, entity: object): void {
+    this.unitOfWork.trackManaged(table, pk, entity);
+  }
 
   /**
    * Marks an entity as dirty (modified).
    * @param entity - The entity to mark as dirty
    */
-  markDirty(entity: unknown): void {
-    this.unitOfWork.markDirty(entity);
-  }
+  markDirty(entity: object): void {
+    this.unitOfWork.markDirty(entity);
+  }
 
   /**
    * Marks an entity as removed.
    * @param entity - The entity to mark as removed
    */
-  markRemoved(entity: unknown): void {
-    this.unitOfWork.markRemoved(entity);
-  }
+  markRemoved(entity: object): void {
+    this.unitOfWork.markRemoved(entity);
+  }
 
   /**
    * Registers a relation change.
@@ -298,30 +298,30 @@ export class OrmSession<E extends DomainEvent = OrmDomainEvent> implements Entit
     return executeHydrated(this, qb);
   }
 
-  /**
-   * Saves an entity graph (root + nested relations) based on a DTO-like payload.
-   * @param entityClass - Root entity constructor
-   * @param payload - DTO payload containing column values and nested relations
-   * @param options - Graph save options
-   * @returns The root entity instance
-   */
-  async saveGraph<TCtor extends EntityConstructor<object>>(
-    entityClass: TCtor,
-    payload: SaveGraphInputPayload<InstanceType<TCtor>>,
-    options?: SaveGraphOptions & { transactional?: boolean }
-  ): Promise<InstanceType<TCtor>>;
-  async saveGraph<TCtor extends EntityConstructor<object>>(
-    entityClass: TCtor,
-    payload: Record<string, unknown>,
-    options?: SaveGraphOptions & { transactional?: boolean }
-  ): Promise<InstanceType<TCtor>> {
-    const { transactional = true, ...graphOptions } = options ?? {};
-    const execute = () => saveGraphInternal(this, entityClass, payload, graphOptions);
-    if (!transactional) {
-      return execute();
-    }
-    return this.transaction(() => execute());
-  }
+  /**
+   * Saves an entity graph (root + nested relations) based on a DTO-like payload.
+   * @param entityClass - Root entity constructor
+   * @param payload - DTO payload containing column values and nested relations
+   * @param options - Graph save options
+   * @returns The root entity instance
+   */
+  async saveGraph<TCtor extends EntityConstructor<object>>(
+    entityClass: TCtor,
+    payload: SaveGraphInputPayload<InstanceType<TCtor>>,
+    options?: SaveGraphOptions & { transactional?: boolean }
+  ): Promise<InstanceType<TCtor>>;
+  async saveGraph<TCtor extends EntityConstructor<object>>(
+    entityClass: TCtor,
+    payload: Record<string, unknown>,
+    options?: SaveGraphOptions & { transactional?: boolean }
+  ): Promise<InstanceType<TCtor>> {
+    const { transactional = true, ...graphOptions } = options ?? {};
+    const execute = () => saveGraphInternal(this, entityClass, payload, graphOptions);
+    if (!transactional) {
+      return execute();
+    }
+    return this.transaction(() => execute());
+  }
 
   /**
    * Persists an entity (either inserts or updates).
@@ -340,7 +340,7 @@ export class OrmSession<E extends DomainEvent = OrmDomainEvent> implements Entit
     const primaryKey = findPrimaryKey(table);
     const pkValue = (entity as Record<string, unknown>)[primaryKey];
     if (pkValue !== undefined && pkValue !== null) {
-      this.trackManaged(table, pkValue, entity);
+      this.trackManaged(table, pkValue as PrimaryKey, entity);
     } else {
       this.trackNew(table, entity);
     }
@@ -354,12 +354,12 @@ export class OrmSession<E extends DomainEvent = OrmDomainEvent> implements Entit
     this.markRemoved(entity);
   }
 
-  /**
-   * Flushes pending changes to the database without session hooks, relation processing, or domain events.
-   */
-  async flush(): Promise<void> {
-    await this.unitOfWork.flush();
-  }
+  /**
+   * Flushes pending changes to the database without session hooks, relation processing, or domain events.
+   */
+  async flush(): Promise<void> {
+    await this.unitOfWork.flush();
+  }
 
   /**
    * Flushes pending changes with interceptors and relation processing.

package/src/orm/relation-change-processor.ts

@@ -78,7 +78,7 @@ export class RelationChangeProcessor {
     const target = entry.change.entity;
     if (!target) return;
 
-    const tracked = this.unitOfWork.findTracked(target);
+    const tracked = this.unitOfWork.findTracked(target as object);
     if (!tracked) return;
 
     const localKey = relation.localKey || findPrimaryKey(entry.rootTable);
@@ -105,7 +105,7 @@ export class RelationChangeProcessor {
     const target = entry.change.entity;
     if (!target) return;
 
-    const tracked = this.unitOfWork.findTracked(target);
+    const tracked = this.unitOfWork.findTracked(target as object);
     if (!tracked) return;
 
     const localKey = relation.localKey || findPrimaryKey(entry.rootTable);
@@ -154,7 +154,7 @@ export class RelationChangeProcessor {
       await this.deletePivotRow(relation, rootId, targetId);
 
       if (relation.cascade === 'all' || relation.cascade === 'remove') {
-        this.unitOfWork.markRemoved(entry.change.entity);
+        this.unitOfWork.markRemoved(entry.change.entity as object);
       }
     }
   }

package/src/orm/relations/has-many.ts

@@ -125,7 +125,7 @@ export class DefaultHasManyCollection<TChild> implements HasManyCollection<TChil
   attach(entity: TChild): void {
     const keyValue = this.root[this.localKey];
     (entity as Record<string, unknown>)[this.relation.foreignKey] = keyValue;
-    this.ctx.markDirty(entity);
+    this.ctx.markDirty(entity as object);
     this.items.push(entity);
     this.ctx.registerRelationChange(
       this.root,

package/src/orm/runtime-types.ts

@@ -20,11 +20,11 @@ export enum EntityStatus {
 /**
  * Represents an entity being tracked by the ORM
  */
-export interface TrackedEntity {
-  /** The table definition this entity belongs to */
-  table: TableDef;
-  /** The actual entity instance */
-  entity: unknown;
+export interface TrackedEntity {
+  /** The table definition this entity belongs to */
+  table: TableDef;
+  /** The actual entity instance */
+  entity: object;
   /** Primary key value of the entity */
   pk: string | number | null;
   /** Current status of the entity */