metal-orm 1.0.14 → 1.0.16

package/src/schema/types.ts

@@ -1,11 +1,12 @@
 import { ColumnDef } from './column.js';
 import { TableDef } from './table.js';
-import {
-  RelationDef,
-  HasManyRelation,
-  BelongsToRelation,
-  BelongsToManyRelation
-} from './relation.js';
+import {
+  RelationDef,
+  HasManyRelation,
+  HasOneRelation,
+  BelongsToRelation,
+  BelongsToManyRelation
+} from './relation.js';
 
 /**
  * Maps a ColumnDef to its TypeScript type representation
@@ -26,11 +27,12 @@ export type InferRow<TTable extends TableDef> = {
   [K in keyof TTable['columns']]: ColumnToTs<TTable['columns'][K]>;
 };
 
-type RelationResult<T extends RelationDef> =
-  T extends HasManyRelation<infer TTarget>        ? InferRow<TTarget>[] :
-  T extends BelongsToRelation<infer TTarget>      ? InferRow<TTarget> | null :
-  T extends BelongsToManyRelation<infer TTarget>  ? (InferRow<TTarget> & { _pivot?: any })[] :
-  never;
+type RelationResult<T extends RelationDef> =
+  T extends HasManyRelation<infer TTarget>        ? InferRow<TTarget>[] :
+  T extends HasOneRelation<infer TTarget>         ? InferRow<TTarget> | null :
+  T extends BelongsToRelation<infer TTarget>      ? InferRow<TTarget> | null :
+  T extends BelongsToManyRelation<infer TTarget>  ? (InferRow<TTarget> & { _pivot?: any })[] :
+  never;
 
 /**
  * Maps relation names to the expected row results
@@ -48,11 +50,17 @@ export interface HasManyCollection<TChild> {
   clear(): void;
 }
 
-export interface BelongsToReference<TParent> {
-  load(): Promise<TParent | null>;
-  get(): TParent | null;
-  set(data: Partial<TParent> | TParent | null): TParent | null;
-}
+export interface BelongsToReference<TParent> {
+  load(): Promise<TParent | null>;
+  get(): TParent | null;
+  set(data: Partial<TParent> | TParent | null): TParent | null;
+}
+
+export interface HasOneReference<TChild> {
+  load(): Promise<TChild | null>;
+  get(): TChild | null;
+  set(data: Partial<TChild> | TChild | null): TChild | null;
+}
 
 export interface ManyToManyCollection<TTarget> {
   load(): Promise<TTarget[]>;
@@ -62,18 +70,20 @@ export interface ManyToManyCollection<TTarget> {
   syncByIds(ids: (number | string)[]): Promise<void>;
 }
 
-export type Entity<
-  TTable extends TableDef,
-  TRow = InferRow<TTable>
-> = TRow & {
-  [K in keyof RelationMap<TTable>]:
-    TTable['relations'][K] extends HasManyRelation<infer TTarget>
-      ? HasManyCollection<Entity<TTarget>>
-      : TTable['relations'][K] extends BelongsToManyRelation<infer TTarget>
-        ? ManyToManyCollection<Entity<TTarget>>
-        : TTable['relations'][K] extends BelongsToRelation<infer TTarget>
-          ? BelongsToReference<Entity<TTarget>>
-          : never;
-} & {
-  $load<K extends keyof RelationMap<TTable>>(relation: K): Promise<RelationMap<TTable>[K]>;
-};
+export type Entity<
+  TTable extends TableDef,
+  TRow = InferRow<TTable>
+> = TRow & {
+  [K in keyof RelationMap<TTable>]:
+    TTable['relations'][K] extends HasManyRelation<infer TTarget>
+      ? HasManyCollection<Entity<TTarget>>
+      : TTable['relations'][K] extends HasOneRelation<infer TTarget>
+        ? HasOneReference<Entity<TTarget>>
+        : TTable['relations'][K] extends BelongsToManyRelation<infer TTarget>
+          ? ManyToManyCollection<Entity<TTarget>>
+          : TTable['relations'][K] extends BelongsToRelation<infer TTarget>
+            ? BelongsToReference<Entity<TTarget>>
+            : never;
+} & {
+  $load<K extends keyof RelationMap<TTable>>(relation: K): Promise<RelationMap<TTable>[K]>;
+};

package/src/orm/db-executor.ts

@@ -1,11 +0,0 @@
-export type QueryResult = {
-  columns: string[];
-  values: unknown[][];
-};
-
-export interface DbExecutor {
-  executeSql(sql: string, params?: unknown[]): Promise<QueryResult[]>;
-  beginTransaction?(): Promise<void>;
-  commitTransaction?(): Promise<void>;
-  rollbackTransaction?(): Promise<void>;
-}

package/src/orm/orm-context.ts

@@ -1,159 +0,0 @@
-import type { Dialect } from '../core/dialect/abstract.js';
-import type { RelationDef } from '../schema/relation.js';
-import type { TableDef } from '../schema/table.js';
-import type { DbExecutor, QueryResult } from './db-executor.js';
-import { DomainEventBus, DomainEventHandler as DomainEventHandlerFn, addDomainEvent } from './domain-event-bus.js';
-import { IdentityMap } from './identity-map.js';
-import { RelationChangeProcessor } from './relation-change-processor.js';
-import { runInTransaction } from './transaction-runner.js';
-import { UnitOfWork } from './unit-of-work.js';
-import {
-  EntityStatus,
-  HasDomainEvents,
-  RelationChange,
-  RelationChangeEntry,
-  RelationKey,
-  TrackedEntity
-} from './runtime-types.js';
-import { createQueryLoggingExecutor, QueryLogger } from './query-logger.js';
-
-export interface OrmInterceptor {
-  beforeFlush?(ctx: OrmContext): Promise<void> | void;
-  afterFlush?(ctx: OrmContext): Promise<void> | void;
-}
-
-export type DomainEventHandler = DomainEventHandlerFn<OrmContext>;
-
-export interface OrmContextOptions {
-  dialect: Dialect;
-  executor: DbExecutor;
-  interceptors?: OrmInterceptor[];
-  domainEventHandlers?: Record<string, DomainEventHandler[]>;
-  queryLogger?: QueryLogger;
-}
-
-export class OrmContext {
-  private readonly identityMap = new IdentityMap();
-  private readonly executorWithLogging: DbExecutor;
-  private readonly unitOfWork: UnitOfWork;
-  private readonly relationChanges: RelationChangeProcessor;
-  private readonly interceptors: OrmInterceptor[];
-  private readonly domainEvents: DomainEventBus<OrmContext>;
-
-  constructor(private readonly options: OrmContextOptions) {
-    this.interceptors = [...(options.interceptors ?? [])];
-    this.executorWithLogging = createQueryLoggingExecutor(options.executor, options.queryLogger);
-    this.unitOfWork = new UnitOfWork(
-      options.dialect,
-      this.executorWithLogging,
-      this.identityMap,
-      () => this
-    );
-    this.relationChanges = new RelationChangeProcessor(
-      this.unitOfWork,
-      options.dialect,
-      this.executorWithLogging
-    );
-    this.domainEvents = new DomainEventBus<OrmContext>(options.domainEventHandlers);
-  }
-
-  get dialect(): Dialect {
-    return this.options.dialect;
-  }
-
-  get executor(): DbExecutor {
-    return this.executorWithLogging;
-  }
-
-  get identityBuckets(): Map<string, Map<string, TrackedEntity>> {
-    return this.unitOfWork.identityBuckets;
-  }
-
-  get tracked(): TrackedEntity[] {
-    return this.unitOfWork.getTracked();
-  }
-
-  getEntity(table: TableDef, pk: string | number): any | undefined {
-    return this.unitOfWork.getEntity(table, pk);
-  }
-
-  setEntity(table: TableDef, pk: string | number, entity: any): void {
-    this.unitOfWork.setEntity(table, pk, entity);
-  }
-
-  trackNew(table: TableDef, entity: any, pk?: string | number): void {
-    this.unitOfWork.trackNew(table, entity, pk);
-  }
-
-  trackManaged(table: TableDef, pk: string | number, 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 {
-    const entry: RelationChangeEntry = {
-      root,
-      relationKey,
-      rootTable,
-      relationName,
-      relation,
-      change
-    };
-    this.relationChanges.registerChange(entry);
-  }
-
-  registerInterceptor(interceptor: OrmInterceptor): void {
-    this.interceptors.push(interceptor);
-  }
-
-  registerDomainEventHandler(name: string, handler: DomainEventHandler): void {
-    this.domainEvents.register(name, handler);
-  }
-
-  async saveChanges(): 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);
-  }
-
-  getEntitiesForTable(table: TableDef): TrackedEntity[] {
-    return this.unitOfWork.getEntitiesForTable(table);
-  }
-}
-
-export { addDomainEvent };
-export { EntityStatus };
-export type {
-  QueryResult,
-  DbExecutor,
-  RelationKey,
-  RelationChange,
-  HasDomainEvents
-};
-export type { QueryLogEntry, QueryLogger } from './query-logger.js';