metal-orm 1.0.15 → 1.0.16

package/src/codegen/naming-strategy.ts

@@ -0,0 +1,64 @@
+import type { TableNode, FunctionTableNode } from '../core/ast/query.js';
+import type { ColumnNode } from '../core/ast/expression.js';
+
+/**
+ * Strategy interface for converting database names to TypeScript identifiers
+ */
+export interface NamingStrategy {
+  /**
+   * Converts a table name to a TypeScript symbol name
+   * @param table - Table node, function table node, or name
+   * @returns Valid TypeScript identifier
+   */
+  tableToSymbol(table: TableNode | FunctionTableNode | string): string;
+
+  /**
+   * Converts a column reference to a property name
+   * @param column - Column node
+   * @returns Valid TypeScript property name
+   */
+  columnToProperty(column: ColumnNode): string;
+}
+
+/**
+ * Default naming strategy that maintains backward compatibility
+ * with the original capitalize() behavior
+ */
+export class DefaultNamingStrategy implements NamingStrategy {
+  /**
+   * Converts table names to TypeScript symbols
+   * @param table - Table node, function table node, or string name
+   * @returns Capitalized table name (handles schema-qualified names)
+   */
+  tableToSymbol(table: TableNode | FunctionTableNode | string): string {
+    const tableName = typeof table === 'string' ? table : table.name;
+
+    // Handle schema-qualified names (e.g., "auth.user" → "AuthUser")
+    if (tableName.includes('.')) {
+      return tableName.split('.')
+        .map(part => this.capitalize(part))
+        .join('');
+    }
+
+    return this.capitalize(tableName);
+  }
+
+  /**
+   * Converts column references to property names
+   * @param column - Column node
+   * @returns Column name as-is (for backward compatibility)
+   */
+  columnToProperty(column: ColumnNode): string {
+    return column.name;
+  }
+
+  /**
+   * Capitalizes the first letter of a string
+   * @param s - String to capitalize
+   * @returns Capitalized string
+   */
+  private capitalize(s: string): string {
+    if (!s) return s;
+    return s.charAt(0).toUpperCase() + s.slice(1);
+  }
+}

package/src/codegen/typescript.ts

