@indexeddb-orm/idb-orm 0.0.1

package/angular-demo-app/src/entities/profile.entity.ts

@@ -0,0 +1,42 @@
+import {
+  BaseEntity,
+  defineEntity,
+} from 'idb-orm';
+import { z } from 'zod';
+
+const ProfileSchema = z.object({
+  id: z.number().optional(),
+  userId: z.number().positive('User ID must be positive'),
+  bio: z.string().optional(),
+  avatar: z.string().url().optional(),
+  website: z.string().url().optional(),
+  location: z.string().optional(),
+  createdAt: z.number(),
+  updatedAt: z.number(),
+});
+
+export type Profile = z.infer<typeof ProfileSchema>;
+
+export class ProfileEntity extends BaseEntity<number> {
+  userId!: number;
+  bio?: string;
+  avatar?: string;
+  website?: string;
+  location?: string;
+  createdAt!: number;
+  updatedAt!: number;
+}
+
+defineEntity(ProfileEntity, {
+  tableName: 'profiles',
+  schema: ProfileSchema,
+  columns: {
+    userId: { indexed: true },
+    bio: { indexed: true },
+    avatar: {},
+    website: {},
+    location: {},
+    createdAt: { indexed: true },
+    updatedAt: { indexed: true },
+  },
+});

package/angular-demo-app/src/entities/tag.entity.ts

