@indexeddb-orm/idb-orm 0.0.1

package/dist/services/RelationLoader.js

@@ -0,0 +1,310 @@
+import { getEntityMetadata } from '../metadata/Entity';
+import { getRelationMetadata } from '../metadata/Relation';
+export class RelationLoader {
+    db;
+    constructor(database) {
+        this.db = database;
+    }
+    resolveTableName(target) {
+        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(entity, entityClass, relationNames) {
+        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[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(entity, entityClass, relationName) {
+        const relations = getRelationMetadata(entityClass);
+        if (!relations || !relations[String(relationName)]) {
+            throw new Error(`Relation 
+        '${String(relationName)}' not found for entity ${entityClass.name}`);
+        }
+        const relationMeta = relations[String(relationName)];
+        return await this.loadRelation(entity, relationMeta);
+    }
+    /**
+     * 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(entity, relationMeta) {
+        const targetName = this.resolveTableName(relationMeta.target);
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        const targetTable = this.db.table(targetName);
+        switch (relationMeta.type) {
+            case 'one-to-one':
+                return await this.loadOneToOne(entity, targetTable, relationMeta);
+            case 'one-to-many':
+                return await this.loadOneToMany(entity, targetTable, relationMeta);
+            case 'many-to-many':
+                return await this.loadManyToMany(entity, targetTable, relationMeta);
+            default:
+                throw new Error(`Unsupported relation type: ${relationMeta.type}`);
+        }
+    }
+    async loadOneToOne(entity, targetTable, relationMeta) {
+        if (relationMeta.foreignKey) {
+            return await targetTable
+                .where(relationMeta.foreignKey)
+                .equals(entity.id)
+                .first();
+        }
+        else {
+            const foreignKeyValue = entity[relationMeta.foreignKey];
+            if (!foreignKeyValue) {
+                return null;
+            }
+            return await targetTable.get(foreignKeyValue);
+        }
+    }
+    async loadOneToMany(entity, targetTable, relationMeta) {
+        if (!relationMeta.foreignKey) {
+            return [];
+        }
+        return await targetTable
+            .where(relationMeta.foreignKey)
+            .equals(entity.id)
+            .toArray();
+    }
+    /**
+     * Load many-to-many relation
+     */
+    async loadManyToMany(entity, targetTable, relationMeta) {
+        if (!relationMeta.joinTable) {
+            return [];
+        }
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        const joinTable = this.db.table(relationMeta.joinTable);
+        const joinRecords = await joinTable
+            .where('sourceId')
+            .equals(entity.id)
+            .toArray();
+        const targetIds = joinRecords.map((record) => record.targetId);
+        if (targetIds.length === 0) {
+            return [];
+        }
+        return await targetTable
+            .where('id')
+            .anyOf(targetIds)
+            .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(entity, entityClass) {
+        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[propertyKey];
+            if (relationData) {
+                await this.saveRelation(savedEntity, relationData, relationMeta);
+            }
+        }
+        return savedEntity;
+    }
+    /**
+     * Delete entity with cascade handling for relations
+     * @param entity - The entity to delete
+     * @param entityClass - The entity class
+     */
+    async deleteWithRelations(entity, entityClass) {
+        const relations = getRelationMetadata(entityClass);
+        if (relations) {
+            for (const [, relationMeta] of Object.entries(relations)) {
+                if (!relationMeta.cascade) {
+                    continue;
+                }
+                await this.deleteRelation(entity, relationMeta);
+            }
+        }
+        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);
+        await table.delete(entity.id);
+    }
+    async deleteRelation(entity, relationMeta) {
+        const targetName = this.resolveTableName(relationMeta.target);
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        const targetTable = this.db.table(targetName);
+        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;
+        }
+    }
+    async deleteOneToOne(entity, targetTable, relationMeta) {
+        if (relationMeta.foreignKey) {
+            await targetTable
+                .where(relationMeta.foreignKey)
+                .equals(entity.id)
+                .delete();
+        }
+        else if (entity.id) {
+            const related = await targetTable.get(entity.id);
+            if (related) {
+                await targetTable.delete(entity.id);
+            }
+        }
+    }
+    async deleteOneToMany(entity, targetTable, relationMeta) {
+        if (!relationMeta.foreignKey) {
+            return;
+        }
+        await targetTable
+            .where(relationMeta.foreignKey)
+            .equals(entity.id)
+            .delete();
+    }
+    async deleteManyToMany(entity, relationMeta) {
+        if (!relationMeta.joinTable) {
+            return;
+        }
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        const joinTable = this.db.table(relationMeta.joinTable);
+        await joinTable
+            .where('sourceId')
+            .equals(entity.id)
+            .delete();
+    }
+    async saveEntity(entity, entityClass) {
+        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);
+        if (entity.id) {
+            await table.put(entity);
+            return entity;
+        }
+        else {
+            const id = await table.add(entity);
+            return { ...entity, id };
+        }
+    }
+    async saveRelation(entity, relationData, relationMeta) {
+        const targetName = this.resolveTableName(relationMeta.target);
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        const targetTable = this.db.table(targetName);
+        switch (relationMeta.type) {
+            case 'one-to-one':
+                await this.saveOneToOne(entity, relationData, targetTable, relationMeta);
+                break;
+            case 'one-to-many':
+                await this
+                    .saveOneToMany(entity, relationData, targetTable, relationMeta);
+                break;
+            case 'many-to-many':
+                await this.saveManyToMany(entity, relationData, targetTable, relationMeta);
+                break;
+        }
+    }
+    async saveOneToOne(entity, relationData, targetTable, relationMeta) {
+        const data = relationData;
+        if (relationMeta.foreignKey) {
+            data[relationMeta.foreignKey] = entity.id;
+        }
+        if (data.id) {
+            await targetTable.update(data.id, data);
+        }
+        else {
+            await targetTable.add(data);
+        }
+    }
+    async saveOneToMany(entity, relationData, targetTable, relationMeta) {
+        if (!relationMeta.foreignKey) {
+            return;
+        }
+        for (const item of relationData) {
+            const data = item;
+            data[relationMeta.foreignKey] = entity.id;
+            if (data.id) {
+                await targetTable.update(data.id, data);
+            }
+            else {
+                await targetTable.add(data);
+            }
+        }
+    }
+    async saveManyToMany(entity, relationData, targetTable, relationMeta) {
+        if (!relationMeta.joinTable) {
+            return;
+        }
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        const joinTable = this.db.table(relationMeta.joinTable);
+        await joinTable
+            .where('sourceId')
+            .equals(entity.id)
+            .delete();
+        for (const item of relationData) {
+            const data = item;
+            let targetId = data.id;
+            if (!targetId) {
+                targetId = await targetTable.add(data);
+            }
+            else {
+                await targetTable.update(data.id, data);
+            }
+            await joinTable.add({
+                sourceId: entity.id,
+                targetId: targetId,
+            });
+        }
+    }
+}

