metal-orm 1.1.11 → 1.1.18

package/src/orm/relations/morph-to.ts

@@ -1,162 +1,162 @@
-import { BelongsToReferenceApi } from '../../schema/types.js';
-import { EntityContext } from '../entity-context.js';
-import { RelationKey } from '../runtime-types.js';
-import { MorphToRelation } from '../../schema/relation.js';
-import { TableDef } from '../../schema/table.js';
-import { EntityMeta, getHydrationRecord, hasEntityMeta } from '../entity-meta.js';
-
-type Row = Record<string, unknown>;
-
-const toKey = (value: unknown): string => (value === null || value === undefined ? '' : String(value));
-
-const hideInternal = (obj: object, keys: string[]): void => {
-  for (const key of keys) {
-    Object.defineProperty(obj, key, {
-      value: obj[key],
-      writable: false,
-      configurable: false,
-      enumerable: false
-    });
-  }
-};
-
-const hideWritable = (obj: object, keys: string[]): void => {
-  for (const key of keys) {
-    const value = obj[key as keyof typeof obj];
-    Object.defineProperty(obj, key, {
-      value,
-      writable: true,
-      configurable: true,
-      enumerable: false
-    });
-  }
-};
-
-export class DefaultMorphToReference<TParent extends object> implements BelongsToReferenceApi<TParent> {
-  private loaded = false;
-  private current: TParent | null = null;
-
-  constructor(
-    private readonly ctx: EntityContext,
-    private readonly meta: EntityMeta<TableDef>,
-    private readonly root: unknown,
-    private readonly relationName: string,
-    private readonly relation: MorphToRelation,
-    private readonly rootTable: TableDef,
-    private readonly loader: () => Promise<Map<string, Row>>,
-    private readonly createEntity: (table: TableDef, row: Row) => TParent,
-    private readonly resolveTargetTable: (typeValue: string) => TableDef | undefined
-  ) {
-    hideInternal(this, [
-      'ctx', 'meta', 'root', 'relationName', 'relation',
-      'rootTable', 'loader', 'createEntity', 'resolveTargetTable'
-    ]);
-    hideWritable(this, ['loaded', 'current']);
-    this.populateFromHydrationCache();
-  }
-
-  async load(): Promise<TParent | null> {
-    if (this.loaded) return this.current;
-    const rootObj = this.root as Row;
-    const typeValue = rootObj[this.relation.typeField];
-    const idValue = rootObj[this.relation.idField];
-    if (!typeValue || idValue === undefined || idValue === null) {
-      this.loaded = true;
-      return this.current;
-    }
-
-    const map = await this.loader();
-    const compositeKey = `${toKey(typeValue)}:${toKey(idValue)}`;
-    const row = map.get(compositeKey);
-    if (row) {
-      const targetTable = this.resolveTargetTable(toKey(typeValue));
-      if (targetTable) {
-        this.current = this.createEntity(targetTable, row);
-      }
-    }
-    this.loaded = true;
-    return this.current;
-  }
-
-  get(): TParent | null {
-    return this.current;
-  }
-
-  set(data: Partial<TParent> | TParent | null): TParent | null {
-    if (data === null) {
-      return this.detachCurrent();
-    }
-
-    const entity = hasEntityMeta(data) ? (data as TParent) : (data as TParent);
-    if (this.current && this.current !== entity) {
-      this.ctx.registerRelationChange(
-        this.root,
-        this.relationKey,
-        this.rootTable,
-        this.relationName,
-        this.relation,
-        { kind: 'remove', entity: this.current }
-      );
-    }
-
-    this.current = entity;
-    this.loaded = true;
-
-    this.ctx.registerRelationChange(
-      this.root,
-      this.relationKey,
-      this.rootTable,
-      this.relationName,
-      this.relation,
-      { kind: 'attach', entity }
-    );
-
-    return entity;
-  }
-
-  toJSON(): unknown {
-    if (!this.current) return null;
-    const entityWithToJSON = this.current as { toJSON?: () => unknown };
-    return typeof entityWithToJSON.toJSON === 'function'
-      ? entityWithToJSON.toJSON()
-      : this.current;
-  }
-
-  private detachCurrent(): TParent | null {
-    const previous = this.current;
-    if (!previous) return null;
-    this.current = null;
-    this.loaded = true;
-    const rootObj = this.root as Row;
-    rootObj[this.relation.typeField] = null;
-    rootObj[this.relation.idField] = null;
-    this.ctx.registerRelationChange(
-      this.root,
-      this.relationKey,
-      this.rootTable,
-      this.relationName,
-      this.relation,
-      { kind: 'remove', entity: previous }
-    );
-    return null;
-  }
-
-  private get relationKey(): RelationKey {
-    return `${this.rootTable.name}.${this.relationName}`;
-  }
-
-  private populateFromHydrationCache(): void {
-    const rootObj = this.root as Row;
-    const typeValue = rootObj[this.relation.typeField];
-    const idValue = rootObj[this.relation.idField];
-    if (!typeValue || idValue === undefined || idValue === null) return;
-    const compositeKey = `${toKey(typeValue)}:${toKey(idValue)}`;
-    const row = getHydrationRecord(this.meta, this.relationName, compositeKey);
-    if (!row) return;
-    const targetTable = this.resolveTargetTable(toKey(typeValue));
-    if (targetTable) {
-      this.current = this.createEntity(targetTable, row);
-      this.loaded = true;
-    }
-  }
-}
+import { BelongsToReferenceApi } from '../../schema/types.js';
+import { EntityContext } from '../entity-context.js';
+import { RelationKey } from '../runtime-types.js';
+import { MorphToRelation } from '../../schema/relation.js';
+import { TableDef } from '../../schema/table.js';
+import { EntityMeta, getHydrationRecord, hasEntityMeta } from '../entity-meta.js';
+
+type Row = Record<string, unknown>;
+
+const toKey = (value: unknown): string => (value === null || value === undefined ? '' : String(value));
+
+const hideInternal = (obj: object, keys: string[]): void => {
+  for (const key of keys) {
+    Object.defineProperty(obj, key, {
+      value: obj[key],
+      writable: false,
+      configurable: false,
+      enumerable: false
+    });
+  }
+};
+
+const hideWritable = (obj: object, keys: string[]): void => {
+  for (const key of keys) {
+    const value = obj[key as keyof typeof obj];
+    Object.defineProperty(obj, key, {
+      value,
+      writable: true,
+      configurable: true,
+      enumerable: false
+    });
+  }
+};
+
+export class DefaultMorphToReference<TParent extends object> implements BelongsToReferenceApi<TParent> {
+  private loaded = false;
+  private current: TParent | null = null;
+
+  constructor(
+    private readonly ctx: EntityContext,
+    private readonly meta: EntityMeta<TableDef>,
+    private readonly root: unknown,
+    private readonly relationName: string,
+    private readonly relation: MorphToRelation,
+    private readonly rootTable: TableDef,
+    private readonly loader: () => Promise<Map<string, Row>>,
+    private readonly createEntity: (table: TableDef, row: Row) => TParent,
+    private readonly resolveTargetTable: (typeValue: string) => TableDef | undefined
+  ) {
+    hideInternal(this, [
+      'ctx', 'meta', 'root', 'relationName', 'relation',
+      'rootTable', 'loader', 'createEntity', 'resolveTargetTable'
+    ]);
+    hideWritable(this, ['loaded', 'current']);
+    this.populateFromHydrationCache();
+  }
+
+  async load(): Promise<TParent | null> {
+    if (this.loaded) return this.current;
+    const rootObj = this.root as Row;
+    const typeValue = rootObj[this.relation.typeField];
+    const idValue = rootObj[this.relation.idField];
+    if (!typeValue || idValue === undefined || idValue === null) {
+      this.loaded = true;
+      return this.current;
+    }
+
+    const map = await this.loader();
+    const compositeKey = `${toKey(typeValue)}:${toKey(idValue)}`;
+    const row = map.get(compositeKey);
+    if (row) {
+      const targetTable = this.resolveTargetTable(toKey(typeValue));
+      if (targetTable) {
+        this.current = this.createEntity(targetTable, row);
+      }
+    }
+    this.loaded = true;
+    return this.current;
+  }
+
+  get(): TParent | null {
+    return this.current;
+  }
+
+  set(data: Partial<TParent> | TParent | null): TParent | null {
+    if (data === null) {
+      return this.detachCurrent();
+    }
+
+    const entity = hasEntityMeta(data) ? (data as TParent) : (data as TParent);
+    if (this.current && this.current !== entity) {
+      this.ctx.registerRelationChange(
+        this.root,
+        this.relationKey,
+        this.rootTable,
+        this.relationName,
+        this.relation,
+        { kind: 'remove', entity: this.current }
+      );
+    }
+
+    this.current = entity;
+    this.loaded = true;
+
+    this.ctx.registerRelationChange(
+      this.root,
+      this.relationKey,
+      this.rootTable,
+      this.relationName,
+      this.relation,
+      { kind: 'attach', entity }
+    );
+
+    return entity;
+  }
+
+  toJSON(): unknown {
+    if (!this.current) return null;
+    const entityWithToJSON = this.current as { toJSON?: () => unknown };
+    return typeof entityWithToJSON.toJSON === 'function'
+      ? entityWithToJSON.toJSON()
+      : this.current;
+  }
+
+  private detachCurrent(): TParent | null {
+    const previous = this.current;
+    if (!previous) return null;
+    this.current = null;
+    this.loaded = true;
+    const rootObj = this.root as Row;
+    rootObj[this.relation.typeField] = null;
+    rootObj[this.relation.idField] = null;
+    this.ctx.registerRelationChange(
+      this.root,
+      this.relationKey,
+      this.rootTable,
+      this.relationName,
+      this.relation,
+      { kind: 'remove', entity: previous }
+    );
+    return null;
+  }
+
+  private get relationKey(): RelationKey {
+    return `${this.rootTable.name}.${this.relationName}`;
+  }
+
+  private populateFromHydrationCache(): void {
+    const rootObj = this.root as Row;
+    const typeValue = rootObj[this.relation.typeField];
+    const idValue = rootObj[this.relation.idField];
+    if (!typeValue || idValue === undefined || idValue === null) return;
+    const compositeKey = `${toKey(typeValue)}:${toKey(idValue)}`;
+    const row = getHydrationRecord(this.meta, this.relationName, compositeKey);
+    if (!row) return;
+    const targetTable = this.resolveTargetTable(toKey(typeValue));
+    if (targetTable) {
+      this.current = this.createEntity(targetTable, row);
+      this.loaded = true;
+    }
+  }
+}

