metal-orm 1.0.41 → 1.0.43

package/src/orm/entity-context.ts

@@ -8,23 +8,23 @@ export interface EntityContext {
     dialect: Dialect;
     executor: DbExecutor;
 
-    getEntity(table: TableDef, pk: any): any;
-    setEntity(table: TableDef, pk: any, entity: any): void;
+    getEntity(table: TableDef, pk: unknown): unknown;
+    setEntity(table: TableDef, pk: unknown, entity: unknown): void;
 
-    trackNew(table: TableDef, entity: any, pk?: any): void;
-    trackManaged(table: TableDef, pk: any, entity: any): void;
+    trackNew(table: TableDef, entity: unknown, pk?: unknown): void;
+    trackManaged(table: TableDef, pk: unknown, entity: unknown): void;
 
-    markDirty(entity: any): void;
-    markRemoved(entity: any): void;
+    markDirty(entity: unknown): void;
+    markRemoved(entity: unknown): void;
 
     getEntitiesForTable(table: TableDef): TrackedEntity[];
 
     registerRelationChange(
-        root: any,
+        root: unknown,
         relationKey: RelationKey,
         rootTable: TableDef,
         relationName: string,
         relation: RelationDef,
-        change: RelationChange<any>
+        change: RelationChange<unknown>
     ): void;
 }

package/src/orm/entity-meta.ts

@@ -21,9 +21,9 @@ export interface EntityMeta<TTable extends TableDef> {
   /** Relations that should be loaded lazily */
   lazyRelations: (keyof RelationMap<TTable>)[];
   /** Cache for relation promises */
-  relationCache: Map<string, Promise<any>>;
+  relationCache: Map<string, Promise<unknown>>;
   /** Hydration data for relations */
-  relationHydration: Map<string, Map<string, any>>;
+  relationHydration: Map<string, Map<string, unknown>>;
   /** Relation wrapper instances */
   relationWrappers: Map<string, unknown>;
 }
