@indexeddb-orm/idb-orm 0.0.1

package/svelte-demo-app/src/stores/appStore.js

@@ -0,0 +1,603 @@
+import { writable } from 'svelte/store';
+import { browser } from '$app/environment';
+import { db } from '$lib/database/Database';
+import { newEntity } from '../../../src/services/EntityFactory';
+import { UserEntity } from '$lib/entities/User';
+import { PostEntity } from '$lib/entities/Post';
+import { ProfileEntity } from '$lib/entities/Profile';
+import { TagEntity } from '$lib/entities/Tag';
+
+// State stores
+export const users = writable([]);
+export const tabIndex = writable(0);
+export const mobileOpen = writable(false);
+export const syncStatus = writable({ enabled: false, isOnline: false, lastSync: undefined });
+export const userStats = writable({ totalUsers: 0, adultUsers: 0, firstUser: '' });
+export const allUsers = writable([]);
+export const allPosts = writable([]);
+export const allProfiles = writable([]);
+export const postStats = writable({ total: 0, published: 0, totalLikes: 0 });
+
+// Actions
+export function setTabIndex(index) {
+  tabIndex.set(index);
+}
+
+export function toggleMobileOpen() {
+  mobileOpen.update(open => !open);
+}
+
+export async function loadUsers() {
+  if (!browser || !db) return;
+  try {
+    const userList = await db.getRepository(UserEntity).toArray();
+    users.set(userList);
+    allUsers.set(userList);
+  } catch (error) {
+    console.error('Error loading users:', error);
+  }
+}
+
+export async function addUser() {
+  if (!browser || !db) return;
+  try {
+    const user = newEntity(UserEntity, {
+      name: `User ${Date.now()}`,
+      email: `user${Date.now()}@example.com`,
+      age: Math.floor(Math.random() * 50) + 18,
+      isActive: true,
+      tags: ['demo', 'svelte'],
+      metadata: { source: 'svelte-demo' },
+      createdAt: Date.now(),
+      updatedAt: Date.now(),
+    });
+
+    await db.saveWithRelations({
+      entity: user,
+      entityClass: UserEntity,
+    });
+
+    await loadUsers();
+    alert('User added successfully!');
+  } catch (error) {
+    console.error('Error adding user:', error);
+    alert('Error adding user: ' + error.message);
+  }
+}
+
+export async function testZodValidation() {
+  if (!browser || !db) return;
+  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 = db.getRepository(UserEntity);
+      await userRepository.add(validUser);
+      console.log('Valid user added to the database');
+      await 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.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.message}`);
+  }
+}
+
+export async function testSchemaMigration() {
+  if (!browser || !db) return;
+  try {
+    console.log('Testing schema migration...');
+
+    // Check if schema has changed
+    const hasChanged = await db.checkSchemaChanges();
+
+    if (hasChanged) {
+      alert('Schema changed! Database was reset.');
+      await loadUsers(); // Reload data
+    } else {
+      alert('No schema changes detected.');
+    }
+  } catch (error) {
+    console.error('Schema migration test error:', error);
+    alert(`Schema migration test error: ${error.message}`);
+  }
+}
+
+export async function toggleAutoReset() {
+  if (!browser) return;
+  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('Error toggling auto-reset:', error);
+    alert(`Error toggling auto-reset: ${error.message}`);
+  }
+}
+
+export async function testTransactions() {
+  if (!browser || !db) return;
+  try {
+    console.log('Testing Dexie transactions with our ORM...');
+
+    // Test 1: Simple transaction using Dexie's transaction method
+    const result = await db.transaction(
+      'rw',
+      [db.getRepository(UserEntity), db.getRepository(ProfileEntity)],
+      async (trans) => {
+        // Create user
+        const user = newEntity(UserEntity, {
+          name: 'Transaction Test User',
+          email: `transaction-${Date.now()}@example.com`,
+          age: 30,
+          tags: ['transaction-test'],
+          metadata: { source: 'transaction-test' },
+          createdAt: Date.now(),
+          updatedAt: Date.now(),
+        });
+
+        const userId = await trans.table('users').add(user);
+        console.log('User created in transaction:', userId);
+
+        // Create profile for the user
+        const profile = newEntity(ProfileEntity, {
+          userId: userId,
+          bio: 'Transaction test profile',
+          avatar: 'https://example.com/avatar.jpg',
+          website: 'https://example.com',
+          location: 'Test City',
+          createdAt: Date.now(),
+          updatedAt: Date.now(),
+        });
+
+        const profileId = await trans.table('profiles').add(profile);
+        console.log('Profile created in transaction:', profileId);
+
+        return { userId, profileId };
+      },
+    );
+
+    console.log('Transaction completed successfully:', result);
+
+    // Test 2: Read-only transaction
+    const userCount = await db.transaction(
+      'r',
+      [db.getRepository(UserEntity)],
+      async (trans) => {
+        const users = await trans.table('users').toArray();
+        console.log('Users read in read-only transaction:', users.length);
+
+        return users.length;
+      },
+    );
+
+    console.log('Read transaction completed, user count:', userCount);
+
+    // Test 3: Transaction with error (rollback)
+    try {
+      await db.transaction('rw', [db.getRepository(UserEntity)], async (trans) => {
+        const user = newEntity(UserEntity, {
+          name: 'Rollback Test User',
+          email: `rollback-${Date.now()}@example.com`,
+          age: 25,
+          tags: ['rollback-test'],
+          metadata: { source: 'rollback-test' },
+          createdAt: Date.now(),
+          updatedAt: Date.now(),
+        });
+
+        await trans.table('users').add(user);
+        console.log('User added before error');
+
+        // Simulate error
+        throw new Error('Simulated transaction error');
+      });
+    } catch (error) {
+      console.log(
+        'Transaction rolled back as expected:',
+        error.message,
+      );
+    }
+
+    alert('Transactions test completed! Check console for details.');
+    await loadUsers();
+  } catch (error) {
+    console.error('Error testing transactions:', error);
+    alert(`Transactions test error: ${error.message}`);
+  }
+}
+
+export async function testCompoundIndexes() {
+  if (!browser || !db) return;
+  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 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 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 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: 30,
+      isActive: false,
+      tags: ['test'],
+      metadata: { source: 'compound-test' },
+      createdAt: Date.now(),
+      updatedAt: Date.now(),
+    });
+
+    await db.getRepository(UserEntity).bulkAdd([testUser1, testUser2]);
+    console.log('Test users added');
+
+    // Test 5: Query with compound index after adding data
+    console.log('Test 5: Query with compound index after adding data');
+    const allActiveUsers = await db
+      .getRepository(UserEntity)
+      .where('isActive')
+      .equals(1)
+      .toArray();
+    console.log('All active users:', allActiveUsers);
+
+    await loadUsers();
+    alert('Compound indexes test completed! Check console for details.');
+  } catch (error) {
+    console.error('Error testing compound indexes:', error);
+    alert(`Compound indexes test error: ${error.message}`);
+  }
+}
+
+export async function testRelations() {
+  if (!browser || !db) return;
+  try {
+    console.log('Testing relations...');
+
+    // Clear existing test data first
+    console.log('Clearing existing test data...');
+    // Get all users and filter by metadata.source in JavaScript
+    const allUsersData = await db.getRepository(UserEntity).toArray();
+    const testUsers = allUsersData.filter(user => user.metadata?.source === 'relation-test');
+    if (testUsers.length > 0) {
+      await db.getRepository(UserEntity).bulkDelete(testUsers.map(u => u.id));
+    }
+    await db.getRepository(ProfileEntity).where('bio').equals('Full-stack developer').delete();
+    await db.getRepository(PostEntity).where('title').startsWith('My First Post').delete();
+    await db.getRepository(PostEntity).where('title').startsWith('Learning Dexie ORM').delete();
+    await db.getRepository(TagEntity).where('name').equals('javascript').delete();
+    await db.getRepository(TagEntity).where('name').equals('typescript').delete();
+
+    // Create a user with profile and posts
+    const user = newEntity(UserEntity, {
+      name: 'John Doe',
+      email: `john+${Date.now()}@example.com`, // Unique email to avoid conflicts
+      age: 30,
+      tags: ['developer'],
+      metadata: { source: 'relation-test' },
+      createdAt: Date.now(),
+      updatedAt: Date.now(),
+    });
+
+    // Create profile
+    newEntity(ProfileEntity, {
+      bio: 'Full-stack developer',
+      avatar: 'https://example.com/avatar.jpg',
+      website: 'https://johndoe.com',
+      location: 'New York',
+      createdAt: Date.now(),
+      updatedAt: Date.now(),
+    });
+
+    // Create posts
+    newEntity(PostEntity, {
+      title: 'My First Post',
+      content: 'This is my first blog post about Dexie ORM!',
+      published: true,
+      likes: 42,
+      postTags: ['javascript', 'dexie'],
+      createdAt: Date.now(),
+      updatedAt: Date.now(),
+    });
+
+    newEntity(PostEntity, {
+      title: 'Learning Dexie ORM',
+      content: 'Learning how to use Dexie ORM with TypeScript and Zod validation.',
+      published: false,
+      likes: 15,
+      postTags: ['typescript', 'orm'],
+      createdAt: Date.now(),
+      updatedAt: Date.now(),
+    });
+
+    console.log('Saving user with relations...');
+    const savedUser = await db.saveWithRelations({
+      entity: user,
+      entityClass: UserEntity,
+    });
+
+    // Load user with all relations
+    await db.loadRelations({
+      entity: savedUser,
+      entityClass: UserEntity,
+      relationNames: ['profile', 'posts'],
+    });
+
+    // Load user with only specific relations
+    const userWithProfileOnly = await db.loadRelations({
+      entity: savedUser,
+      entityClass: UserEntity,
+      relationNames: ['profile'],
+    });
+    console.log('User with profile only:', userWithProfileOnly);
+
+    // Load single relation by name
+    const userProfile = await db.loadRelationByName({
+      entity: savedUser,
+      entityClass: UserEntity,
+      relationName: 'profile',
+    });
+    console.log('Profile loaded separately:', userProfile);
+
+    alert('Relations test completed! Check console for details.');
+    await loadUsers();
+  } catch (error) {
+    console.error('Error testing relations:', error);
+    alert(`Relations test error: ${error.message}`);
+  }
+}
+
+export async function testAggregations() {
+  if (!browser || !db) return;
+  try {
+    console.log('Testing aggregations...');
+
+    // Test 1: Basic statistics
+    console.log('Test 1: Basic user statistics');
+    const userStatsData = await db.aggregate({
+      entityClass: UserEntity,
+      options: {
+        count: true,
+        avg: ['age'],
+        min: ['age'],
+        max: ['age'],
+      },
+    });
+    console.log('User stats:', userStatsData);
+
+    // Test 2: Group by age
+    console.log('Test 2: Users grouped by age');
+    const usersByAge = await db.aggregate({
+      entityClass: UserEntity,
+      options: {
+        groupBy: 'age',
+        count: true,
+        avg: ['age'],
+      },
+    });
+    console.log('Users by age:', usersByAge);
+
+    // Test 3: Active users only
+    console.log('Test 3: Active users statistics');
+    const activeUserStats = await db.aggregate({
+      entityClass: UserEntity,
+      options: {
+        where: { isActive: true },
+        count: true,
+        avg: ['age'],
+      },
+    });
+    console.log('Active user stats:', activeUserStats);
+
+    // Test 4: Post statistics
+    console.log('Test 4: Post statistics');
+    const postStatsData = await db.aggregate({
+      entityClass: PostEntity,
+      options: {
+        where: { published: true },
+        count: true,
+        sum: ['likes'],
+        avg: ['likes'],
+      },
+    });
+    console.log('Post stats:', postStatsData);
+
+    // Test 5: Posts grouped by author
+    console.log('Test 5: Posts grouped by author');
+    const postsByAuthor = await db.aggregate({
+      entityClass: PostEntity,
+      options: {
+        groupBy: 'authorId',
+        count: true,
+        sum: ['likes'],
+      },
+    });
+    console.log('Posts by author:', postsByAuthor);
+
+    // Test 6: Top 5 oldest users
+    console.log('Test 6: Top 5 oldest users');
+    const oldestUsers = await db.aggregate({
+      entityClass: UserEntity,
+      options: {
+        sort: { field: 'createdAt', direction: 'asc' },
+        limit: 5,
+      },
+    });
+    console.log('Oldest users:', oldestUsers);
+
+    alert(
+      'Aggregations test completed! Check console for detailed results.',
+    );
+    await loadUsers();
+  } catch (error) {
+    console.error('Error testing aggregations:', error);
+    alert(`Aggregations test error: ${error.message}`);
+  }
+}
+
+export async function clearAll() {
+  if (!browser || !db) return;
+  try {
+    await db.getRepository(UserEntity).clear();
+    await db.getRepository(PostEntity).clear();
+    await db.getRepository(ProfileEntity).clear();
+    await db.getRepository(TagEntity).clear();
+    await loadUsers();
+    alert('All data cleared!');
+  } catch (error) {
+    console.error('Error clearing data:', error);
+    alert(`Error clearing data: ${error.message}`);
+  }
+}
+
+export async function loadLiveQueryData() {
+  if (!browser || !db) return;
+  try {
+    // Load all users
+    const userList = await db.getRepository(UserEntity).toArray();
+    allUsers.set(userList);
+    
+    // Load adult users
+    const adultUsersData = await db.getRepository(UserEntity).where('age').above(18).toArray();
+    
+    // Load user count
+    const userCount = await db.getRepository(UserEntity).count();
+    
+    // Load first user
+    const firstUserData = await db.getRepository(UserEntity).orderBy('id').first();
+    
+    // Load all posts
+    const postList = await db.getRepository(PostEntity).toArray();
+    allPosts.set(postList);
+    
+    // Load all profiles
+    const profileList = await db.getRepository(ProfileEntity).toArray();
+    allProfiles.set(profileList);
+    
+    // Update user stats
+    userStats.set({
+      totalUsers: userCount,
+      adultUsers: adultUsersData.length,
+      firstUser: firstUserData?.name || 'None'
+    });
+    
+    // Update post stats
+    const total = await db.getRepository(PostEntity).count();
+    const published = await db.getRepository(PostEntity).where('published').equals(1).count();
+    const allPostsData = await db.getRepository(PostEntity).toArray();
+    const totalLikes = allPostsData.reduce((sum, post) => sum + (post.likes || 0), 0);
+    
+    postStats.set({ total, published, totalLikes });
+  } catch (error) {
+    console.error('Error loading live query data:', error);
+  }
+}

package/svelte-demo-app/svelte.config.js

@@ -0,0 +1,18 @@
+import adapter from '@sveltejs/adapter-auto';
+
+/** @type {import('@sveltejs/kit').Config} */
+const config = {
+	kit: {
+		adapter: adapter(),
+		// Disable SSR for IndexedDB compatibility
+		prerender: {
+			handleHttpError: 'warn'
+		}
+	},
+	// Disable SSR for client-side only rendering
+	ssr: {
+		noExternal: ['idb-orm']
+	}
+};
+
+export default config;

package/svelte-demo-app/tsconfig.json

@@ -0,0 +1,14 @@
+{
+	"extends": "./.svelte-kit/tsconfig.json",
+	"compilerOptions": {
+		"allowJs": true,
+		"checkJs": true,
+		"esModuleInterop": true,
+		"forceConsistentCasingInFileNames": true,
+		"resolveJsonModule": true,
+		"skipLibCheck": true,
+		"sourceMap": true,
+		"strict": true,
+		"allowSyntheticDefaultImports": true
+	}
+}

package/svelte-demo-app/vite.config.ts

@@ -0,0 +1,6 @@
+import { sveltekit } from '@sveltejs/kit/vite';
+import { defineConfig } from 'vite';
+
+export default defineConfig({
+	plugins: [sveltekit()]
+});