metal-orm 1.0.8 → 1.0.9

package/src/{runtime → orm}/relations/has-many.ts

@@ -1,111 +1,111 @@
-import { HasManyCollection } from '../../schema/types';
-import { OrmContext, RelationKey } from '../orm-context';
-import { HasManyRelation } from '../../schema/relation';
-import { TableDef } from '../../schema/table';
-import { EntityMeta, getHydrationRows } from '../entity-meta';
-
-type Rows = Record<string, any>[];
-
-const toKey = (value: unknown): string => (value === null || value === undefined ? '' : String(value));
-
-export class DefaultHasManyCollection<TChild> implements HasManyCollection<TChild> {
-  private loaded = false;
-  private items: TChild[] = [];
-  private readonly added = new Set<TChild>();
-  private readonly removed = new Set<TChild>();
-
-  constructor(
-    private readonly ctx: OrmContext,
-    private readonly meta: EntityMeta<any>,
-    private readonly root: any,
-    private readonly relationName: string,
-    private readonly relation: HasManyRelation,
-    private readonly rootTable: TableDef,
-    private readonly loader: () => Promise<Map<string, Rows>>,
-    private readonly createEntity: (row: Record<string, any>) => TChild,
-    private readonly localKey: string
-  ) {
-    this.hydrateFromCache();
-  }
-
-  async load(): Promise<TChild[]> {
-    if (this.loaded) return this.items;
-    const map = await this.loader();
-    const key = toKey(this.root[this.localKey]);
-    const rows = map.get(key) ?? [];
-    this.items = rows.map(row => this.createEntity(row));
-    this.loaded = true;
-    return this.items;
-  }
-
-  getItems(): TChild[] {
-    return this.items;
-  }
-
-  add(data: Partial<TChild>): TChild {
-    const keyValue = this.root[this.localKey];
-    const childRow: Record<string, any> = {
-      ...data,
-      [this.relation.foreignKey]: keyValue
-    };
-    const entity = this.createEntity(childRow);
-    this.added.add(entity);
-    this.items.push(entity);
-    this.ctx.registerRelationChange(
-      this.root,
-      this.relationKey,
-      this.rootTable,
-      this.relationName,
-      this.relation,
-      { kind: 'add', entity }
-    );
-    return entity;
-  }
-
-  attach(entity: TChild): void {
-    const keyValue = this.root[this.localKey];
-    (entity as Record<string, any>)[this.relation.foreignKey] = keyValue;
-    this.ctx.markDirty(entity);
-    this.items.push(entity);
-    this.ctx.registerRelationChange(
-      this.root,
-      this.relationKey,
-      this.rootTable,
-      this.relationName,
-      this.relation,
-      { kind: 'attach', entity }
-    );
-  }
-
-  remove(entity: TChild): void {
-    this.items = this.items.filter(item => item !== entity);
-    this.removed.add(entity);
-    this.ctx.registerRelationChange(
-      this.root,
-      this.relationKey,
-      this.rootTable,
-      this.relationName,
-      this.relation,
-      { kind: 'remove', entity }
-    );
-  }
-
-  clear(): void {
-    for (const entity of [...this.items]) {
-      this.remove(entity);
-    }
-  }
-
-  private get relationKey(): RelationKey {
-    return `${this.rootTable.name}.${this.relationName}`;
-  }
-
-  private hydrateFromCache(): void {
-    const keyValue = this.root[this.localKey];
-    if (keyValue === undefined || keyValue === null) return;
-    const rows = getHydrationRows(this.meta, this.relationName, keyValue);
-    if (!rows?.length) return;
-    this.items = rows.map(row => this.createEntity(row));
-    this.loaded = true;
-  }
-}
+import { HasManyCollection } from '../../schema/types.js';
+import { OrmContext, RelationKey } from '../orm-context.js';
+import { HasManyRelation } from '../../schema/relation.js';
+import { TableDef } from '../../schema/table.js';
+import { EntityMeta, getHydrationRows } from '../entity-meta.js';
+
+type Rows = Record<string, any>[];
+
+const toKey = (value: unknown): string => (value === null || value === undefined ? '' : String(value));
+
+export class DefaultHasManyCollection<TChild> implements HasManyCollection<TChild> {
+  private loaded = false;
+  private items: TChild[] = [];
+  private readonly added = new Set<TChild>();
+  private readonly removed = new Set<TChild>();
+
+  constructor(
+    private readonly ctx: OrmContext,
+    private readonly meta: EntityMeta<any>,
+    private readonly root: any,
+    private readonly relationName: string,
+    private readonly relation: HasManyRelation,
+    private readonly rootTable: TableDef,
+    private readonly loader: () => Promise<Map<string, Rows>>,
+    private readonly createEntity: (row: Record<string, any>) => TChild,
+    private readonly localKey: string
+  ) {
+    this.hydrateFromCache();
+  }
+
+  async load(): Promise<TChild[]> {
+    if (this.loaded) return this.items;
+    const map = await this.loader();
+    const key = toKey(this.root[this.localKey]);
+    const rows = map.get(key) ?? [];
+    this.items = rows.map(row => this.createEntity(row));
+    this.loaded = true;
+    return this.items;
+  }
+
+  getItems(): TChild[] {
+    return this.items;
+  }
+
+  add(data: Partial<TChild>): TChild {
+    const keyValue = this.root[this.localKey];
+    const childRow: Record<string, any> = {
+      ...data,
+      [this.relation.foreignKey]: keyValue
+    };
+    const entity = this.createEntity(childRow);
+    this.added.add(entity);
+    this.items.push(entity);
+    this.ctx.registerRelationChange(
+      this.root,
+      this.relationKey,
+      this.rootTable,
+      this.relationName,
+      this.relation,
+      { kind: 'add', entity }
+    );
+    return entity;
+  }
+
+  attach(entity: TChild): void {
+    const keyValue = this.root[this.localKey];
+    (entity as Record<string, any>)[this.relation.foreignKey] = keyValue;
+    this.ctx.markDirty(entity);
+    this.items.push(entity);
+    this.ctx.registerRelationChange(
+      this.root,
+      this.relationKey,
+      this.rootTable,
+      this.relationName,
+      this.relation,
+      { kind: 'attach', entity }
+    );
+  }
+
+  remove(entity: TChild): void {
+    this.items = this.items.filter(item => item !== entity);
+    this.removed.add(entity);
+    this.ctx.registerRelationChange(
+      this.root,
+      this.relationKey,
+      this.rootTable,
+      this.relationName,
+      this.relation,
+      { kind: 'remove', entity }
+    );
+  }
+
+  clear(): void {
+    for (const entity of [...this.items]) {
+      this.remove(entity);
+    }
+  }
+
+  private get relationKey(): RelationKey {
+    return `${this.rootTable.name}.${this.relationName}`;
+  }
+
+  private hydrateFromCache(): void {
+    const keyValue = this.root[this.localKey];
+    if (keyValue === undefined || keyValue === null) return;
+    const rows = getHydrationRows(this.meta, this.relationName, keyValue);
+    if (!rows?.length) return;
+    this.items = rows.map(row => this.createEntity(row));
+    this.loaded = true;
+  }
+}

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