package/dist/services/SchemaBuilder.d.ts

@@ -0,0 +1,68 @@
+import type { EntityConstructor } from '../types';
+export interface TableSchema {
+    tableName: string;
+    schema: string;
+}
+export interface SchemaChange {
+    tableName: string;
+    changeType: 'added' | 'removed' | 'modified';
+    oldSchema?: string;
+    newSchema?: string;
+}
+export declare class SchemaBuilder {
+    /**
+     * Build indexeddb schema from entities
+     * @param entities - Array of entity constructors
+     * @returns IndexedDB schema object with table definitions
+     *
+     * @example
+     * const schema = SchemaBuilder.buildSchema([User, Post]);
+     */
+    static buildSchema(entities: EntityConstructor[]): Record<string, string>;
+    /**
+     * Build detailed table schemas for comparison
+     * @param entities - Array of entity constructors
+     * @returns Array of detailed table schema objects
+     *
+     * @example
+     * const tables = SchemaBuilder.buildTableSchemas([User, Post]);
+     */
+    static buildTableSchemas(entities: EntityConstructor[]): TableSchema[];
+    /**
+     * Generate hash for schema to detect changes
+     * @param schema - Schema object to hash
+     * @returns Hash string for schema comparison
+     *
+     * @example
+     * const hash = SchemaBuilder.generateSchemaHash(schema);
+     */
+    static generateSchemaHash(schema: Record<string, string>): string;
+    /**
+     * Compare two schema arrays and return changes
+     * @param oldSchemas - Previous schema array
+     * @param newSchemas - Current schema array
+     * @returns Array of schema changes detected
+     *
+     * @example
+     * const changes = SchemaBuilder.compareSchemas(oldSchemas, newSchemas);
+     */
+    static compareSchemas(oldSchemas: TableSchema[], newSchemas: TableSchema[]): SchemaChange[];
+    /**
+     * Store table schemas in localStorage
+     * @param dbName - Database name for key generation
+     * @param tableSchemas - Array of table schemas to store
+     *
+     * @example
+     * SchemaBuilder.storeTableSchemas('app-db', tables);
+     */
+    static storeTableSchemas(dbName: string, tableSchemas: TableSchema[]): void;
+    /**
+     * Get stored table schemas from localStorage
+     * @param dbName - Database name for key lookup
+     * @returns Array of stored table schemas or empty array if none found
+     *
+     * @example
+     * const tables = SchemaBuilder.getStoredTableSchemas('app-db');
+     */
+    static getStoredTableSchemas(dbName: string): TableSchema[];
+}

