metal-orm 1.1.8 → 1.1.10

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

@@ -1,14 +1,14 @@
-import { and, eq } from '../core/ast/expression.js';
-import type { ValueOperandInput } 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 { UpdateQueryBuilder } from '../query-builder/update.js';
-import { findPrimaryKey } from '../query-builder/hydration-planner.js';
-import type { BelongsToManyRelation, HasManyRelation, HasOneRelation } from '../schema/relation.js';
-import { RelationKinds } from '../schema/relation.js';
-import type { TableDef } from '../schema/table.js';
-import type { DbExecutor } from '../core/execution/db-executor.js';
+import { and, eq } from '../core/ast/expression.js';
+import type { ValueOperandInput } 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 { UpdateQueryBuilder } from '../query-builder/update.js';
+import { findPrimaryKey } from '../query-builder/hydration-planner.js';
+import type { BelongsToManyRelation, HasManyRelation, HasOneRelation, MorphOneRelation, MorphManyRelation, MorphToRelation } from '../schema/relation.js';
+import { RelationKinds } from '../schema/relation.js';
+import type { TableDef } from '../schema/table.js';
+import type { DbExecutor } from '../core/execution/db-executor.js';
 import type { RelationChangeEntry } from './runtime-types.js';
 import { UnitOfWork } from './unit-of-work.js';
 
@@ -67,6 +67,15 @@ export class RelationChangeProcessor {
         case RelationKinds.BelongsTo:
           await this.handleBelongsToChange(entry);
           break;
+        case RelationKinds.MorphOne:
+          await this.handleMorphOneChange(entry);
+          break;
+        case RelationKinds.MorphMany:
+          await this.handleMorphManyChange(entry);
+          break;
+        case RelationKinds.MorphTo:
+          await this.handleMorphToChange(entry);
+          break;
       }
     }
   }
