metal-orm 1.0.33 → 1.0.34

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "metal-orm",
-  "version": "1.0.33",
+  "version": "1.0.34",
   "type": "module",
   "types": "./dist/index.d.ts",
   "engines": {
@@ -14,11 +14,6 @@
       "types": "./dist/index.d.ts",
       "import": "./dist/index.js",
       "require": "./dist/index.cjs"
-    },
-    "./decorators": {
-      "types": "./dist/decorators/index.d.ts",
-      "import": "./dist/decorators/index.js",
-      "require": "./dist/decorators/index.cjs"
     }
   },
   "files": [

package/scripts/generate-entities.mjs

@@ -438,7 +438,7 @@ const renderEntityFile = (schema, options) => {
   ];
   const decoratorImports = decoratorOrder.filter(name => decoratorSet.has(name));
   if (decoratorImports.length) {
-    imports.push(`import { ${decoratorImports.join(', ')} } from 'metal-orm/decorators';`);
+    imports.push(`import { ${decoratorImports.join(', ')} } from 'metal-orm';`);
   }
 
   const ormTypes = [];

package/src/index.ts

@@ -38,6 +38,7 @@ 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';
+export * from './decorators/index.js';
 
 // NEW: execution abstraction + helpers
 export * from './core/execution/db-executor.js';

package/src/orm/entity.ts

@@ -1,5 +1,5 @@
 import { TableDef } from '../schema/table.js';
-import { Entity, RelationMap, HasManyCollection, HasOneReference, BelongsToReference, ManyToManyCollection } from '../schema/types.js';
+import { EntityInstance, 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';
@@ -49,7 +49,7 @@ export const createEntityProxy = <
   table: TTable,
   row: Record<string, any>,
   lazyRelations: TLazy[] = [] as TLazy[]
-): Entity<TTable> => {
+): EntityInstance<TTable> => {
   const target: Record<string, any> = { ...row };
   const meta: EntityMeta<TTable> = {
     ctx,
@@ -66,7 +66,7 @@ export const createEntityProxy = <
     writable: false
   });
 
-  let proxy: Entity<TTable>;
+  let proxy: EntityInstance<TTable>;
   const handler: ProxyHandler<any> = {
     get(targetObj, prop, receiver) {
       if (prop === ENTITY_META) {
@@ -99,7 +99,7 @@ export const createEntityProxy = <
     }
   };
 
-  proxy = new Proxy(target, handler) as Entity<TTable>;
+  proxy = new Proxy(target, handler) as EntityInstance<TTable>;
   populateHydrationCache(proxy, row, meta);
   return proxy;
 };
@@ -109,7 +109,7 @@ export const createEntityFromRow = <TTable extends TableDef>(
   table: TTable,
   row: Record<string, any>,
   lazyRelations: (keyof RelationMap<TTable>)[] = []
-): Entity<TTable> => {
+): EntityInstance<TTable> => {
   const pkName = findPrimaryKey(table);
   const pkValue = row[pkName];
   if (pkValue !== undefined && pkValue !== null) {

package/src/orm/execute.ts

@@ -1,5 +1,5 @@
 import { TableDef } from '../schema/table.js';
-import { Entity } from '../schema/types.js';
+import { EntityInstance } from '../schema/types.js';
 import { hydrateRows } from './hydration.js';
 import { OrmSession } from './orm-session.ts';
 import { SelectQueryBuilder } from '../query-builder/select.js';
@@ -28,7 +28,7 @@ const flattenResults = (results: { columns: string[]; values: unknown[][] }[]):
 const executeWithEntityContext = async <TTable extends TableDef>(
   entityCtx: EntityContext,
   qb: SelectQueryBuilder<any, TTable>
-): Promise<Entity<TTable>[]> => {
+): Promise<EntityInstance<TTable>[]> => {
   const ast = qb.getAST();
   const compiled = entityCtx.dialect.compileSelect(ast);
   const executed = await entityCtx.executor.executeSql(compiled.sql, compiled.params);
@@ -45,7 +45,7 @@ const executeWithEntityContext = async <TTable extends TableDef>(
 export async function executeHydrated<TTable extends TableDef>(
   session: OrmSession,
   qb: SelectQueryBuilder<any, TTable>
-): Promise<Entity<TTable>[]> {
+): Promise<EntityInstance<TTable>[]> {
   return executeWithEntityContext(session, qb);
 }
 
@@ -53,7 +53,7 @@ export async function executeHydratedWithContexts<TTable extends TableDef>(
   _execCtx: ExecutionContext,
   hydCtx: HydrationContext,
   qb: SelectQueryBuilder<any, TTable>
-): Promise<Entity<TTable>[]> {
+): Promise<EntityInstance<TTable>[]> {
   const entityCtx = hydCtx.entityContext;
   if (!entityCtx) {
     throw new Error('Hydration context is missing an EntityContext');

package/src/orm/orm-session.ts

@@ -1,139 +1,139 @@
-import { Dialect } from '../core/dialect/abstract.js';
-import { eq } from '../core/ast/expression.js';
-import type { DbExecutor } from '../core/execution/db-executor.js';
+import { Dialect } from '../core/dialect/abstract.js';
+import { eq } from '../core/ast/expression.js';
+import type { DbExecutor } from '../core/execution/db-executor.js';
 import { SelectQueryBuilder } from '../query-builder/select.js';
 import { findPrimaryKey } from '../query-builder/hydration-planner.js';
 import type { ColumnDef } from '../schema/column.js';
 import type { TableDef } from '../schema/table.js';
-import { Entity } from '../schema/types.js';
-import { RelationDef } from '../schema/relation.js';
-
-import { selectFromEntity, getTableDefFromEntity } from '../decorators/bootstrap.js';
-import type { EntityConstructor } from './entity-metadata.js';
-import { Orm } from './orm.js';
-import { IdentityMap } from './identity-map.js';
-import { UnitOfWork } from './unit-of-work.js';
-import { DomainEventBus, DomainEventHandler, InitialHandlers } from './domain-event-bus.js';
-import { RelationChangeProcessor } from './relation-change-processor.js';
-import { createQueryLoggingExecutor, QueryLogger } from './query-logger.js';
-import { ExecutionContext } from './execution-context.js';
-import type { HydrationContext } from './hydration-context.js';
-import type { EntityContext } from './entity-context.js';
-import {
-  DomainEvent,
-  OrmDomainEvent,
-  RelationChange,
-  RelationChangeEntry,
-  RelationKey,
-  TrackedEntity
-} from './runtime-types.js';
-import { executeHydrated } from './execute.js';
-import { runInTransaction } from './transaction-runner.js';
-
-export interface OrmInterceptor {
-  beforeFlush?(ctx: EntityContext): Promise<void> | void;
-  afterFlush?(ctx: EntityContext): Promise<void> | void;
-}
-
-export interface OrmSessionOptions<E extends DomainEvent = OrmDomainEvent> {
-  orm: Orm<E>;
-  executor: DbExecutor;
-  queryLogger?: QueryLogger;
-  interceptors?: OrmInterceptor[];
-  domainEventHandlers?: InitialHandlers<E, OrmSession<E>>;
-}
-
-export class OrmSession<E extends DomainEvent = OrmDomainEvent> implements EntityContext {
-  readonly orm: Orm<E>;
-  readonly executor: DbExecutor;
-  readonly identityMap: IdentityMap;
-  readonly unitOfWork: UnitOfWork;
-  readonly domainEvents: DomainEventBus<E, OrmSession<E>>;
-  readonly relationChanges: RelationChangeProcessor;
-
-  private readonly interceptors: OrmInterceptor[];
-
-  constructor(opts: OrmSessionOptions<E>) {
-    this.orm = opts.orm;
-    this.executor = createQueryLoggingExecutor(opts.executor, opts.queryLogger);
-    this.interceptors = [...(opts.interceptors ?? [])];
-
-    this.identityMap = new IdentityMap();
-    this.unitOfWork = new UnitOfWork(this.orm.dialect, this.executor, this.identityMap, () => this);
-    this.relationChanges = new RelationChangeProcessor(this.unitOfWork, this.orm.dialect, this.executor);
-    this.domainEvents = new DomainEventBus<E, OrmSession<E>>(opts.domainEventHandlers);
-  }
-
-  get dialect(): Dialect {
-    return this.orm.dialect;
-  }
-
-  get identityBuckets(): Map<string, Map<string, TrackedEntity>> {
-    return this.unitOfWork.identityBuckets;
-  }
-
-  get tracked(): TrackedEntity[] {
-    return this.unitOfWork.getTracked();
-  }
-
-  getEntity(table: TableDef, pk: any): any | undefined {
-    return this.unitOfWork.getEntity(table, pk);
-  }
-
-  setEntity(table: TableDef, pk: any, entity: any): void {
-    this.unitOfWork.setEntity(table, pk, entity);
-  }
-
-  trackNew(table: TableDef, entity: any, pk?: any): void {
-    this.unitOfWork.trackNew(table, entity, pk);
-  }
-
-  trackManaged(table: TableDef, pk: any, entity: any): void {
-    this.unitOfWork.trackManaged(table, pk, entity);
-  }
-
-  markDirty(entity: any): void {
-    this.unitOfWork.markDirty(entity);
-  }
-
-  markRemoved(entity: any): void {
-    this.unitOfWork.markRemoved(entity);
-  }
-
-  registerRelationChange = (
-    root: any,
-    relationKey: RelationKey,
-    rootTable: TableDef,
-    relationName: string,
-    relation: RelationDef,
-    change: RelationChange<any>
-  ): void => {
-    this.relationChanges.registerChange(
-      buildRelationChangeEntry(root, relationKey, rootTable, relationName, relation, change)
-    );
-  };
-
-  getEntitiesForTable(table: TableDef): TrackedEntity[] {
-    return this.unitOfWork.getEntitiesForTable(table);
-  }
-
-  registerInterceptor(interceptor: OrmInterceptor): void {
-    this.interceptors.push(interceptor);
-  }
-
-  registerDomainEventHandler<TType extends E['type']>(
-    type: TType,
-    handler: DomainEventHandler<Extract<E, { type: TType }>, OrmSession<E>>
-  ): void {
-    this.domainEvents.on(type, handler);
-  }
-
-  async find<TTable extends TableDef>(entityClass: EntityConstructor, id: any): Promise<Entity<TTable> | null> {
-    const table = getTableDefFromEntity(entityClass);
-    if (!table) {
-      throw new Error('Entity metadata has not been bootstrapped');
-    }
-    const primaryKey = findPrimaryKey(table);
+import { EntityInstance } from '../schema/types.js';
+import { RelationDef } from '../schema/relation.js';
+
+import { selectFromEntity, getTableDefFromEntity } from '../decorators/bootstrap.js';
+import type { EntityConstructor } from './entity-metadata.js';
+import { Orm } from './orm.js';
+import { IdentityMap } from './identity-map.js';
+import { UnitOfWork } from './unit-of-work.js';
+import { DomainEventBus, DomainEventHandler, InitialHandlers } from './domain-event-bus.js';
+import { RelationChangeProcessor } from './relation-change-processor.js';
+import { createQueryLoggingExecutor, QueryLogger } from './query-logger.js';
+import { ExecutionContext } from './execution-context.js';
+import type { HydrationContext } from './hydration-context.js';
+import type { EntityContext } from './entity-context.js';
+import {
+  DomainEvent,
+  OrmDomainEvent,
+  RelationChange,
+  RelationChangeEntry,
+  RelationKey,
+  TrackedEntity
+} from './runtime-types.js';
+import { executeHydrated } from './execute.js';
+import { runInTransaction } from './transaction-runner.js';
+
+export interface OrmInterceptor {
+  beforeFlush?(ctx: EntityContext): Promise<void> | void;
+  afterFlush?(ctx: EntityContext): Promise<void> | void;
+}
+
+export interface OrmSessionOptions<E extends DomainEvent = OrmDomainEvent> {
+  orm: Orm<E>;
+  executor: DbExecutor;
+  queryLogger?: QueryLogger;
+  interceptors?: OrmInterceptor[];
+  domainEventHandlers?: InitialHandlers<E, OrmSession<E>>;
+}
+
+export class OrmSession<E extends DomainEvent = OrmDomainEvent> implements EntityContext {
+  readonly orm: Orm<E>;
+  readonly executor: DbExecutor;
+  readonly identityMap: IdentityMap;
+  readonly unitOfWork: UnitOfWork;
+  readonly domainEvents: DomainEventBus<E, OrmSession<E>>;
+  readonly relationChanges: RelationChangeProcessor;
+
+  private readonly interceptors: OrmInterceptor[];
+
+  constructor(opts: OrmSessionOptions<E>) {
+    this.orm = opts.orm;
+    this.executor = createQueryLoggingExecutor(opts.executor, opts.queryLogger);
+    this.interceptors = [...(opts.interceptors ?? [])];
+
+    this.identityMap = new IdentityMap();
+    this.unitOfWork = new UnitOfWork(this.orm.dialect, this.executor, this.identityMap, () => this);
+    this.relationChanges = new RelationChangeProcessor(this.unitOfWork, this.orm.dialect, this.executor);
+    this.domainEvents = new DomainEventBus<E, OrmSession<E>>(opts.domainEventHandlers);
+  }
+
+  get dialect(): Dialect {
+    return this.orm.dialect;
+  }
+
+  get identityBuckets(): Map<string, Map<string, TrackedEntity>> {
+    return this.unitOfWork.identityBuckets;
+  }
+
+  get tracked(): TrackedEntity[] {
+    return this.unitOfWork.getTracked();
+  }
+
+  getEntity(table: TableDef, pk: any): any | undefined {
+    return this.unitOfWork.getEntity(table, pk);
+  }
+
+  setEntity(table: TableDef, pk: any, entity: any): void {
+    this.unitOfWork.setEntity(table, pk, entity);
+  }
+
+  trackNew(table: TableDef, entity: any, pk?: any): void {
+    this.unitOfWork.trackNew(table, entity, pk);
+  }
+
+  trackManaged(table: TableDef, pk: any, entity: any): void {
+    this.unitOfWork.trackManaged(table, pk, entity);
+  }
+
+  markDirty(entity: any): void {
+    this.unitOfWork.markDirty(entity);
+  }
+
+  markRemoved(entity: any): void {
+    this.unitOfWork.markRemoved(entity);
+  }
+
+  registerRelationChange = (
+    root: any,
+    relationKey: RelationKey,
+    rootTable: TableDef,
+    relationName: string,
+    relation: RelationDef,
+    change: RelationChange<any>
+  ): void => {
+    this.relationChanges.registerChange(
+      buildRelationChangeEntry(root, relationKey, rootTable, relationName, relation, change)
+    );
+  };
+
+  getEntitiesForTable(table: TableDef): TrackedEntity[] {
+    return this.unitOfWork.getEntitiesForTable(table);
+  }
+
+  registerInterceptor(interceptor: OrmInterceptor): void {
+    this.interceptors.push(interceptor);
+  }
+
+  registerDomainEventHandler<TType extends E['type']>(
+    type: TType,
+    handler: DomainEventHandler<Extract<E, { type: TType }>, OrmSession<E>>
+  ): void {
+    this.domainEvents.on(type, handler);
+  }
+
+  async find<TTable extends TableDef>(entityClass: EntityConstructor, id: any): Promise<EntityInstance<TTable> | null> {
+    const table = getTableDefFromEntity(entityClass);
+    if (!table) {
+      throw new Error('Entity metadata has not been bootstrapped');
+    }
+    const primaryKey = findPrimaryKey(table);
     const column = table.columns[primaryKey];
     if (!column) {
       throw new Error('Entity table does not expose a primary key');
@@ -146,100 +146,100 @@ export class OrmSession<E extends DomainEvent = OrmDomainEvent> implements Entit
       .select(columnSelections)
       .where(eq(column, id))
       .limit(1);
-    const rows = await executeHydrated(this, qb);
-    return rows[0] ?? null;
-  }
-
-  async findOne<TTable extends TableDef>(qb: SelectQueryBuilder<any, TTable>): Promise<Entity<TTable> | null> {
-    const limited = qb.limit(1);
-    const rows = await executeHydrated(this, limited);
-    return rows[0] ?? null;
-  }
-
-  async findMany<TTable extends TableDef>(qb: SelectQueryBuilder<any, TTable>): Promise<Entity<TTable>[]> {
-    return executeHydrated(this, qb);
-  }
-
-  async persist(entity: object): Promise<void> {
-    if (this.unitOfWork.findTracked(entity)) {
-      return;
-    }
-    const table = getTableDefFromEntity((entity as any).constructor as EntityConstructor);
-    if (!table) {
-      throw new Error('Entity metadata has not been bootstrapped');
-    }
-    const primaryKey = findPrimaryKey(table);
-    const pkValue = (entity as Record<string, any>)[primaryKey];
-    if (pkValue !== undefined && pkValue !== null) {
-      this.trackManaged(table, pkValue, entity);
-    } else {
-      this.trackNew(table, entity);
-    }
-  }
-
-  async remove(entity: object): Promise<void> {
-    this.markRemoved(entity);
-  }
-
-  async flush(): Promise<void> {
-    await this.unitOfWork.flush();
-  }
-
-  async commit(): Promise<void> {
-    await runInTransaction(this.executor, async () => {
-      for (const interceptor of this.interceptors) {
-        await interceptor.beforeFlush?.(this);
-      }
-
-      await this.unitOfWork.flush();
-      await this.relationChanges.process();
-      await this.unitOfWork.flush();
-
-      for (const interceptor of this.interceptors) {
-        await interceptor.afterFlush?.(this);
-      }
-    });
-
-    await this.domainEvents.dispatch(this.unitOfWork.getTracked(), this);
-  }
-
-  async rollback(): Promise<void> {
-    await this.executor.rollbackTransaction?.();
-    this.unitOfWork.reset();
-    this.relationChanges.reset();
-  }
-
-  getExecutionContext(): ExecutionContext {
-    return {
-      dialect: this.orm.dialect,
-      executor: this.executor,
-      interceptors: this.orm.interceptors
-    };
-  }
-
-  getHydrationContext(): HydrationContext<E> {
-    return {
-      identityMap: this.identityMap,
-      unitOfWork: this.unitOfWork,
-      domainEvents: this.domainEvents,
-      relationChanges: this.relationChanges,
-      entityContext: this
-    };
-  }
-}
-
-const buildRelationChangeEntry = (
-  root: any,
-  relationKey: RelationKey,
-  rootTable: TableDef,
-  relationName: string,
-  relation: RelationDef,
-  change: RelationChange<any>
-): RelationChangeEntry => ({
-  root,
-  relationKey,
-  rootTable,
-  relationName,
-  relation,
-  change
-});
+    const rows = await executeHydrated(this, qb);
+    return rows[0] ?? null;
+  }
+
+  async findOne<TTable extends TableDef>(qb: SelectQueryBuilder<any, TTable>): Promise<EntityInstance<TTable> | null> {
+    const limited = qb.limit(1);
+    const rows = await executeHydrated(this, limited);
+    return rows[0] ?? null;
+  }
+
+  async findMany<TTable extends TableDef>(qb: SelectQueryBuilder<any, TTable>): Promise<EntityInstance<TTable>[]> {
+    return executeHydrated(this, qb);
+  }
+
+  async persist(entity: object): Promise<void> {
+    if (this.unitOfWork.findTracked(entity)) {
+      return;
+    }
+    const table = getTableDefFromEntity((entity as any).constructor as EntityConstructor);
+    if (!table) {
+      throw new Error('Entity metadata has not been bootstrapped');
+    }
+    const primaryKey = findPrimaryKey(table);
+    const pkValue = (entity as Record<string, any>)[primaryKey];
+    if (pkValue !== undefined && pkValue !== null) {
+      this.trackManaged(table, pkValue, entity);
+    } else {
+      this.trackNew(table, entity);
+    }
+  }
+
+  async remove(entity: object): Promise<void> {
+    this.markRemoved(entity);
+  }
+
+  async flush(): Promise<void> {
+    await this.unitOfWork.flush();
+  }
+
+  async commit(): Promise<void> {
+    await runInTransaction(this.executor, async () => {
+      for (const interceptor of this.interceptors) {
+        await interceptor.beforeFlush?.(this);
+      }
+
+      await this.unitOfWork.flush();
+      await this.relationChanges.process();
+      await this.unitOfWork.flush();
+
+      for (const interceptor of this.interceptors) {
+        await interceptor.afterFlush?.(this);
+      }
+    });
+
+    await this.domainEvents.dispatch(this.unitOfWork.getTracked(), this);
+  }
+
+  async rollback(): Promise<void> {
+    await this.executor.rollbackTransaction?.();
+    this.unitOfWork.reset();
+    this.relationChanges.reset();
+  }
+
+  getExecutionContext(): ExecutionContext {
+    return {
+      dialect: this.orm.dialect,
+      executor: this.executor,
+      interceptors: this.orm.interceptors
+    };
+  }
+
+  getHydrationContext(): HydrationContext<E> {
+    return {
+      identityMap: this.identityMap,
+      unitOfWork: this.unitOfWork,
+      domainEvents: this.domainEvents,
+      relationChanges: this.relationChanges,
+      entityContext: this
+    };
+  }
+}
+
+const buildRelationChangeEntry = (
+  root: any,
+  relationKey: RelationKey,
+  rootTable: TableDef,
+  relationName: string,
+  relation: RelationDef,
+  change: RelationChange<any>
+): RelationChangeEntry => ({
+  root,
+  relationKey,
+  rootTable,
+  relationName,
+  relation,
+  change
+});