@indexeddb-orm/idb-orm 0.0.1

package/vue-demo-app/src/services/useAppLogic.ts

@@ -0,0 +1,565 @@
+import { newEntity } from 'idb-orm';
+import {
+ onMounted,ref,
+} from 'vue';
+
+import { db } from '../database/Database';
+import { PostEntity } from '../entities/Post';
+import { ProfileEntity } from '../entities/Profile';
+import { TagEntity } from '../entities/Tag';
+import { UserEntity } from '../entities/User';
+
+export function useAppLogic() {
+  const users = ref<UserEntity[]>([]);
+  const tabIndex = ref(0);
+  const mobileOpen = ref(false);
+
+  const tabs = [
+    { label: 'Admin', key: 'admin' },
+    { label: 'Cloud Sync', key: 'cloud' },
+  ];
+
+  onMounted(() => {
+    loadUsers();
+  });
+
+  const loadUsers = async () => {
+    try {
+      const userRepository = db.getRepository(UserEntity);
+      const userData = await userRepository.toArray();
+      users.value = userData;
+      console.log('Users loaded:', userData);
+    } catch (error) {
+      console.error('Error loading users:', error);
+    }
+  };
+
+  const addUser = async () => {
+    try {
+      const newUser = newEntity(UserEntity, {
+        name: 'Test User ' + (users.value.length + 1),
+        email: 'user' + (users.value.length + 1) + '@example.com',
+        age: 25 + users.value.length,
+        tags: ['test'],
+        metadata: { source: 'manual' },
+      });
+
+      const userRepository = db.getRepository(UserEntity);
+      await userRepository.add(newUser);
+      await loadUsers();
+    } catch (error) {
+      console.error('Error adding user:', error);
+    }
+  };
+
+  const testZodValidation = async () => {
+    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 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}`);
+    }
+  };
+
+  const testSchemaMigration = async () => {
+    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 as Error).message}`);
+    }
+  };
+
+  const toggleAutoReset = async () => {
+    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 as Error).message}`);
+    }
+  };
+
+  const testTransactions = async () => {
+    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 as 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 as Error).message}`);
+    }
+  };
+
+  const testCompoundIndexes = async () => {
+    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 as Error).message}`);
+    }
+  };
+
+  const testRelations = async () => {
+    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 allUsers = await db.getRepository(UserEntity).toArray();
+      const testUsers = allUsers.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 as Error).message}`);
+    }
+  };
+
+  const testAggregations = async () => {
+    try {
+      console.log('Testing aggregations...');
+
+      // Test 1: Basic statistics
+      console.log('Test 1: Basic user statistics');
+      const userStats = await db.aggregate({
+        entityClass: UserEntity,
+        options: {
+          count: true,
+          avg: ['age'],
+          min: ['age'],
+          max: ['age'],
+        },
+      });
+      console.log('User stats:', userStats);
+
+      // 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 postStats = await db.aggregate({
+        entityClass: PostEntity,
+        options: {
+          where: { published: true },
+          count: true,
+          sum: ['likes'],
+          avg: ['likes'],
+        },
+      });
+      console.log('Post stats:', postStats);
+
+      // 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 as Error).message}`);
+    }
+  };
+
+  const clearAll = async () => {
+    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 as Error).message}`);
+    }
+  };
+
+  const handleDrawerToggle = () => {
+    mobileOpen.value = !mobileOpen.value;
+  };
+
+  return {
+    // State
+    users,
+    tabIndex,
+    setTabIndex: (index: number) => { tabIndex.value = index; },
+    mobileOpen,
+    tabs,
+
+    // Actions
+    addUser,
+    testZodValidation,
+    testSchemaMigration,
+    toggleAutoReset,
+    testTransactions,
+    testCompoundIndexes,
+    testRelations,
+    testAggregations,
+    clearAll,
+    handleDrawerToggle,
+  };
+}

package/vue-demo-app/src/services/useCloudSyncDemo.ts

@@ -0,0 +1,84 @@
+import {
+ onMounted,ref,
+} from 'vue';
+
+import { db } from '../database/Database';
+
+export function useCloudSyncDemo() {
+  const syncStatus = ref<{
+    enabled: boolean;
+    lastSync?: Date;
+    isOnline?: boolean;
+  }>({ enabled: false });
+  const isLoading = ref(false);
+
+  onMounted(() => {
+    // Get initial sync status
+    const status = db.getSyncStatus();
+    syncStatus.value = status;
+  });
+
+  const handleManualSync = async () => {
+    isLoading.value = true;
+    try {
+      await db.sync();
+      // Update status after sync
+      const newStatus = db.getSyncStatus();
+      syncStatus.value = newStatus;
+      alert('Sync completed successfully!');
+    } catch (error) {
+      console.error('Sync failed:', error);
+      alert(`Sync failed: ${(error as Error).message}`);
+    } finally {
+      isLoading.value = false;
+    }
+  };
+
+  const handleEnableCloudSync = async () => {
+    isLoading.value = true;
+    try {
+      await db.enableCloudSync({
+        databaseUrl: 'https://your-database-url.dexie.cloud',
+        enableOfflineSupport: true,
+        syncInterval: 30000,
+      });
+
+      const newStatus = db.getSyncStatus();
+      syncStatus.value = newStatus;
+      alert('Cloud sync enabled successfully!');
+    } catch (error) {
+      console.error('Failed to enable cloud sync:', error);
+      alert(`Failed to enable cloud sync: ${(error as Error).message}`);
+    } finally {
+      isLoading.value = false;
+    }
+  };
+
+  const handleDisableCloudSync = () => {
+    db.disableCloudSync();
+    syncStatus.value = { enabled: false };
+    alert('Cloud sync disabled');
+  };
+
+  const handleSyncTables = async () => {
+    isLoading.value = true;
+    try {
+      await db.syncTables(['users', 'posts']);
+      alert('Tables synced successfully!');
+    } catch (error) {
+      console.error('Table sync failed:', error);
+      alert(`Table sync failed: ${(error as Error).message}`);
+    } finally {
+      isLoading.value = false;
+    }
+  };
+
+  return {
+    syncStatus,
+    isLoading,
+    handleManualSync,
+    handleEnableCloudSync,
+    handleDisableCloudSync,
+    handleSyncTables,
+  };
+}