@indexeddb-orm/idb-orm 0.0.1

package/src/services/RelationLoader.ts

@@ -0,0 +1,532 @@
+import { getEntityMetadata } from '../metadata/Entity';
+import { getRelationMetadata } from '../metadata/Relation';
+import type { EntityConstructor } from '../types';
+import { BaseEntity } from './BaseEntity';
+
+export class RelationLoader {
+  private db: {
+    table: (_name: string) => unknown;
+  };
+
+  constructor(database: {
+    table: (_name: string) => unknown;
+  }) {
+    this.db = database;
+  }
+
+  private resolveTableName(target: string | EntityConstructor): string {
+    if (typeof target === 'string') return target;
+
+    const meta = getEntityMetadata(target);
+    if (meta?.tableName) return meta.tableName;
+
+    const n = target.name;
+
+    return (/Entity$/i.test(n)
+    ? n.replace(/Entity$/i, '')
+    : n).toLowerCase() + 's';
+  }
+
+  /**
+   * Load relations for an entity
+   * @param entity - The entity to load relations for
+   * @param entityClass - The entity class
+   * @param relationNames - Optional array of specific relation names to load.
+   * If not provided, loads all eager relations.
+   */
+  async loadRelations<T extends BaseEntity>(
+    entity: T,
+    entityClass: EntityConstructor<T>,
+    relationNames?: string[],
+  ): Promise<T> {
+    const relations = getRelationMetadata(entityClass);
+
+    if (!relations)  {
+      return entity;
+    }
+
+    const loadedEntity = { ...entity };
+
+    const relationsToLoad = relationNames
+      ? relationNames.filter(name => relations[name])
+      : Object.entries(relations)
+          .filter(([, meta]) => meta.eager)
+          .map(([name]) => name);
+
+    for (const relationName of relationsToLoad) {
+      const relationMeta = relations[relationName];
+
+      if (relationMeta) {
+        (loadedEntity as Record<string, unknown>)[relationName] =
+          await this.loadRelation(entity, relationMeta);
+      }
+    }
+
+    return loadedEntity;
+  }
+
+  /**
+   * Load a specific relation by name
+   * @param entity - The entity to load relation for
+   * @param entityClass - The entity class
+   * @param relationName - The name of the relation to load
+   * @returns Promise resolving to the loaded relation data
+   */
+  async loadRelationByName<
+    T extends BaseEntity,
+    K extends keyof T
+  >(
+    entity: T,
+    entityClass: EntityConstructor<T>,
+    relationName: K,
+  ): Promise<T[K]> {
+    const relations = getRelationMetadata(entityClass);
+
+    if (!relations || !relations[String(relationName as string)]) {
+      throw new Error(
+        `Relation 
+        '${String(relationName)}' not found for entity ${entityClass.name}`,
+      );
+    }
+
+    const relationMeta = relations[String(relationName as string)];
+
+    return await this.loadRelation(entity, relationMeta) as T[K];
+  }
+
+  /**
+   * Load a specific relation based on metadata
+   * @param entity - The entity to load relation for
+   * @param relationMeta - The relation metadata containing:
+   * type, target, and configuration
+   * @returns Promise resolving to the loaded relation data
+   */
+  async loadRelation<T extends BaseEntity>(
+    entity: T,
+    relationMeta: {
+      type: string;
+      target: string | EntityConstructor;
+      foreignKey?: string;
+      joinTable?: string;
+    },
+  ): Promise<unknown> {
+    const targetName = this.resolveTableName(relationMeta.target);
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    const targetTable = this.db.table(targetName) as any;
+
+    switch (relationMeta.type) {
+      case 'one-to-one':
+        return await this.loadOneToOne(
+          entity as Record<string, unknown>,
+          targetTable,
+          relationMeta,
+        );
+
+      case 'one-to-many':
+        return await this.loadOneToMany(
+          entity as Record<string, unknown>,
+          targetTable,
+          relationMeta,
+        );
+
+      case 'many-to-many':
+        return await this.loadManyToMany(
+          entity as Record<string, unknown>,
+          targetTable,
+          relationMeta,
+        );
+
+      default:
+        throw new Error(`Unsupported relation type: ${relationMeta.type}`);
+    }
+  }
+
+  private async loadOneToOne(
+    entity: Record<string, unknown>,
+    targetTable: {
+      where: (_field: string) => {
+        equals: (_value: unknown) => { first: () => Promise<unknown> };
+      };
+      get: (_id: string | number) => Promise<unknown>;
+    },
+    relationMeta: { foreignKey?: string },
+  ): Promise<unknown> {
+    if (relationMeta.foreignKey) {
+      return await targetTable
+        .where(relationMeta.foreignKey)
+        .equals(entity.id)
+        .first();
+    } else {
+      const foreignKeyValue = entity[relationMeta.foreignKey as string];
+
+      if (!foreignKeyValue) {
+        return null;
+      }
+
+      return await targetTable.get(foreignKeyValue as string | number);
+    }
+  }
+
+  private async loadOneToMany(
+    entity: Record<string, unknown>,
+    targetTable: {
+      where: (_field: string) => {
+        equals: (_value: unknown) => { toArray: () => Promise<unknown[]> };
+      };
+    },
+    relationMeta: { foreignKey?: string },
+  ): Promise<unknown[]> {
+    if (!relationMeta.foreignKey) {
+      return [];
+    }
+
+    return await targetTable
+      .where(relationMeta.foreignKey)
+      .equals(entity.id)
+      .toArray();
+  }
+
+  /**
+   * Load many-to-many relation
+   */
+  private async loadManyToMany(
+    entity: Record<string, unknown>,
+    targetTable: {
+      where: (_field: string) => {
+        anyOf: (_values: unknown[]) => { toArray: () => Promise<unknown[]> };
+      };
+    },
+    relationMeta: { joinTable?: string },
+  ): Promise<unknown[]> {
+    if (!relationMeta.joinTable) {
+      return [];
+    }
+
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    const joinTable = this.db.table(relationMeta.joinTable) as any;
+    const joinRecords = await joinTable
+      .where('sourceId')
+      .equals(entity.id)
+      .toArray();
+    const targetIds = joinRecords.map((record: unknown) =>
+      (record as Record<string, unknown>).targetId,
+    );
+
+    if (targetIds.length === 0) {
+      return [];
+    }
+
+    return await targetTable
+      .where('id')
+      .anyOf(targetIds as (string | number)[])
+      .toArray();
+  }
+
+  /**
+   * Save entity with all its relations
+   * @param entity - The entity to save with relations
+   * @param entityClass - The entity class
+   * @returns Promise resolving to the saved entity with relations
+   */
+  async saveWithRelations<T extends BaseEntity>(
+    entity: T,
+    entityClass: EntityConstructor<T>,
+  ): Promise<T> {
+    const relations = getRelationMetadata(entityClass);
+
+    if (!relations) {
+      return await this.saveEntity(entity, entityClass);
+    }
+
+    const savedEntity = await this.saveEntity(entity, entityClass);
+
+    for (const [propertyKey, relationMeta] of Object.entries(relations)) {
+      const relationData = (entity as Record<string, unknown>)[propertyKey];
+
+      if (relationData) {
+        await this.saveRelation(
+          savedEntity as Record<string, unknown>,
+          relationData,
+          relationMeta,
+        );
+      }
+    }
+
+    return savedEntity;
+  }
+
+  /**
+   * Delete entity with cascade handling for relations
+   * @param entity - The entity to delete
+   * @param entityClass - The entity class
+   */
+  async deleteWithRelations<T extends BaseEntity>(
+    entity: T,
+    entityClass: EntityConstructor<T>,
+  ): Promise<void> {
+    const relations = getRelationMetadata(entityClass);
+
+    if (relations) {
+      for (const [, relationMeta] of Object.entries(relations)) {
+        if (!relationMeta.cascade) {
+          continue;
+        }
+
+        await this.deleteRelation(
+          entity as unknown as Record<string, unknown>,
+          relationMeta as unknown as {
+            type: string;
+            target: string | EntityConstructor;
+            foreignKey?: string;
+            joinTable?: string;
+          },
+        );
+      }
+    }
+
+
+    const baseMeta = getEntityMetadata(entityClass);
+    const baseName = baseMeta?.tableName
+      || ((/Entity$/i.test(entityClass.name)
+        ? entityClass.name.replace(/Entity$/i, '')
+        : entityClass.name).toLowerCase() + 's');
+
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    const table = this.db.table(baseName) as any;
+
+    await table.delete(entity.id as string | number);
+  }
+
+  private async deleteRelation(
+    entity: Record<string, unknown>,
+    relationMeta: {
+      type: string;
+      target: string | EntityConstructor;
+      foreignKey?: string;
+      joinTable?: string;
+    },
+  ): Promise<void> {
+    const targetName = this.resolveTableName(relationMeta.target);
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    const targetTable = this.db.table(targetName) as any;
+
+    switch (relationMeta.type) {
+      case 'one-to-one':
+        await this.deleteOneToOne(entity, targetTable, relationMeta);
+        break;
+      case 'one-to-many':
+        await this.deleteOneToMany(entity, targetTable, relationMeta);
+        break;
+      case 'many-to-many':
+        await this.deleteManyToMany(entity, relationMeta);
+        break;
+    }
+  }
+
+  private async deleteOneToOne(
+    entity: Record<string, unknown>,
+    targetTable: {
+      where: (_field: string) => {
+        equals: (_value: unknown) => { delete: () => Promise<unknown> };
+      };
+      delete: (_id: string | number) => Promise<unknown>;
+      get: (_id: string | number) => Promise<unknown>;
+    },
+    relationMeta: { foreignKey?: string },
+  ): Promise<void> {
+    if (relationMeta.foreignKey) {
+      await targetTable
+        .where(relationMeta.foreignKey)
+        .equals(entity.id)
+        .delete();
+    } else if (entity.id) {
+      const related = await targetTable.get(entity.id as string | number);
+
+      if (related) {
+        await targetTable.delete(entity.id as string | number);
+      }
+    }
+  }
+
+  private async deleteOneToMany(
+    entity: Record<string, unknown>,
+    targetTable: {
+      where: (_field: string) => {
+        equals: (_value: unknown) => { delete: () => Promise<unknown> };
+      };
+    },
+    relationMeta: { foreignKey?: string },
+  ): Promise<void> {
+    if (!relationMeta.foreignKey) {
+      return;
+    }
+
+    await targetTable
+      .where(relationMeta.foreignKey)
+      .equals(entity.id)
+      .delete();
+  }
+
+  private async deleteManyToMany(
+    entity: Record<string, unknown>,
+    relationMeta: { joinTable?: string },
+  ): Promise<void> {
+    if (!relationMeta.joinTable) {
+      return;
+    }
+
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    const joinTable = this.db.table(relationMeta.joinTable) as any;
+
+    await joinTable
+      .where('sourceId')
+      .equals(entity.id)
+      .delete();
+  }
+
+  private async saveEntity<T extends BaseEntity>(
+    entity: T,
+    entityClass: EntityConstructor<T>,
+  ): Promise<T> {
+
+    const baseMeta2 = getEntityMetadata(entityClass);
+    const baseName2 = baseMeta2?.tableName
+      || ((/Entity$/i.test(entityClass.name)
+        ? entityClass.name.replace(/Entity$/i, '')
+        : entityClass.name).toLowerCase() + 's');
+
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    const table = this.db.table(baseName2) as any;
+
+    if (entity.id) {
+      await table.put(entity);
+
+      return entity;
+    } else {
+      const id = await table.add(entity);
+
+      return { ...entity, id };
+    }
+  }
+
+  private async saveRelation(
+    entity: Record<string, unknown>,
+    relationData: unknown,
+    relationMeta: {
+      type: string;
+      target: string | EntityConstructor;
+      foreignKey?: string;
+      joinTable?: string
+    },
+  ): Promise<void> {
+    const targetName = this.resolveTableName(relationMeta.target);
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    const targetTable = this.db.table(targetName) as any;
+
+    switch (relationMeta.type) {
+      case 'one-to-one':
+        await this.saveOneToOne(entity, relationData, targetTable, relationMeta);
+
+        break;
+
+      case 'one-to-many':
+        await this
+        .saveOneToMany(entity, relationData as unknown[], targetTable, relationMeta);
+
+        break;
+
+      case 'many-to-many':
+        await this.saveManyToMany(
+          entity, relationData as unknown[], targetTable, relationMeta,
+        );
+
+        break;
+    }
+  }
+
+  private async saveOneToOne(
+    entity: Record<string, unknown>,
+    relationData: unknown,
+    targetTable: {
+      update: (_id: string | number, _data: unknown) => Promise<unknown>;
+      add: (_data: unknown) => Promise<unknown>;
+    },
+    relationMeta: { foreignKey?: string },
+  ): Promise<void> {
+    const data = relationData as Record<string, unknown>;
+
+    if (relationMeta.foreignKey) {
+      data[relationMeta.foreignKey] = entity.id;
+    }
+
+    if (data.id) {
+      await targetTable.update(data.id as string | number, data);
+    } else {
+      await targetTable.add(data);
+    }
+  }
+
+  private async saveOneToMany(
+    entity: Record<string, unknown>,
+    relationData: unknown[],
+    targetTable: {
+      update: (_id: string | number, _data: unknown) => Promise<unknown>;
+      add: (_data: unknown) => Promise<unknown>;
+    },
+    relationMeta: { foreignKey?: string },
+  ): Promise<void> {
+    if (!relationMeta.foreignKey) {
+      return;
+    }
+
+    for (const item of relationData) {
+      const data = item as Record<string, unknown>;
+
+      data[relationMeta.foreignKey] = entity.id;
+
+      if (data.id) {
+        await targetTable.update(data.id as string | number, data);
+      } else {
+        await targetTable.add(data);
+      }
+    }
+  }
+
+  private async saveManyToMany(
+    entity: Record<string, unknown>,
+    relationData: unknown[],
+    targetTable: {
+      add: (_data: unknown) => Promise<unknown>;
+      update: (_id: string | number, _data: unknown) => Promise<unknown>;
+    },
+    relationMeta: { joinTable?: string },
+  ): Promise<void> {
+    if (!relationMeta.joinTable) {
+      return;
+    }
+
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    const joinTable = this.db.table(relationMeta.joinTable) as any;
+
+    await joinTable
+      .where('sourceId')
+      .equals(entity.id)
+      .delete();
+
+    for (const item of relationData) {
+      const data = item as Record<string, unknown>;
+      let targetId = data.id;
+
+      if (!targetId) {
+        targetId = await targetTable.add(data);
+      } else {
+        await targetTable.update(data.id as string | number, data);
+      }
+
+      await joinTable.add({
+        sourceId: entity.id,
+        targetId: targetId,
+      });
+    }
+  }
+}