@@ -40,7 +40,7 @@ export const getHydrationRows = <TTable extends TableDef>(
   meta: EntityMeta<TTable>,
   relationName: string,
   key: unknown
-): Record<string, any>[] | undefined => {
+): Record<string, unknown>[] | undefined => {
   const map = meta.relationHydration.get(relationName);
   if (!map) return undefined;
   const rows = map.get(toKey(key));
@@ -60,7 +60,7 @@ export const getHydrationRecord = <TTable extends TableDef>(
   meta: EntityMeta<TTable>,
   relationName: string,
   key: unknown
-): Record<string, any> | undefined => {
+): Record<string, unknown> | undefined => {
   const map = meta.relationHydration.get(relationName);
   if (!map) return undefined;
   const value = map.get(toKey(key));
@@ -68,7 +68,7 @@ export const getHydrationRecord = <TTable extends TableDef>(
   if (Array.isArray(value)) {
     return value[0];
   }
-  return value;
+  return value as Record<string, unknown>;
 };
 
 /**
@@ -77,9 +77,9 @@ export const getHydrationRecord = <TTable extends TableDef>(
  * @returns Entity metadata or undefined if not found
  * @typeParam TTable - Table definition type
  */
-export const getEntityMeta = <TTable extends TableDef>(entity: any): EntityMeta<TTable> | undefined => {
+export const getEntityMeta = <TTable extends TableDef>(entity: unknown): EntityMeta<TTable> | undefined => {
   if (!entity || typeof entity !== 'object') return undefined;
-  return (entity as any)[ENTITY_META];
+  return (entity as { [ENTITY_META]: EntityMeta<TTable> })[ENTITY_META];
 };
 
 /**
@@ -87,6 +87,6 @@ export const getEntityMeta = <TTable extends TableDef>(entity: any): EntityMeta<
  * @param entity - Entity instance to check
  * @returns True if the entity has metadata, false otherwise
  */
-export const hasEntityMeta = (entity: any): entity is { [ENTITY_META]: EntityMeta<TableDef> } => {
+export const hasEntityMeta = (entity: unknown): entity is { [ENTITY_META]: EntityMeta<TableDef> } => {
   return Boolean(getEntityMeta(entity));
 };

package/src/orm/entity-metadata.ts

@@ -1,9 +1,10 @@
-import { ColumnType, ColumnDef } from '../schema/column.js';
+import { ColumnDef } from '../schema/column.js';
 import { defineTable, TableDef, TableHooks } from '../schema/table.js';
 import { CascadeMode, RelationKinds } from '../schema/relation.js';
 
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
 export type EntityConstructor<T = object> = new (...args: any[]) => T;
-export type EntityOrTableTarget = EntityConstructor<any> | TableDef;
+export type EntityOrTableTarget = EntityConstructor | TableDef;
 export type EntityOrTableTargetResolver = EntityOrTableTarget | (() => EntityOrTableTarget);
 
 export type ColumnDefLike<T extends ColumnDef = ColumnDef> = Omit<T, 'name' | 'table'>;
@@ -57,7 +58,7 @@ export type RelationMetadata =
   | BelongsToManyRelationMetadata;
 
 export interface EntityMetadata<TColumns extends Record<string, ColumnDefLike> = Record<string, ColumnDefLike>> {
-  target: EntityConstructor<any>;
+  target: EntityConstructor;
   tableName: string;
   columns: TColumns;
   relations: Record<string, RelationMetadata>;
@@ -65,13 +66,13 @@ export interface EntityMetadata<TColumns extends Record<string, ColumnDefLike> =
   table?: TableDef<MaterializeColumns<TColumns>>;
 }
 
-const metadataMap = new Map<EntityConstructor<any>, EntityMetadata>();
+const metadataMap = new Map<EntityConstructor, EntityMetadata>();
 
 export const registerEntityMetadata = (meta: EntityMetadata): void => {
   metadataMap.set(meta.target, meta);
 };
 
-export const ensureEntityMetadata = (target: EntityConstructor<any>): EntityMetadata => {
+export const ensureEntityMetadata = (target: EntityConstructor): EntityMetadata => {
   let meta = metadataMap.get(target);
   if (!meta) {
     meta = {
@@ -85,7 +86,7 @@ export const ensureEntityMetadata = (target: EntityConstructor<any>): EntityMeta
   return meta;
 };
 
-export const getEntityMetadata = (target: EntityConstructor<any>): EntityMetadata | undefined => {
+export const getEntityMetadata = (target: EntityConstructor): EntityMetadata | undefined => {
   return metadataMap.get(target);
 };
 
@@ -98,7 +99,7 @@ export const clearEntityMetadata = (): void => {
 };
 
 export const addColumnMetadata = (
-  target: EntityConstructor<any>,
+  target: EntityConstructor,
   propertyKey: string,
   column: ColumnDefLike
 ): void => {
@@ -107,7 +108,7 @@ export const addColumnMetadata = (
 };
 
 export const addRelationMetadata = (
-  target: EntityConstructor<any>,
+  target: EntityConstructor,
   propertyKey: string,
   relation: RelationMetadata
 ): void => {
@@ -116,7 +117,7 @@ export const addRelationMetadata = (
 };
 
 export const setEntityTableName = (
-  target: EntityConstructor<any>,
+  target: EntityConstructor,
   tableName: string,
   hooks?: TableHooks
 ): void => {
@@ -135,6 +136,7 @@ export const buildTableDef = <TColumns extends Record<string, ColumnDefLike>>(me
   }
 
   const columns = Object.entries(meta.columns).reduce<MaterializeColumns<TColumns>>((acc, [key, def]) => {
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
     (acc as any)[key] = {
       ...def,
       name: key,

package/src/orm/entity.ts

@@ -13,7 +13,7 @@ import { findPrimaryKey } from '../query-builder/hydration-planner.js';
 /**
  * Type representing an array of database rows.
  */
-type Rows = Record<string, any>[];
+type Rows = Record<string, unknown>[];
 
 /**
  * Caches relation loader results across entities of the same type.
@@ -23,8 +23,8 @@ type Rows = Record<string, any>[];
  * @param factory - The factory function to create the cache
  * @returns Promise with the cached relation data
  */
-const relationLoaderCache = <T extends Map<string, any>>(
-  meta: EntityMeta<any>,
+const relationLoaderCache = <T extends Map<string, unknown>>(
+  meta: EntityMeta<TableDef>,
   relationName: string,
   factory: () => Promise<T>
 ): Promise<T> => {
@@ -68,10 +68,10 @@ export const createEntityProxy = <
 >(
   ctx: EntityContext,
   table: TTable,
-  row: Record<string, any>,
+  row: Record<string, unknown>,
   lazyRelations: TLazy[] = [] as TLazy[]
 ): EntityInstance<TTable> => {
-  const target: Record<string, any> = { ...row };
+  const target: Record<string, unknown> = { ...row };
   const meta: EntityMeta<TTable> = {
     ctx,
     table,
@@ -87,8 +87,7 @@ export const createEntityProxy = <
     writable: false
   });
 
-  let proxy: EntityInstance<TTable>;
-  const handler: ProxyHandler<any> = {
+  const handler: ProxyHandler<object> = {
     get(targetObj, prop, receiver) {
       if (prop === ENTITY_META) {
         return meta;
@@ -96,7 +95,7 @@ export const createEntityProxy = <
 
       if (prop === '$load') {
         return async (relationName: keyof RelationMap<TTable>) => {
-          const wrapper = getRelationWrapper(meta, relationName as string, proxy);
+          const wrapper = getRelationWrapper(meta as unknown as EntityMeta<TableDef>, relationName as string, receiver);
           if (wrapper && typeof wrapper.load === 'function') {
             return wrapper.load();
           }
@@ -105,7 +104,7 @@ export const createEntityProxy = <
       }
 
       if (typeof prop === 'string' && table.relations[prop]) {
-        return getRelationWrapper(meta, prop, proxy);
+        return getRelationWrapper(meta as unknown as EntityMeta<TableDef>, prop, receiver);
       }
 
       return Reflect.get(targetObj, prop, receiver);
@@ -114,13 +113,13 @@ export const createEntityProxy = <
     set(targetObj, prop, value, receiver) {
       const result = Reflect.set(targetObj, prop, value, receiver);
       if (typeof prop === 'string' && table.columns[prop]) {
-        ctx.markDirty(proxy);
+        ctx.markDirty(receiver);
       }
       return result;
     }
   };
 
-  proxy = new Proxy(target, handler) as EntityInstance<TTable>;
+  const proxy = new Proxy(target, handler) as EntityInstance<TTable>;
   populateHydrationCache(proxy, row, meta);
   return proxy;
 };
@@ -141,7 +140,7 @@ export const createEntityFromRow = <
 >(
   ctx: EntityContext,
   table: TTable,
-  row: Record<string, any>,
+  row: Record<string, unknown>,
   lazyRelations: (keyof RelationMap<TTable>)[] = []
 ): TResult => {
   const pkName = findPrimaryKey(table);
@@ -176,8 +175,8 @@ const toKey = (value: unknown): string => (value === null || value === undefined
  * @param meta - The entity metadata
  */
 const populateHydrationCache = <TTable extends TableDef>(
-  entity: any,
-  row: Record<string, any>,
+  entity: Record<string, unknown>,
+  row: Record<string, unknown>,
   meta: EntityMeta<TTable>
 ): void => {
   for (const relationName of Object.keys(meta.table.relations)) {
@@ -188,8 +187,8 @@ const populateHydrationCache = <TTable extends TableDef>(
       const rootValue = entity[localKey];
       if (rootValue === undefined || rootValue === null) continue;
       if (!data || typeof data !== 'object') continue;
-      const cache = new Map<string, Record<string, any>>();
-      cache.set(toKey(rootValue), data as Record<string, any>);
+      const cache = new Map<string, Record<string, unknown>>();
+      cache.set(toKey(rootValue), data as Record<string, unknown>);
       meta.relationHydration.set(relationName, cache);
       meta.relationCache.set(relationName, Promise.resolve(cache));
       continue;
@@ -210,7 +209,7 @@ const populateHydrationCache = <TTable extends TableDef>(
 
     if (relation.type === RelationKinds.BelongsTo) {
       const targetKey = relation.localKey || findPrimaryKey(relation.target);
-      const cache = new Map<string, Record<string, any>>();
+      const cache = new Map<string, Record<string, unknown>>();
       for (const item of data) {
         const pkValue = item[targetKey];
         if (pkValue === undefined || pkValue === null) continue;
@@ -232,18 +231,18 @@ const populateHydrationCache = <TTable extends TableDef>(
  * @returns The relation wrapper or undefined
  */
 const getRelationWrapper = (
-  meta: EntityMeta<any>,
+  meta: EntityMeta<TableDef>,
   relationName: string,
-  owner: any
-): HasManyCollection<any> | HasOneReference<any> | BelongsToReference<any> | ManyToManyCollection<any> | undefined => {
+  owner: unknown
+): HasManyCollection<unknown> | HasOneReference<unknown> | BelongsToReference<unknown> | ManyToManyCollection<unknown> | undefined => {
   if (meta.relationWrappers.has(relationName)) {
-    return meta.relationWrappers.get(relationName) as HasManyCollection<any>;
+    return meta.relationWrappers.get(relationName) as HasManyCollection<unknown>;
   }
 
   const relation = meta.table.relations[relationName];
   if (!relation) return undefined;
 
-  const wrapper = instantiateWrapper(meta, relationName, relation as any, owner);
+  const wrapper = instantiateWrapper(meta, relationName, relation, owner);
   if (wrapper) {
     meta.relationWrappers.set(relationName, wrapper);
   }
@@ -260,11 +259,11 @@ const getRelationWrapper = (
  * @returns The relation wrapper or undefined
  */
 const instantiateWrapper = (
-  meta: EntityMeta<any>,
+  meta: EntityMeta<TableDef>,
   relationName: string,
   relation: HasManyRelation | HasOneRelation | BelongsToRelation | BelongsToManyRelation,
-  owner: any
-): HasManyCollection<any> | HasOneReference<any> | BelongsToReference<any> | ManyToManyCollection<any> | undefined => {
+  owner: unknown
+): HasManyCollection<unknown> | HasOneReference<unknown> | BelongsToReference<unknown> | ManyToManyCollection<unknown> | undefined => {
   switch (relation.type) {
     case RelationKinds.HasOne: {
       const hasOne = relation as HasOneRelation;
@@ -280,7 +279,7 @@ const instantiateWrapper = (
         hasOne,
         meta.table,
         loader,
-        (row: Record<string, any>) => createEntityFromRow(meta.ctx, hasOne.target, row),
+        (row: Record<string, unknown>) => createEntityFromRow(meta.ctx, hasOne.target, row),
         localKey
       );
     }
@@ -298,7 +297,7 @@ const instantiateWrapper = (
         hasMany,
         meta.table,
         loader,
-        (row: Record<string, any>) => createEntityFromRow(meta.ctx, relation.target, row),
+        (row: Record<string, unknown>) => createEntityFromRow(meta.ctx, relation.target, row),
         localKey
       );
     }
@@ -316,7 +315,7 @@ const instantiateWrapper = (
         belongsTo,
         meta.table,
         loader,
-        (row: Record<string, any>) => createEntityFromRow(meta.ctx, relation.target, row),
+        (row: Record<string, unknown>) => createEntityFromRow(meta.ctx, relation.target, row),
         targetKey
       );
     }
@@ -334,7 +333,7 @@ const instantiateWrapper = (
         many,
         meta.table,
         loader,
-        (row: Record<string, any>) => createEntityFromRow(meta.ctx, relation.target, row),
+        (row: Record<string, unknown>) => createEntityFromRow(meta.ctx, relation.target, row),
         localKey
       );
     }

package/src/orm/execute.ts

@@ -8,7 +8,7 @@ import { EntityContext } from './entity-context.js';
 import { ExecutionContext } from './execution-context.js';
 import { HydrationContext } from './hydration-context.js';
 
-type Row = Record<string, any>;
+type Row = Record<string, unknown>;
 
 const flattenResults = (results: { columns: string[]; values: unknown[][] }[]): Row[] => {
   const rows: Row[] = [];
@@ -27,7 +27,7 @@ const flattenResults = (results: { columns: string[]; values: unknown[][] }[]):
 
 const executeWithEntityContext = async <TTable extends TableDef>(
   entityCtx: EntityContext,
-  qb: SelectQueryBuilder<any, TTable>
+  qb: SelectQueryBuilder<unknown, TTable>
 ): Promise<EntityInstance<TTable>[]> => {
   const ast = qb.getAST();
   const compiled = entityCtx.dialect.compileSelect(ast);
@@ -44,7 +44,7 @@ const executeWithEntityContext = async <TTable extends TableDef>(
 
 export async function executeHydrated<TTable extends TableDef>(
   session: OrmSession,
-  qb: SelectQueryBuilder<any, TTable>
+  qb: SelectQueryBuilder<unknown, TTable>
 ): Promise<EntityInstance<TTable>[]> {
   return executeWithEntityContext(session, qb);
 }
@@ -52,7 +52,7 @@ export async function executeHydrated<TTable extends TableDef>(
 export async function executeHydratedWithContexts<TTable extends TableDef>(
   _execCtx: ExecutionContext,
   hydCtx: HydrationContext,
-  qb: SelectQueryBuilder<any, TTable>
+  qb: SelectQueryBuilder<unknown, TTable>
 ): Promise<EntityInstance<TTable>[]> {
   const entityCtx = hydCtx.entityContext;
   if (!entityCtx) {

package/src/orm/hydration.ts

@@ -1,6 +1,10 @@
-import { HydrationPlan, HydrationRelationPlan } from '../core/hydration/types.js';
-import { RelationKinds } from '../schema/relation.js';
-import { isRelationAlias, makeRelationAlias } from '../query-builder/relation-alias.js';
+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
@@ -8,13 +12,13 @@ import { isRelationAlias, makeRelationAlias } from '../query-builder/relation-al
  * @param plan - Hydration plan
  * @returns Hydrated result objects with nested relations
  */
-export const hydrateRows = (rows: Record<string, any>[], plan?: HydrationPlan): Record<string, any>[] => {
+export const hydrateRows = (rows: Record<string, unknown>[], plan?: HydrationPlan): Record<string, unknown>[] => {
   if (!plan || !rows.length) return rows;
 
-  const rootMap = new Map<any, Record<string, any>>();
-  const relationIndex = new Map<any, Record<string, Set<any>>>();
+  const rootMap = new Map<unknown, Record<string, unknown>>();
+  const relationIndex = new Map<unknown, Record<string, Set<unknown>>>();
 
-  const getOrCreateParent = (row: Record<string, any>) => {
+  const getOrCreateParent = (row: Record<string, unknown>) => {
     const rootId = row[plan.rootPrimaryKey];
     if (rootId === undefined) return undefined;
 
@@ -25,7 +29,7 @@ export const hydrateRows = (rows: Record<string, any>[], plan?: HydrationPlan):
     return rootMap.get(rootId);
   };
 
-  const getRelationSeenSet = (rootId: any, relationName: string): Set<any> => {
+  const getRelationSeenSet = (rootId: unknown, relationName: string): Set<unknown> => {
     let byRelation = relationIndex.get(rootId);
     if (!byRelation) {
       byRelation = {};
@@ -34,7 +38,7 @@ export const hydrateRows = (rows: Record<string, any>[], plan?: HydrationPlan):
 
     let seen = byRelation[relationName];
     if (!seen) {
-      seen = new Set<any>();
+      seen = new Set<unknown>();
       byRelation[relationName] = seen;
     }
 
@@ -48,32 +52,32 @@ export const hydrateRows = (rows: Record<string, any>[], plan?: HydrationPlan):
     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 any[];
-      bucket.push(buildChild(row, rel));
-    }
+    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, any>, plan: HydrationPlan): Record<string, any> => {
-  const base: Record<string, any> = {};
+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));
@@ -82,15 +86,14 @@ const createBaseRow = (row: Record<string, any>, plan: HydrationPlan): Record<st
     base[key] = row[key];
   }
 
-  for (const rel of plan.relations) {
-    base[rel.name] = rel.type === RelationKinds.HasOne ? null : [];
-  }
-
+  for (const rel of plan.relations) {
+    base[rel.name] = rel.type === RelationKinds.HasOne ? null : [];
+  }
   return base;
 };
 
-const buildChild = (row: Record<string, any>, rel: HydrationRelationPlan): Record<string, any> => {
-  const child: Record<string, any> = {};
+const buildChild = (row: Record<string, unknown>, rel: HydrationRelationPlan): Record<string, unknown> => {
+  const child: Record<string, unknown> = {};
   for (const col of rel.columns) {
     const key = makeRelationAlias(rel.aliasPrefix, col);
     child[col] = row[key];
@@ -98,16 +101,16 @@ const buildChild = (row: Record<string, any>, rel: HydrationRelationPlan): Recor
 
   const pivot = buildPivot(row, rel);
   if (pivot) {
-    (child as any)._pivot = pivot;
+    (child as { _pivot: unknown })._pivot = pivot;
   }
 
   return child;
 };
 
-const buildPivot = (row: Record<string, any>, rel: HydrationRelationPlan): Record<string, any> | undefined => {
+const buildPivot = (row: Record<string, unknown>, rel: HydrationRelationPlan): Record<string, unknown> | undefined => {
   if (!rel.pivot) return undefined;
 
-  const pivot: Record<string, any> = {};
+  const pivot: Record<string, unknown> = {};
   for (const col of rel.pivot.columns) {
     const key = makeRelationAlias(rel.pivot.aliasPrefix, col);
     pivot[col] = row[key];

package/src/orm/identity-map.ts

@@ -8,7 +8,7 @@ export class IdentityMap {
     return this.buckets;
   }
 
-  getEntity(table: TableDef, pk: string | number): any | undefined {
+  getEntity(table: TableDef, pk: string | number): unknown | undefined {
     const bucket = this.buckets.get(table.name);
     return bucket?.get(this.toIdentityKey(pk))?.entity;
   }

package/src/orm/lazy-batch.ts

@@ -7,7 +7,7 @@ import type { QueryResult } from '../core/execution/db-executor.js';
 import { ColumnDef } from '../schema/column.js';
 import { findPrimaryKey } from '../query-builder/hydration-planner.js';
 
-type Rows = Record<string, any>[];
+type Rows = Record<string, unknown>[];
 
 const selectAllColumns = (table: TableDef): Record<string, ColumnDef> =>
   Object.entries(table.columns).reduce((acc, [name, def]) => {
@@ -20,7 +20,7 @@ const rowsFromResults = (results: QueryResult[]): Rows => {
   for (const result of results) {
     const { columns, values } = result;
     for (const valueRow of values) {
-      const row: Record<string, any> = {};
+      const row: Record<string, unknown> = {};
       columns.forEach((column, idx) => {
         row[column] = valueRow[idx];
       });
@@ -30,7 +30,7 @@ const rowsFromResults = (results: QueryResult[]): Rows => {
   return rows;
 };
 
-const executeQuery = async (ctx: EntityContext, qb: SelectQueryBuilder<any, TableDef<any>>): Promise<Rows> => {
+const executeQuery = async (ctx: EntityContext, qb: SelectQueryBuilder<unknown, TableDef>): Promise<Rows> => {
   const compiled = ctx.dialect.compileSelect(qb.getAST());
   const results = await ctx.executor.executeSql(compiled.sql, compiled.params);
   return rowsFromResults(results);
@@ -86,7 +86,7 @@ export const loadHasOneRelation = async (
   rootTable: TableDef,
   _relationName: string,
   relation: HasOneRelation
-): Promise<Map<string, Record<string, any>>> => {
+): Promise<Map<string, Record<string, unknown>>> => {
   const localKey = relation.localKey || findPrimaryKey(rootTable);
   const roots = ctx.getEntitiesForTable(rootTable);
   const keys = new Set<unknown>();
@@ -110,7 +110,7 @@ export const loadHasOneRelation = async (
   qb.where(inList(fkColumn, Array.from(keys) as (string | number | LiteralNode)[]));
 
   const rows = await executeQuery(ctx, qb);
-  const lookup = new Map<string, Record<string, any>>();
+  const lookup = new Map<string, Record<string, unknown>>();
 
   for (const row of rows) {
     const fkValue = row[relation.foreignKey];
@@ -129,7 +129,7 @@ export const loadBelongsToRelation = async (
   rootTable: TableDef,
   _relationName: string,
   relation: BelongsToRelation
-): Promise<Map<string, Record<string, any>>> => {
+): Promise<Map<string, Record<string, unknown>>> => {
   const roots = ctx.getEntitiesForTable(rootTable);
   const foreignKeys = new Set<unknown>();
 
@@ -152,7 +152,7 @@ export const loadBelongsToRelation = async (
 
   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>>();
+  const map = new Map<string, Record<string, unknown>>();
 
   for (const row of rows) {
     const keyValue = row[targetKey];
@@ -192,7 +192,7 @@ export const loadBelongsToManyRelation = async (
   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 rootLookup = new Map<string, { targetId: unknown; pivot: Record<string, unknown> }[]>();
   const targetIds = new Set<unknown>();
 
   for (const pivot of pivotRows) {
@@ -222,7 +222,7 @@ export const loadBelongsToManyRelation = async (
   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>>();
+  const targetMap = new Map<string, Record<string, unknown>>();
 
   for (const row of targetRows) {
     const pkValue = row[targetKey];