package/src/orm/runtime-types.ts

@@ -1,98 +1,98 @@
-import { RelationDef } from '../schema/relation.js';
-import { TableDef } from '../schema/table.js';
-
-/**
- * Entity status enum representing the lifecycle state of an entity
- */
-export enum EntityStatus {
-  /** Entity is newly created and not yet persisted */
-  New = 'new',
-  /** Entity is managed by the ORM and synchronized with the database */
-  Managed = 'managed',
-  /** Entity has been modified but not yet persisted */
-  Dirty = 'dirty',
-  /** Entity has been marked for removal */
-  Removed = 'removed',
-  /** Entity is detached from the ORM context */
-  Detached = 'detached'
-}
-
-/**
- * Represents an entity being tracked by the ORM
- */
-export interface TrackedEntity {
-  /** The table definition this entity belongs to */
-  table: TableDef;
-  /** The actual entity instance */
-  entity: object;
-  /** Primary key value of the entity */
-  pk: string | number | null;
-  /** Current status of the entity */
-  status: EntityStatus;
-  /** Original values of the entity when it was loaded */
-  original: Record<string, unknown> | null;
-}
-
-/**
- * Type representing a key for relation navigation
- */
-export type RelationKey = string;
-
-/**
- * Represents a change operation on a relation
- * @typeParam T - Type of the related entity
- */
+import { RelationDef } from '../schema/relation.js';
+import { TableDef } from '../schema/table.js';
+
+/**
+ * Entity status enum representing the lifecycle state of an entity
+ */
+export enum EntityStatus {
+  /** Entity is newly created and not yet persisted */
+  New = 'new',
+  /** Entity is managed by the ORM and synchronized with the database */
+  Managed = 'managed',
+  /** Entity has been modified but not yet persisted */
+  Dirty = 'dirty',
+  /** Entity has been marked for removal */
+  Removed = 'removed',
+  /** Entity is detached from the ORM context */
+  Detached = 'detached'
+}
+
+/**
+ * Represents an entity being tracked by the ORM
+ */
+export interface TrackedEntity {
+  /** The table definition this entity belongs to */
+  table: TableDef;
+  /** The actual entity instance */
+  entity: object;
+  /** Primary key value of the entity */
+  pk: string | number | null;
+  /** Current status of the entity */
+  status: EntityStatus;
+  /** Original values of the entity when it was loaded */
+  original: Record<string, unknown> | null;
+}
+
+/**
+ * Type representing a key for relation navigation
+ */
+export type RelationKey = string;
+
+/**
+ * Represents a change operation on a relation
+ * @typeParam T - Type of the related entity
+ */
 export type RelationChange<T> =
   | { kind: 'add'; entity: T; pivot?: Record<string, unknown> }
   | { kind: 'attach'; entity: T; pivot?: Record<string, unknown> }
   | { kind: 'update'; entity: T; pivot: Record<string, unknown> }
   | { kind: 'remove'; entity: T; pivot?: Record<string, unknown> }
   | { kind: 'detach'; entity: T; pivot?: Record<string, unknown> };