@@ -1,149 +1,149 @@
-import { ManyToManyCollection } from '../../schema/types';
-import { OrmContext, RelationKey } from '../orm-context';
-import { BelongsToManyRelation } from '../../schema/relation';
-import { TableDef } from '../../schema/table';
-import { findPrimaryKey } from '../../builder/hydration-planner';
-import { EntityMeta, getHydrationRows } from '../entity-meta';
-
-type Rows = Record<string, any>[];
-
-const toKey = (value: unknown): string => (value === null || value === undefined ? '' : String(value));
-
-export class DefaultManyToManyCollection<TTarget> implements ManyToManyCollection<TTarget> {
-  private loaded = false;
-  private items: TTarget[] = [];
-
-  constructor(
-    private readonly ctx: OrmContext,
-    private readonly meta: EntityMeta<any>,
-    private readonly root: any,
-    private readonly relationName: string,
-    private readonly relation: BelongsToManyRelation,
-    private readonly rootTable: TableDef,
-    private readonly loader: () => Promise<Map<string, Rows>>,
-    private readonly createEntity: (row: Record<string, any>) => TTarget,
-    private readonly localKey: string
-  ) {
-    this.hydrateFromCache();
-  }
-
-  async load(): Promise<TTarget[]> {
-    if (this.loaded) return this.items;
-    const map = await this.loader();
-    const key = toKey(this.root[this.localKey]);
-    const rows = map.get(key) ?? [];
-    this.items = rows.map(row => {
-      const entity = this.createEntity(row);
-      if ((row as any)._pivot) {
-        (entity as any)._pivot = row._pivot;
-      }
-      return entity;
-    });
-    this.loaded = true;
-    return this.items;
-  }
-
-  getItems(): TTarget[] {
-    return this.items;
-  }
-
-  attach(target: TTarget | number | string): void {
-    const entity = this.ensureEntity(target);
-    const id = this.extractId(entity);
-    if (id == null) return;
-    if (this.items.some(item => this.extractId(item) === id)) {
-      return;
-    }
-    this.items.push(entity);
-    this.ctx.registerRelationChange(
-      this.root,
-      this.relationKey,
-      this.rootTable,
-      this.relationName,
-      this.relation,
-      { kind: 'attach', entity }
-    );
-  }
-
-  detach(target: TTarget | number | string): void {
-    const id = typeof target === 'number' || typeof target === 'string'
-      ? target
-      : this.extractId(target);
-
-    if (id == null) return;
-
-    const existing = this.items.find(item => this.extractId(item) === id);
-    if (!existing) return;
-
-    this.items = this.items.filter(item => this.extractId(item) !== id);
-    this.ctx.registerRelationChange(
-      this.root,
-      this.relationKey,
-      this.rootTable,
-      this.relationName,
-      this.relation,
-      { kind: 'detach', entity: existing }
-    );
-  }
-
-  async syncByIds(ids: (number | string)[]): Promise<void> {
-    await this.load();
-    const targetKey = this.relation.targetKey || findPrimaryKey(this.relation.target);
-    const normalized = new Set(ids.map(id => toKey(id)));
-    const currentIds = new Set(this.items.map(item => toKey(this.extractId(item))));
-
-    for (const id of normalized) {
-      if (!currentIds.has(id)) {
-        this.attach(id);
-      }
-    }
-
-    for (const item of [...this.items]) {
-      const itemId = toKey(this.extractId(item));
-      if (!normalized.has(itemId)) {
-        this.detach(item);
-      }
-    }
-  }
-
-  private ensureEntity(target: TTarget | number | string): TTarget {
-    if (typeof target === 'number' || typeof target === 'string') {
-      const stub: Record<string, any> = {
-        [this.targetKey]: target
-      };
-      return this.createEntity(stub);
-    }
-    return target;
-  }
-
-  private extractId(entity: TTarget | number | string | null | undefined): number | string | null {
-    if (entity === null || entity === undefined) return null;
-    if (typeof entity === 'number' || typeof entity === 'string') {
-      return entity;
-    }
-    return (entity as any)[this.targetKey] ?? null;
-  }
-
-  private get relationKey(): RelationKey {
-    return `${this.rootTable.name}.${this.relationName}`;
-  }
-
-  private get targetKey(): string {
-    return this.relation.targetKey || findPrimaryKey(this.relation.target);
-  }
-
-  private hydrateFromCache(): void {
-    const keyValue = this.root[this.localKey];
-    if (keyValue === undefined || keyValue === null) return;
-    const rows = getHydrationRows(this.meta, this.relationName, keyValue);
-    if (!rows?.length) return;
-    this.items = rows.map(row => {
-      const entity = this.createEntity(row);
-      if ((row as any)._pivot) {
-        (entity as any)._pivot = (row as any)._pivot;
-      }
-      return entity;
-    });
-    this.loaded = true;
-  }
-}
+import { ManyToManyCollection } from '../../schema/types.js';
+import { OrmContext, RelationKey } from '../orm-context.js';
+import { BelongsToManyRelation } from '../../schema/relation.js';
+import { TableDef } from '../../schema/table.js';
+import { findPrimaryKey } from '../../query-builder/hydration-planner.js';
+import { EntityMeta, getHydrationRows } from '../entity-meta.js';
+
+type Rows = Record<string, any>[];
+
+const toKey = (value: unknown): string => (value === null || value === undefined ? '' : String(value));
+
+export class DefaultManyToManyCollection<TTarget> implements ManyToManyCollection<TTarget> {
+  private loaded = false;
+  private items: TTarget[] = [];
+
+  constructor(
+    private readonly ctx: OrmContext,
+    private readonly meta: EntityMeta<any>,
+    private readonly root: any,
+    private readonly relationName: string,
+    private readonly relation: BelongsToManyRelation,
+    private readonly rootTable: TableDef,
+    private readonly loader: () => Promise<Map<string, Rows>>,
+    private readonly createEntity: (row: Record<string, any>) => TTarget,
+    private readonly localKey: string
+  ) {
+    this.hydrateFromCache();
+  }
+
+  async load(): Promise<TTarget[]> {
+    if (this.loaded) return this.items;
+    const map = await this.loader();
+    const key = toKey(this.root[this.localKey]);
+    const rows = map.get(key) ?? [];
+    this.items = rows.map(row => {
+      const entity = this.createEntity(row);
+      if ((row as any)._pivot) {
+        (entity as any)._pivot = row._pivot;
+      }
+      return entity;
+    });
+    this.loaded = true;
+    return this.items;
+  }
+
+  getItems(): TTarget[] {
+    return this.items;
+  }
+
+  attach(target: TTarget | number | string): void {
+    const entity = this.ensureEntity(target);
+    const id = this.extractId(entity);
+    if (id == null) return;
+    if (this.items.some(item => this.extractId(item) === id)) {
+      return;
+    }
+    this.items.push(entity);
+    this.ctx.registerRelationChange(
+      this.root,
+      this.relationKey,
+      this.rootTable,
+      this.relationName,
+      this.relation,
+      { kind: 'attach', entity }
+    );
+  }
+
+  detach(target: TTarget | number | string): void {
+    const id = typeof target === 'number' || typeof target === 'string'
+      ? target
+      : this.extractId(target);
+
+    if (id == null) return;
+
+    const existing = this.items.find(item => this.extractId(item) === id);
+    if (!existing) return;
+
+    this.items = this.items.filter(item => this.extractId(item) !== id);
+    this.ctx.registerRelationChange(
+      this.root,
+      this.relationKey,
+      this.rootTable,
+      this.relationName,
+      this.relation,
+      { kind: 'detach', entity: existing }
+    );
+  }
+
+  async syncByIds(ids: (number | string)[]): Promise<void> {
+    await this.load();
+    const targetKey = this.relation.targetKey || findPrimaryKey(this.relation.target);
+    const normalized = new Set(ids.map(id => toKey(id)));
+    const currentIds = new Set(this.items.map(item => toKey(this.extractId(item))));
+
+    for (const id of normalized) {
+      if (!currentIds.has(id)) {
+        this.attach(id);
+      }
+    }
+
+    for (const item of [...this.items]) {
+      const itemId = toKey(this.extractId(item));
+      if (!normalized.has(itemId)) {
+        this.detach(item);
+      }
+    }
+  }
+
+  private ensureEntity(target: TTarget | number | string): TTarget {
+    if (typeof target === 'number' || typeof target === 'string') {
+      const stub: Record<string, any> = {
+        [this.targetKey]: target
+      };
+      return this.createEntity(stub);
+    }
+    return target;
+  }
+
+  private extractId(entity: TTarget | number | string | null | undefined): number | string | null {
+    if (entity === null || entity === undefined) return null;
+    if (typeof entity === 'number' || typeof entity === 'string') {
+      return entity;
+    }
+    return (entity as any)[this.targetKey] ?? null;
+  }
+
+  private get relationKey(): RelationKey {
+    return `${this.rootTable.name}.${this.relationName}`;
+  }
+
+  private get targetKey(): string {
+    return this.relation.targetKey || findPrimaryKey(this.relation.target);
+  }
+
+  private hydrateFromCache(): void {
+    const keyValue = this.root[this.localKey];
+    if (keyValue === undefined || keyValue === null) return;
+    const rows = getHydrationRows(this.meta, this.relationName, keyValue);
+    if (!rows?.length) return;
+    this.items = rows.map(row => {
+      const entity = this.createEntity(row);
+      if ((row as any)._pivot) {
+        (entity as any)._pivot = (row as any)._pivot;
+      }
+      return entity;
+    });
+    this.loaded = true;
+  }
+}

