metal-orm 1.0.8 → 1.0.9

package/src/orm/orm-context.ts

@@ -0,0 +1,154 @@
+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';
+
+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[]>;
+}
+
+export class OrmContext {
+  private readonly identityMap = new IdentityMap();
+  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.unitOfWork = new UnitOfWork(
+      options.dialect,
+      options.executor,
+      this.identityMap,
+      () => this
+    );
+    this.relationChanges = new RelationChangeProcessor(
+      this.unitOfWork,
+      options.dialect,
+      options.executor
+    );
+    this.domainEvents = new DomainEventBus<OrmContext>(options.domainEventHandlers);
+  }
+
+  get dialect(): Dialect {
+    return this.options.dialect;
+  }
+
+  get executor(): DbExecutor {
+    return this.options.executor;
+  }
+
+  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
+};

package/src/orm/relation-change-processor.ts

@@ -0,0 +1,140 @@
+import { and, eq } from '../core/ast/expression.js';
+import type { Dialect } from '../core/dialect/abstract.js';
+import { DeleteQueryBuilder } from '../query-builder/delete.js';
+import { InsertQueryBuilder } from '../query-builder/insert.js';
+import { findPrimaryKey } from '../query-builder/hydration-planner.js';
+import type { BelongsToManyRelation, HasManyRelation } from '../schema/relation.js';
+import { RelationKinds } from '../schema/relation.js';
+import type { TableDef } from '../schema/table.js';
+import type { DbExecutor } from './db-executor.js';
+import type { RelationChangeEntry } from './runtime-types.js';
+import { UnitOfWork } from './unit-of-work.js';
+
+export class RelationChangeProcessor {
+  private readonly relationChanges: RelationChangeEntry[] = [];
+
+  constructor(
+    private readonly unitOfWork: UnitOfWork,
+    private readonly dialect: Dialect,
+    private readonly executor: DbExecutor
+  ) {}
+
+  registerChange(entry: RelationChangeEntry): void {
+    this.relationChanges.push(entry);
+  }
+
+  async process(): Promise<void> {
+    if (!this.relationChanges.length) return;
+    const entries = [...this.relationChanges];
+    this.relationChanges.length = 0;
+
+    for (const entry of entries) {
+      switch (entry.relation.type) {
+        case RelationKinds.HasMany:
+          await this.handleHasManyChange(entry);
+          break;
+        case RelationKinds.BelongsToMany:
+          await this.handleBelongsToManyChange(entry);
+          break;
+        case RelationKinds.BelongsTo:
+          await this.handleBelongsToChange(entry);
+          break;
+      }
+    }
+  }
+
+  private async handleHasManyChange(entry: RelationChangeEntry): Promise<void> {
+    const relation = entry.relation as HasManyRelation;
+    const target = entry.change.entity;
+    if (!target) return;
+
+    const tracked = this.unitOfWork.findTracked(target);
+    if (!tracked) return;
+
+    const localKey = relation.localKey || findPrimaryKey(entry.rootTable);
+    const rootValue = entry.root[localKey];
+    if (rootValue === undefined || rootValue === null) return;
+
+    if (entry.change.kind === 'add' || entry.change.kind === 'attach') {
+      this.assignHasManyForeignKey(tracked.entity, relation, rootValue);
+      this.unitOfWork.markDirty(tracked.entity);
+      return;
+    }
+
+    if (entry.change.kind === 'remove') {
+      this.detachHasManyChild(tracked.entity, relation);
+    }
+  }
+
+  private async handleBelongsToChange(_entry: RelationChangeEntry): Promise<void> {
+    // Reserved for future cascade/persist behaviors for belongs-to relations.
+  }
+
+  private async handleBelongsToManyChange(entry: RelationChangeEntry): Promise<void> {
+    const relation = entry.relation as BelongsToManyRelation;
+    const rootKey = relation.localKey || findPrimaryKey(entry.rootTable);
+    const rootId = entry.root[rootKey];
+    if (rootId === undefined || rootId === null) return;
+
+    const targetId = this.resolvePrimaryKeyValue(entry.change.entity, relation.target);
+    if (targetId === null) return;
+
+    if (entry.change.kind === 'attach' || entry.change.kind === 'add') {
+      await this.insertPivotRow(relation, rootId, targetId);
+      return;
+    }
+
+    if (entry.change.kind === 'detach' || entry.change.kind === 'remove') {
+      await this.deletePivotRow(relation, rootId, targetId);
+
+      if (relation.cascade === 'all' || relation.cascade === 'remove') {
+        this.unitOfWork.markRemoved(entry.change.entity);
+      }
+    }
+  }
+
+  private assignHasManyForeignKey(child: any, relation: HasManyRelation, rootValue: unknown): void {
+    const current = child[relation.foreignKey];
+    if (current === rootValue) return;
+    child[relation.foreignKey] = rootValue;
+  }
+
+  private detachHasManyChild(child: any, relation: HasManyRelation): void {
+    if (relation.cascade === 'all' || relation.cascade === 'remove') {
+      this.unitOfWork.markRemoved(child);
+      return;
+    }
+    child[relation.foreignKey] = null;
+    this.unitOfWork.markDirty(child);
+  }
+
+  private async insertPivotRow(relation: BelongsToManyRelation, rootId: string | number, targetId: string | number): Promise<void> {
+    const payload = {
+      [relation.pivotForeignKeyToRoot]: rootId,
+      [relation.pivotForeignKeyToTarget]: targetId
+    };
+    const builder = new InsertQueryBuilder(relation.pivotTable).values(payload);
+    const compiled = builder.compile(this.dialect);
+    await this.executor.executeSql(compiled.sql, compiled.params);
+  }
+
+  private async deletePivotRow(relation: BelongsToManyRelation, rootId: string | number, targetId: string | number): Promise<void> {
+    const rootCol = relation.pivotTable.columns[relation.pivotForeignKeyToRoot];
+    const targetCol = relation.pivotTable.columns[relation.pivotForeignKeyToTarget];
+    if (!rootCol || !targetCol) return;
+
+    const builder = new DeleteQueryBuilder(relation.pivotTable).where(
+      and(eq(rootCol, rootId), eq(targetCol, targetId))
+    );
+    const compiled = builder.compile(this.dialect);
+    await this.executor.executeSql(compiled.sql, compiled.params);
+  }
+
+  private resolvePrimaryKeyValue(entity: any, table: TableDef): string | number | null {
+    if (!entity) return null;
+    const key = findPrimaryKey(table);
+    const value = entity[key];
+    if (value === undefined || value === null) return null;
+    return value;
+  }
+}