@@ -1,7 +1,7 @@
-import { SelectQueryNode } from '../core/ast/query.js';
-import {
-  ExpressionNode,
-  OperandNode,
+import { SelectQueryNode } from '../core/ast/query.js';
+import {
+  ExpressionNode,
+  OperandNode,
   BinaryExpressionNode,
   LogicalExpressionNode,
   InExpressionNode,
@@ -20,18 +20,12 @@ import {
   visitExpression,
   visitOperand
 } from '../core/ast/expression.js';
-import { SQL_OPERATOR_REGISTRY } from '../core/sql/sql-operator-config.js';
-import { SqlOperator } from '../core/sql/sql.js';
-import { isRelationAlias } from '../query-builder/relation-alias.js';
-import { HydrationMetadata } from '../core/hydration/types.js';
-import { getJoinRelationName } from '../core/ast/join-metadata.js';
-
-/**
- * Capitalizes the first letter of a string
- * @param s - String to capitalize
- * @returns Capitalized string
- */
-const capitalize = (s: string) => s.charAt(0).toUpperCase() + s.slice(1);
+import { SQL_OPERATOR_REGISTRY } from '../core/sql/sql-operator-config.js';
+import { SqlOperator } from '../core/sql/sql.js';
+import { isRelationAlias } from '../query-builder/relation-alias.js';
+import { HydrationMetadata } from '../core/hydration/types.js';
+import { getJoinRelationName } from '../core/ast/join-metadata.js';
+import { NamingStrategy, DefaultNamingStrategy } from './naming-strategy.js';
 
 const assertNever = (value: never): never => {
   throw new Error(`Unhandled SQL operator: ${value}`);
@@ -41,6 +35,7 @@ const assertNever = (value: never): never => {
  * Generates TypeScript code from query AST nodes
  */
 export class TypeScriptGenerator implements ExpressionVisitor<string>, OperandVisitor<string> {
+  constructor(private namingStrategy: NamingStrategy = new DefaultNamingStrategy()) {}
 
   /**
    * Generates TypeScript code from a query AST
@@ -54,14 +49,14 @@ export class TypeScriptGenerator implements ExpressionVisitor<string>, OperandVi
     return lines.join('\n');
   }
 
-  /**
-   * Builds TypeScript method chain lines from query AST
-   * @param ast - Query AST
-   * @returns Array of TypeScript method chain lines
-   */
-  private buildSelectLines(ast: SelectQueryNode): string[] {
-    const lines: string[] = [];
-    const hydration = (ast.meta as HydrationMetadata | undefined)?.hydration;
+  /**
+   * Builds TypeScript method chain lines from query AST
+   * @param ast - Query AST
+   * @returns Array of TypeScript method chain lines
+   */
+  private buildSelectLines(ast: SelectQueryNode): string[] {
+    const lines: string[] = [];
+    const hydration = (ast.meta as HydrationMetadata | undefined)?.hydration;
     const hydratedRelations = new Set(hydration?.relations?.map(r => r.name) ?? []);
 
     const selections = ast.columns
@@ -77,29 +72,29 @@ export class TypeScriptGenerator implements ExpressionVisitor<string>, OperandVi
       lines.push(`  ${sel}${index < selections.length - 1 ? ',' : ''}`);
     });
     lines.push(`})`);
-    lines.push(`.from(${capitalize(ast.from.name)})`);
-
-    if (ast.distinct && ast.distinct.length) {
-      const cols = ast.distinct.map(c => `${capitalize(c.table)}.${c.name}`).join(', ');
-      lines.push(`.distinct(${cols})`);
-    }
-
-    ast.joins.forEach(join => {
-      const relationName = getJoinRelationName(join);
-      if (relationName && hydratedRelations.has(relationName)) {
-        return;
-      }
-
-      if (relationName) {
-        if (join.kind === 'INNER') {
-          lines.push(`.joinRelation('${relationName}')`);
-        } else {
-          lines.push(`.joinRelation('${relationName}', '${join.kind}')`);
-        }
-      } else {
-        const table = capitalize(join.table.name);
-        const cond = this.printExpression(join.condition);
-        let method = 'innerJoin';
+    lines.push(`.from(${this.namingStrategy.tableToSymbol(ast.from)})`);
+
+    if (ast.distinct && ast.distinct.length) {
+      const cols = ast.distinct.map(c => `${this.namingStrategy.tableToSymbol(c.table)}.${c.name}`).join(', ');
+      lines.push(`.distinct(${cols})`);
+    }
+
+    ast.joins.forEach(join => {
+      const relationName = getJoinRelationName(join);
+      if (relationName && hydratedRelations.has(relationName)) {
+        return;
+      }
+
+      if (relationName) {
+        if (join.kind === 'INNER') {
+          lines.push(`.joinRelation('${relationName}')`);
+        } else {
+          lines.push(`.joinRelation('${relationName}', '${join.kind}')`);
+        }
+      } else {
+        const table = this.namingStrategy.tableToSymbol(join.table);
+        const cond = this.printExpression(join.condition);
+        let method = 'innerJoin';
         if (join.kind === 'LEFT') method = 'leftJoin';
         if (join.kind === 'RIGHT') method = 'rightJoin';
         lines.push(`.${method}(${table}, ${cond})`);
@@ -121,7 +116,7 @@ export class TypeScriptGenerator implements ExpressionVisitor<string>, OperandVi
     }
 
     if (ast.groupBy && ast.groupBy.length) {
-      const cols = ast.groupBy.map(c => `${capitalize(c.table)}.${c.name}`).join(', ');
+      const cols = ast.groupBy.map(c => `${this.namingStrategy.tableToSymbol(c.table)}.${c.name}`).join(', ');
       lines.push(`.groupBy(${cols})`);
     }
 
@@ -131,7 +126,7 @@ export class TypeScriptGenerator implements ExpressionVisitor<string>, OperandVi
 
     if (ast.orderBy && ast.orderBy.length) {
       ast.orderBy.forEach(o => {
-        lines.push(`.orderBy(${capitalize(o.column.table)}.${o.column.name}, '${o.direction}')`);
+        lines.push(`.orderBy(${this.namingStrategy.tableToSymbol(o.column.table)}.${o.column.name}, '${o.direction}')`);
       });
     }
 
@@ -292,7 +287,7 @@ export class TypeScriptGenerator implements ExpressionVisitor<string>, OperandVi
    * @returns TypeScript code representation
    */
   private printColumnOperand(column: ColumnNode): string {
-    return `${capitalize(column.table)}.${column.name}`;
+    return `${this.namingStrategy.tableToSymbol(column.table)}.${column.name}`;
   }
 
   /**
@@ -321,7 +316,7 @@ export class TypeScriptGenerator implements ExpressionVisitor<string>, OperandVi
    * @returns TypeScript code representation
    */
   private printJsonPathOperand(json: JsonPathNode): string {
-    return `jsonPath(${capitalize(json.column.table)}.${json.column.name}, '${json.path}')`;
+    return `jsonPath(${this.namingStrategy.tableToSymbol(json.column.table)}.${json.column.name}, '${json.path}')`;
   }
 
   /**
@@ -364,14 +359,14 @@ export class TypeScriptGenerator implements ExpressionVisitor<string>, OperandVi
 
     if (node.partitionBy && node.partitionBy.length > 0) {
       const partitionClause =
-        'PARTITION BY ' + node.partitionBy.map(col => `${capitalize(col.table)}.${col.name}`).join(', ');
+        'PARTITION BY ' + node.partitionBy.map(col => `${this.namingStrategy.tableToSymbol(col.table)}.${col.name}`).join(', ');
       parts.push(partitionClause);
     }
 
     if (node.orderBy && node.orderBy.length > 0) {
       const orderClause =
         'ORDER BY ' +
-        node.orderBy.map(o => `${capitalize(o.column.table)}.${o.column.name} ${o.direction}`).join(', ');
+        node.orderBy.map(o => `${this.namingStrategy.tableToSymbol(o.column.table)}.${o.column.name} ${o.direction}`).join(', ');
       parts.push(orderClause);
     }
 

package/src/core/ddl/schema-generator.ts

@@ -1,6 +1,6 @@
 import type { TableDef, IndexDef, IndexColumn } from '../../schema/table.js';
 import type { ColumnDef, ForeignKeyReference } from '../../schema/column.js';
-import type { SchemaDialect, DialectName } from './schema-dialect.js';
+import type { SchemaDialect } from './schema-dialect.js';
 import { deriveIndexName } from './naming-strategy.js';
 import {
   formatLiteral,
@@ -10,6 +10,7 @@ import {
   Quoter
 } from './sql-writing.js';
 import { DatabaseTable, DatabaseColumn, ColumnDiff } from './schema-types.js';
+import { DialectName } from './schema-dialect.js';
 
 export interface SchemaGenerateResult {
   tableSql: string;
@@ -152,4 +153,4 @@ const orderTablesByDependencies = (tables: TableDef[]): TableDef[] => {
 };
 
 // Re-export DialectName for backward compatibility
-export { DialectName };
+export type { DialectName };

package/src/core/ddl/schema-introspect.ts

@@ -1,4 +1,4 @@
-import { DialectName } from './schema-generator.js';
+import type { DialectName } from './schema-generator.js';
 import { DatabaseSchema } from './schema-types.js';
 import { DbExecutor } from '../execution/db-executor.js';
 import type { IntrospectOptions, SchemaIntrospector, IntrospectContext } from './introspect/types.js';

package/src/core/dialect/abstract.ts

@@ -291,6 +291,34 @@ export abstract class Dialect
     this.registerDefaultExpressionCompilers();
   }
 
+  /**
+   * Creates a new Dialect instance (for testing purposes)
+   * @param functionStrategy - Optional function strategy
+   * @returns New Dialect instance
+   */
+  static create(functionStrategy?: FunctionStrategy): Dialect {
+    // Create a minimal concrete implementation for testing
+    class TestDialect extends Dialect {
+      protected readonly dialect: DialectName = 'sqlite';
+      quoteIdentifier(id: string): string {
+        return `"${id}"`;
+      }
+      protected compileSelectAst(): never {
+        throw new Error('Not implemented');
+      }
+      protected compileInsertAst(): never {
+        throw new Error('Not implemented');
+      }
+      protected compileUpdateAst(): never {
+        throw new Error('Not implemented');
+      }
+      protected compileDeleteAst(): never {
+        throw new Error('Not implemented');
+      }
+    }
+    return new TestDialect(functionStrategy);
+  }
+
   /**
    * Registers an expression compiler for a specific node type
    * @param type - Expression node type

package/src/decorators/column.ts

@@ -16,11 +16,20 @@ export interface ColumnOptions {
 export type ColumnInput = ColumnOptions | ColumnDef;
 
 const normalizeColumnInput = (input: ColumnInput): ColumnDefLike => {
+  const asOptions = input as ColumnOptions;
+  const asDefinition = input as ColumnDef;
   const column: ColumnDefLike = {
-    type: (input as ColumnOptions).type ?? (input as ColumnDef).type,
-    args: (input as ColumnOptions).args ?? (input as ColumnDef).args,
-    notNull: (input as ColumnOptions).notNull ?? (input as ColumnDef).notNull,
-    primary: (input as ColumnOptions).primary ?? (input as ColumnDef).primary
+    type: asOptions.type ?? asDefinition.type,
+    args: asOptions.args ?? asDefinition.args,
+    notNull: asOptions.notNull ?? asDefinition.notNull,
+    primary: asOptions.primary ?? asDefinition.primary,
+    unique: asDefinition.unique,
+    default: asDefinition.default,
+    autoIncrement: asDefinition.autoIncrement,
+    generated: asDefinition.generated,
+    check: asDefinition.check,
+    references: asDefinition.references,
+    comment: asDefinition.comment
   };
 
   if (!column.type) {

package/src/index.ts

@@ -23,13 +23,20 @@ export * from './core/functions/datetime.js';
 export * from './orm/als.js';
 export * from './orm/hydration.js';
 export * from './codegen/typescript.js';
-export * from './orm/orm-context.js';
+export * from './orm/orm-session.js';
+export * from './orm/orm.js';
 export * from './orm/entity.js';
 export * from './orm/lazy-batch.js';
 export * from './orm/relations/has-many.js';
 export * from './orm/relations/belongs-to.js';
 export * from './orm/relations/many-to-many.js';
 export * from './orm/execute.js';
+export * from './orm/entity-context.js';
+export * from './orm/execution-context.js';
+export * from './orm/hydration-context.js';
+export * from './orm/domain-event-bus.js';
+export * from './orm/runtime-types.js';
+export * from './orm/query-logger.js';
 
 // NEW: execution abstraction + helpers
 export * from './core/execution/db-executor.js';

package/src/orm/entity-context.ts

@@ -0,0 +1,30 @@
+import { Dialect } from '../core/dialect/abstract.js';
+import type { DbExecutor } from '../core/execution/db-executor.js';
+import { TableDef } from '../schema/table.js';
+import { RelationDef } from '../schema/relation.js';
+import { RelationChange, RelationKey, TrackedEntity } from './runtime-types.js';
+
+export interface EntityContext {
+    dialect: Dialect;
+    executor: DbExecutor;
+
+    getEntity(table: TableDef, pk: any): any;
+    setEntity(table: TableDef, pk: any, entity: any): void;
+
+    trackNew(table: TableDef, entity: any, pk?: any): void;
+    trackManaged(table: TableDef, pk: any, entity: any): void;
+
+    markDirty(entity: any): void;
+    markRemoved(entity: any): void;
+
+    getEntitiesForTable(table: TableDef): TrackedEntity[];
+
+    registerRelationChange(
+        root: any,
+        relationKey: RelationKey,
+        rootTable: TableDef,
+        relationName: string,
+        relation: RelationDef,
+        change: RelationChange<any>
+    ): void;
+}

package/src/orm/entity-meta.ts

@@ -1,5 +1,5 @@
 import { TableDef } from '../schema/table.js';
-import { OrmContext } from './orm-context.js';
+import { EntityContext } from './entity-context.js';
 import { RelationMap } from '../schema/types.js';
 
 export const ENTITY_META = Symbol('EntityMeta');
@@ -7,7 +7,7 @@ export const ENTITY_META = Symbol('EntityMeta');
 const toKey = (value: unknown): string => (value === null || value === undefined ? '' : String(value));
 
 export interface EntityMeta<TTable extends TableDef> {
-  ctx: OrmContext;
+  ctx: EntityContext;
   table: TTable;
   lazyRelations: (keyof RelationMap<TTable>)[];
   relationCache: Map<string, Promise<any>>;

package/src/orm/entity-metadata.ts

@@ -6,12 +6,7 @@ export type EntityConstructor = new (...args: any[]) => any;
 export type EntityOrTableTarget = EntityConstructor | TableDef;
 export type EntityOrTableTargetResolver = EntityOrTableTarget | (() => EntityOrTableTarget);
 
-export interface ColumnDefLike {
-  type: ColumnType;
-  args?: ColumnDef['args'];
-  primary?: boolean;
-  notNull?: boolean;
-}
+export type ColumnDefLike = Omit<ColumnDef, 'name' | 'table'>;
 
 interface BaseRelationMetadata {
   propertyKey: string;

package/src/orm/entity.ts

@@ -1,13 +1,13 @@
 import { TableDef } from '../schema/table.js';
-import { Entity, RelationMap, HasManyCollection, HasOneReference, BelongsToReference, ManyToManyCollection } from '../schema/types.js';
-import { OrmContext } from './orm-context.js';
-import { ENTITY_META, EntityMeta, getEntityMeta } from './entity-meta.js';
-import { DefaultHasManyCollection } from './relations/has-many.js';
-import { DefaultHasOneReference } from './relations/has-one.js';
-import { DefaultBelongsToReference } from './relations/belongs-to.js';
-import { DefaultManyToManyCollection } from './relations/many-to-many.js';
-import { HasManyRelation, HasOneRelation, BelongsToRelation, BelongsToManyRelation, RelationKinds } from '../schema/relation.js';
-import { loadHasManyRelation, loadHasOneRelation, loadBelongsToRelation, loadBelongsToManyRelation } from './lazy-batch.js';
+import { Entity, RelationMap, HasManyCollection, HasOneReference, BelongsToReference, ManyToManyCollection } from '../schema/types.js';
+import { EntityContext } from './entity-context.js';
+import { ENTITY_META, EntityMeta, getEntityMeta } from './entity-meta.js';
+import { DefaultHasManyCollection } from './relations/has-many.js';
+import { DefaultHasOneReference } from './relations/has-one.js';
+import { DefaultBelongsToReference } from './relations/belongs-to.js';
+import { DefaultManyToManyCollection } from './relations/many-to-many.js';
+import { HasManyRelation, HasOneRelation, BelongsToRelation, BelongsToManyRelation, RelationKinds } from '../schema/relation.js';
+import { loadHasManyRelation, loadHasOneRelation, loadBelongsToRelation, loadBelongsToManyRelation } from './lazy-batch.js';
 import { findPrimaryKey } from '../query-builder/hydration-planner.js';
 
 type Rows = Record<string, any>[];
@@ -45,7 +45,7 @@ export const createEntityProxy = <
   TTable extends TableDef,
   TLazy extends keyof RelationMap<TTable> = keyof RelationMap<TTable>
 >(
-  ctx: OrmContext,
+  ctx: EntityContext,
   table: TTable,
   row: Record<string, any>,
   lazyRelations: TLazy[] = [] as TLazy[]
@@ -105,7 +105,7 @@ export const createEntityProxy = <
 };
 
 export const createEntityFromRow = <TTable extends TableDef>(
-  ctx: OrmContext,
+  ctx: EntityContext,
   table: TTable,
   row: Record<string, any>,
   lazyRelations: (keyof RelationMap<TTable>)[] = []
@@ -129,60 +129,60 @@ export const createEntityFromRow = <TTable extends TableDef>(
 
 const toKey = (value: unknown): string => (value === null || value === undefined ? '' : String(value));
 
-  const populateHydrationCache = <TTable extends TableDef>(
-    entity: any,
-    row: Record<string, any>,
-    meta: EntityMeta<TTable>
-  ): void => {
-    for (const relationName of Object.keys(meta.table.relations)) {
-      const relation = meta.table.relations[relationName];
-      const data = row[relationName];
-      if (relation.type === RelationKinds.HasOne) {
-        const localKey = relation.localKey || findPrimaryKey(meta.table);
-        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>);
-        meta.relationHydration.set(relationName, cache);
-        meta.relationCache.set(relationName, Promise.resolve(cache));
-        continue;
-      }
-
-      if (!Array.isArray(data)) continue;
-
-      if (relation.type === RelationKinds.HasMany || relation.type === RelationKinds.BelongsToMany) {
-        const localKey = relation.localKey || findPrimaryKey(meta.table);
-        const rootValue = entity[localKey];
-        if (rootValue === undefined || rootValue === null) continue;
-        const cache = new Map<string, Rows>();
-        cache.set(toKey(rootValue), data as Rows);
+const populateHydrationCache = <TTable extends TableDef>(
+  entity: any,
+  row: Record<string, any>,
+  meta: EntityMeta<TTable>
+): void => {
+  for (const relationName of Object.keys(meta.table.relations)) {
+    const relation = meta.table.relations[relationName];
+    const data = row[relationName];
+    if (relation.type === RelationKinds.HasOne) {
+      const localKey = relation.localKey || findPrimaryKey(meta.table);
+      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>);
+      meta.relationHydration.set(relationName, cache);
+      meta.relationCache.set(relationName, Promise.resolve(cache));
+      continue;
+    }
+
+    if (!Array.isArray(data)) continue;
+
+    if (relation.type === RelationKinds.HasMany || relation.type === RelationKinds.BelongsToMany) {
+      const localKey = relation.localKey || findPrimaryKey(meta.table);
+      const rootValue = entity[localKey];
+      if (rootValue === undefined || rootValue === null) continue;
+      const cache = new Map<string, Rows>();
+      cache.set(toKey(rootValue), data as Rows);
+      meta.relationHydration.set(relationName, cache);
+      meta.relationCache.set(relationName, Promise.resolve(cache));
+      continue;
+    }
+
+    if (relation.type === RelationKinds.BelongsTo) {
+      const targetKey = relation.localKey || findPrimaryKey(relation.target);
+      const cache = new Map<string, Record<string, any>>();
+      for (const item of data) {
+        const pkValue = item[targetKey];
+        if (pkValue === undefined || pkValue === null) continue;
+        cache.set(toKey(pkValue), item);
+      }
+      if (cache.size) {
         meta.relationHydration.set(relationName, cache);
         meta.relationCache.set(relationName, Promise.resolve(cache));
-        continue;
-      }
-
-      if (relation.type === RelationKinds.BelongsTo) {
-        const targetKey = relation.localKey || findPrimaryKey(relation.target);
-        const cache = new Map<string, Record<string, any>>();
-        for (const item of data) {
-          const pkValue = item[targetKey];
-          if (pkValue === undefined || pkValue === null) continue;
-          cache.set(toKey(pkValue), item);
-        }
-        if (cache.size) {
-          meta.relationHydration.set(relationName, cache);
-          meta.relationCache.set(relationName, Promise.resolve(cache));
-        }
       }
     }
-  };
+  }
+};
 
-const getRelationWrapper = (
-  meta: EntityMeta<any>,
-  relationName: string,
-  owner: any
-): HasManyCollection<any> | HasOneReference<any> | BelongsToReference<any> | ManyToManyCollection<any> | undefined => {
+const getRelationWrapper = (
+  meta: EntityMeta<any>,
+  relationName: string,
+  owner: any
+): HasManyCollection<any> | HasOneReference<any> | BelongsToReference<any> | ManyToManyCollection<any> | undefined => {
   if (meta.relationWrappers.has(relationName)) {
     return meta.relationWrappers.get(relationName) as HasManyCollection<any>;
   }
@@ -198,34 +198,34 @@ const getRelationWrapper = (
   return wrapper;
 };
 
-const instantiateWrapper = (
-  meta: EntityMeta<any>,
-  relationName: string,
-  relation: HasManyRelation | HasOneRelation | BelongsToRelation | BelongsToManyRelation,
-  owner: any
-): HasManyCollection<any> | HasOneReference<any> | BelongsToReference<any> | ManyToManyCollection<any> | undefined => {
-  switch (relation.type) {
-    case RelationKinds.HasOne: {
-      const hasOne = relation as HasOneRelation;
-      const localKey = hasOne.localKey || findPrimaryKey(meta.table);
-      const loader = () => relationLoaderCache(meta, relationName, () =>
-        loadHasOneRelation(meta.ctx, meta.table, relationName, hasOne)
-      );
-      return new DefaultHasOneReference(
-        meta.ctx,
-        meta,
-        owner,
-        relationName,
-        hasOne,
-        meta.table,
-        loader,
-        (row: Record<string, any>) => createEntityFromRow(meta.ctx, hasOne.target, row),
-        localKey
-      );
-    }
-    case RelationKinds.HasMany: {
-      const hasMany = relation as HasManyRelation;
-      const localKey = hasMany.localKey || findPrimaryKey(meta.table);
+const instantiateWrapper = (
+  meta: EntityMeta<any>,
+  relationName: string,
+  relation: HasManyRelation | HasOneRelation | BelongsToRelation | BelongsToManyRelation,
+  owner: any
+): HasManyCollection<any> | HasOneReference<any> | BelongsToReference<any> | ManyToManyCollection<any> | undefined => {
+  switch (relation.type) {
+    case RelationKinds.HasOne: {
+      const hasOne = relation as HasOneRelation;
+      const localKey = hasOne.localKey || findPrimaryKey(meta.table);
+      const loader = () => relationLoaderCache(meta, relationName, () =>
+        loadHasOneRelation(meta.ctx, meta.table, relationName, hasOne)
+      );
+      return new DefaultHasOneReference(
+        meta.ctx,
+        meta,
+        owner,
+        relationName,
+        hasOne,
+        meta.table,
+        loader,
+        (row: Record<string, any>) => createEntityFromRow(meta.ctx, hasOne.target, row),
+        localKey
+      );
+    }
+    case RelationKinds.HasMany: {
+      const hasMany = relation as HasManyRelation;
+      const localKey = hasMany.localKey || findPrimaryKey(meta.table);
       const loader = () => relationLoaderCache(meta, relationName, () =>
         loadHasManyRelation(meta.ctx, meta.table, relationName, hasMany)
       );