@indexeddb-orm/idb-orm 0.0.1

package/angular-demo-app/src/services/cloud-sync.service.ts

@@ -0,0 +1,95 @@
+import { Injectable } from '@angular/core';
+import { BehaviorSubject } from 'rxjs';
+
+@Injectable({
+  providedIn: 'root',
+})
+export class CloudSyncService {
+  private syncStatusSubject = new BehaviorSubject<{
+    enabled: boolean;
+    isOnline?: boolean;
+    lastSync?: Date;
+  }>({
+    enabled: false,
+    isOnline: undefined,
+    lastSync: undefined,
+  });
+  private isLoadingSubject = new BehaviorSubject<boolean>(false);
+
+  public syncStatus$ = this.syncStatusSubject.asObservable();
+  public isLoading$ = this.isLoadingSubject.asObservable();
+
+  async handleManualSync(): Promise<void> {
+    this.isLoadingSubject.next(true);
+    this.syncStatusSubject.next({
+      ...this.syncStatusSubject.value,
+      lastSync: new Date(),
+    });
+
+    try {
+      // Simulate sync process
+      await new Promise(resolve => setTimeout(resolve, 2000));
+      this.syncStatusSubject.next({
+        ...this.syncStatusSubject.value,
+        lastSync: new Date(),
+      });
+    } catch (error) {
+      console.error('Sync error:', error);
+    } finally {
+      this.isLoadingSubject.next(false);
+    }
+  }
+
+  async handleEnableCloudSync(): Promise<void> {
+    this.isLoadingSubject.next(true);
+
+    try {
+      // Simulate enabling cloud sync
+      await new Promise(resolve => setTimeout(resolve, 1000));
+      this.syncStatusSubject.next({
+        enabled: true,
+        isOnline: true,
+        lastSync: new Date(),
+      });
+    } catch (error) {
+      console.error('Enable cloud sync error:', error);
+    } finally {
+      this.isLoadingSubject.next(false);
+    }
+  }
+
+  async handleDisableCloudSync(): Promise<void> {
+    this.isLoadingSubject.next(true);
+
+    try {
+      // Simulate disabling cloud sync
+      await new Promise(resolve => setTimeout(resolve, 1000));
+      this.syncStatusSubject.next({
+        enabled: false,
+        isOnline: false,
+        lastSync: this.syncStatusSubject.value.lastSync,
+      });
+    } catch (error) {
+      console.error('Disable cloud sync error:', error);
+    } finally {
+      this.isLoadingSubject.next(false);
+    }
+  }
+
+  async handleSyncTables(): Promise<void> {
+    this.isLoadingSubject.next(true);
+
+    try {
+      // Simulate table sync
+      await new Promise(resolve => setTimeout(resolve, 1500));
+      this.syncStatusSubject.next({
+        ...this.syncStatusSubject.value,
+        lastSync: new Date(),
+      });
+    } catch (error) {
+      console.error('Table sync error:', error);
+    } finally {
+      this.isLoadingSubject.next(false);
+    }
+  }
+}

package/angular-demo-app/src/services/database.service.ts

@@ -0,0 +1,26 @@
+import { Injectable } from '@angular/core';
+import { Database } from 'idb-orm';
+
+import { PostEntity } from '../entities/post.entity';
+import { PostTagEntity } from '../entities/post-tag.entity';
+import { ProfileEntity } from '../entities/profile.entity';
+import { TagEntity } from '../entities/tag.entity';
+import { UserEntity } from '../entities/user.entity';
+
+@Injectable({
+  providedIn: 'root',
+})
+export class DatabaseService {
+  public db: Database;
+
+  constructor() {
+    this.db = Database.createDatabase({
+      name: 'DexieORMDemo',
+      version: 6,
+      entities: [UserEntity, PostEntity, ProfileEntity, TagEntity, PostTagEntity],
+      config: {
+        migrations: [],
+      },
+    });
+  }
+}

package/angular-demo-app/src/services/live-query.service.ts