package/src/{runtime → orm}/relations/belongs-to.ts

@@ -1,92 +1,92 @@
-import { BelongsToReference } from '../../schema/types';
-import { OrmContext, RelationKey } from '../orm-context';
-import { BelongsToRelation } from '../../schema/relation';
-import { TableDef } from '../../schema/table';
-import { EntityMeta, getHydrationRecord, hasEntityMeta } from '../entity-meta';
-
-type Rows = Record<string, any>;
-
-const toKey = (value: unknown): string => (value === null || value === undefined ? '' : String(value));
-
-export class DefaultBelongsToReference<TParent> implements BelongsToReference<TParent> {
-  private loaded = false;
-  private current: TParent | null = null;
-
-  constructor(
-    private readonly ctx: OrmContext,
-    private readonly meta: EntityMeta<any>,
-    private readonly root: any,
-    private readonly relationName: string,
-    private readonly relation: BelongsToRelation,
-    private readonly rootTable: TableDef,
-    private readonly loader: () => Promise<Map<string, Rows>>,
-    private readonly createEntity: (row: Record<string, any>) => TParent,
-    private readonly targetKey: string
-  ) {
-    this.populateFromHydrationCache();
-  }
-
-  async load(): Promise<TParent | null> {
-    if (this.loaded) return this.current;
-    const map = await this.loader();
-    const fkValue = this.root[this.relation.foreignKey];
-    if (fkValue === null || fkValue === undefined) {
-      this.current = null;
-    } else {
-      const row = map.get(toKey(fkValue));
-      this.current = row ? this.createEntity(row) : null;
-    }
-    this.loaded = true;
-    return this.current;
-  }
-
-  get(): TParent | null {
-    return this.current;
-  }
-
-  set(data: Partial<TParent> | TParent | null): TParent | null {
-    if (data === null) {
-      const previous = this.current;
-      this.root[this.relation.foreignKey] = null;
-      this.current = null;
-      this.ctx.registerRelationChange(
-        this.root,
-        this.relationKey,
-        this.rootTable,
-        this.relationName,
-        this.relation,
-        { kind: 'remove', entity: previous }
-      );
-      return null;
-    }
-
-    const entity = hasEntityMeta(data) ? (data as TParent) : this.createEntity(data as Record<string, any>);
-    const pkValue = (entity as any)[this.targetKey];
-    if (pkValue !== undefined) {
-      this.root[this.relation.foreignKey] = pkValue;
-    }
-    this.current = entity;
-    this.ctx.registerRelationChange(
-      this.root,
-      this.relationKey,
-      this.rootTable,
-      this.relationName,
-      this.relation,
-      { kind: 'attach', entity }
-    );
-    return entity;
-  }
-
-  private get relationKey(): RelationKey {
-    return `${this.rootTable.name}.${this.relationName}`;
-  }
-
-  private populateFromHydrationCache(): void {
-    const fkValue = this.root[this.relation.foreignKey];
-    if (fkValue === undefined || fkValue === null) return;
-    const row = getHydrationRecord(this.meta, this.relationName, fkValue);
-    if (!row) return;
-    this.current = this.createEntity(row);
-    this.loaded = true;
-  }
-}
+import { BelongsToReference } from '../../schema/types.js';
+import { OrmContext, RelationKey } from '../orm-context.js';
+import { BelongsToRelation } from '../../schema/relation.js';
+import { TableDef } from '../../schema/table.js';
+import { EntityMeta, getHydrationRecord, hasEntityMeta } from '../entity-meta.js';
+
+type Rows = Record<string, any>;
+
+const toKey = (value: unknown): string => (value === null || value === undefined ? '' : String(value));
+
+export class DefaultBelongsToReference<TParent> implements BelongsToReference<TParent> {
+  private loaded = false;
+  private current: TParent | null = null;
+
+  constructor(
+    private readonly ctx: OrmContext,
+    private readonly meta: EntityMeta<any>,
+    private readonly root: any,
+    private readonly relationName: string,
+    private readonly relation: BelongsToRelation,
+    private readonly rootTable: TableDef,
+    private readonly loader: () => Promise<Map<string, Rows>>,
+    private readonly createEntity: (row: Record<string, any>) => TParent,
+    private readonly targetKey: string
+  ) {
+    this.populateFromHydrationCache();
+  }
+
+  async load(): Promise<TParent | null> {
+    if (this.loaded) return this.current;
+    const map = await this.loader();
+    const fkValue = this.root[this.relation.foreignKey];
+    if (fkValue === null || fkValue === undefined) {
+      this.current = null;
+    } else {
+      const row = map.get(toKey(fkValue));
+      this.current = row ? this.createEntity(row) : null;
+    }
+    this.loaded = true;
+    return this.current;
+  }
+
+  get(): TParent | null {
+    return this.current;
+  }
+
+  set(data: Partial<TParent> | TParent | null): TParent | null {
+    if (data === null) {
+      const previous = this.current;
+      this.root[this.relation.foreignKey] = null;
+      this.current = null;
+      this.ctx.registerRelationChange(
+        this.root,
+        this.relationKey,
+        this.rootTable,
+        this.relationName,
+        this.relation,
+        { kind: 'remove', entity: previous }
+      );
+      return null;
+    }
+
+    const entity = hasEntityMeta(data) ? (data as TParent) : this.createEntity(data as Record<string, any>);
+    const pkValue = (entity as any)[this.targetKey];
+    if (pkValue !== undefined) {
+      this.root[this.relation.foreignKey] = pkValue;
+    }
+    this.current = entity;
+    this.ctx.registerRelationChange(
+      this.root,
+      this.relationKey,
+      this.rootTable,
+      this.relationName,
+      this.relation,
+      { kind: 'attach', entity }
+    );
+    return entity;
+  }
+
+  private get relationKey(): RelationKey {
+    return `${this.rootTable.name}.${this.relationName}`;
+  }
+
+  private populateFromHydrationCache(): void {
+    const fkValue = this.root[this.relation.foreignKey];
+    if (fkValue === undefined || fkValue === null) return;
+    const row = getHydrationRecord(this.meta, this.relationName, fkValue);
+    if (!row) return;
+    this.current = this.createEntity(row);
+    this.loaded = true;
+  }
+}