package/src/orm/runtime-types.ts

@@ -0,0 +1,39 @@
+import { RelationDef } from '../schema/relation.js';
+import { TableDef } from '../schema/table.js';
+
+export enum EntityStatus {
+  New = 'new',
+  Managed = 'managed',
+  Dirty = 'dirty',
+  Removed = 'removed',
+  Detached = 'detached'
+}
+
+export interface TrackedEntity {
+  table: TableDef;
+  entity: any;
+  pk: string | number | null;
+  status: EntityStatus;
+  original: Record<string, any> | null;
+}
+
+export type RelationKey = string;
+
+export type RelationChange<T> =
+  | { kind: 'add'; entity: T }
+  | { kind: 'attach'; entity: T }
+  | { kind: 'remove'; entity: T }
+  | { kind: 'detach'; entity: T };
+
+export interface RelationChangeEntry {
+  root: any;
+  relationKey: RelationKey;
+  rootTable: TableDef;
+  relationName: string;
+  relation: RelationDef;
+  change: RelationChange<any>;
+}
+
+export interface HasDomainEvents {
+  domainEvents?: any[];
+}

package/src/orm/transaction-runner.ts

@@ -0,0 +1,17 @@
+import type { DbExecutor } from './db-executor.js';
+
+export const runInTransaction = async (executor: DbExecutor, action: () => Promise<void>): Promise<void> => {
+  if (!executor.beginTransaction) {
+    await action();
+    return;
+  }
+
+  await executor.beginTransaction();
+  try {
+    await action();
+    await executor.commitTransaction?.();
+  } catch (error) {
+    await executor.rollbackTransaction?.();
+    throw error;
+  }
+};