-
-/**
- * Represents a relation change entry in the unit of work
- */
-export interface RelationChangeEntry {
-  /** Root entity that owns the relation */
-  root: unknown;
-  /** Key of the relation being changed */
-  relationKey: RelationKey;
-  /** Table definition of the root entity */
-  rootTable: TableDef;
-  /** Name of the relation */
-  relationName: string;
-  /** Relation definition */
-  relation: RelationDef;
-  /** The change being applied */
-  change: RelationChange<unknown>;
-}
-
-/**
- * Represents a domain event that can be emitted by entities
- * @typeParam TType - Type of the event (string literal)
- */
-export interface DomainEvent<TType extends string = string> {
-  /** Type identifier for the event */
-  readonly type: TType;
-  /** Timestamp when the event occurred */
-  readonly occurredAt?: Date;
-}
-
-/**
- * Type representing any domain event
- */
-export type AnyDomainEvent = DomainEvent<string>;
-
-/**
- * Type representing ORM-specific domain events
- */
-export type OrmDomainEvent = AnyDomainEvent;
-
-/**
- * Interface for entities that can emit domain events
- * @typeParam E - Type of domain events this entity can emit
- */
-export interface HasDomainEvents<E extends DomainEvent = AnyDomainEvent> {
-  /** Array of domain events emitted by this entity */
-  domainEvents?: E[];
-}
+
+/**
+ * Represents a relation change entry in the unit of work
+ */
+export interface RelationChangeEntry {
+  /** Root entity that owns the relation */
+  root: unknown;
+  /** Key of the relation being changed */
+  relationKey: RelationKey;
+  /** Table definition of the root entity */
+  rootTable: TableDef;
+  /** Name of the relation */
+  relationName: string;
+  /** Relation definition */
+  relation: RelationDef;
+  /** The change being applied */
+  change: RelationChange<unknown>;
+}
+
+/**
+ * Represents a domain event that can be emitted by entities
+ * @typeParam TType - Type of the event (string literal)
+ */
+export interface DomainEvent<TType extends string = string> {
+  /** Type identifier for the event */
+  readonly type: TType;
+  /** Timestamp when the event occurred */
+  readonly occurredAt?: Date;
+}
+
+/**
+ * Type representing any domain event
+ */
+export type AnyDomainEvent = DomainEvent<string>;
+
+/**
+ * Type representing ORM-specific domain events
+ */
+export type OrmDomainEvent = AnyDomainEvent;
+
+/**
+ * Interface for entities that can emit domain events
+ * @typeParam E - Type of domain events this entity can emit
+ */
+export interface HasDomainEvents<E extends DomainEvent = AnyDomainEvent> {
+  /** Array of domain events emitted by this entity */
+  domainEvents?: E[];
+}