metal-orm 1.0.41 → 1.0.43

package/src/orm/orm-session.ts

@@ -141,8 +141,8 @@ 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: any): any | undefined {
-    return this.unitOfWork.getEntity(table, pk);
+  getEntity(table: TableDef, pk: unknown): unknown | undefined {
+    return this.unitOfWork.getEntity(table, pk as string | number);
   }
 
   /**
@@ -151,8 +151,8 @@ export class OrmSession<E extends DomainEvent = OrmDomainEvent> implements Entit
    * @param pk - The primary key value
    * @param entity - The entity instance
    */
-  setEntity(table: TableDef, pk: any, entity: any): void {
-    this.unitOfWork.setEntity(table, pk, entity);
+  setEntity(table: TableDef, pk: unknown, entity: unknown): void {
+    this.unitOfWork.setEntity(table, pk as string | number, entity);
   }
 
   /**
@@ -161,8 +161,8 @@ export class OrmSession<E extends DomainEvent = OrmDomainEvent> implements Entit
    * @param entity - The entity instance
    * @param pk - Optional primary key value
    */
-  trackNew(table: TableDef, entity: any, pk?: any): void {
-    this.unitOfWork.trackNew(table, entity, pk);
+  trackNew(table: TableDef, entity: unknown, pk?: unknown): void {
+    this.unitOfWork.trackNew(table, entity, pk as string | number);
   }
 
   /**
@@ -171,15 +171,15 @@ export class OrmSession<E extends DomainEvent = OrmDomainEvent> implements Entit
    * @param pk - The primary key value
    * @param entity - The entity instance
    */
-  trackManaged(table: TableDef, pk: any, entity: any): void {
-    this.unitOfWork.trackManaged(table, pk, entity);
+  trackManaged(table: TableDef, pk: unknown, entity: unknown): void {
+    this.unitOfWork.trackManaged(table, pk as string | number, entity);
   }
 
   /**
    * Marks an entity as dirty (modified).
    * @param entity - The entity to mark as dirty
    */
-  markDirty(entity: any): void {
+  markDirty(entity: unknown): void {
     this.unitOfWork.markDirty(entity);
   }
 
@@ -187,7 +187,7 @@ export class OrmSession<E extends DomainEvent = OrmDomainEvent> implements Entit
    * Marks an entity as removed.
    * @param entity - The entity to mark as removed
    */
-  markRemoved(entity: any): void {
+  markRemoved(entity: unknown): void {
     this.unitOfWork.markRemoved(entity);
   }
 
@@ -201,12 +201,12 @@ export class OrmSession<E extends DomainEvent = OrmDomainEvent> implements Entit
    * @param change - The relation change
    */
   registerRelationChange = (
-    root: any,
+    root: unknown,
     relationKey: RelationKey,
     rootTable: TableDef,
     relationName: string,
     relation: RelationDef,
-    change: RelationChange<any>
+    change: RelationChange<unknown>
   ): void => {
     this.relationChanges.registerChange(
       buildRelationChangeEntry(root, relationKey, rootTable, relationName, relation, change)
@@ -250,9 +250,9 @@ export class OrmSession<E extends DomainEvent = OrmDomainEvent> implements Entit
    * @returns The entity instance or null if not found
    * @throws If entity metadata is not bootstrapped or table has no primary key
    */
-  async find<TCtor extends EntityConstructor<any>>(
+  async find<TCtor extends EntityConstructor<object>>(
     entityClass: TCtor,
-    id: any
+    id: unknown
   ): Promise<InstanceType<TCtor> | null> {
     const table = getTableDefFromEntity(entityClass);
     if (!table) {
@@ -269,7 +269,7 @@ export class OrmSession<E extends DomainEvent = OrmDomainEvent> implements Entit
     }, {});
     const qb = selectFromEntity(entityClass)
       .select(columnSelections)
-      .where(eq(column, id))
+      .where(eq(column, id as string | number))
       .limit(1);
     const rows = await executeHydrated(this, qb);
     return (rows[0] ?? null) as InstanceType<TCtor> | null;
@@ -281,7 +281,7 @@ export class OrmSession<E extends DomainEvent = OrmDomainEvent> implements Entit
    * @param qb - The query builder
    * @returns The first entity instance or null if not found
    */
-  async findOne<TTable extends TableDef>(qb: SelectQueryBuilder<any, TTable>): Promise<EntityInstance<TTable> | null> {
+  async findOne<TTable extends TableDef>(qb: SelectQueryBuilder<unknown, TTable>): Promise<EntityInstance<TTable> | null> {
     const limited = qb.limit(1);
     const rows = await executeHydrated(this, limited);
     return rows[0] ?? null;
@@ -293,7 +293,7 @@ export class OrmSession<E extends DomainEvent = OrmDomainEvent> implements Entit
    * @param qb - The query builder
    * @returns Array of entity instances
    */
-  async findMany<TTable extends TableDef>(qb: SelectQueryBuilder<any, TTable>): Promise<EntityInstance<TTable>[]> {
+  async findMany<TTable extends TableDef>(qb: SelectQueryBuilder<unknown, TTable>): Promise<EntityInstance<TTable>[]> {
     return executeHydrated(this, qb);
   }
 
@@ -304,9 +304,9 @@ export class OrmSession<E extends DomainEvent = OrmDomainEvent> implements Entit
    * @param options - Graph save options
    * @returns The root entity instance
    */
-  async saveGraph<TCtor extends EntityConstructor<any>>(
+  async saveGraph<TCtor extends EntityConstructor<object>>(
     entityClass: TCtor,
-    payload: Record<string, any>,
+    payload: Record<string, unknown>,
     options?: SaveGraphOptions & { transactional?: boolean }
   ): Promise<InstanceType<TCtor>> {
     const { transactional = true, ...graphOptions } = options ?? {};
@@ -326,12 +326,13 @@ export class OrmSession<E extends DomainEvent = OrmDomainEvent> implements Entit
     if (this.unitOfWork.findTracked(entity)) {
       return;
     }
-    const table = getTableDefFromEntity((entity as any).constructor as EntityConstructor<any>);
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    const table = getTableDefFromEntity((entity as { constructor: EntityConstructor }).constructor);
     if (!table) {
       throw new Error('Entity metadata has not been bootstrapped');
     }
     const primaryKey = findPrimaryKey(table);
-    const pkValue = (entity as Record<string, any>)[primaryKey];
+    const pkValue = (entity as Record<string, unknown>)[primaryKey];
     if (pkValue !== undefined && pkValue !== null) {
       this.trackManaged(table, pkValue, entity);
     } else {
@@ -449,12 +450,12 @@ export class OrmSession<E extends DomainEvent = OrmDomainEvent> implements Entit
 }
 
 const buildRelationChangeEntry = (
-  root: any,
+  root: unknown,
   relationKey: RelationKey,
   rootTable: TableDef,
   relationName: string,
   relation: RelationDef,
-  change: RelationChange<any>
+  change: RelationChange<unknown>
 ): RelationChangeEntry => ({
   root,
   relationKey,

package/src/orm/orm.ts

@@ -8,9 +8,8 @@ import { OrmSession } from './orm-session.js';
 
 /**
  * Options for creating an ORM instance.
- * @template E - The domain event type
  */
-export interface OrmOptions<E extends DomainEvent = OrmDomainEvent> {
+export interface OrmOptions {
   /** The database dialect */
   dialect: Dialect;
   /** The database executor factory */
@@ -61,7 +60,7 @@ export class Orm<E extends DomainEvent = OrmDomainEvent> {
    * Creates a new ORM instance.
    * @param opts - ORM options
    */
-  constructor(opts: OrmOptions<E>) {
+  constructor(opts: OrmOptions) {
     this.dialect = opts.dialect;
     this.interceptors = opts.interceptors ?? new InterceptorPipeline();
     this.namingStrategy = opts.namingStrategy ?? new DefaultNamingStrategy();
@@ -92,8 +91,6 @@ export class Orm<E extends DomainEvent = OrmDomainEvent> {
     try {
       // A real transaction scope: begin before running user code, commit/rollback after.
       return await session.transaction(() => fn(session));
-    } catch (err) {
-      throw err;
     } finally {
       await session.dispose();
     }

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

@@ -86,13 +86,13 @@ export class RelationChangeProcessor {
     if (rootValue === undefined || rootValue === null) return;
 
     if (entry.change.kind === 'add' || entry.change.kind === 'attach') {
-      this.assignHasManyForeignKey(tracked.entity, relation, rootValue);
+      this.assignHasManyForeignKey(tracked.entity as Record<string, unknown>, relation, rootValue);
       this.unitOfWork.markDirty(tracked.entity);
       return;
     }
 
     if (entry.change.kind === 'remove') {
-      this.detachHasManyChild(tracked.entity, relation);
+      this.detachHasManyChild(tracked.entity as Record<string, unknown>, relation);
     }
   }
 
@@ -113,13 +113,13 @@ export class RelationChangeProcessor {
     if (rootValue === undefined || rootValue === null) return;
 
     if (entry.change.kind === 'attach' || entry.change.kind === 'add') {
-      this.assignHasOneForeignKey(tracked.entity, relation, rootValue);
+      this.assignHasOneForeignKey(tracked.entity as Record<string, unknown>, relation, rootValue);
       this.unitOfWork.markDirty(tracked.entity);
       return;
     }
 
     if (entry.change.kind === 'remove') {
-      this.detachHasOneChild(tracked.entity, relation);
+      this.detachHasOneChild(tracked.entity as Record<string, unknown>, relation);
     }
   }
 
@@ -128,6 +128,7 @@ export class RelationChangeProcessor {
    * @param _entry - The relation change entry (reserved for future use)
    */
   private async handleBelongsToChange(_entry: RelationChangeEntry): Promise<void> {
+    void _entry;
     // Reserved for future cascade/persist behaviors for belongs-to relations.
   }
 
@@ -141,7 +142,7 @@ export class RelationChangeProcessor {
     const rootId = entry.root[rootKey];
     if (rootId === undefined || rootId === null) return;
 
-    const targetId = this.resolvePrimaryKeyValue(entry.change.entity, relation.target);
+    const targetId = this.resolvePrimaryKeyValue(entry.change.entity as Record<string, unknown>, relation.target);
     if (targetId === null) return;
 
     if (entry.change.kind === 'attach' || entry.change.kind === 'add') {
@@ -164,7 +165,7 @@ export class RelationChangeProcessor {
    * @param relation - The has-many relation
    * @param rootValue - The root entity's primary key value
    */
-  private assignHasManyForeignKey(child: any, relation: HasManyRelation, rootValue: unknown): void {
+  private assignHasManyForeignKey(child: Record<string, unknown>, relation: HasManyRelation, rootValue: unknown): void {
     const current = child[relation.foreignKey];
     if (current === rootValue) return;
     child[relation.foreignKey] = rootValue;
@@ -175,7 +176,7 @@ export class RelationChangeProcessor {
    * @param child - The child entity
    * @param relation - The has-many relation
    */
-  private detachHasManyChild(child: any, relation: HasManyRelation): void {
+  private detachHasManyChild(child: Record<string, unknown>, relation: HasManyRelation): void {
     if (relation.cascade === 'all' || relation.cascade === 'remove') {
       this.unitOfWork.markRemoved(child);
       return;
@@ -190,7 +191,7 @@ export class RelationChangeProcessor {
    * @param relation - The has-one relation
    * @param rootValue - The root entity's primary key value
    */
-  private assignHasOneForeignKey(child: any, relation: HasOneRelation, rootValue: unknown): void {
+  private assignHasOneForeignKey(child: Record<string, unknown>, relation: HasOneRelation, rootValue: unknown): void {
     const current = child[relation.foreignKey];
     if (current === rootValue) return;
     child[relation.foreignKey] = rootValue;
@@ -201,7 +202,7 @@ export class RelationChangeProcessor {
    * @param child - The child entity
    * @param relation - The has-one relation
    */
-  private detachHasOneChild(child: any, relation: HasOneRelation): void {
+  private detachHasOneChild(child: Record<string, unknown>, relation: HasOneRelation): void {
     if (relation.cascade === 'all' || relation.cascade === 'remove') {
       this.unitOfWork.markRemoved(child);
       return;
@@ -250,11 +251,11 @@ export class RelationChangeProcessor {
    * @param table - The table definition
    * @returns The primary key value or null
    */
-  private resolvePrimaryKeyValue(entity: any, table: TableDef): string | number | null {
+  private resolvePrimaryKeyValue(entity: Record<string, unknown>, table: TableDef): string | number | null {
     if (!entity) return null;
     const key = findPrimaryKey(table);
     const value = entity[key];
     if (value === undefined || value === null) return null;
-    return value;
+    return (value as string | number | null | undefined) ?? null;
   }
 }

package/src/orm/relations/belongs-to.ts

@@ -5,11 +5,11 @@ import { BelongsToRelation } from '../../schema/relation.js';
 import { TableDef } from '../../schema/table.js';
 import { EntityMeta, getHydrationRecord, hasEntityMeta } from '../entity-meta.js';
 
-type Rows = Record<string, any>;
+type Rows = Record<string, unknown>;
 
 const toKey = (value: unknown): string => (value === null || value === undefined ? '' : String(value));
 
-const hideInternal = (obj: any, keys: string[]): void => {
+const hideInternal = (obj: object, keys: string[]): void => {
   for (const key of keys) {
     Object.defineProperty(obj, key, {
       value: obj[key],
@@ -26,13 +26,13 @@ export class DefaultBelongsToReference<TParent> implements BelongsToReference<TP
 
   constructor(
     private readonly ctx: EntityContext,
-    private readonly meta: EntityMeta<any>,
-    private readonly root: any,
+    private readonly meta: EntityMeta<TableDef>,
+    private readonly root: unknown,
     private readonly relationName: string,
     private readonly relation: BelongsToRelation,
     private readonly rootTable: TableDef,
     private readonly loader: () => Promise<Map<string, Rows>>,
-    private readonly createEntity: (row: Record<string, any>) => TParent,
+    private readonly createEntity: (row: Record<string, unknown>) => TParent,
     private readonly targetKey: string
   ) {
     hideInternal(this, ['ctx', 'meta', 'root', 'relationName', 'relation', 'rootTable', 'loader', 'createEntity', 'targetKey']);
@@ -42,7 +42,7 @@ export class DefaultBelongsToReference<TParent> implements BelongsToReference<TP
   async load(): Promise<TParent | null> {
     if (this.loaded) return this.current;
     const map = await this.loader();
-    const fkValue = this.root[this.relation.foreignKey];
+    const fkValue = (this.root as Record<string, unknown>)[this.relation.foreignKey];
     if (fkValue === null || fkValue === undefined) {
       this.current = null;
     } else {
@@ -60,7 +60,7 @@ export class DefaultBelongsToReference<TParent> implements BelongsToReference<TP
   set(data: Partial<TParent> | TParent | null): TParent | null {
     if (data === null) {
       const previous = this.current;
-      this.root[this.relation.foreignKey] = null;
+      (this.root as Record<string, unknown>)[this.relation.foreignKey] = null;
       this.current = null;
       this.ctx.registerRelationChange(
         this.root,
@@ -73,10 +73,10 @@ export class DefaultBelongsToReference<TParent> implements BelongsToReference<TP
       return null;
     }
 
-    const entity = hasEntityMeta(data) ? (data as TParent) : this.createEntity(data as Record<string, any>);
-    const pkValue = (entity as any)[this.targetKey];
+    const entity = hasEntityMeta(data) ? (data as TParent) : this.createEntity(data as Record<string, unknown>);
+    const pkValue = (entity as Record<string, unknown>)[this.targetKey];
     if (pkValue !== undefined) {
-      this.root[this.relation.foreignKey] = pkValue;
+      (this.root as Record<string, unknown>)[this.relation.foreignKey] = pkValue;
     }
     this.current = entity;
     this.ctx.registerRelationChange(
@@ -95,7 +95,7 @@ export class DefaultBelongsToReference<TParent> implements BelongsToReference<TP
   }
 
   private populateFromHydrationCache(): void {
-    const fkValue = this.root[this.relation.foreignKey];
+    const fkValue = (this.root as Record<string, unknown>)[this.relation.foreignKey];
     if (fkValue === undefined || fkValue === null) return;
     const row = getHydrationRecord(this.meta, this.relationName, fkValue);
     if (!row) return;

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

@@ -5,11 +5,11 @@ import { HasManyRelation } from '../../schema/relation.js';
 import { TableDef } from '../../schema/table.js';
 import { EntityMeta, getHydrationRows } from '../entity-meta.js';
 
-type Rows = Record<string, any>[];
+type Rows = Record<string, unknown>[];
 
 const toKey = (value: unknown): string => (value === null || value === undefined ? '' : String(value));
 
-const hideInternal = (obj: any, keys: string[]): void => {
+const hideInternal = (obj: object, keys: string[]): void => {
   for (const key of keys) {
     Object.defineProperty(obj, key, {
       value: obj[key],
@@ -28,13 +28,13 @@ export class DefaultHasManyCollection<TChild> implements HasManyCollection<TChil
 
   constructor(
     private readonly ctx: EntityContext,
-    private readonly meta: EntityMeta<any>,
-    private readonly root: any,
+    private readonly meta: EntityMeta<TableDef>,
+    private readonly root: unknown,
     private readonly relationName: string,
     private readonly relation: HasManyRelation,
     private readonly rootTable: TableDef,
     private readonly loader: () => Promise<Map<string, Rows>>,
-    private readonly createEntity: (row: Record<string, any>) => TChild,
+    private readonly createEntity: (row: Record<string, unknown>) => TChild,
     private readonly localKey: string
   ) {
     hideInternal(this, ['ctx', 'meta', 'root', 'relationName', 'relation', 'rootTable', 'loader', 'createEntity', 'localKey']);
@@ -44,7 +44,7 @@ export class DefaultHasManyCollection<TChild> implements HasManyCollection<TChil
   async load(): Promise<TChild[]> {
     if (this.loaded) return this.items;
     const map = await this.loader();
-    const key = toKey(this.root[this.localKey]);
+    const key = toKey((this.root as Record<string, unknown>)[this.localKey]);
     const rows = map.get(key) ?? [];
     this.items = rows.map(row => this.createEntity(row));
     this.loaded = true;
@@ -56,8 +56,8 @@ export class DefaultHasManyCollection<TChild> implements HasManyCollection<TChil
   }
 
   add(data: Partial<TChild>): TChild {
-    const keyValue = this.root[this.localKey];
-    const childRow: Record<string, any> = {
+    const keyValue = (this.root as Record<string, unknown>)[this.localKey];
+    const childRow: Record<string, unknown> = {
       ...data,
       [this.relation.foreignKey]: keyValue
     };
@@ -77,7 +77,7 @@ export class DefaultHasManyCollection<TChild> implements HasManyCollection<TChil
 
   attach(entity: TChild): void {
     const keyValue = this.root[this.localKey];
-    (entity as Record<string, any>)[this.relation.foreignKey] = keyValue;
+    (entity as Record<string, unknown>)[this.relation.foreignKey] = keyValue;
     this.ctx.markDirty(entity);
     this.items.push(entity);
     this.ctx.registerRelationChange(
@@ -114,7 +114,7 @@ export class DefaultHasManyCollection<TChild> implements HasManyCollection<TChil
   }
 
   private hydrateFromCache(): void {
-    const keyValue = this.root[this.localKey];
+    const keyValue = (this.root as Record<string, unknown>)[this.localKey];
     if (keyValue === undefined || keyValue === null) return;
     const rows = getHydrationRows(this.meta, this.relationName, keyValue);
     if (!rows?.length) return;

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

@@ -5,11 +5,11 @@ import { HasOneRelation } from '../../schema/relation.js';
 import { TableDef } from '../../schema/table.js';
 import { EntityMeta, getHydrationRecord, hasEntityMeta } from '../entity-meta.js';
 
-type Row = Record<string, any>;
+type Row = Record<string, unknown>;
 
 const toKey = (value: unknown): string => (value === null || value === undefined ? '' : String(value));
 
-const hideInternal = (obj: any, keys: string[]): void => {
+const hideInternal = (obj: object, keys: string[]): void => {
   for (const key of keys) {
     Object.defineProperty(obj, key, {
       value: obj[key],
@@ -26,8 +26,8 @@ export class DefaultHasOneReference<TChild> implements HasOneReference<TChild> {
 
   constructor(
     private readonly ctx: EntityContext,
-    private readonly meta: EntityMeta<any>,
-    private readonly root: any,
+    private readonly meta: EntityMeta<TableDef>,
+    private readonly root: unknown,
     private readonly relationName: string,
     private readonly relation: HasOneRelation,
     private readonly rootTable: TableDef,
@@ -52,7 +52,7 @@ export class DefaultHasOneReference<TChild> implements HasOneReference<TChild> {
   async load(): Promise<TChild | null> {
     if (this.loaded) return this.current;
     const map = await this.loader();
-    const keyValue = this.root[this.localKey];
+    const keyValue = (this.root as Record<string, unknown>)[this.localKey];
     if (keyValue === undefined || keyValue === null) {
       this.loaded = true;
       return this.current;
@@ -121,7 +121,8 @@ export class DefaultHasOneReference<TChild> implements HasOneReference<TChild> {
   }
 
   private assignForeignKey(entity: TChild): void {
-    const keyValue = this.root[this.localKey];
+    const keyValue = (this.root as Record<string, unknown>)[this.localKey];
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
     (entity as Row)[this.relation.foreignKey] = keyValue;
   }
 
@@ -130,7 +131,7 @@ export class DefaultHasOneReference<TChild> implements HasOneReference<TChild> {
   }
 
   private populateFromHydrationCache(): void {
-    const keyValue = this.root[this.localKey];
+    const keyValue = (this.root as Record<string, unknown>)[this.localKey];
     if (keyValue === undefined || keyValue === null) return;
     const row = getHydrationRecord(this.meta, this.relationName, keyValue);
     if (!row) return;

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

@@ -6,11 +6,11 @@ import { TableDef } from '../../schema/table.js';
 import { findPrimaryKey } from '../../query-builder/hydration-planner.js';
 import { EntityMeta, getHydrationRows } from '../entity-meta.js';
 
-type Rows = Record<string, any>[];
+type Rows = Record<string, unknown>[];
 
 const toKey = (value: unknown): string => (value === null || value === undefined ? '' : String(value));
 
-const hideInternal = (obj: any, keys: string[]): void => {
+const hideInternal = (obj: object, keys: string[]): void => {
   for (const key of keys) {
     Object.defineProperty(obj, key, {
       value: obj[key],
@@ -27,13 +27,13 @@ export class DefaultManyToManyCollection<TTarget> implements ManyToManyCollectio
 
   constructor(
     private readonly ctx: EntityContext,
-    private readonly meta: EntityMeta<any>,
-    private readonly root: any,
+    private readonly meta: EntityMeta<TableDef>,
+    private readonly root: unknown,
     private readonly relationName: string,
     private readonly relation: BelongsToManyRelation,
     private readonly rootTable: TableDef,
     private readonly loader: () => Promise<Map<string, Rows>>,
-    private readonly createEntity: (row: Record<string, any>) => TTarget,
+    private readonly createEntity: (row: Record<string, unknown>) => TTarget,
     private readonly localKey: string
   ) {
     hideInternal(this, ['ctx', 'meta', 'root', 'relationName', 'relation', 'rootTable', 'loader', 'createEntity', 'localKey']);
@@ -47,8 +47,8 @@ export class DefaultManyToManyCollection<TTarget> implements ManyToManyCollectio
     const rows = map.get(key) ?? [];
     this.items = rows.map(row => {
       const entity = this.createEntity(row);
-      if ((row as any)._pivot) {
-        (entity as any)._pivot = row._pivot;
+      if ((row as { _pivot?: unknown })._pivot) {
+        (entity as { _pivot?: unknown })._pivot = (row as { _pivot?: unknown })._pivot;
       }
       return entity;
     });
@@ -103,7 +103,6 @@ export class DefaultManyToManyCollection<TTarget> implements ManyToManyCollectio
 
   async syncByIds(ids: (number | string)[]): Promise<void> {
     await this.load();
-    const targetKey = this.relation.targetKey || findPrimaryKey(this.relation.target);
     const normalized = new Set(ids.map(id => toKey(id)));
     const currentIds = new Set(this.items.map(item => toKey(this.extractId(item))));
 
@@ -123,7 +122,7 @@ export class DefaultManyToManyCollection<TTarget> implements ManyToManyCollectio
 
   private ensureEntity(target: TTarget | number | string): TTarget {
     if (typeof target === 'number' || typeof target === 'string') {
-      const stub: Record<string, any> = {
+      const stub: Record<string, unknown> = {
         [this.targetKey]: target
       };
       return this.createEntity(stub);
@@ -136,7 +135,7 @@ export class DefaultManyToManyCollection<TTarget> implements ManyToManyCollectio
     if (typeof entity === 'number' || typeof entity === 'string') {
       return entity;
     }
-    return (entity as any)[this.targetKey] ?? null;
+    return (entity as Record<string, unknown>)[this.targetKey] as string | number | null ?? null;
   }
 
   private get relationKey(): RelationKey {
@@ -148,14 +147,15 @@ export class DefaultManyToManyCollection<TTarget> implements ManyToManyCollectio
   }
 
   private hydrateFromCache(): void {
-    const keyValue = this.root[this.localKey];
+    const keyValue = (this.root as Record<string, unknown>)[this.localKey];
     if (keyValue === undefined || keyValue === null) return;
     const rows = getHydrationRows(this.meta, this.relationName, keyValue);
     if (!rows?.length) return;
     this.items = rows.map(row => {
       const entity = this.createEntity(row);
-      if ((row as any)._pivot) {
-        (entity as any)._pivot = (row as any)._pivot;
+      // eslint-disable-next-line @typescript-eslint/no-explicit-any
+      if ((row as { _pivot?: unknown })._pivot) {
+        (entity as { _pivot?: unknown })._pivot = (row as { _pivot?: unknown })._pivot;
       }
       return entity;
     });

package/src/orm/runtime-types.ts

@@ -24,13 +24,13 @@ export interface TrackedEntity {
   /** The table definition this entity belongs to */
   table: TableDef;
   /** The actual entity instance */
-  entity: any;
+  entity: unknown;
   /** Primary key value of the entity */
   pk: string | number | null;
   /** Current status of the entity */
   status: EntityStatus;
   /** Original values of the entity when it was loaded */
-  original: Record<string, any> | null;
+  original: Record<string, unknown> | null;
 }
 
 /**
@@ -53,7 +53,7 @@ export type RelationChange<T> =
  */
 export interface RelationChangeEntry {
   /** Root entity that owns the relation */
-  root: any;
+  root: unknown;
   /** Key of the relation being changed */
   relationKey: RelationKey;
   /** Table definition of the root entity */
@@ -63,7 +63,7 @@ export interface RelationChangeEntry {
   /** Relation definition */
   relation: RelationDef;
   /** The change being applied */
-  change: RelationChange<any>;
+  change: RelationChange<unknown>;
 }
 
 /**