@@ -138,28 +147,28 @@ export class RelationChangeProcessor {
    * Handles changes for belongs-to-many relations.
    * @param entry - The relation change entry
    */
-  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 as Record<string, unknown>, relation.target);
-    if (targetId === null) return;
-
-    const pivotPayload = this.buildPivotPayload(relation, entry.change.pivot);
-
-    if (entry.change.kind === 'update') {
-      if (pivotPayload) {
-        await this.updatePivotRow(relation, rootId, targetId, pivotPayload);
-      }
-      return;
-    }
-
-    if (entry.change.kind === 'attach' || entry.change.kind === 'add') {
-      await this.insertPivotRow(relation, rootId, targetId, pivotPayload);
-      return;
-    }
+  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 as Record<string, unknown>, relation.target);
+    if (targetId === null) return;
+
+    const pivotPayload = this.buildPivotPayload(relation, entry.change.pivot);
+
+    if (entry.change.kind === 'update') {
+      if (pivotPayload) {
+        await this.updatePivotRow(relation, rootId, targetId, pivotPayload);
+      }
+      return;
+    }
+
+    if (entry.change.kind === 'attach' || entry.change.kind === 'add') {
+      await this.insertPivotRow(relation, rootId, targetId, pivotPayload);
+      return;
+    }
 
     if (entry.change.kind === 'detach' || entry.change.kind === 'remove') {
       await this.deletePivotRow(relation, rootId, targetId);
@@ -228,46 +237,46 @@ export class RelationChangeProcessor {
    * @param rootId - The root entity's primary key value
    * @param targetId - The target entity's primary key value
    */
-  private async insertPivotRow(
-    relation: BelongsToManyRelation,
-    rootId: string | number,
-    targetId: string | number,
-    pivotPayload?: Record<string, unknown>
-  ): Promise<void> {
-    const payload = {
-      [relation.pivotForeignKeyToRoot]: rootId,
-      [relation.pivotForeignKeyToTarget]: targetId,
-      ...(pivotPayload ?? {})
-    };
-    const builder = new InsertQueryBuilder(relation.pivotTable)
-      .values(payload as Record<string, ValueOperandInput>);
-    const compiled = builder.compile(this.dialect);
-    await this.executor.executeSql(compiled.sql, compiled.params);
-  }
-
-  /**
-   * Updates a pivot row for belongs-to-many relations.
-   * @param relation - The belongs-to-many relation
-   * @param rootId - The root entity's primary key value
-   * @param targetId - The target entity's primary key value
-   * @param pivotPayload - The pivot columns to update
-   */
-  private async updatePivotRow(
-    relation: BelongsToManyRelation,
-    rootId: string | number,
-    targetId: string | number,
-    pivotPayload: Record<string, unknown>
-  ): Promise<void> {
-    const rootCol = relation.pivotTable.columns[relation.pivotForeignKeyToRoot];
-    const targetCol = relation.pivotTable.columns[relation.pivotForeignKeyToTarget];
-    if (!rootCol || !targetCol) return;
-
-    const builder = new UpdateQueryBuilder(relation.pivotTable)
-      .set(pivotPayload)
-      .where(and(eq(rootCol, rootId), eq(targetCol, targetId)));
-    const compiled = builder.compile(this.dialect);
-    await this.executor.executeSql(compiled.sql, compiled.params);
-  }
+  private async insertPivotRow(
+    relation: BelongsToManyRelation,
+    rootId: string | number,
+    targetId: string | number,
+    pivotPayload?: Record<string, unknown>
+  ): Promise<void> {
+    const payload = {
+      [relation.pivotForeignKeyToRoot]: rootId,
+      [relation.pivotForeignKeyToTarget]: targetId,
+      ...(pivotPayload ?? {})
+    };
+    const builder = new InsertQueryBuilder(relation.pivotTable)
+      .values(payload as Record<string, ValueOperandInput>);
+    const compiled = builder.compile(this.dialect);
+    await this.executor.executeSql(compiled.sql, compiled.params);
+  }
+
+  /**
+   * Updates a pivot row for belongs-to-many relations.
+   * @param relation - The belongs-to-many relation
+   * @param rootId - The root entity's primary key value
+   * @param targetId - The target entity's primary key value
+   * @param pivotPayload - The pivot columns to update
+   */
+  private async updatePivotRow(
+    relation: BelongsToManyRelation,
+    rootId: string | number,
+    targetId: string | number,
+    pivotPayload: Record<string, unknown>
+  ): Promise<void> {
+    const rootCol = relation.pivotTable.columns[relation.pivotForeignKeyToRoot];
+    const targetCol = relation.pivotTable.columns[relation.pivotForeignKeyToTarget];
+    if (!rootCol || !targetCol) return;
+
+    const builder = new UpdateQueryBuilder(relation.pivotTable)
+      .set(pivotPayload)
+      .where(and(eq(rootCol, rootId), eq(targetCol, targetId)));
+    const compiled = builder.compile(this.dialect);
+    await this.executor.executeSql(compiled.sql, compiled.params);
+  }
 
   /**
    * Deletes a pivot row for belongs-to-many relations.
@@ -293,26 +302,119 @@ export class RelationChangeProcessor {
    * @param table - The table definition
    * @returns The primary key value or null
    */
-  private resolvePrimaryKeyValue(entity: Record<string, unknown>, 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 as string | number | null | undefined) ?? null;
-  }
-
-  private buildPivotPayload(
-    relation: BelongsToManyRelation,
-    pivot: Record<string, unknown> | undefined
-  ): Record<string, unknown> | undefined {
-    if (!pivot) return undefined;
-    const payload: Record<string, unknown> = {};
-    for (const [key, value] of Object.entries(pivot)) {
-      if (value === undefined) continue;
-      if (!relation.pivotTable.columns[key]) continue;
-      if (key === relation.pivotForeignKeyToRoot || key === relation.pivotForeignKeyToTarget) continue;
-      payload[key] = value;
-    }
-    return Object.keys(payload).length ? payload : undefined;
-  }
-}
+  private resolvePrimaryKeyValue(entity: Record<string, unknown>, 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 as string | number | null | undefined) ?? null;
+  }
+
+  private buildPivotPayload(
+    relation: BelongsToManyRelation,
+    pivot: Record<string, unknown> | undefined
+  ): Record<string, unknown> | undefined {
+    if (!pivot) return undefined;
+    const payload: Record<string, unknown> = {};
+    for (const [key, value] of Object.entries(pivot)) {
+      if (value === undefined) continue;
+      if (!relation.pivotTable.columns[key]) continue;
+      if (key === relation.pivotForeignKeyToRoot || key === relation.pivotForeignKeyToTarget) continue;
+      payload[key] = value;
+    }
+    return Object.keys(payload).length ? payload : undefined;
+  }
+
+  private async handleMorphOneChange(entry: RelationChangeEntry): Promise<void> {
+    const relation = entry.relation as MorphOneRelation;
+    const target = entry.change.entity;
+    if (!target) return;
+
+    const tracked = this.unitOfWork.findTracked(target as object);
+    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') {
+      const child = tracked.entity as Record<string, unknown>;
+      child[relation.idField] = rootValue;
+      child[relation.typeField] = relation.typeValue;
+      this.unitOfWork.markDirty(tracked.entity);
+      return;
+    }
+
+    if (entry.change.kind === 'remove') {
+      const child = tracked.entity as Record<string, unknown>;
+      if (relation.cascade === 'all' || relation.cascade === 'remove') {
+        this.unitOfWork.markRemoved(child);
+        return;
+      }
+      child[relation.idField] = null;
+      child[relation.typeField] = null;
+      this.unitOfWork.markDirty(child);
+    }
+  }
+
+  private async handleMorphManyChange(entry: RelationChangeEntry): Promise<void> {
+    const relation = entry.relation as MorphManyRelation;
+    const target = entry.change.entity;
+    if (!target) return;
+
+    const tracked = this.unitOfWork.findTracked(target as object);
+    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') {
+      const child = tracked.entity as Record<string, unknown>;
+      child[relation.idField] = rootValue;
+      child[relation.typeField] = relation.typeValue;
+      this.unitOfWork.markDirty(tracked.entity);
+      return;
+    }
+
+    if (entry.change.kind === 'remove') {
+      const child = tracked.entity as Record<string, unknown>;
+      if (relation.cascade === 'all' || relation.cascade === 'remove') {
+        this.unitOfWork.markRemoved(child);
+        return;
+      }
+      child[relation.idField] = null;
+      child[relation.typeField] = null;
+      this.unitOfWork.markDirty(child);
+    }
+  }
+
+  private async handleMorphToChange(entry: RelationChangeEntry): Promise<void> {
+    const relation = entry.relation as MorphToRelation;
+    const target = entry.change.entity;
+    if (!target) return;
+
+    if (entry.change.kind === 'attach' || entry.change.kind === 'add') {
+      const targetEntity = target as Record<string, unknown>;
+      for (const [typeValue, targetTable] of Object.entries(relation.targets)) {
+        const targetPk = relation.targetKey || findPrimaryKey(targetTable);
+        const pkValue = targetEntity[targetPk];
+        if (pkValue !== undefined && pkValue !== null) {
+          const rootEntity = entry.root as Record<string, unknown>;
+          rootEntity[relation.typeField] = typeValue;
+          rootEntity[relation.idField] = pkValue;
+          this.unitOfWork.markDirty(entry.root as object);
+          break;
+        }
+      }
+      return;
+    }
+
+    if (entry.change.kind === 'remove') {
+      const rootEntity = entry.root as Record<string, unknown>;
+      rootEntity[relation.typeField] = null;
+      rootEntity[relation.idField] = null;
+      this.unitOfWork.markDirty(entry.root as object);
+    }
+  }
+}

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