@@ -0,0 +1,63 @@
+import { Injectable } from '@angular/core';
+import { BehaviorSubject } from 'rxjs';
+
+import { ProfileEntity } from '../entities/profile.entity';
+import { UserEntity } from '../entities/user.entity';
+import { DatabaseService } from './database.service';
+
+@Injectable({
+  providedIn: 'root',
+})
+export class LiveQueryService {
+  private _usersWithProfilesSubject =
+  new BehaviorSubject<(UserEntity & { profile?: ProfileEntity })[]>([]);
+  private allUsersSubject = new BehaviorSubject<UserEntity[]>([]);
+  private userStatsSubject = new BehaviorSubject<{
+    totalUsers: number;
+    adultUsers: number;
+    firstUser: string;
+  }>({ totalUsers: 0, adultUsers: 0, firstUser: '' });
+
+  public usersWithProfiles$ = this._usersWithProfilesSubject.asObservable();
+  public allUsers$ = this.allUsersSubject.asObservable();
+  public userStats$ = this.userStatsSubject.asObservable();
+
+  constructor(private _dbService: DatabaseService) {
+    this.loadData();
+  }
+
+  private async loadData(): Promise<void> {
+    try {
+      // Load users with profiles
+      const users = await this._dbService.db.getRepository(UserEntity).toArray();
+      const profiles = await this._dbService.
+      db.getRepository(ProfileEntity).toArray();
+
+      const usersWithProfiles = users.map(user => {
+        const profile = profiles.find(p => p.userId === user.id);
+
+        return Object.assign(user, { profile });
+      });
+
+      this._usersWithProfilesSubject.next(usersWithProfiles);
+      this.allUsersSubject.next(users);
+
+      // Calculate stats
+      const totalUsers = users.length;
+      const adultUsers = users.filter(u => u.age >= 18).length;
+      const firstUser = users[0]?.name || '';
+
+      this.userStatsSubject.next({
+        totalUsers,
+        adultUsers,
+        firstUser,
+      });
+    } catch (error) {
+      console.error('Error loading live query data:', error);
+    }
+  }
+
+  refresh(): void {
+    this.loadData();
+  }
+}

package/angular-demo-app/src/services/posts-live-query.service.ts

@@ -0,0 +1,86 @@
+import { Injectable } from '@angular/core';
+import { newEntity } from 'idb-orm';
+import { BehaviorSubject } from 'rxjs';
+
+import { PostEntity } from '../entities/post.entity';
+import { DatabaseService } from './database.service';
+
+@Injectable({
+  providedIn: 'root',
+})
+export class PostsLiveQueryService {
+  private allPostsSubject = new BehaviorSubject<PostEntity[]>([]);
+  private topPostsSubject = new BehaviorSubject<PostEntity[]>([]);
+  private publishedPostsSubject = new BehaviorSubject<PostEntity[]>([]);
+  private postStatsSubject = new BehaviorSubject<{
+    total: number;
+    published: number;
+    totalLikes: number;
+  }>({ total: 0, published: 0, totalLikes: 0 });
+
+  public allPosts$ = this.allPostsSubject.asObservable();
+  public topPosts$ = this.topPostsSubject.asObservable();
+  public publishedPosts$ = this.publishedPostsSubject.asObservable();
+  public postStats$ = this.postStatsSubject.asObservable();
+
+  constructor(private _dbService: DatabaseService) {
+    this.loadData();
+  }
+
+  private async loadData(): Promise<void> {
+    try {
+      const allPosts = await this._dbService.db.getRepository(PostEntity).toArray();
+      const topPosts = await this._dbService.db.getRepository(PostEntity)
+        .orderBy('likes')
+        .reverse()
+        .limit(3)
+        .toArray();
+      const publishedPosts = await this._dbService.db.getRepository(PostEntity)
+        .where('published').equals(1)
+        .toArray();
+
+      this.allPostsSubject.next(allPosts);
+      this.topPostsSubject.next(topPosts);
+      this.publishedPostsSubject.next(publishedPosts);
+
+      // Calculate stats
+      const totalPosts = allPosts.length;
+      const published = publishedPosts.length;
+      const totalLikes = allPosts.reduce((sum, post) => sum + (post.likes || 0), 0);
+
+      this.postStatsSubject.next({
+        total: totalPosts,
+        published,
+        totalLikes,
+      });
+    } catch (error) {
+      console.error('Error loading posts live query data:', error);
+    }
+  }
+
+  async addSamplePost(): Promise<void> {
+    try {
+      const post = newEntity(PostEntity, {
+        title: `Sample Post ${Date.now()}`,
+        content: 'This is a sample post created by the demo app.',
+        published: Math.random() > 0.5,
+        likes: Math.floor(Math.random() * 100),
+        createdAt: Date.now(),
+        authorId: 1, // Assuming user with ID 1 exists
+      });
+
+      await this._dbService.db.saveWithRelations({
+        entity: post,
+        entityClass: PostEntity,
+      });
+
+      this.loadData();
+    } catch (error) {
+      console.error('Error adding sample post:', error);
+    }
+  }
+
+  refresh(): void {
+    this.loadData();
+  }
+}