package/dist/services/SchemaBuilder.js

@@ -0,0 +1,191 @@
+import { getColumnMetadata, getCompoundIndexMetadata, } from '../metadata/Column';
+import { getEntityMetadata } from '../metadata/Entity';
+import { logger } from '../utils/logger';
+import { getDefinedCompoundIndexes } from './EntityRegistry';
+export class SchemaBuilder {
+    /**
+     * Build indexeddb schema from entities
+     * @param entities - Array of entity constructors
+     * @returns IndexedDB schema object with table definitions
+     *
+     * @example
+     * const schema = SchemaBuilder.buildSchema([User, Post]);
+     */
+    static buildSchema(entities) {
+        const schema = {};
+        schema.migrationMetadata = 'key, value, updatedAt';
+        entities.forEach(entity => {
+            const metadata = getEntityMetadata(entity);
+            const tableName = metadata?.tableName || entity.name.toLowerCase() + 's';
+            const columns = getColumnMetadata(entity);
+            const compoundIndexes = getDefinedCompoundIndexes(entity)
+                || getCompoundIndexMetadata(entity);
+            let primaryKeySpec = '';
+            const indexSpecs = [];
+            Object.entries(columns).forEach(([propertyKey, columnMeta]) => {
+                if (columnMeta.primaryKey) {
+                    primaryKeySpec = columnMeta.autoIncrement
+                        ? `++${propertyKey}`
+                        : propertyKey;
+                }
+                else if (columnMeta.unique) {
+                    indexSpecs.push(`&${propertyKey}`);
+                }
+                else if (columnMeta.indexed) {
+                    indexSpecs.push(`${propertyKey}`);
+                }
+            });
+            const compoundIndexStrings = [];
+            compoundIndexes.forEach(compoundIndex => {
+                const indexColumns = compoundIndex.columns.join('+');
+                const bracketed = `[${indexColumns}]`;
+                const spec = compoundIndex.unique ? `&${bracketed}` : `${bracketed}`;
+                compoundIndexStrings.push(spec);
+            });
+            const parts = [
+                primaryKeySpec, ...indexSpecs, ...compoundIndexStrings,
+            ].filter(Boolean);
+            schema[tableName] = parts.join(',');
+            if (!schema[tableName]) {
+                schema[tableName] = '++id';
+            }
+        });
+        return schema;
+    }
+    /**
+     * Build detailed table schemas for comparison
+     * @param entities - Array of entity constructors
+     * @returns Array of detailed table schema objects
+     *
+     * @example
+     * const tables = SchemaBuilder.buildTableSchemas([User, Post]);
+     */
+    static buildTableSchemas(entities) {
+        return entities.map(entity => {
+            const metadata = getEntityMetadata(entity);
+            const tableName = metadata?.tableName || entity.name.toLowerCase() + 's';
+            const columns = getColumnMetadata(entity);
+            const compoundIndexes = getCompoundIndexMetadata(entity);
+            let primaryKeySpec = '';
+            const indexSpecs = [];
+            Object.entries(columns).forEach(([propertyKey, columnMeta]) => {
+                if (columnMeta.primaryKey) {
+                    primaryKeySpec = columnMeta.autoIncrement
+                        ? `++${propertyKey}`
+                        : propertyKey;
+                }
+                else if (columnMeta.unique) {
+                    indexSpecs.push(`&${propertyKey}`);
+                }
+                else if (columnMeta.indexed) {
+                    indexSpecs.push(`${propertyKey}`);
+                }
+            });
+            const compoundIndexStrings = [];
+            compoundIndexes.forEach(compoundIndex => {
+                const indexColumns = compoundIndex.columns.join('+');
+                const bracketed = `[${indexColumns}]`;
+                const spec = compoundIndex.unique ? `&${bracketed}` : `${bracketed}`;
+                compoundIndexStrings.push(spec);
+            });
+            const parts = [
+                primaryKeySpec, ...indexSpecs, ...compoundIndexStrings,
+            ].filter(Boolean);
+            return {
+                tableName,
+                schema: parts.join(','),
+            };
+        });
+    }
+    /**
+     * Generate hash for schema to detect changes
+     * @param schema - Schema object to hash
+     * @returns Hash string for schema comparison
+     *
+     * @example
+     * const hash = SchemaBuilder.generateSchemaHash(schema);
+     */
+    static generateSchemaHash(schema) {
+        const schemaString = JSON.stringify(schema, Object.keys(schema).sort());
+        return btoa(schemaString).slice(0, 16);
+    }
+    /**
+     * Compare two schema arrays and return changes
+     * @param oldSchemas - Previous schema array
+     * @param newSchemas - Current schema array
+     * @returns Array of schema changes detected
+     *
+     * @example
+     * const changes = SchemaBuilder.compareSchemas(oldSchemas, newSchemas);
+     */
+    static compareSchemas(oldSchemas, newSchemas) {
+        const changes = [];
+        const oldSchemaMap = new Map(oldSchemas.map(s => [s.tableName, s]));
+        const newSchemaMap = new Map(newSchemas.map(s => [s.tableName, s]));
+        newSchemas.forEach(newSchema => {
+            if (!oldSchemaMap.has(newSchema.tableName)) {
+                changes.push({
+                    tableName: newSchema.tableName,
+                    changeType: 'added',
+                    newSchema: newSchema.schema,
+                });
+            }
+        });
+        oldSchemas.forEach(oldSchema => {
+            if (!newSchemaMap.has(oldSchema.tableName)) {
+                changes.push({
+                    tableName: oldSchema.tableName,
+                    changeType: 'removed',
+                    oldSchema: oldSchema.schema,
+                });
+            }
+        });
+        newSchemas.forEach(newSchema => {
+            const oldSchema = oldSchemaMap.get(newSchema.tableName);
+            if (oldSchema && oldSchema.schema !== newSchema.schema) {
+                changes.push({
+                    tableName: newSchema.tableName,
+                    changeType: 'modified',
+                    oldSchema: oldSchema.schema,
+                    newSchema: newSchema.schema,
+                });
+            }
+        });
+        return changes;
+    }
+    /**
+     * Store table schemas in localStorage
+     * @param dbName - Database name for key generation
+     * @param tableSchemas - Array of table schemas to store
+     *
+     * @example
+     * SchemaBuilder.storeTableSchemas('app-db', tables);
+     */
+    static storeTableSchemas(dbName, tableSchemas) {
+        const key = `${dbName}_table_schemas`;
+        const serialized = JSON.stringify(tableSchemas);
+        localStorage.setItem(key, serialized);
+    }
+    /**
+     * Get stored table schemas from localStorage
+     * @param dbName - Database name for key lookup
+     * @returns Array of stored table schemas or empty array if none found
+     *
+     * @example
+     * const tables = SchemaBuilder.getStoredTableSchemas('app-db');
+     */
+    static getStoredTableSchemas(dbName) {
+        const key = `${dbName}_table_schemas`;
+        const stored = localStorage.getItem(key);
+        if (!stored) {
+            return [];
+        }
+        try {
+            return JSON.parse(stored);
+        }
+        catch (error) {
+            logger.error('Failed to parse stored table schemas:', error);
+            return [];
+        }
+    }
+}

package/dist/services/index.d.ts

@@ -0,0 +1,7 @@
+export { AggregationService } from './AggregationService';
+export { BaseEntity } from './BaseEntity';
+export { CloudSyncService } from './CloudSyncService';
+export { EntitySchema } from './EntitySchema';
+export { MigrationManager } from './MigrationManager';
+export { RelationLoader } from './RelationLoader';
+export { SchemaBuilder } from './SchemaBuilder';

package/dist/services/index.js

@@ -0,0 +1,7 @@
+export { AggregationService } from './AggregationService';
+export { BaseEntity } from './BaseEntity';
+export { CloudSyncService } from './CloudSyncService';
+export { EntitySchema } from './EntitySchema';
+export { MigrationManager } from './MigrationManager';
+export { RelationLoader } from './RelationLoader';
+export { SchemaBuilder } from './SchemaBuilder';