@@ -0,0 +1,36 @@
+import {
+  BaseEntity,
+  defineEntity,
+} from 'idb-orm';
+import { z } from 'zod';
+
+const TagSchema = z.object({
+  id: z.number().optional(),
+  name: z.string().min(1, 'Tag name is required'),
+  color: z.string().regex(/^#[0-9A-F]{6}$/i, 'Color must be a valid hex color'),
+  description: z.string().optional(),
+  createdAt: z.number(),
+  updatedAt: z.number(),
+});
+
+export type Tag = z.infer<typeof TagSchema>;
+
+export class TagEntity extends BaseEntity<number> {
+  name!: string;
+  color!: string;
+  description?: string;
+  createdAt!: number;
+  updatedAt!: number;
+}
+
+defineEntity(TagEntity, {
+  tableName: 'tags',
+  schema: TagSchema,
+  columns: {
+    name: { required: true, unique: true, indexed: true },
+    color: { required: true },
+    description: {},
+    createdAt: { indexed: true },
+    updatedAt: { indexed: true },
+  },
+});

package/angular-demo-app/src/entities/user.entity.ts

@@ -0,0 +1,59 @@
+import {
+ BaseEntity, defineEntity,
+} from 'idb-orm';
+import { z } from 'zod';
+
+import type { PostEntity } from './post.entity';
+import type { ProfileEntity } from './profile.entity';
+
+// Zod schema for validation
+export const UserSchema = z.object({
+  id: z.number().optional(),
+  name: z.string().min(2, 'Name must be at least 2 characters'),
+  email: z.string().email('Invalid email format'),
+  age: z.number().min(18, 'Must be at least 18 years old'),
+  createdAt: z.number(),
+  updatedAt: z.number(),
+  isActive: z.boolean().default(true),
+  tags: z.array(z.string()).default([]),
+  metadata: z.record(z.string(), z.unknown()).default({}),
+});
+
+export type User = z.infer<typeof UserSchema>;
+
+export class UserEntity extends BaseEntity<number> {
+  name!: string;
+  email!: string;
+  age!: number;
+  createdAt!: number;
+  updatedAt!: number;
+  isActive!: boolean;
+  tags!: string[];
+  metadata!: Record<string, unknown>;
+  posts?: PostEntity[];
+  profile?: ProfileEntity;
+}
+
+defineEntity(UserEntity, {
+  tableName: 'users',
+  schema: UserSchema,
+  columns: {
+    name: { required: true, indexed: true },
+    email: { required: true, unique: true },
+    age: { indexed: true },
+    createdAt: { indexed: true },
+    updatedAt: { indexed: true },
+    isActive: { indexed: true },
+    tags: {},
+    metadata: { indexed: true },
+  },
+  compoundIndexes: [
+    { columns: ['name', 'email'], unique: false, name: 'name_email_index' },
+    { columns: ['age', 'isActive'], unique: false, name: 'age_active_index' },
+    { columns: ['email'], unique: true, name: 'unique_email_index' },
+  ],
+  relations: {
+    posts: { type: 'one-to-many', target: 'posts', foreignKey: 'authorId' },
+    profile: { type: 'one-to-one', target: 'profiles', foreignKey: 'userId' },
+  },
+});

package/angular-demo-app/src/favicon.ico

@@ -0,0 +1 @@
+data:image/x-icon;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAQEAYAAABPYyMiAAAABmJLR0T///////8JWPfcAAAACXBIWXMAAABIAAAASABGyWs+AAAAF0lEQVRIx2NgGAWjYBSMglEwCkbBSAcACAABAAGiyb5oAAAAAElFTkSuQmCC

package/angular-demo-app/src/index.html

@@ -0,0 +1,16 @@
+<!doctype html>
+<html lang="en">
+<head>
+  <meta charset="utf-8">
+  <title>IndexedDB ORM Demo App</title>
+  <base href="/">
+  <meta name="viewport" content="width=device-width, initial-scale=1">
+  <link rel="icon" type="image/x-icon" href="favicon.ico">
+  <link rel="preconnect" href="https://fonts.gstatic.com">
+  <link href="https://fonts.googleapis.com/css2?family=Roboto:wght@300;400;500&display=swap" rel="stylesheet">
+  <link href="https://fonts.googleapis.com/icon?family=Material+Icons" rel="stylesheet">
+</head>
+<body class="mat-typography">
+  <app-root></app-root>
+</body>
+</html>

package/angular-demo-app/src/main.ts

@@ -0,0 +1,13 @@
+import { bootstrapApplication } from '@angular/platform-browser';
+import { provideAnimations } from '@angular/platform-browser/animations';
+import { provideRouter } from '@angular/router';
+
+import { AppComponent } from './app/app.component';
+import { routes } from './app/app.routes';
+
+bootstrapApplication(AppComponent, {
+  providers: [
+    provideRouter(routes),
+    provideAnimations(),
+  ],
+}).catch(err => console.error(err));

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

@@ -0,0 +1,449 @@
+import { Injectable } from '@angular/core';
+import { newEntity } from 'idb-orm';
+import { BehaviorSubject } from 'rxjs';
+
+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';
+import { DatabaseService } from './database.service';
+
+@Injectable({
+  providedIn: 'root',
+})
+export class AppLogicService {
+  private usersSubject = new BehaviorSubject<UserEntity[]>([]);
+  private tabIndexSubject = new BehaviorSubject<number>(0);
+  private mobileOpenSubject = new BehaviorSubject<boolean>(false);
+
+  public users$ = this.usersSubject.asObservable();
+  public tabIndex$ = this.tabIndexSubject.asObservable();
+  public mobileOpen$ = this.mobileOpenSubject.asObservable();
+
+  constructor(private _dbService: DatabaseService) {
+    this.loadUsers();
+  }
+
+  async loadUsers(): Promise<void> {
+    try {
+      const users = await this._dbService.db.getRepository(UserEntity).toArray();
+      this.usersSubject.next(users);
+    } catch (error) {
+      console.error('Error loading users:', error);
+    }
+  }
+
+  async addUser(): Promise<void> {
+    try {
+      const user = newEntity(UserEntity, {
+        name: `Test User ${Date.now()}`,
+        email: `user${Date.now()}@example.com`,
+        age: Math.floor(Math.random() * 50) + 18,
+        isActive: true,
+        createdAt: Date.now(),
+        updatedAt: Date.now(),
+        tags: ['demo'],
+        metadata: { source: 'demo' },
+      });
+
+      await this._dbService.db.saveWithRelations({
+        entity: user,
+        entityClass: UserEntity,
+      });
+
+      await this.loadUsers();
+    } catch (error) {
+      console.error('Error adding user:', error);
+    }
+  }
+
+  async testZodValidation(): Promise<void> {
+    try {
+      console.log('Testing Zod validation...');
+
+      // Test 1: Manual validation of an invalid object
+      console.log('Test 1: Manual validation of invalid object');
+      const invalidUser = newEntity(UserEntity, {
+        name: 'A', // Too short (min 2 chars)
+        email: 'invalid-email', // Invalid email
+        age: 15, // Too young (min 18)
+        tags: ['test'],
+        metadata: { source: 'validation-test' },
+        createdAt: Date.now(),
+        updatedAt: Date.now(),
+      });
+
+      console.log('Object to validate:', invalidUser);
+
+      // Manual call to .validate() on the object
+      const validationResult = invalidUser.validate();
+      console.log('Validation result:', validationResult);
+
+      if (!validationResult.isValid) {
+        console.log('Validation errors:');
+        validationResult.errors.forEach((error, index) => {
+          console.log(`  ${index + 1}. ${error}`);
+        });
+      }
+
+      // Test 2: Manual validation of a valid object
+      console.log('\nTest 2: Manual validation of a valid object');
+      const validUser = newEntity(UserEntity, {
+        name: 'John Doe', // Valid
+        email: 'john@example.com', // Valid
+        age: 25, // Valid
+        tags: ['developer', 'typescript'],
+        metadata: { source: 'validation-test', role: 'admin' },
+        createdAt: Date.now(),
+        updatedAt: Date.now(),
+      });
+
+      console.log('Object to validate:', validUser);
+
+      const validResult = validUser.validate();
+      console.log('Validation result:', validResult);
+
+      if (validResult.isValid) {
+        console.log('Validation passed successfully!');
+
+        // Add the valid user to the DB
+        const userRepository = this._dbService.db.getRepository(UserEntity);
+        await userRepository.add(validUser);
+        console.log('Valid user added to the database');
+        await this.loadUsers();
+      }
+
+      // Test 3: validateOrThrow() - throwing errors
+      console.log('\nTest 3: validateOrThrow() - throwing errors');
+      try {
+        invalidUser.validateOrThrow();
+        console.log(
+          'validateOrThrow() did not throw - this should not happen',
+        );
+      } catch (error) {
+        console.log(
+          'validateOrThrow() threw as expected:',
+          (error as Error).message,
+        );
+      }
+
+      alert(
+        `Validation test finished!
+        \n\nInvalid object: ${validationResult.errors.length} errors\n` +
+          `Valid object: ${validResult.isValid ? 'OK' : 'ERRORS'}\n\nCheck console for details.`,
+      );
+    } catch (error) {
+      console.log('Zod validation caught the error:', error);
+      alert(`Zod validation working! Error: ${(error as Error).message}`);
+    }
+  }
+
+  async testSchemaMigration(): Promise<void> {
+    try {
+      // This would test schema migration in a real scenario
+      console.log('Schema migration test - would test version upgrades here');
+      alert('Schema migration test completed (demo)');
+    } catch (error) {
+      console.error('Schema migration error:', error);
+    }
+  }
+
+  async testRelations(): Promise<void> {
+    try {
+      // Clear existing test data
+      // Get all users and filter by metadata.source in JavaScript
+      const allUsers = await this._dbService.db.getRepository(UserEntity).toArray();
+      const testUsers = allUsers.filter(user => user.metadata?.['source'] === 'relation-test');
+      if (testUsers.length > 0) {
+        await this._dbService.db
+        .getRepository(UserEntity).bulkDelete(testUsers.map(u => u.id!));
+      }
+      await this._dbService.db.getRepository(ProfileEntity).where('bio').startsWith('Test profile').delete();
+      await this._dbService.db.getRepository(PostEntity).where('title').startsWith('Test post').delete();
+      await this._dbService.db.getRepository(TagEntity).where('name').startsWith('test-tag').delete();
+
+      // Create test user
+      const user = new UserEntity();
+      Object.assign(user, {
+        name: 'John Doe',
+        email: `john+${Date.now()}@example.com`,
+        age: 30,
+        isActive: true,
+        metadata: { source: 'relation-test' },
+      });
+
+      const savedUser = await this._dbService.db.saveWithRelations({
+        entity: user,
+        entityClass: UserEntity,
+      });
+
+      // Create profile
+      const profile = new ProfileEntity();
+      Object.assign(profile, {
+        bio: 'Test profile for John Doe',
+        userId: savedUser.id!,
+      });
+
+      await this._dbService.db.saveWithRelations({
+        entity: profile,
+        entityClass: ProfileEntity,
+      });
+
+      // Create post
+      const post = new PostEntity();
+      Object.assign(post, {
+        title: 'Test post',
+        content: 'This is a test post',
+        published: true,
+        likes: 5,
+        createdAt: new Date(),
+        userId: savedUser.id!,
+      });
+
+      await this._dbService.db.saveWithRelations({
+        entity: post,
+        entityClass: PostEntity,
+      });
+
+      // Create tag
+      const tag = new TagEntity();
+      Object.assign(tag, {
+        name: 'test-tag-1',
+        color: '#ff0000',
+      });
+
+      await this._dbService.db.saveWithRelations({
+        entity: tag,
+        entityClass: TagEntity,
+      });
+
+      console.log('Relations test completed successfully');
+      alert('Relations test completed! Check console for details.');
+      await this.loadUsers();
+    } catch (error) {
+      console.error('Error testing relations:', error);
+      alert('Error testing relations: ' + (error as Error).message);
+    }
+  }
+
+  async testTransactions(): Promise<void> {
+    try {
+      await this._dbService.db.transaction('rw', [this._dbService.db.getRepository(UserEntity), this._dbService.db.getRepository(PostEntity)], async () => {
+        const user = newEntity(UserEntity, {
+          name: 'Transaction User',
+          email: `transaction${Date.now()}@example.com`,
+          age: 25,
+          isActive: true,
+        });
+
+        const savedUser = await this._dbService.db.saveWithRelations({
+          entity: user,
+          entityClass: UserEntity,
+        });
+
+        const post = newEntity(PostEntity, {
+          title: 'Transaction Post',
+          content: 'Created in transaction',
+          published: false,
+          likes: 0,
+          createdAt: Date.now(),
+          authorId: savedUser.id!,
+        });
+
+        await this._dbService.db.saveWithRelations({
+          entity: post,
+          entityClass: PostEntity,
+        });
+      });
+
+      console.log('Transaction test completed');
+      alert('Transaction test completed!');
+      await this.loadUsers();
+    } catch (error) {
+      console.error('Transaction error:', error);
+      alert('Transaction error: ' + (error as Error).message);
+    }
+  }
+
+  async testCompoundIndexes(): Promise<void> {
+    try {
+      console.log('Testing compound indexes...');
+
+      // Test 1: Query using compound index (name + email)
+      console.log('Test 1: Query using compound index (name + email)');
+      const usersByNameEmail = await this._dbService.db
+        .getRepository(UserEntity)
+        .where(['name', 'email'])
+        .equals(['John Doe', 'john@example.com'])
+        .toArray();
+      console.log('Users by name+email:', usersByNameEmail);
+
+      // Test 2: Query using compound index (age + isActive)
+      console.log('Test 2: Query using compound index (age + isActive)');
+      const activeAdults = await this._dbService.db
+        .getRepository(UserEntity)
+        .where(['age', 'isActive'])
+        .above([18, 1])
+        .toArray();
+      console.log('Active adults (age > 18, isActive = true):', activeAdults);
+
+      // Test 3: Query using unique compound index (email)
+      console.log('Test 3: Query using unique compound index (email)');
+      const userByEmail = await this._dbService.db
+        .getRepository(UserEntity)
+        .where('email')
+        .equals('john@example.com')
+        .first();
+      console.log('User by email:', userByEmail);
+
+      // Test 4: Add some test data to demonstrate compound indexes
+      console.log('Test 4: Adding test data for compound indexes');
+      const testUser1 = newEntity(UserEntity, {
+        name: 'Alice Smith',
+        email: 'alice@example.com',
+        age: 25,
+        isActive: true,
+        tags: ['test'],
+        metadata: { source: 'compound-test' },
+        createdAt: Date.now(),
+        updatedAt: Date.now(),
+      });
+
+      const testUser2 = newEntity(UserEntity, {
+        name: 'Bob Johnson',
+        email: 'bob@example.com',
+        age: 17,
+        isActive: false,
+        tags: ['test'],
+        metadata: { source: 'compound-test' },
+        createdAt: Date.now(),
+        updatedAt: Date.now(),
+      });
+
+      await this._dbService.db.saveWithRelations({
+        entity: testUser1,
+        entityClass: UserEntity,
+      });
+
+      await this._dbService.db.saveWithRelations({
+        entity: testUser2,
+        entityClass: UserEntity,
+      });
+
+      // Test 5: Query the new test data
+      console.log('Test 5: Querying test data with compound indexes');
+      const testActiveAdults = await this._dbService.db
+        .getRepository(UserEntity)
+        .where(['age', 'isActive'])
+        .above([18, 1])
+        .toArray();
+
+      const testInactiveMinors = await this._dbService.db
+        .getRepository(UserEntity)
+        .where(['age', 'isActive'])
+        .below([18, 1])
+        .toArray();
+
+      console.log('Test active adults:', testActiveAdults);
+      console.log('Test inactive minors:', testInactiveMinors);
+
+      alert(
+        `Compound index test completed!\n\n` +
+        `Name+Email query: ${usersByNameEmail.length} results\n` +
+        `Active adults: ${activeAdults.length} results\n` +
+        `Email query: ${userByEmail ? 'Found' : 'Not found'}\n` +
+        `Test active adults: ${testActiveAdults.length} results\n` +
+        `Test inactive minors: ${testInactiveMinors.length} results\n\n` +
+        `Check console for detailed results.`,
+      );
+
+      await this.loadUsers();
+    } catch (error) {
+      console.error('Compound index error:', error);
+      alert('Compound index error: ' + (error as Error).message);
+    }
+  }
+
+  async testAggregations(): Promise<void> {
+    try {
+      // Test basic statistics
+      const userStats = await this._dbService.db.aggregate({
+        entityClass: UserEntity,
+        options: {
+          count: true,
+          avg: ['age'],
+        },
+      });
+
+      // Test active users only
+      const activeUserStats = await this._dbService.db.aggregate({
+        entityClass: UserEntity,
+        options: {
+          where: { isActive: true },
+          count: true,
+          avg: ['age'],
+        },
+      });
+
+      console.log('Aggregation test results:', {
+        totalUsers: userStats.count,
+        activeUsers: activeUserStats.count,
+        averageAge: userStats.avg?.['age'],
+        activeUserAvgAge: activeUserStats.avg?.['age'],
+      });
+
+      alert(`Aggregation test completed!\nTotal users: ${userStats.count}\nActive users: ${activeUserStats.count}\nAverage age: ${userStats.avg?.['age']?.toFixed(1) || 'N/A'}\nActive users avg age: ${activeUserStats.avg?.['age']?.toFixed(1) || 'N/A'}`);
+    } catch (error) {
+      console.error('Aggregation error:', error);
+      alert('Aggregation error: ' + (error as Error).message);
+    }
+  }
+
+  async clearAll(): Promise<void> {
+    try {
+      await this._dbService.db.getRepository(UserEntity).clear();
+      await this._dbService.db.getRepository(ProfileEntity).clear();
+      await this._dbService.db.getRepository(PostEntity).clear();
+      await this._dbService.db.getRepository(TagEntity).clear();
+      await this._dbService.db.getRepository(PostTagEntity).clear();
+
+      await this.loadUsers();
+      console.log('All data cleared');
+      alert('All data cleared!');
+    } catch (error) {
+      console.error('Error clearing data:', error);
+      alert('Error clearing data: ' + (error as Error).message);
+    }
+  }
+
+  async toggleAutoReset(): Promise<void> {
+    try {
+      // Show current status
+      const currentStatus =
+        localStorage.getItem('DexieORMDemo_auto_reset') !== 'false';
+
+      const newStatus = !currentStatus;
+      localStorage.setItem('DexieORMDemo_auto_reset', newStatus.toString());
+
+      alert(
+        `Auto-reset ${newStatus ? 'enabled' : 'disabled'}! ${
+          newStatus
+            ? 'Database will reset on schema changes.'
+            : 'Database will not reset on schema changes.'
+        }`,
+      );
+    } catch (error) {
+      console.error('Auto-reset toggle error:', error);
+      alert(`Auto-reset toggle error: ${(error as Error).message}`);
+    }
+  }
+
+  setTabIndex(index: number): void {
+    this.tabIndexSubject.next(index);
+  }
+
+  toggleMobileOpen(): void {
+    this.mobileOpenSubject.next(!this.mobileOpenSubject.value);
+  }
+}