package/angular-demo-app/src/services/typescript-demo.service.ts

@@ -0,0 +1,59 @@
+import { Injectable } from '@angular/core';
+import { BehaviorSubject } from 'rxjs';
+
+import { PostEntity } from '../entities/post.entity';
+import { ProfileEntity } from '../entities/profile.entity';
+import { UserEntity } from '../entities/user.entity';
+import { DatabaseService } from './database.service';
+
+@Injectable({
+  providedIn: 'root',
+})
+export class TypeScriptDemoService {
+  private usersSubject = new BehaviorSubject<UserEntity[]>([]);
+  private postsSubject = new BehaviorSubject<PostEntity[]>([]);
+  private profilesSubject = new BehaviorSubject<ProfileEntity[]>([]);
+
+  public users$ = this.usersSubject.asObservable();
+  public posts$ = this.postsSubject.asObservable();
+  public profiles$ = this.profilesSubject.asObservable();
+
+  constructor(private _dbService: DatabaseService) {
+    this.loadData();
+  }
+
+  private async loadData(): Promise<void> {
+    try {
+      const [users, posts, profiles] = await Promise.all([
+        this._dbService.db.getRepository(UserEntity).toArray(),
+        this._dbService.db.getRepository(PostEntity).toArray(),
+        this._dbService.db.getRepository(ProfileEntity).toArray(),
+      ]);
+
+      this.usersSubject.next(users);
+      this.postsSubject.next(posts);
+      this.profilesSubject.next(profiles);
+    } catch (error) {
+      console.error('Error loading TypeScript demo data:', error);
+    }
+  }
+
+  onUserClick(user: UserEntity): void {
+    console.log('User clicked:', user);
+    alert(`User clicked: ${user.name} (${user.email})`);
+  }
+
+  onPostClick(post: PostEntity): void {
+    console.log('Post clicked:', post);
+    alert(`Post clicked: ${post.title} - ${post.published ? 'Published' : 'Draft'}`);
+  }
+
+  onProfileClick(profile: ProfileEntity): void {
+    console.log('Profile clicked:', profile);
+    alert(`Profile clicked: ${profile.bio}`);
+  }
+
+  refresh(): void {
+    this.loadData();
+  }
+}

package/angular-demo-app/src/styles.scss

@@ -0,0 +1,50 @@
+/* You can add global styles to this file, and also import other style files */
+
+/* Reset and base styles */
+* {
+  box-sizing: border-box;
+}
+
+html, body {
+  margin: 0;
+  padding: 0;
+  width: 100%;
+  height: 100%;
+  overflow-x: hidden;
+}
+
+body {
+  font-family: Roboto, "Helvetica Neue", sans-serif;
+}
+
+#root {
+  width: 100%;
+  min-height: 100vh;
+}
+
+/* Angular Material overrides */
+.mat-mdc-card {
+  margin-bottom: 16px;
+}
+
+.mat-mdc-button {
+  text-transform: none !important;
+}
+
+/* Custom scrollbar */
+::-webkit-scrollbar {
+  width: 8px;
+}
+
+::-webkit-scrollbar-track {
+  background: #f1f1f1;
+}
+
+::-webkit-scrollbar-thumb {
+  background: #c1c1c1;
+  border-radius: 4px;
+}
+
+::-webkit-scrollbar-thumb:hover {
+  background: #a8a8a8;
+}

