http-request-manager 18.7.20 → 18.7.21

package/DATABASE_README.md

@@ -0,0 +1,1176 @@
+# Database Manager Service
+
+The `DatabaseManagerService` is a wrapper service for Dexie.js that provides IndexedDB interactions using RxJS Observables. It enables offline-first applications with sophisticated local data storage and querying capabilities.
+
+## Overview
+
+This service provides:
+
+- **IndexedDB Management** - Complete wrapper around Dexie.js for IndexedDB operations
+- **Observable API** - All operations return Observables for reactive programming
+- **Table Management** - Create and manage database tables with flexible schemas
+- **CRUD Operations** - Full support for Create, Read, Update, Delete operations
+- **Querying** - Advanced querying capabilities with filtering and sorting
+- **Bulk Operations** - Optimized methods for batch operations
+- **Schema Inspection** - Check table existence and retrieve schema definitions
+
+## Installation
+
+```typescript
+import { HttpRequestManagerModule } from 'http-request-manager';
+
+@NgModule({
+  imports: [HttpRequestManagerModule.forRoot({})]
+})
+export class AppModule { }
+```
+
+## Basic Usage
+
+### Service Injection
+
+```typescript
+import { Component, inject } from '@angular/core';
+import { DatabaseManagerService, TableSchemaDef } from 'http-request-manager';
+
+@Component({
+  selector: 'app-database-demo',
+  template: `
+    <div class="database-demo">
+      <h2>Database Operations Demo</h2>
+      
+      <div class="actions">
+        <button (click)="initializeTables()">Initialize Tables</button>
+        <button (click)="addSampleData()">Add Sample Data</button>
+        <button (click)="loadData()">Load Data</button>
+        <button (click)="clearData()">Clear All</button>
+      </div>
+      
+      <div class="status">
+        <p>Loading: {{ isLoading ? 'Yes' : 'No' }}</p>
+        <p>Table Status: {{ tableStatus }}</p>
+      </div>
+      
+      <div class="data-display" *ngIf="data.length > 0">
+        <h3>Stored Data ({{ data.length }} records)</h3>
+        <div *ngFor="let item of data" class="data-item">
+          <strong>{{ item.name }}</strong> - {{ item.email }}
+          <button (click)="deleteItem(item.id)">Delete</button>
+        </div>
+      </div>
+      
+      <div class="search-section">
+        <h3>Search</h3>
+        <input [(ngModel)]="searchQuery" placeholder="Search by name...">
+        <button (click)="search()">Search</button>
+        <div *ngFor="let result of searchResults" class="search-result">
+          {{ result.name }} - {{ result.email }}
+        </div>
+      </div>
+    </div>
+  `
+})
+export class DatabaseDemoComponent {
+  private dbManager = inject(DatabaseManagerService);
+  
+  data: any[] = [];
+  searchResults: any[] = [];
+  searchQuery = '';
+  isLoading = false;
+  tableStatus = 'Not initialized';
+
+  initializeTables() {
+    const tableDef = TableSchemaDef.adapt({
+      table: 'users',
+      schema: '++id, name, email, age, createdAt'
+    });
+
+    this.dbManager.createDatabaseTable(tableDef).subscribe({
+      next: () => {
+        this.tableStatus = 'Table created successfully';
+        console.log('Users table initialized');
+      },
+      error: (error) => {
+        this.tableStatus = `Error: ${error.message}`;
+        console.error('Table creation failed:', error);
+      }
+    });
+  }
+
+  addSampleData() {
+    const users = [
+      { name: 'John Doe', email: 'john@example.com', age: 30, createdAt: new Date() },
+      { name: 'Jane Smith', email: 'jane@example.com', age: 25, createdAt: new Date() },
+      { name: 'Bob Johnson', email: 'bob@example.com', age: 35, createdAt: new Date() }
+    ];
+
+    this.dbManager.createTableRecords('users', users).subscribe({
+      next: () => {
+        console.log('Sample data added');
+        this.loadData();
+      },
+      error: (error) => console.error('Failed to add data:', error)
+    });
+  }
+
+  loadData() {
+    this.isLoading = true;
+    this.dbManager.getTableRecords('users').subscribe({
+      next: (users) => {
+        this.data = users;
+        this.isLoading = false;
+        console.log('Data loaded:', users);
+      },
+      error: (error) => {
+        console.error('Failed to load data:', error);
+        this.isLoading = false;
+      }
+    });
+  }
+
+  deleteItem(id: number) {
+    this.dbManager.deleteTableRecord('users', id).subscribe({
+      next: () => {
+        console.log('Record deleted');
+        this.loadData();
+      },
+      error: (error) => console.error('Delete failed:', error)
+    });
+  }
+
+  search() {
+    if (this.searchQuery.trim()) {
+      this.dbManager.findTableRecords('users', 'name', this.searchQuery).subscribe({
+        next: (results) => {
+          this.searchResults = results;
+          console.log('Search results:', results);
+        },
+        error: (error) => console.error('Search failed:', error)
+      });
+    }
+  }
+
+  clearData() {
+    this.dbManager.clearTableRecords('users').subscribe({
+      next: () => {
+        this.data = [];
+        this.searchResults = [];
+        console.log('All data cleared');
+      },
+      error: (error) => console.error('Clear failed:', error)
+    });
+  }
+}
+```
+
+## API Reference
+
+### Table Management
+
+#### createDatabaseTable(tableDef: TableSchemaDef): Observable<void>
+
+Create a new database table:
+
+```typescript
+const tableDef = TableSchemaDef.adapt({
+  table: 'products',
+  schema: '++id, name, price, category, createdAt'
+});
+
+this.dbManager.createDatabaseTable(tableDef).subscribe(() => {
+  console.log('Products table created');
+});
+```
+
+#### hasDatabaseTable(tableName: string): Observable<boolean>
+
+Check if table exists:
+
+```typescript
+this.dbManager.hasDatabaseTable('users').subscribe(exists => {
+  if (exists) {
+    console.log('Users table exists');
+  } else {
+    console.log('Users table does not exist');
+  }
+});
+```
+
+#### getTableSchema(tableName: string): Observable<any>
+
+Get table schema definition:
+
+```typescript
+this.dbManager.getTableSchema('users').subscribe(schema => {
+  console.log('Table schema:', schema);
+});
+```
+
+### CRUD Operations
+
+#### createTableRecord(tableName: string, data: any): Observable<any>
+
+Create a single record:
+
+```typescript
+this.dbManager.createTableRecord('users', {
+  name: 'John Doe',
+  email: 'john@example.com',
+  age: 30
+}).subscribe(createdRecord => {
+  console.log('Record created with ID:', createdRecord.id);
+});
+```
+
+#### createTableRecords(tableName: string, dataArray: any[]): Observable<any[]>
+
+Create multiple records:
+
+```typescript
+const users = [
+  { name: 'John Doe', email: 'john@example.com', age: 30 },
+  { name: 'Jane Smith', email: 'jane@example.com', age: 25 },
+  { name: 'Bob Johnson', email: 'bob@example.com', age: 35 }
+];
+
+this.dbManager.createTableRecords('users', users).subscribe(createdRecords => {
+  console.log('Created', createdRecords.length, 'records');
+});
+```
+
+#### getTableRecords(tableName: string): Observable<any[]>
+
+Get all records from a table:
+
+```typescript
+this.dbManager.getTableRecords('users').subscribe(users => {
+  console.log('All users:', users);
+});
+```
+
+#### getTableRecord(tableName: string, id: any): Observable<any>
+
+Get a specific record by ID:
+
+```typescript
+this.dbManager.getTableRecord('users', 1).subscribe(user => {
+  console.log('User with ID 1:', user);
+});
+```
+
+#### updateTableRecord(tableName: string, data: any): Observable<any>
+
+Update an existing record:
+
+```typescript
+this.dbManager.updateTableRecord('users', {
+  id: 1,
+  name: 'John Smith',
+  email: 'john.smith@example.com',
+  age: 31
+}).subscribe(updatedRecord => {
+  console.log('Updated record:', updatedRecord);
+});
+```
+
+#### deleteTableRecord(tableName: string, id: any): Observable<void>
+
+Delete a record by ID:
+
+```typescript
+this.dbManager.deleteTableRecord('users', 1).subscribe(() => {
+  console.log('Record deleted');
+});
+```
+
+### Querying Operations
+
+#### findTableRecords(tableName: string, field: string, value: any): Observable<any[]>
+
+Find records by field value:
+
+```typescript
+// Find users by age
+this.dbManager.findTableRecords('users', 'age', 30).subscribe(users => {
+  console.log('Users aged 30:', users);
+});
+
+// Find users by name (partial match)
+this.dbManager.findTableRecords('users', 'name', 'John').subscribe(users => {
+  console.log('Users with "John" in name:', users);
+});
+```
+
+#### queryTableRecords(tableName: string, queryFn: Function): Observable<any[]>
+
+Execute custom queries:
+
+```typescript
+this.dbManager.queryTableRecords('users', (table) => {
+  return table
+    .where('age')
+    .above(25)
+    .sortBy('name');
+}).subscribe(users => {
+  console.log('Users over 25, sorted by name:', users);
+});
+```
+
+#### countTableRecords(tableName: string): Observable<number>
+
+Count records in a table:
+
+```typescript
+this.dbManager.countTableRecords('users').subscribe(count => {
+  console.log('Total users:', count);
+});
+```
+
+### Bulk Operations
+
+#### bulkCreateTableRecords(tableName: string, dataArray: any[]): Observable<any[]>
+
+Optimized bulk insert:
+
+```typescript
+const largeDataset = Array.from({length: 1000}, (_, i) => ({
+  name: `User ${i}`,
+  email: `user${i}@example.com`,
+  age: Math.floor(Math.random() * 50) + 18
+}));
+
+this.dbManager.bulkCreateTableRecords('users', largeDataset).subscribe(result => {
+  console.log('Bulk insert completed:', result.length, 'records');
+});
+```
+
+#### bulkDeleteTableRecords(tableName: string, ids: any[]): Observable<void>
+
+Bulk delete by IDs:
+
+```typescript
+const idsToDelete = [1, 2, 3, 4, 5];
+
+this.dbManager.bulkDeleteTableRecords('users', idsToDelete).subscribe(() => {
+  console.log('Bulk delete completed');
+});
+```
+
+### Table Maintenance
+
+#### clearTableRecords(tableName: string): Observable<void>
+
+Clear all records from a table:
+
+```typescript
+this.dbManager.clearTableRecords('users').subscribe(() => {
+  console.log('All user records cleared');
+});
+```
+
+#### deleteDatabaseTable(tableName: string): Observable<void>
+
+Delete an entire table:
+
+```typescript
+this.dbManager.deleteDatabaseTable('old_table').subscribe(() => {
+  console.log('Table deleted');
+});
+```
+
+## Configuration
+
+### Table Schema Definition
+
+```typescript
+interface TableSchemaDef {
+  table: string;        // Table name
+  schema: string;       // Dexie schema syntax
+}
+
+// Common schema patterns
+const schemas = {
+  // Simple table with auto-increment ID
+  simple: '++id, name, email',
+  
+  // Table with custom primary key
+  customKey: 'id, name, email',
+  
+  // Table with indexes
+  indexed: '++id, name, email, age',
+  
+  // Table with compound indexes
+  compound: '++id, [firstName+lastName], email, age',
+  
+  // Table with dates and complex types
+  complex: '++id, name, email, createdAt, metadata'
+};
+
+// Create schema definition
+const tableDef = TableSchemaDef.adapt({
+  table: 'users',
+  schema: '++id, name, email, age, createdAt'
+});
+```
+
+### Schema Syntax Reference
+
+| Syntax | Description | Example |
+|--------|-------------|---------|
+| `++id` | Auto-increment primary key | `++id` |
+| `id` | String/increment primary key | `id` |
+| `name` | Indexed field | `name` |
+| `[field1+field2]` | Compound index | `[firstName+lastName]` |
+| `*tags` | Multi-entry index | `*tags` |
+
+## Advanced Examples
+
+### E-commerce Product Catalog
+
+```typescript
+@Injectable()
+export class ProductCatalogService {
+  private dbManager = inject(DatabaseManagerService);
+
+  constructor() {
+    this.initializeProductTables();
+  }
+
+  private initializeProductTables() {
+    // Products table
+    const productSchema = TableSchemaDef.adapt({
+      table: 'products',
+      schema: '++id, name, description, price, categoryId, brand, tags, createdAt, updatedAt'
+    });
+
+    // Categories table
+    const categorySchema = TableSchemaDef.adapt({
+      table: 'categories',
+      schema: '++id, name, description, parentId'
+    });
+
+    // Reviews table
+    const reviewSchema = TableSchemaDef.adapt({
+      table: 'reviews',
+      schema: '++id, productId, userId, rating, comment, createdAt'
+    });
+
+    // Initialize all tables
+    [productSchema, categorySchema, reviewSchema].forEach(schema => {
+      this.dbManager.createDatabaseTable(schema).subscribe({
+        next: () => console.log(`Table ${schema.table} initialized`),
+        error: (error) => console.error(`Failed to create ${schema.table}:`, error)
+      });
+    });
+  }
+
+  // Product operations
+  addProduct(product: any) {
+    return this.dbManager.createTableRecord('products', {
+      ...product,
+      createdAt: new Date(),
+      updatedAt: new Date()
+    });
+  }
+
+  getProduct(id: number) {
+    return this.dbManager.getTableRecord('products', id);
+  }
+
+  getAllProducts() {
+    return this.dbManager.getTableRecords('products');
+  }
+
+  updateProduct(product: any) {
+    return this.dbManager.updateTableRecord('products', {
+      ...product,
+      updatedAt: new Date()
+    });
+  }
+
+  deleteProduct(id: number) {
+    // Delete product and its reviews
+    return this.dbManager.deleteTableRecord('products', id).pipe(
+      switchMap(() => this.dbManager.queryTableRecords('reviews', (table) => 
+        table.where('productId').equals(id).delete()
+      ))
+    );
+  }
+
+  // Search and filtering
+  searchProducts(query: string) {
+    return this.dbManager.queryTableRecords('products', (table) => {
+      return table
+        .filter(product => 
+          product.name.toLowerCase().includes(query.toLowerCase()) ||
+          product.description.toLowerCase().includes(query.toLowerCase())
+        )
+        .sortBy('name');
+    });
+  }
+
+  getProductsByCategory(categoryId: number) {
+    return this.dbManager.findTableRecords('products', 'categoryId', categoryId);
+  }
+
+  getProductsByPriceRange(minPrice: number, maxPrice: number) {
+    return this.dbManager.queryTableRecords('products', (table) => {
+      return table
+        .where('price')
+        .between(minPrice, maxPrice)
+        .sortBy('price');
+    });
+  }
+
+  getPopularProducts(limit: number = 10) {
+    return this.dbManager.queryTableRecords('reviews', (table) => {
+      return table
+        .toArray()
+        .then(reviews => {
+          // Calculate average ratings
+          const productRatings = new Map();
+          reviews.forEach(review => {
+            const current = productRatings.get(review.productId) || { total: 0, count: 0 };
+            productRatings.set(review.productId, {
+              total: current.total + review.rating,
+              count: current.count + 1
+            });
+          });
+
+          // Get top rated products
+          const topRated = Array.from(productRatings.entries())
+            .map(([productId, rating]) => ({
+              productId,
+              averageRating: rating.total / rating.count,
+              reviewCount: rating.count
+            }))
+            .sort((a, b) => b.averageRating - a.averageRating)
+            .slice(0, limit);
+
+          return topRated;
+        });
+    });
+  }
+}
+```
+
+### Offline-First User Profile Management
+
+```typescript
+@Injectable()
+export class UserProfileService {
+  private dbManager = inject(DatabaseManagerService);
+  private syncQueue: any[] = [];
+
+  constructor() {
+    this.initializeUserTables();
+    this.setupOnlineSync();
+  }
+
+  private initializeUserTables() {
+    const userSchema = TableSchemaDef.adapt({
+      table: 'user_profiles',
+      schema: '++id, userId, email, profileData, lastSyncAt, isDirty'
+    });
+
+    const activitySchema = TableSchemaDef.adapt({
+      table: 'user_activities',
+      schema: '++id, userId, activityType, data, timestamp'
+    });
+
+    [userSchema, activitySchema].forEach(schema => {
+      this.dbManager.createDatabaseTable(schema).subscribe({
+        next: () => console.log(`Table ${schema.table} initialized`),
+        error: (error) => console.error(`Failed to create ${schema.table}:`, error)
+      });
+    });
+  }
+
+  // Profile management
+  saveProfile(userId: string, profileData: any) {
+    const profile = {
+      userId,
+      email: profileData.email,
+      profileData,
+      lastSyncAt: new Date(),
+      isDirty: !navigator.onLine // Mark as dirty if offline
+    };
+
+    return this.dbManager.createTableRecord('user_profiles', profile).pipe(
+      tap(() => {
+        if (!navigator.onLine) {
+          this.syncQueue.push({ action: 'create', data: profile });
+          this.saveSyncQueue();
+        }
+      })
+    );
+  }
+
+  getProfile(userId: string) {
+    return this.dbManager.findTableRecords('user_profiles', 'userId', userId).pipe(
+      map(profiles => profiles[0] || null)
+    );
+  }
+
+  updateProfile(userId: string, updates: any) {
+    return this.getProfile(userId).pipe(
+      switchMap(profile => {
+        if (!profile) {
+          throw new Error('Profile not found');
+        }
+
+        const updatedProfile = {
+          ...profile,
+          ...updates,
+          lastSyncAt: new Date(),
+          isDirty: !navigator.onLine
+        };
+
+        return this.dbManager.updateTableRecord('user_profiles', updatedProfile).pipe(
+          tap(() => {
+            if (!navigator.onLine) {
+              this.syncQueue.push({ action: 'update', data: updatedProfile });
+              this.saveSyncQueue();
+            }
+          })
+        );
+      })
+    );
+  }
+
+  // Activity tracking
+  logActivity(userId: string, activityType: string, data: any) {
+    const activity = {
+      userId,
+      activityType,
+      data,
+      timestamp: new Date()
+    };
+
+    return this.dbManager.createTableRecord('user_activities', activity);
+  }
+
+  getUserActivities(userId: string, limit: number = 50) {
+    return this.dbManager.queryTableRecords('user_activities', (table) => {
+      return table
+        .where('userId')
+        .equals(userId)
+        .reverse()
+        .limit(limit)
+        .toArray();
+    });
+  }
+
+  // Sync management
+  private setupOnlineSync() {
+    window.addEventListener('online', () => {
+      console.log('Back online, syncing data...');
+      this.syncPendingChanges();
+    });
+  }
+
+  private syncPendingChanges() {
+    const queue = this.loadSyncQueue();
+    
+    queue.forEach(item => {
+      switch (item.action) {
+        case 'create':
+          this.syncCreate(item.data);
+          break;
+        case 'update':
+          this.syncUpdate(item.data);
+          break;
+        case 'delete':
+          this.syncDelete(item.data);
+          break;
+      }
+    });
+
+    // Clear queue after successful sync
+    this.syncQueue = [];
+    this.saveSyncQueue();
+  }
+
+  private syncCreate(data: any) {
+    // Sync with server API
+    console.log('Syncing create operation:', data);
+    // Implementation would depend on your API
+  }
+
+  private syncUpdate(data: any) {
+    // Sync with server API
+    console.log('Syncing update operation:', data);
+    // Implementation would depend on your API
+  }
+
+  private syncDelete(data: any) {
+    // Sync with server API
+    console.log('Syncing delete operation:', data);
+    // Implementation would depend on your API
+  }
+
+  private saveSyncQueue() {
+    localStorage.setItem('sync_queue', JSON.stringify(this.syncQueue));
+  }
+
+  private loadSyncQueue(): any[] {
+    try {
+      const queue = localStorage.getItem('sync_queue');
+      return queue ? JSON.parse(queue) : [];
+    } catch (error) {
+      console.error('Failed to load sync queue:', error);
+      return [];
+    }
+  }
+
+  // Data export/import for backup
+  exportUserData(userId: string) {
+    return combineLatest([
+      this.getProfile(userId),
+      this.getUserActivities(userId, 1000) // Export more activities
+    ]).pipe(
+      map(([profile, activities]) => ({
+        profile,
+        activities,
+        exportedAt: new Date().toISOString()
+      }))
+    );
+  }
+
+  importUserData(userId: string, data: any) {
+    return this.dbManager.createTableRecords('user_profiles', [data.profile]).pipe(
+      switchMap(() => 
+        this.dbManager.createTableRecords('user_activities', data.activities)
+      )
+    );
+  }
+}
+```
+
+### Real-time Analytics Data Store
+
+```typescript
+@Injectable()
+export class AnalyticsDataService {
+  private dbManager = inject(DatabaseManagerService);
+  private readonly MAX_RECORDS = 10000;
+
+  constructor() {
+    this.initializeAnalyticsTables();
+  }
+
+  private initializeAnalyticsTables() {
+    const eventsSchema = TableSchemaDef.adapt({
+      table: 'analytics_events',
+      schema: '++id, eventType, userId, sessionId, timestamp, data'
+    });
+
+    const sessionsSchema = TableSchemaDef.adapt({
+      table: 'analytics_sessions',
+      schema: '++id, sessionId, userId, startTime, endTime, duration, pageViews'
+    });
+
+    const metricsSchema = TableSchemaDef.adapt({
+      table: 'analytics_metrics',
+      schema: '++id, metricName, value, timestamp, dimensions'
+    });
+
+    [eventsSchema, sessionsSchema, metricsSchema].forEach(schema => {
+      this.dbManager.createDatabaseTable(schema).subscribe({
+        next: () => console.log(`Analytics table ${schema.table} initialized`),
+        error: (error) => console.error(`Failed to create analytics table:`, error)
+      });
+    });
+  }
+
+  // Event tracking
+  trackEvent(eventType: string, userId: string, sessionId: string, data: any) {
+    const event = {
+      eventType,
+      userId,
+      sessionId,
+      timestamp: new Date(),
+      data
+    };
+
+    return this.dbManager.createTableRecord('analytics_events', event).pipe(
+      tap(() => this.cleanupOldEvents())
+    );
+  }
+
+  // Session management
+  startSession(userId: string, sessionId: string) {
+    const session = {
+      sessionId,
+      userId,
+      startTime: new Date(),
+      endTime: null,
+      duration: 0,
+      pageViews: 0
+    };
+
+    return this.dbManager.createTableRecord('analytics_sessions', session);
+  }
+
+  endSession(sessionId: string) {
+    return this.dbManager.queryTableRecords('analytics_sessions', (table) => {
+      return table.where('sessionId').equals(sessionId).first();
+    }).pipe(
+      switchMap(session => {
+        if (!session) {
+          throw new Error('Session not found');
+        }
+
+        const endTime = new Date();
+        const duration = endTime.getTime() - session.startTime.getTime();
+
+        const updatedSession = {
+          ...session,
+          endTime,
+          duration
+        };
+
+        return this.dbManager.updateTableRecord('analytics_sessions', updatedSession);
+      })
+    );
+  }
+
+  // Metrics calculation
+  recordMetric(metricName: string, value: number, dimensions: any = {}) {
+    const metric = {
+      metricName,
+      value,
+      timestamp: new Date(),
+      dimensions
+    };
+
+    return this.dbManager.createTableRecord('analytics_metrics', metric);
+  }
+
+  getDailyMetrics(metricName: string, date: Date) {
+    const startOfDay = new Date(date.getFullYear(), date.getMonth(), date.getDate());
+    const endOfDay = new Date(startOfDay.getTime() + 24 * 60 * 60 * 1000);
+
+    return this.dbManager.queryTableRecords('analytics_metrics', (table) => {
+      return table
+        .where('metricName')
+        .equals(metricName)
+        .and(metric => 
+          metric.timestamp >= startOfDay && metric.timestamp < endOfDay
+        )
+        .toArray();
+    });
+  }
+
+  getUserBehaviorReport(userId: string, days: number = 7) {
+    const startDate = new Date(Date.now() - days * 24 * 60 * 60 * 1000);
+
+    return this.dbManager.queryTableRecords('analytics_events', (table) => {
+      return table
+        .where('userId')
+        .equals(userId)
+        .and(event => event.timestamp >= startDate)
+        .sortBy('timestamp');
+    }).pipe(
+      map(events => {
+        // Process events into meaningful metrics
+        const eventCounts = events.reduce((acc, event) => {
+          acc[event.eventType] = (acc[event.eventType] || 0) + 1;
+          return acc;
+        }, {});
+
+        const sessionData = events.reduce((acc, event) => {
+          const sessionId = event.sessionId;
+          if (!acc[sessionId]) {
+            acc[sessionId] = {
+              sessionId,
+              eventCount: 0,
+              startTime: event.timestamp,
+              endTime: event.timestamp,
+              duration: 0
+            };
+          }
+          
+          acc[sessionId].eventCount++;
+          acc[sessionId].endTime = event.timestamp;
+          acc[sessionId].duration = acc[sessionId].endTime - acc[sessionId].startTime;
+          
+          return acc;
+        }, {});
+
+        return {
+          userId,
+          period: { startDate, endDate: new Date() },
+          totalEvents: events.length,
+          eventTypes: eventCounts,
+          sessions: Object.values(sessionData),
+          averageSessionDuration: Object.values(sessionData).reduce((sum: number, session: any) => 
+            sum + session.duration, 0) / Object.keys(sessionData).length
+        };
+      })
+    );
+  }
+
+  // Data cleanup
+  private cleanupOldEvents() {
+    this.dbManager.countTableRecords('analytics_events').subscribe(count => {
+      if (count > this.MAX_RECORDS) {
+        const recordsToDelete = count - this.MAX_RECORDS;
+        
+        this.dbManager.queryTableRecords('analytics_events', (table) => {
+          return table
+            .orderBy('timestamp')
+            .limit(recordsToDelete)
+            .toArray()
+            .then(events => {
+              const ids = events.map(event => event.id);
+              return this.dbManager.bulkDeleteTableRecords('analytics_events', ids);
+            });
+        }).subscribe();
+      }
+    });
+  }
+
+  // Aggregated data for dashboard
+  getDashboardMetrics() {
+    const today = new Date();
+    const yesterday = new Date(today.getTime() - 24 * 60 * 60 * 1000);
+    const weekAgo = new Date(today.getTime() - 7 * 24 * 60 * 60 * 1000);
+
+    return combineLatest([
+      this.getDailyMetrics('page_views', today),
+      this.getDailyMetrics('page_views', yesterday),
+      this.dbManager.queryTableRecords('analytics_sessions', (table) => 
+        table.where('startTime').above(weekAgo).toArray()
+      )
+    ]).pipe(
+      map(([todayViews, yesterdayViews, weeklySessions]) => ({
+        todayViews: todayViews.length,
+        yesterdayViews: yesterdayViews.length,
+        weeklyActiveUsers: new Set(weeklySessions.map(s => s.userId)).size,
+        weeklySessions: weeklySessions.length,
+        averageSessionDuration: weeklySessions.reduce((sum, s) => sum + s.duration, 0) / weeklySessions.length
+      }))
+    );
+  }
+}
+```
+
+## Performance Optimization
+
+### Indexing Strategy
+
+```typescript
+// ✅ Good - Proper indexing
+const wellIndexedSchema = TableSchemaDef.adapt({
+  table: 'products',
+  schema: `
+    ++id, 
+    name, 
+    price, 
+    categoryId,
+    [categoryId+brand],
+    *tags,
+    createdAt
+  `
+});
+
+// ❌ Avoid - No indexes on frequently queried fields
+const poorSchema = TableSchemaDef.adapt({
+  table: 'products',
+  schema: '++id, name, price, categoryId, description'
+});
+```
+
+### Batch Operations
+
+```typescript
+@Injectable()
+export class OptimizedDataService {
+  private dbManager = inject(DatabaseManagerService);
+
+  // Batch insert for better performance
+  bulkInsertUsers(users: any[]) {
+    // Process in chunks to avoid memory issues
+    const chunkSize = 100;
+    const chunks = this.chunkArray(users, chunkSize);
+    
+    return from(chunks).pipe(
+      mergeMap(chunk => 
+        this.dbManager.bulkCreateTableRecords('users', chunk),
+        2 // Process 2 chunks concurrently
+      )
+    );
+  }
+
+  // Efficient searching
+  searchUsersAdvanced(query: string, filters: any) {
+    return this.dbManager.queryTableRecords('users', (table) => {
+      let result = table.toCollection();
+
+      // Apply filters efficiently using indexes
+      if (filters.ageMin !== undefined) {
+        result = result.and(user => user.age >= filters.ageMin);
+      }
+
+      if (filters.ageMax !== undefined) {
+        result = result.and(user => user.age <= filters.ageMax);
+      }
+
+      if (query) {
+        result = result.and(user => 
+          user.name.toLowerCase().includes(query.toLowerCase()) ||
+          user.email.toLowerCase().includes(query.toLowerCase())
+        );
+      }
+
+      return result.sortBy('name');
+    });
+  }
+
+  private chunkArray(array: any[], size: number): any[][] {
+    const chunks = [];
+    for (let i = 0; i < array.length; i += size) {
+      chunks.push(array.slice(i, i + size));
+    }
+    return chunks;
+  }
+}
+```
+
+## Best Practices
+
+### 1. Schema Design
+
+```typescript
+// ✅ Good - Well-designed schema
+const goodSchema = TableSchemaDef.adapt({
+  table: 'ecommerce_products',
+  schema: `
+    ++id,                    // Auto-increment ID
+    name,                    // Searchable field
+    price,                   // Filterable field
+    categoryId,              // Foreign key
+    [categoryId+brand],      // Compound index for common queries
+    *tags,                   // Multi-entry for filtering
+    createdAt,               // Timestamp for sorting
+    updatedAt                // Change tracking
+  `
+});
+
+// ❌ Avoid - Poor schema design
+const badSchema = TableSchemaDef.adapt({
+  table: 'products',
+  schema: '++id, name, price, description, category, brand, tags, created, updated'
+});
+```
+
+### 2. Error Handling
+
+```typescript
+// ✅ Good - Comprehensive error handling
+addUser(user: any) {
+  return this.dbManager.createTableRecord('users', user).pipe(
+    catchError(error => {
+      if (error.name === 'ConstraintError') {
+        return throwError(() => new Error('User already exists'));
+      }
+      return throwError(() => new Error('Database operation failed'));
+    })
+  );
+}
+```
+
+### 3. Memory Management
+
+```typescript
+// ✅ Good - Limit query results
+getRecentUsers(limit: number = 50) {
+  return this.dbManager.queryTableRecords('users', (table) => {
+    return table
+      .orderBy('createdAt')
+      .reverse()
+      .limit(limit)
+      .toArray();
+  });
+}
+```
+
+## Troubleshooting
+
+### Common Issues
+
+#### 1. Schema Conflicts
+```typescript
+// Check existing schema
+this.dbManager.getTableSchema('users').subscribe(schema => {
+  console.log('Existing schema:', schema);
+});
+
+// Handle schema updates carefully
+// Version your database schema
+const currentVersion = 1;
+const newVersion = 2;
+
+// Implement migration logic
+if (currentVersion < newVersion) {
+  this.migrateDatabase();
+}
+```
+
+#### 2. Large Dataset Performance
+```typescript
+// Use pagination for large datasets
+getPaginatedUsers(page: number, pageSize: number) {
+  const offset = (page - 1) * pageSize;
+  
+  return this.dbManager.queryTableRecords('users', (table) => {
+    return table
+      .offset(offset)
+      .limit(pageSize)
+      .toArray();
+  });
+}
+```
+
+#### 3. Storage Quota
+```typescript
+// Monitor storage usage
+@Injectable()
+export class StorageMonitorService {
+  private dbManager = inject(DatabaseManagerService);
+
+  checkStorageUsage() {
+    if ('storage' in navigator && 'estimate' in navigator.storage) {
+      navigator.storage.estimate().then(estimate => {
+        const used = estimate.usage || 0;
+        const quota = estimate.quota || 0;
+        const percentage = (used / quota) * 100;
+        
+        console.log(`Storage used: ${used} / ${quota} (${percentage.toFixed(2)}%)`);
+        
+        if (percentage > 80) {
+          this.cleanupOldData();
+        }
+      });
+    }
+  }
+
+  private cleanupOldData() {
+    // Implement cleanup logic
+    const cutoffDate = new Date(Date.now() - 30 * 24 * 60 * 60 * 1000); // 30 days ago
+    
+    this.dbManager.queryTableRecords('analytics_events', (table) => {
+      return table.where('timestamp').below(cutoffDate).delete();
+    }).subscribe();
+  }
+}
+```
+
+## Related Documentation
+
+- [HTTP State Service](http-state/README.md)
+- [Local Storage Service](local-storage/README.md)
+- [Utils Service](utils/README.md)
+- [Architecture Overview](../architecture/README.md)
+- [Dexie.js Documentation](https://dexie.org/docs/)