metal-orm 1.0.41 → 1.0.43

package/src/core/dialect/base/function-table-formatter.ts

@@ -1,4 +1,5 @@
 import { CompilerContext } from '../abstract.js';
+import { OperandNode } from '../../ast/expression.js';
 import { SqlDialectBase } from './sql-dialect.js';
 
 export interface FunctionTableNode {
@@ -57,9 +58,9 @@ export class FunctionTableFormatter {
    */
   private static formatArgs(fn: FunctionTableNode, ctx?: CompilerContext, dialect?: SqlDialectBase): string {
     return (fn.args || [])
-      .map((a: any) => {
+      .map((a: OperandNode) => {
         if (ctx && dialect) {
-          return (dialect as any).compileOperand(a, ctx);
+          return (dialect as unknown as { compileOperand(n: OperandNode, c: CompilerContext): string }).compileOperand(a, ctx);
         }
         return String(a);
       })

package/src/core/dialect/base/join-compiler.ts

@@ -1,5 +1,7 @@
 import { CompilerContext } from '../abstract.js';
 import { JoinNode } from '../../ast/join.js';
+import { TableSourceNode } from '../../ast/query.js';
+import { ExpressionNode } from '../../ast/expression.js';
 
 /**
  * Compiler for JOIN clauses in SELECT statements.
@@ -9,12 +11,12 @@ export class JoinCompiler {
   static compileJoins(
     joins: JoinNode[] | undefined,
     ctx: CompilerContext,
-    compileFrom: (from: any, ctx: CompilerContext) => string,
-    compileExpression: (expr: any, ctx: CompilerContext) => string
+    compileFrom: (from: TableSourceNode, ctx: CompilerContext) => string,
+    compileExpression: (expr: ExpressionNode, ctx: CompilerContext) => string
   ): string {
     if (!joins || joins.length === 0) return '';
     const parts = joins.map(j => {
-      const table = compileFrom(j.table as any, ctx);
+      const table = compileFrom(j.table, ctx);
       const cond = compileExpression(j.condition, ctx);
       return `${j.kind} JOIN ${table} ON ${cond}`;
     });

package/src/core/dialect/base/returning-strategy.ts

@@ -35,6 +35,7 @@ export class NoReturningStrategy implements ReturningStrategy {
    * @throws Error indicating RETURNING is not supported.
    */
   compileReturning(returning: ColumnNode[] | undefined, _ctx: CompilerContext): string {
+    void _ctx;
     if (!returning || returning.length === 0) return '';
     throw new Error('RETURNING is not supported by this dialect.');
   }

package/src/core/dialect/base/sql-dialect.ts

@@ -11,7 +11,7 @@ import {
   OrderByNode,
   TableNode
 } from '../../ast/query.js';
-import { ColumnNode } from '../../ast/expression.js';
+import { ColumnNode, OperandNode } from '../../ast/expression.js';
 import { FunctionTableFormatter } from './function-table-formatter.js';
 import { PaginationStrategy, StandardLimitOffsetPagination } from './pagination-strategy.js';
 import { CteCompiler } from './cte-compiler.js';
@@ -134,7 +134,7 @@ export abstract class SqlDialectBase extends Dialect {
   }
 
   private compileUpdateAssignments(
-    assignments: { column: ColumnNode; value: any }[],
+    assignments: { column: ColumnNode; value: OperandNode }[],
     table: TableNode,
     ctx: CompilerContext
   ): string {
@@ -190,7 +190,7 @@ export abstract class SqlDialectBase extends Dialect {
   }
 
   protected compileFrom(ast: SelectQueryNode['from'], ctx?: CompilerContext): string {
-    const tableSource = ast as any;
+    const tableSource = ast;
     if (tableSource.type === 'FunctionTable') {
       return this.compileFunctionTable(tableSource, ctx);
     }

package/src/core/dialect/mssql/functions.ts

@@ -1,5 +1,4 @@
 import { StandardFunctionStrategy } from '../../functions/standard-strategy.js';
-import { FunctionRenderContext } from '../../functions/types.js';
 import { LiteralNode } from '../../ast/expression.js';
 
 export class MssqlFunctionStrategy extends StandardFunctionStrategy {
@@ -84,27 +83,27 @@ export class MssqlFunctionStrategy extends StandardFunctionStrategy {
             return `DATEPART(dw, ${compiledArgs[0]})`;
         });
 
-        this.add('WEEK_OF_YEAR', ({ compiledArgs }) => {
-            if (compiledArgs.length !== 1) throw new Error('WEEK_OF_YEAR expects 1 argument');
-            return `DATEPART(wk, ${compiledArgs[0]})`;
-        });
-
-        this.add('DATE_TRUNC', ({ node, compiledArgs }) => {
-            if (compiledArgs.length !== 2) throw new Error('DATE_TRUNC expects 2 arguments (part, date)');
-            const [, date] = compiledArgs;
-            const partArg = node.args[0] as LiteralNode;
-            const partClean = String(partArg.value).replace(/['"]/g, '').toLowerCase();
-            // SQL Server 2022+ has DATETRUNC
-            return `DATETRUNC(${partClean}, ${date})`;
-        });
-
-        this.add('GROUP_CONCAT', ctx => {
-            const arg = ctx.compiledArgs[0];
-            const separatorOperand = this.getGroupConcatSeparatorOperand(ctx);
-            const separator = ctx.compileOperand(separatorOperand);
-            const orderClause = this.buildOrderByExpression(ctx);
-            const withinGroup = orderClause ? ` WITHIN GROUP (${orderClause})` : '';
-            return `STRING_AGG(${arg}, ${separator})${withinGroup}`;
-        });
-    }
-}
+        this.add('WEEK_OF_YEAR', ({ compiledArgs }) => {
+            if (compiledArgs.length !== 1) throw new Error('WEEK_OF_YEAR expects 1 argument');
+            return `DATEPART(wk, ${compiledArgs[0]})`;
+        });
+
+        this.add('DATE_TRUNC', ({ node, compiledArgs }) => {
+            if (compiledArgs.length !== 2) throw new Error('DATE_TRUNC expects 2 arguments (part, date)');
+            const [, date] = compiledArgs;
+            const partArg = node.args[0] as LiteralNode;
+            const partClean = String(partArg.value).replace(/['"]/g, '').toLowerCase();
+            // SQL Server 2022+ has DATETRUNC
+            return `DATETRUNC(${partClean}, ${date})`;
+        });
+
+        this.add('GROUP_CONCAT', ctx => {
+            const arg = ctx.compiledArgs[0];
+            const separatorOperand = this.getGroupConcatSeparatorOperand(ctx);
+            const separator = ctx.compileOperand(separatorOperand);
+            const orderClause = this.buildOrderByExpression(ctx);
+            const withinGroup = orderClause ? ` WITHIN GROUP (${orderClause})` : '';
+            return `STRING_AGG(${arg}, ${separator})${withinGroup}`;
+        });
+    }
+}

package/src/core/dialect/mssql/index.ts

@@ -1,10 +1,7 @@
 import { CompilerContext } from '../abstract.js';
 import {
   SelectQueryNode,
-  DeleteQueryNode,
-  TableSourceNode,
-  DerivedTableNode,
-  OrderByNode
+  DeleteQueryNode
 } from '../../ast/query.js';
 import { JsonPathNode } from '../../ast/expression.js';
 import { MssqlFunctionStrategy } from './functions.js';

package/src/core/dialect/mysql/functions.ts

@@ -1,5 +1,4 @@
 import { StandardFunctionStrategy } from '../../functions/standard-strategy.js';
-import { FunctionRenderContext } from '../../functions/types.js';
 import { LiteralNode } from '../../ast/expression.js';
 
 export class MysqlFunctionStrategy extends StandardFunctionStrategy {

package/src/core/dialect/postgres/functions.ts

@@ -1,5 +1,4 @@
 import { StandardFunctionStrategy } from '../../functions/standard-strategy.js';
-import { FunctionRenderContext } from '../../functions/types.js';
 import { LiteralNode } from '../../ast/expression.js';
 
 export class PostgresFunctionStrategy extends StandardFunctionStrategy {
@@ -69,36 +68,36 @@ export class PostgresFunctionStrategy extends StandardFunctionStrategy {
             return `TO_CHAR(${date}, ${format})`;
         });
 
-        this.add('END_OF_MONTH', ({ compiledArgs }) => {
-            if (compiledArgs.length !== 1) throw new Error('END_OF_MONTH expects 1 argument');
-            return `(date_trunc('month', ${compiledArgs[0]}) + interval '1 month' - interval '1 day')::DATE`;
-        });
-
-        this.add('DAY_OF_WEEK', ({ compiledArgs }) => {
-            if (compiledArgs.length !== 1) throw new Error('DAY_OF_WEEK expects 1 argument');
-            return `EXTRACT(DOW FROM ${compiledArgs[0]})`;
-        });
-
-        this.add('WEEK_OF_YEAR', ({ compiledArgs }) => {
-            if (compiledArgs.length !== 1) throw new Error('WEEK_OF_YEAR expects 1 argument');
-            return `EXTRACT(WEEK FROM ${compiledArgs[0]})`;
-        });
-
-        this.add('DATE_TRUNC', ({ node, compiledArgs }) => {
-            if (compiledArgs.length !== 2) throw new Error('DATE_TRUNC expects 2 arguments (part, date)');
-            const [, date] = compiledArgs;
-            const partArg = node.args[0] as LiteralNode;
-            const partClean = String(partArg.value).replace(/['"]/g, '').toLowerCase();
-            return `DATE_TRUNC('${partClean}', ${date})`;
-        });
-
-        this.add('GROUP_CONCAT', ctx => {
-            const arg = ctx.compiledArgs[0];
-            const orderClause = this.buildOrderByExpression(ctx);
-            const orderSegment = orderClause ? ` ${orderClause}` : '';
-            const separatorOperand = this.getGroupConcatSeparatorOperand(ctx);
-            const separator = ctx.compileOperand(separatorOperand);
-            return `STRING_AGG(${arg}, ${separator}${orderSegment})`;
-        });
-    }
-}
+        this.add('END_OF_MONTH', ({ compiledArgs }) => {
+            if (compiledArgs.length !== 1) throw new Error('END_OF_MONTH expects 1 argument');
+            return `(date_trunc('month', ${compiledArgs[0]}) + interval '1 month' - interval '1 day')::DATE`;
+        });
+
+        this.add('DAY_OF_WEEK', ({ compiledArgs }) => {
+            if (compiledArgs.length !== 1) throw new Error('DAY_OF_WEEK expects 1 argument');
+            return `EXTRACT(DOW FROM ${compiledArgs[0]})`;
+        });
+
+        this.add('WEEK_OF_YEAR', ({ compiledArgs }) => {
+            if (compiledArgs.length !== 1) throw new Error('WEEK_OF_YEAR expects 1 argument');
+            return `EXTRACT(WEEK FROM ${compiledArgs[0]})`;
+        });
+
+        this.add('DATE_TRUNC', ({ node, compiledArgs }) => {
+            if (compiledArgs.length !== 2) throw new Error('DATE_TRUNC expects 2 arguments (part, date)');
+            const [, date] = compiledArgs;
+            const partArg = node.args[0] as LiteralNode;
+            const partClean = String(partArg.value).replace(/['"]/g, '').toLowerCase();
+            return `DATE_TRUNC('${partClean}', ${date})`;
+        });
+
+        this.add('GROUP_CONCAT', ctx => {
+            const arg = ctx.compiledArgs[0];
+            const orderClause = this.buildOrderByExpression(ctx);
+            const orderSegment = orderClause ? ` ${orderClause}` : '';
+            const separatorOperand = this.getGroupConcatSeparatorOperand(ctx);
+            const separator = ctx.compileOperand(separatorOperand);
+            return `STRING_AGG(${arg}, ${separator}${orderSegment})`;
+        });
+    }
+}

package/src/core/dialect/postgres/index.ts

@@ -36,6 +36,7 @@ export class PostgresDialect extends SqlDialectBase {
   }
 
   protected compileReturning(returning: ColumnNode[] | undefined, ctx: CompilerContext): string {
+    void ctx;
     if (!returning || returning.length === 0) return '';
     const columns = this.formatReturningColumns(returning);
     return ` RETURNING ${columns}`;

package/src/core/dialect/sqlite/functions.ts

@@ -1,12 +1,11 @@
-import { StandardFunctionStrategy } from '../../functions/standard-strategy.js';
-import { FunctionRenderContext } from '../../functions/types.js';
-import { LiteralNode } from '../../ast/expression.js';
-
-export class SqliteFunctionStrategy extends StandardFunctionStrategy {
-    constructor() {
-        super();
-        this.registerOverrides();
-    }
+import { StandardFunctionStrategy } from '../../functions/standard-strategy.js';
+import { LiteralNode } from '../../ast/expression.js';
+
+export class SqliteFunctionStrategy extends StandardFunctionStrategy {
+    constructor() {
+        super();
+        this.registerOverrides();
+    }
 
     private registerOverrides() {
         // Override Standard/Abstract definitions with SQLite specifics
@@ -110,13 +109,13 @@ export class SqliteFunctionStrategy extends StandardFunctionStrategy {
                 return `date(${date})`;
             }
             return `date(${date}, 'start of ${partClean}')`;
-        });
-
-        this.add('GROUP_CONCAT', ctx => {
-            const arg = ctx.compiledArgs[0];
-            const separatorOperand = this.getGroupConcatSeparatorOperand(ctx);
-            const separator = ctx.compileOperand(separatorOperand);
-            return `GROUP_CONCAT(${arg}, ${separator})`;
-        });
-    }
-}
+        });
+
+        this.add('GROUP_CONCAT', ctx => {
+            const arg = ctx.compiledArgs[0];
+            const separatorOperand = this.getGroupConcatSeparatorOperand(ctx);
+            const separator = ctx.compileOperand(separatorOperand);
+            return `GROUP_CONCAT(${arg}, ${separator})`;
+        });
+    }
+}

package/src/core/dialect/sqlite/index.ts

@@ -37,10 +37,12 @@ export class SqliteDialect extends SqlDialectBase {
   }
 
   protected compileQualifiedColumn(column: ColumnNode, _table: TableNode): string {
+    void _table;
     return this.quoteIdentifier(column.name);
   }
 
   protected compileReturning(returning: ColumnNode[] | undefined, ctx: CompilerContext): string {
+    void ctx;
     if (!returning || returning.length === 0) return '';
     const columns = this.formatReturningColumns(returning);
     return ` RETURNING ${columns}`;

package/src/core/execution/db-executor.ts

@@ -36,7 +36,7 @@ export function rowsToQueryResult(
   }
 
   const columns = Object.keys(rows[0]);
-  const values = rows.map(row => columns.map(c => (row as any)[c]));
+  const values = rows.map(row => columns.map(c => row[c]));
   return { columns, values };
 }
 

package/src/core/execution/executors/mysql-executor.ts

@@ -8,7 +8,7 @@ export interface MysqlClientLike {
   query(
     sql: string,
     params?: unknown[]
-  ): Promise<[any, any?]>; // rows, metadata
+  ): Promise<[unknown, unknown?]>; // rows, metadata
   beginTransaction?(): Promise<void>;
   commit?(): Promise<void>;
   rollback?(): Promise<void>;
@@ -27,7 +27,7 @@ export function createMysqlExecutor(
       transactions: supportsTransactions,
     },
     async executeSql(sql, params) {
-      const [rows] = await client.query(sql, params as any[]);
+      const [rows] = await client.query(sql, params);
 
       if (!Array.isArray(rows)) {
         // e.g. insert/update returning only headers, treat as no rows

package/src/core/execution/executors/postgres-executor.ts

@@ -16,7 +16,7 @@ export function createPostgresExecutor(
 ): DbExecutor {
   return createExecutorFromQueryRunner({
     async query(sql, params) {
-      const { rows } = await client.query(sql, params as any[]);
+      const { rows } = await client.query(sql, params);
       return rows;
     },
     async beginTransaction() {

package/src/core/execution/pooling/pool.ts

@@ -49,6 +49,7 @@ export class Pool<TResource> {
             }, interval);
 
             // Best-effort: avoid keeping the event loop alive.
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
             (this.reapTimer as any).unref?.();
         }
 
@@ -100,6 +101,7 @@ export class Pool<TResource> {
                 if (idx >= 0) this.waiters.splice(idx, 1);
                 waiter.reject(new Error('Pool acquire timeout'));
             }, timeout);
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
             (timer as any).unref?.();
         }
 

package/src/core/functions/datetime.ts

@@ -6,7 +6,7 @@ import { FunctionNode, OperandNode, isOperandNode } from '../ast/expression.js';
 
 type OperandInput = OperandNode | ColumnDef | string | number | boolean | null;
 
-const isColumnDef = (val: any): val is ColumnDef => !!val && typeof val === 'object' && 'type' in val && 'name' in val;
+const isColumnDef = (val: unknown): val is ColumnDef => !!val && typeof val === 'object' && 'type' in val && 'name' in val;
 
 const toOperand = (input: OperandInput): OperandNode => {
     if (isOperandNode(input)) return input;

package/src/core/functions/numeric.ts

@@ -6,7 +6,7 @@ import { FunctionNode, OperandNode, isOperandNode } from '../ast/expression.js';
 
 type OperandInput = OperandNode | ColumnDef | string | number | boolean | null;
 
-const isColumnDef = (val: any): val is ColumnDef => !!val && typeof val === 'object' && 'type' in val && 'name' in val;
+const isColumnDef = (val: unknown): val is ColumnDef => !!val && typeof val === 'object' && 'type' in val && 'name' in val;
 
 const toOperand = (input: OperandInput): OperandNode => {
     if (isOperandNode(input)) return input;

package/src/core/functions/text.ts

@@ -6,7 +6,7 @@ import { FunctionNode, OperandNode, isOperandNode } from '../ast/expression.js';
 
 type OperandInput = OperandNode | ColumnDef | string | number | boolean | null;
 
-const isColumnDef = (val: any): val is ColumnDef => !!val && typeof val === 'object' && 'type' in val && 'name' in val;
+const isColumnDef = (val: unknown): val is ColumnDef => !!val && typeof val === 'object' && 'type' in val && 'name' in val;
 
 const toOperand = (input: OperandInput): OperandNode => {
   if (isOperandNode(input)) return input;

package/src/decorators/bootstrap.ts

@@ -18,11 +18,14 @@ import {
   RelationMetadata
 } from '../orm/entity-metadata.js';
 
+import { tableRef, type TableRef } from '../schema/table.js';
+
 const isTableDef = (value: unknown): value is TableDef => {
   return typeof value === 'object' && value !== null && 'columns' in (value as TableDef);
 };
 
 const unwrapTarget = (target: EntityOrTableTargetResolver): EntityOrTableTarget => {
+  // eslint-disable-next-line @typescript-eslint/no-unsafe-function-type
   if (typeof target === 'function' && (target as Function).prototype === undefined) {
     return (target as () => EntityOrTableTarget)();
   }
@@ -31,22 +34,22 @@ const unwrapTarget = (target: EntityOrTableTargetResolver): EntityOrTableTarget
 
 const resolveTableTarget = (
   target: EntityOrTableTargetResolver,
-  tableMap: Map<EntityConstructor<any>, TableDef>
+  tableMap: Map<EntityConstructor, TableDef>
 ): TableDef => {
   const resolved = unwrapTarget(target);
   if (isTableDef(resolved)) {
     return resolved;
   }
-  const table = tableMap.get(resolved as EntityConstructor<any>);
+  const table = tableMap.get(resolved as EntityConstructor);
   if (!table) {
-    throw new Error(`Entity '${(resolved as EntityConstructor<any>).name}' is not registered with decorators`);
+    throw new Error(`Entity '${(resolved as EntityConstructor).name}' is not registered with decorators`);
   }
   return table;
 };
 
 const buildRelationDefinitions = (
   meta: { relations: Record<string, RelationMetadata> },
-  tableMap: Map<EntityConstructor<any>, TableDef>
+  tableMap: Map<EntityConstructor, TableDef>
 ): Record<string, RelationDef> => {
   const relations: Record<string, RelationDef> = {};
 
@@ -103,7 +106,7 @@ const buildRelationDefinitions = (
 
 export const bootstrapEntities = (): TableDef[] => {
   const metas = getAllEntityMetadata();
-  const tableMap = new Map<EntityConstructor<any>, TableDef>();
+  const tableMap = new Map<EntityConstructor, TableDef>();
 
   for (const meta of metas) {
     const table = buildTableDef(meta);
@@ -119,7 +122,7 @@ export const bootstrapEntities = (): TableDef[] => {
   return metas.map(meta => meta.table!) as TableDef[];
 };
 
-export const getTableDefFromEntity = <TTable extends TableDef = TableDef>(ctor: EntityConstructor<any>): TTable | undefined => {
+export const getTableDefFromEntity = <TTable extends TableDef = TableDef>(ctor: EntityConstructor): TTable | undefined => {
   const meta = getEntityMetadata(ctor);
   if (!meta) return undefined;
   if (!meta.table) {
@@ -129,11 +132,27 @@ export const getTableDefFromEntity = <TTable extends TableDef = TableDef>(ctor:
 };
 
 export const selectFromEntity = <TTable extends TableDef = TableDef>(
-  ctor: EntityConstructor<any>
-): SelectQueryBuilder<any, TTable> => {
+  ctor: EntityConstructor
+): SelectQueryBuilder<unknown, TTable> => {
   const table = getTableDefFromEntity(ctor);
   if (!table) {
     throw new Error(`Entity '${ctor.name}' is not registered with decorators or has not been bootstrapped`);
   }
   return new SelectQueryBuilder(table as TTable);
 };
+
+/**
+ * Public API: opt-in ergonomic entity reference (decorator-level).
+ *
+ * Lazily bootstraps entity metadata (via getTableDefFromEntity) and returns a
+ * `tableRef(...)`-style proxy so users can write `u.id` instead of `u.columns.id`.
+ */
+export const entityRef = <TTable extends TableDef = TableDef>(
+  ctor: EntityConstructor
+): TableRef<TTable> => {
+  const table = getTableDefFromEntity<TTable>(ctor);
+  if (!table) {
+    throw new Error(`Entity '${ctor.name}' is not registered with decorators or has not been bootstrapped`);
+  }
+  return tableRef(table);
+};

package/src/decorators/column.ts

@@ -9,7 +9,6 @@ import {
   DualModePropertyDecorator,
   getOrCreateMetadataBag,
   isStandardDecoratorContext,
-  registerInitializer,
   StandardDecoratorContext
 } from './decorator-metadata.js';
 
@@ -21,7 +20,7 @@ export interface ColumnOptions {
   tsType?: ColumnDef['tsType'];
 }
 
-export type ColumnInput = ColumnOptions | ColumnDef<any, any>;
+export type ColumnInput = ColumnOptions | ColumnDef;
 
 const normalizeColumnInput = (input: ColumnInput): ColumnDefLike => {
   const asOptions = input as ColumnOptions;
@@ -60,8 +59,8 @@ const resolveConstructor = (target: unknown): EntityConstructor | undefined => {
     return target as EntityConstructor;
   }
 
-  if (target && typeof (target as any).constructor === 'function') {
-    return (target as any).constructor as EntityConstructor;
+  if (target && typeof (target as { constructor: unknown }).constructor === 'function') {
+    return (target as { constructor: unknown }).constructor as EntityConstructor;
   }
 
   return undefined;
@@ -88,13 +87,6 @@ const registerColumnFromContext = (
     bag.columns.push({ propertyName, column: { ...column } });
   }
 
-  registerInitializer(context, function () {
-    const ctor = resolveConstructor(this);
-    if (!ctor) {
-      return;
-    }
-    registerColumn(ctor, propertyName, column);
-  });
 };
 
 export function Column(definition: ColumnInput) {

package/src/decorators/decorator-metadata.ts

@@ -4,7 +4,6 @@ export interface StandardDecoratorContext {
   kind: string;
   name?: string | symbol;
   metadata?: Record<PropertyKey, unknown>;
-  addInitializer?(initializer: (this: unknown) => void): void;
   static?: boolean;
   private?: boolean;
 }
@@ -15,7 +14,9 @@ export interface DualModePropertyDecorator {
 }
 
 export interface DualModeClassDecorator {
+  // eslint-disable-next-line @typescript-eslint/no-unsafe-function-type
   <TFunction extends Function>(value: TFunction): void | TFunction;
+  // eslint-disable-next-line @typescript-eslint/no-unsafe-function-type
   <TFunction extends Function>(value: TFunction, context: StandardDecoratorContext): void | TFunction;
 }
 
@@ -27,7 +28,7 @@ export interface DecoratorMetadataBag {
 const METADATA_KEY = 'metal-orm:decorators';
 
 export const isStandardDecoratorContext = (value: unknown): value is StandardDecoratorContext => {
-  return typeof value === 'object' && value !== null && 'kind' in (value as any);
+  return typeof value === 'object' && value !== null && 'kind' in (value as object);
 };
 
 export const getOrCreateMetadataBag = (context: StandardDecoratorContext): DecoratorMetadataBag => {
@@ -44,10 +45,3 @@ export const getOrCreateMetadataBag = (context: StandardDecoratorContext): Decor
 export const readMetadataBag = (context: StandardDecoratorContext): DecoratorMetadataBag | undefined => {
   return context.metadata?.[METADATA_KEY] as DecoratorMetadataBag | undefined;
 };
-
-export const registerInitializer = (
-  context: StandardDecoratorContext,
-  initializer: (this: unknown) => void
-): void => {
-  context.addInitializer?.(initializer);
-};

package/src/decorators/entity.ts

@@ -1,4 +1,5 @@
 import { TableHooks } from '../schema/table.js';
+import { RelationKinds } from '../schema/relation.js';
 import {
   addColumnMetadata,
   addRelationMetadata,
@@ -22,7 +23,7 @@ const toSnakeCase = (value: string): string => {
     .toLowerCase();
 };
 
-const deriveTableNameFromConstructor = (ctor: Function): string => {
+const deriveTableNameFromConstructor = (ctor: EntityConstructor<unknown>): string => {
   const fallback = 'unknown';
   const rawName = ctor.name || fallback;
   const strippedName = rawName.replace(/Entity$/i, '');
@@ -50,14 +51,29 @@ export function Entity(options: EntityOptions = {}) {
       if (bag) {
         const meta = ensureEntityMetadata(ctor);
         for (const entry of bag.columns) {
-          if (!meta.columns[entry.propertyName]) {
-            addColumnMetadata(ctor, entry.propertyName, { ...entry.column });
+          if (meta.columns[entry.propertyName]) {
+            throw new Error(
+              `Column '${entry.propertyName}' is already defined on entity '${ctor.name}'.`
+            );
           }
+          addColumnMetadata(ctor, entry.propertyName, { ...entry.column });
         }
         for (const entry of bag.relations) {
-          if (!meta.relations[entry.propertyName]) {
-            addRelationMetadata(ctor, entry.propertyName, entry.relation);
+          if (meta.relations[entry.propertyName]) {
+            throw new Error(
+              `Relation '${entry.propertyName}' is already defined on entity '${ctor.name}'.`
+            );
           }
+          const relationCopy =
+            entry.relation.kind === RelationKinds.BelongsToMany
+              ? {
+                ...entry.relation,
+                defaultPivotColumns: entry.relation.defaultPivotColumns
+                  ? [...entry.relation.defaultPivotColumns]
+                  : undefined
+              }
+              : { ...entry.relation };
+          addRelationMetadata(ctor, entry.propertyName, relationCopy);
         }
       }
     }

package/src/decorators/relations.ts

@@ -9,7 +9,6 @@ import {
   DualModePropertyDecorator,
   getOrCreateMetadataBag,
   isStandardDecoratorContext,
-  registerInitializer,
   StandardDecoratorContext
 } from './decorator-metadata.js';
 
@@ -54,8 +53,8 @@ const resolveConstructor = (instanceOrCtor: unknown): EntityConstructor | undefi
   if (typeof instanceOrCtor === 'function') {
     return instanceOrCtor as EntityConstructor;
   }
-  if (instanceOrCtor && typeof (instanceOrCtor as any).constructor === 'function') {
-    return (instanceOrCtor as any).constructor as EntityConstructor;
+  if (instanceOrCtor && typeof (instanceOrCtor as { constructor: new (...args: unknown[]) => unknown }).constructor === 'function') {
+    return (instanceOrCtor as { constructor: new (...args: unknown[]) => unknown }).constructor as EntityConstructor;
   }
   return undefined;
 };
@@ -80,14 +79,6 @@ const createFieldDecorator = (
       if (!bag.relations.some(entry => entry.propertyName === propertyName)) {
         bag.relations.push({ propertyName, relation: relationMetadata });
       }
-
-      registerInitializer(ctx, function () {
-        const ctor = resolveConstructor(this);
-        if (!ctor) {
-          return;
-        }
-        registerRelation(ctor, propertyName, relationMetadata);
-      });
       return;
     }