@@ -1,143 +1,143 @@
-import { BelongsToReferenceApi } from '../../schema/types.js';
-import { EntityContext } from '../entity-context.js';
-import { RelationKey } from '../runtime-types.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, 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
-    });
-  }
-};
-
-/**
- * Default implementation of a belongs-to reference.
- * Manages a reference to a parent entity from a child entity through a foreign key.
- *
- * @template TParent The type of the parent entity.
- */
-export class DefaultBelongsToReference<TParent extends object> implements BelongsToReferenceApi<TParent> {
-  private loaded = false;
-  private current: TParent | null = null;
-
-  /**
-   * @param ctx The entity context for tracking changes.
-   * @param meta Metadata for the child entity.
-   * @param root The child entity instance (carrying the foreign key).
-   * @param relationName The name of the relation.
-   * @param relation Relation definition.
-   * @param rootTable Table definition of the child entity.
-   * @param loader Function to load the parent entity.
-   * @param createEntity Function to create entity instances from rows.
-   * @param targetKey The primary key of the target (parent) table.
-   */
-  constructor(
-    private readonly ctx: EntityContext,
-    private readonly meta: EntityMeta<TableDef>,
-    private readonly root: unknown,
-    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, unknown>) => TParent,
-    private readonly targetKey: string
-  ) {
-    hideInternal(this, ['ctx', 'meta', 'root', 'relationName', 'relation', 'rootTable', 'loader', 'createEntity', 'targetKey']);
-    hideWritable(this, ['loaded', 'current']);
-    this.populateFromHydrationCache();
-  }
-
-  async load(): Promise<TParent | null> {
-    if (this.loaded) return this.current;
-    const map = await this.loader();
-    const fkValue = (this.root as Record<string, unknown>)[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 as Record<string, unknown>)[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, unknown>);
-    const pkValue = (entity as Record<string, unknown>)[this.targetKey];
-    if (pkValue !== undefined) {
-      (this.root as Record<string, unknown>)[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 as Record<string, unknown>)[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;
-  }
-
-  toJSON(): unknown {
-    if (!this.current) return null;
-    const entityWithToJSON = this.current as { toJSON?: () => unknown };
-    return typeof entityWithToJSON.toJSON === 'function'
-      ? entityWithToJSON.toJSON()
-      : this.current;
-  }
-}
+import { BelongsToReferenceApi } from '../../schema/types.js';
+import { EntityContext } from '../entity-context.js';
+import { RelationKey } from '../runtime-types.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, 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
+    });
+  }
+};
+
+/**
+ * Default implementation of a belongs-to reference.
+ * Manages a reference to a parent entity from a child entity through a foreign key.
+ *
+ * @template TParent The type of the parent entity.
+ */
+export class DefaultBelongsToReference<TParent extends object> implements BelongsToReferenceApi<TParent> {
+  private loaded = false;
+  private current: TParent | null = null;
+
+  /**
+   * @param ctx The entity context for tracking changes.
+   * @param meta Metadata for the child entity.
+   * @param root The child entity instance (carrying the foreign key).
+   * @param relationName The name of the relation.
+   * @param relation Relation definition.
+   * @param rootTable Table definition of the child entity.
+   * @param loader Function to load the parent entity.
+   * @param createEntity Function to create entity instances from rows.
+   * @param targetKey The primary key of the target (parent) table.
+   */
+  constructor(
+    private readonly ctx: EntityContext,
+    private readonly meta: EntityMeta<TableDef>,
+    private readonly root: unknown,
+    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, unknown>) => TParent,
+    private readonly targetKey: string
+  ) {
+    hideInternal(this, ['ctx', 'meta', 'root', 'relationName', 'relation', 'rootTable', 'loader', 'createEntity', 'targetKey']);
+    hideWritable(this, ['loaded', 'current']);
+    this.populateFromHydrationCache();
+  }
+
+  async load(): Promise<TParent | null> {
+    if (this.loaded) return this.current;
+    const map = await this.loader();
+    const fkValue = (this.root as Record<string, unknown>)[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 as Record<string, unknown>)[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, unknown>);
+    const pkValue = (entity as Record<string, unknown>)[this.targetKey];
+    if (pkValue !== undefined) {
+      (this.root as Record<string, unknown>)[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 as Record<string, unknown>)[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;
+  }
+
+  toJSON(): unknown {
+    if (!this.current) return null;
+    const entityWithToJSON = this.current as { toJSON?: () => unknown };
+    return typeof entityWithToJSON.toJSON === 'function'
+      ? entityWithToJSON.toJSON()
+      : this.current;
+  }
+}