package/angular-demo-app/tsconfig.app.json

@@ -0,0 +1,13 @@
+{
+  "extends": "./tsconfig.json",
+  "compilerOptions": {
+    "outDir": "./out-tsc/app",
+    "types": []
+  },
+  "files": [
+    "src/main.ts"
+  ],
+  "include": [
+    "src/**/*.d.ts"
+  ]
+}

package/angular-demo-app/tsconfig.json

@@ -0,0 +1,34 @@
+{
+  "compileOnSave": false,
+  "compilerOptions": {
+    "baseUrl": "./",
+    "outDir": "./dist/out-tsc",
+    "forceConsistentCasingInFileNames": true,
+    "strict": true,
+    "noImplicitOverride": true,
+    "noPropertyAccessFromIndexSignature": true,
+    "noImplicitReturns": true,
+    "noFallthroughCasesInSwitch": true,
+    "sourceMap": true,
+    "declaration": false,
+    "downlevelIteration": true,
+    "experimentalDecorators": true,
+    "moduleResolution": "node",
+    "importHelpers": true,
+    "target": "ES2022",
+    "module": "ES2022",
+    "skipLibCheck": true,
+    "useDefineForClassFields": false,
+    "allowSyntheticDefaultImports": true,
+    "lib": [
+      "ES2022",
+      "dom"
+    ]
+  },
+  "angularCompilerOptions": {
+    "enableI18nLegacyMessageIdFormat": false,
+    "strictInjectionParameters": true,
+    "strictInputAccessModifiers": true,
+    "strictTemplates": true
+  }
+}

package/angular-demo-app/tsconfig.spec.json

@@ -0,0 +1,13 @@
+{
+  "extends": "./tsconfig.json",
+  "compilerOptions": {
+    "outDir": "./out-tsc/spec",
+    "types": [
+      "jasmine"
+    ]
+  },
+  "include": [
+    "src/**/*.spec.ts",
+    "src/**/*.d.ts"
+  ]
+}

package/dist/Database.d.ts

