metal-orm 1.0.15 → 1.0.17

package/src/core/functions/standard-strategy.ts

@@ -1,4 +1,5 @@
-import { FunctionStrategy, FunctionRenderer, FunctionRenderContext } from './types.js';
+import { FunctionStrategy, FunctionRenderer, FunctionRenderContext } from './types.js';
+import { LiteralNode, OperandNode } from '../ast/expression.js';
 
 export class StandardFunctionStrategy implements FunctionStrategy {
     protected renderers: Map<string, FunctionRenderer> = new Map();
@@ -7,11 +8,16 @@ export class StandardFunctionStrategy implements FunctionStrategy {
         this.registerStandard();
     }
 
-    protected registerStandard() {
-        // Register ANSI standard implementations
-        this.add('ABS', ({ compiledArgs }) => `ABS(${compiledArgs[0]})`);
-        this.add('UPPER', ({ compiledArgs }) => `UPPER(${compiledArgs[0]})`);
-        this.add('LOWER', ({ compiledArgs }) => `LOWER(${compiledArgs[0]})`);
+    protected registerStandard() {
+        // Register ANSI standard implementations
+        this.add('COUNT', ({ compiledArgs }) => `COUNT(${compiledArgs.join(', ')})`);
+        this.add('SUM', ({ compiledArgs }) => `SUM(${compiledArgs[0]})`);
+        this.add('AVG', ({ compiledArgs }) => `AVG(${compiledArgs[0]})`);
+        this.add('MIN', ({ compiledArgs }) => `MIN(${compiledArgs[0]})`);
+        this.add('MAX', ({ compiledArgs }) => `MAX(${compiledArgs[0]})`);
+        this.add('ABS', ({ compiledArgs }) => `ABS(${compiledArgs[0]})`);
+        this.add('UPPER', ({ compiledArgs }) => `UPPER(${compiledArgs[0]})`);
+        this.add('LOWER', ({ compiledArgs }) => `LOWER(${compiledArgs[0]})`);
         this.add('LENGTH', ({ compiledArgs }) => `LENGTH(${compiledArgs[0]})`);
         this.add('TRIM', ({ compiledArgs }) => `TRIM(${compiledArgs[0]})`);
         this.add('LTRIM', ({ compiledArgs }) => `LTRIM(${compiledArgs[0]})`);
@@ -33,15 +39,49 @@ export class StandardFunctionStrategy implements FunctionStrategy {
         this.add('FROM_UNIXTIME', ({ compiledArgs }) => `FROM_UNIXTIME(${compiledArgs[0]})`);
         this.add('END_OF_MONTH', ({ compiledArgs }) => `LAST_DAY(${compiledArgs[0]})`);
         this.add('DAY_OF_WEEK', ({ compiledArgs }) => `DAYOFWEEK(${compiledArgs[0]})`);
-        this.add('WEEK_OF_YEAR', ({ compiledArgs }) => `WEEKOFYEAR(${compiledArgs[0]})`);
-        this.add('DATE_TRUNC', ({ compiledArgs }) => `DATE_TRUNC(${compiledArgs[0]}, ${compiledArgs[1]})`);
+        this.add('WEEK_OF_YEAR', ({ compiledArgs }) => `WEEKOFYEAR(${compiledArgs[0]})`);
+        this.add('DATE_TRUNC', ({ compiledArgs }) => `DATE_TRUNC(${compiledArgs[0]}, ${compiledArgs[1]})`);
+        this.add('GROUP_CONCAT', ctx => this.renderGroupConcat(ctx));
     }
 
     protected add(name: string, renderer: FunctionRenderer) {
         this.renderers.set(name, renderer);
     }
 
-    getRenderer(name: string): FunctionRenderer | undefined {
-        return this.renderers.get(name);
-    }
-}
+    getRenderer(name: string): FunctionRenderer | undefined {
+        return this.renderers.get(name);
+    }
+
+    private renderGroupConcat(ctx: FunctionRenderContext): string {
+        const arg = ctx.compiledArgs[0];
+        const orderClause = this.buildOrderByExpression(ctx);
+        const orderSegment = orderClause ? ` ${orderClause}` : '';
+        const separatorClause = this.formatGroupConcatSeparator(ctx);
+        return `GROUP_CONCAT(${arg}${orderSegment}${separatorClause})`;
+    }
+
+    protected buildOrderByExpression(ctx: FunctionRenderContext): string {
+        const orderBy = ctx.node.orderBy;
+        if (!orderBy || orderBy.length === 0) {
+            return '';
+        }
+        const parts = orderBy.map(order => `${ctx.compileOperand(order.column)} ${order.direction}`);
+        return `ORDER BY ${parts.join(', ')}`;
+    }
+
+    protected formatGroupConcatSeparator(ctx: FunctionRenderContext): string {
+        if (!ctx.node.separator) {
+            return '';
+        }
+        return ` SEPARATOR ${ctx.compileOperand(ctx.node.separator)}`;
+    }
+
+    protected getGroupConcatSeparatorOperand(ctx: FunctionRenderContext): OperandNode {
+        return ctx.node.separator ?? StandardFunctionStrategy.DEFAULT_GROUP_CONCAT_SEPARATOR;
+    }
+
+    protected static readonly DEFAULT_GROUP_CONCAT_SEPARATOR: LiteralNode = {
+        type: 'Literal',
+        value: ','
+    };
+}

package/src/core/functions/text.ts

@@ -11,7 +11,8 @@ const isColumnDef = (val: any): val is ColumnDef => !!val && typeof val === 'obj
 const toOperand = (input: OperandInput): OperandNode => {
   if (isOperandNode(input)) return input;
   if (isColumnDef(input)) return columnOperand(input);
-  return valueToOperand(input as any);
+
+  return valueToOperand(input);
 };
 
 const fn = (key: string, args: OperandInput[]): FunctionNode => ({

package/src/core/functions/types.ts

@@ -1,11 +1,11 @@
-import { FunctionNode } from '../ast/expression.js';
-
-export interface FunctionRenderContext {
-    node: FunctionNode;
-    compiledArgs: string[];
-    // Helper to allow dialects to call back into the compiler if needed
-    // compileOperand: (node: OperandNode) => string;
-}
+import { FunctionNode, OperandNode } from '../ast/expression.js';
+
+export interface FunctionRenderContext {
+    node: FunctionNode;
+    compiledArgs: string[];
+    /** Helper to compile additional operands (e.g., separators or ORDER BY columns) */
+    compileOperand: (operand: OperandNode) => string;
+}
 
 export type FunctionRenderer = (ctx: FunctionRenderContext) => string;
 

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

@@ -2,10 +2,11 @@ export * from './schema/table.js';
 export * from './schema/column.js';
 export * from './schema/relation.js';
 export * from './schema/types.js';
-export * from './query-builder/select.js';
-export * from './query-builder/insert.js';
-export * from './query-builder/update.js';
-export * from './query-builder/delete.js';
+export * from './query-builder/select.js';
+export * from './query-builder/select-helpers.js';
+export * from './query-builder/insert.js';
+export * from './query-builder/update.js';
+export * from './query-builder/delete.js';
 export * from './core/ast/expression.js';
 export * from './core/hydration/types.js';
 export * from './core/dialect/mysql/index.js';
@@ -23,13 +24,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/domain-event-bus.ts

@@ -1,32 +1,53 @@
-import type { HasDomainEvents, TrackedEntity } from './runtime-types.js';
+import type { DomainEvent, HasDomainEvents, TrackedEntity } from './runtime-types.js';
 
-export type DomainEventHandler<Context> = (event: any, ctx: Context) => Promise<void> | void;
+type EventOfType<E extends DomainEvent, TType extends E['type']> =
+  Extract<E, { type: TType }>;
 
-export class DomainEventBus<Context> {
-  private readonly handlers = new Map<string, DomainEventHandler<Context>[]>();
+export type DomainEventHandler<E extends DomainEvent, Context> =
+  (event: E, ctx: Context) => Promise<void> | void;
 
-  constructor(initialHandlers?: Record<string, DomainEventHandler<Context>[]>) {
-    const handlers = initialHandlers ?? {};
-    Object.entries(handlers).forEach(([name, list]) => {
-      this.handlers.set(name, [...list]);
-    });
+export type InitialHandlers<E extends DomainEvent, Context> = {
+  [K in E['type']]?: DomainEventHandler<EventOfType<E, K>, Context>[];
+};
+
+export class DomainEventBus<E extends DomainEvent, Context> {
+  private readonly handlers = new Map<E['type'], DomainEventHandler<E, Context>[]>();
+
+  constructor(initialHandlers?: InitialHandlers<E, Context>) {
+    if (initialHandlers) {
+      for (const key in initialHandlers) {
+        const type = key as E['type'];
+        const list = initialHandlers[type] ?? [];
+        this.handlers.set(type, [...(list as DomainEventHandler<E, Context>[])]);
+      }
+    }
   }
 
-  register(name: string, handler: DomainEventHandler<Context>): void {
-    const existing = this.handlers.get(name) ?? [];
-    existing.push(handler);
-    this.handlers.set(name, existing);
+  on<TType extends E['type']>(
+    type: TType,
+    handler: DomainEventHandler<EventOfType<E, TType>, Context>
+  ): void {
+    const key = type as E['type'];
+    const existing = this.handlers.get(key) ?? [];
+    existing.push(handler as unknown as DomainEventHandler<E, Context>);
+    this.handlers.set(key, existing);
+  }
+
+  register<TType extends E['type']>(
+    type: TType,
+    handler: DomainEventHandler<EventOfType<E, TType>, Context>
+  ): void {
+    this.on(type, handler);
   }
 
   async dispatch(trackedEntities: Iterable<TrackedEntity>, ctx: Context): Promise<void> {
     for (const tracked of trackedEntities) {
-      const entity = tracked.entity as HasDomainEvents;
-      if (!entity.domainEvents || !entity.domainEvents.length) continue;
+      const entity = tracked.entity as HasDomainEvents<E>;
+      if (!entity.domainEvents?.length) continue;
 
       for (const event of entity.domainEvents) {
-        const eventName = this.getEventName(event);
-        const handlers = this.handlers.get(eventName);
-        if (!handlers) continue;
+        const handlers = this.handlers.get(event.type as E['type']);
+        if (!handlers?.length) continue;
 
         for (const handler of handlers) {
           await handler(event, ctx);
@@ -36,15 +57,12 @@ export class DomainEventBus<Context> {
       entity.domainEvents = [];
     }
   }
-
-  private getEventName(event: any): string {
-    if (!event) return 'Unknown';
-    if (typeof event === 'string') return event;
-    return event.constructor?.name ?? 'Unknown';
-  }
 }
 
-export const addDomainEvent = (entity: HasDomainEvents, event: any): void => {
+export const addDomainEvent = <E extends DomainEvent>(
+  entity: HasDomainEvents<E>,
+  event: E
+): void => {
   if (!entity.domainEvents) {
     entity.domainEvents = [];
   }

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,20 +1,41 @@
 import { TableDef } from '../schema/table.js';
-import { OrmContext } from './orm-context.js';
+import { EntityContext } from './entity-context.js';
 import { RelationMap } from '../schema/types.js';
 
+/**
+ * Symbol used to store entity metadata on entity instances
+ */
 export const ENTITY_META = Symbol('EntityMeta');
 
 const toKey = (value: unknown): string => (value === null || value === undefined ? '' : String(value));
 
+/**
+ * Metadata stored on entity instances for ORM internal use
+ * @typeParam TTable - Table definition type
+ */
 export interface EntityMeta<TTable extends TableDef> {
-  ctx: OrmContext;
+  /** Entity context */
+  ctx: EntityContext;
+  /** Table definition */
   table: TTable;
+  /** Relations that should be loaded lazily */
   lazyRelations: (keyof RelationMap<TTable>)[];
+  /** Cache for relation promises */
   relationCache: Map<string, Promise<any>>;
+  /** Hydration data for relations */
   relationHydration: Map<string, Map<string, any>>;
+  /** Relation wrapper instances */
   relationWrappers: Map<string, unknown>;
 }
 
+/**
+ * Gets hydration rows for a specific relation and key
+ * @param meta - Entity metadata
+ * @param relationName - Name of the relation
+ * @param key - Key to look up in the hydration map
+ * @returns Array of hydration rows or undefined if not found
+ * @typeParam TTable - Table definition type
+ */
 export const getHydrationRows = <TTable extends TableDef>(
   meta: EntityMeta<TTable>,
   relationName: string,
@@ -27,6 +48,14 @@ export const getHydrationRows = <TTable extends TableDef>(
   return Array.isArray(rows) ? rows : undefined;
 };
 
+/**
+ * Gets a single hydration record for a specific relation and key
+ * @param meta - Entity metadata
+ * @param relationName - Name of the relation
+ * @param key - Key to look up in the hydration map
+ * @returns Single hydration record or undefined if not found
+ * @typeParam TTable - Table definition type
+ */
 export const getHydrationRecord = <TTable extends TableDef>(
   meta: EntityMeta<TTable>,
   relationName: string,
@@ -42,11 +71,22 @@ export const getHydrationRecord = <TTable extends TableDef>(
   return value;
 };
 
+/**
+ * Gets entity metadata from an entity instance
+ * @param entity - Entity instance to get metadata from
+ * @returns Entity metadata or undefined if not found
+ * @typeParam TTable - Table definition type
+ */
 export const getEntityMeta = <TTable extends TableDef>(entity: any): EntityMeta<TTable> | undefined => {
   if (!entity || typeof entity !== 'object') return undefined;
   return (entity as any)[ENTITY_META];
 };
 
+/**
+ * Checks if an entity has metadata attached
+ * @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> } => {
   return Boolean(getEntityMeta(entity));
 };

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)
       );