@@ -0,0 +1,206 @@
+import Dexie, { type Table } from 'dexie';
+import { BaseEntity } from './services/BaseEntity';
+import type { AggregationOptions, AggregationResult, CloudSyncConfig, DatabaseConfig, EntityConstructor, Migration } from './types';
+export declare class Database extends Dexie {
+    private entitySchemas;
+    private migrationManager;
+    private relationLoader;
+    private aggregationService;
+    private cloudSyncService;
+    migrationMetadata: Table<{
+        key: string;
+        value: string | number;
+        updatedAt: number;
+    }>;
+    constructor(config: DatabaseConfig);
+    /**
+     * Get repository for entity (TypeORM style)
+     *
+     * @example
+     * const users = db.getRepository(User);
+     * const id = await users.add({ name: 'Ann' } as User);
+     */
+    getRepository<T extends BaseEntity, TKey extends Extract<NonNullable<T['id']>, string | number> = Extract<NonNullable<T['id']>, string | number>>(entityClass: EntityConstructor<T>): Table<T, TKey>;
+    /**
+     * Perform aggregation on entity data
+     *
+     * @example
+     * const result = await db.aggregate({
+     *   entityClass: Post,
+     *   options: { where: { category: 'tech' } },
+     * });
+     */
+    aggregate<T extends BaseEntity>(params: {
+        entityClass: EntityConstructor<T>;
+        options: AggregationOptions<T>;
+    }): Promise<AggregationResult>;
+    /**
+     * Create database with entity registration
+     *
+     * @example
+     * const db = Database.createDatabase({
+     *   name: 'app-db',
+     *   version: 1,
+     *   entities: [User, Post],
+     * });
+     */
+    static createDatabase(params: {
+        name: string;
+        version: number;
+        entities: EntityConstructor[];
+        config?: Partial<DatabaseConfig>;
+    }): Database;
+    /**
+     * Clear all data from database
+     *
+     * @example
+     * await db.clearAllData();
+     */
+    clearAllData(): Promise<void>;
+    /**
+     * Reset database when schema changes
+     *
+     * @example
+     * await db.resetDatabase();
+     */
+    resetDatabase(): Promise<void>;
+    /**
+     * Check if schema has changed and reset if needed
+     *
+     * @example
+     * const changed = await db.checkSchemaChanges();
+     */
+    checkSchemaChanges(): Promise<boolean>;
+    /**
+     * Manually perform selective reset for changed tables only
+     *
+     * @example
+     * await db.performSelectiveReset();
+     */
+    performSelectiveReset(): Promise<void>;
+    /**
+     * Run migrations for schema changes
+     *
+     * @example
+     * await db.runMigrations(migrations);
+     */
+    runMigrations(migrations: Migration[]): Promise<void>;
+    /**
+     * Get typed table for entity
+     *
+     * @example
+     * const posts = db.getTypedTable(Post);
+     */
+    getTypedTable<T extends BaseEntity, TKey extends Extract<NonNullable<T['id']>, string | number> = Extract<NonNullable<T['id']>, string | number>>(entityClass: EntityConstructor<T>): Table<T, TKey>;
+    /**
+     * Get table with proper typing for specific entity
+     *
+     * @example
+     * const users = db.getTableForEntity(User);
+     */
+    getTableForEntity<T extends BaseEntity, TKey extends Extract<NonNullable<T['id']>, string | number> = Extract<NonNullable<T['id']>, string | number>>(entityClass: EntityConstructor<T>): Table<T, TKey>;
+    /**
+     * Get all entities
+     *
+     * @example
+     * const all = db.getEntities();
+     */
+    getEntities(): EntityConstructor[];
+    /**
+     * Get entity by table name
+     *
+     * @example
+     * const UserClass = db.getEntity('users');
+     */
+    getEntity(tableName: string): EntityConstructor | undefined;
+    /**
+     * Load relations for an entity
+     *
+     * @example
+     * const userWithRelations = await db.loadRelations({
+     *   entity: user,
+     *   entityClass: User,
+     *   relationNames: ['posts'],
+     * });
+     */
+    loadRelations<T extends BaseEntity>(params: {
+        entity: T;
+        entityClass: EntityConstructor<T>;
+        relationNames?: string[];
+    }): Promise<T>;
+    /**
+     * Load a specific relation by name
+     *
+     * @example
+     * const posts = await db.loadRelationByName({
+     *   entity: { id: userId },
+     *   entityClass: User,
+     *   relationName: 'posts',
+     * });
+     */
+    loadRelationByName<T extends BaseEntity, K extends keyof T>(params: {
+        entity: T | {
+            id: string | number;
+        };
+        entityClass: EntityConstructor<T>;
+        relationName: K;
+    }): Promise<T[K]>;
+    /**
+     * Save entity with relations
+     *
+     * @example
+     * const saved = await db.saveWithRelations({
+     *   entity: user,
+     *   entityClass: User,
+     * });
+     */
+    saveWithRelations<T extends BaseEntity>(params: {
+        entity: T;
+        entityClass: EntityConstructor<T>;
+    }): Promise<T>;
+    /**
+     * Delete entity with cascade handling for relations
+     *
+     * @example
+     * await db.deleteWithRelations({
+     *   entity: user,
+     *   entityClass: User,
+     * });
+     */
+    deleteWithRelations<T extends BaseEntity>(params: {
+        entity: T;
+        entityClass: EntityConstructor<T>;
+    }): Promise<void>;
+    /**
+     * Manual sync with cloud
+     */
+    sync(): Promise<void>;
+    /**
+     * Get sync status
+     */
+    getSyncStatus(): {
+        enabled: boolean;
+        lastSync?: Date;
+        isOnline?: boolean;
+    };
+    /**
+     * Enable cloud sync (if not already enabled)
+     */
+    enableCloudSync(config: CloudSyncConfig): Promise<void>;
+    /**
+     * Disable cloud sync
+     */
+    disableCloudSync(): void;
+    /**
+     * Check if cloud sync is enabled
+     */
+    isCloudSyncEnabled(): boolean;
+    /**
+     * Get cloud sync configuration
+     */
+    getCloudSyncConfig(): CloudSyncConfig | undefined;
+    /**
+     * Force sync specific tables
+     */
+    syncTables(tableNames: string[]): Promise<void>;
+}