@sailboat-computer/data-storage/examples/basic-usage.ts

Shared data storage library for sailboat computer v3

/**
 * Basic usage example for the data storage package
 * 
 * This example demonstrates how to use the unified storage manager
 * with local storage fallback.
 */

import {
  createUnifiedStorageManager,
  StorageTier,
  StorageConfig,
  UnifiedStorageManagerOptions
} from '../src';

async function main() {
  console.log('Data Storage Package - Basic Usage Example');
  console.log('------------------------------------------');
  
  // Create storage configuration
  const config: StorageConfig = {
    providers: {
      hot: {
        type: 'redis',
        config: {
          host: 'localhost',
          port: 6379,
          password: '',
          db: 0,
          tls: false
        }
      },
      warm: {
        type: 'influxdb',
        config: {
          url: 'http://localhost:8086',
          token: 'your-token',
          org: 'sailboat-computer',
          bucket: 'sensor-data'
        }
      },
      cold: {
        type: 'postgresql',
        config: {
          host: 'localhost',
          port: 5432,
          database: 'sailboat_data',
          user: 'postgres',
          password: 'postgres',
          ssl: false
        }
      },
      batching: {
        timeBased: {
          enabled: true,
          intervalMs: 5000
        },
        sizeBased: {
          enabled: true,
          maxBatchSize: 100
        },
        priorityOverride: true
      }
    }
  };
  
  // Create unified storage manager options
  const options: Partial<UnifiedStorageManagerOptions> = {
    localStorage: {
      directory: './data',
      maxSizeBytes: 100 * 1024 * 1024, // 100MB
      encrypt: false,
      compressionLevel: 6
    },
    sync: {
      enabled: true,
      intervalMs: 60000, // 1 minute
      batchSize: 100
    },
    resilience: {
      circuitBreaker: {
        failureThreshold: 3,
        resetTimeoutMs: 30000 // 30 seconds
      },
      retry: {
        maxRetries: 3,
        baseDelayMs: 1000 // 1 second
      },
      timeout: {
        defaultTimeoutMs: 5000, // 5 seconds
        operationTimeouts: {
          store: 10000, // 10 seconds
          retrieve: 15000, // 15 seconds
          update: 10000, // 10 seconds
          delete: 5000, // 5 seconds
          storeBatch: 30000, // 30 seconds
          retrieveBatch: 30000, // 30 seconds
          cleanup: 60000, // 60 seconds
          migrate: 60000 // 60 seconds
        }
      }
    },
    logger: {
      level: 'info',
      console: true
    }
  };
  
  try {
    // Create unified storage manager
    console.log('Creating unified storage manager...');
    const storageManager = createUnifiedStorageManager(config, options);
    
    // Initialize storage manager
    console.log('Initializing storage manager...');
    await storageManager.initialize();
    
    // Store data
    console.log('Storing data...');
    const sensorData = {
      sensorId: 'temp-sensor-1',
      value: 25.5,
      unit: 'celsius',
      timestamp: new Date(),
      quality: 'good'
    };
    
    const id = await storageManager.store(sensorData, 'sensor-readings', {
      timestamp: new Date(),
      tags: {
        location: 'cabin',
        sensor: 'temperature'
      },
      tier: StorageTier.HOT
    });
    
    console.log(`Data stored with ID: ${id}`);
    
    // Retrieve data
    console.log('Retrieving data...');
    const results = await storageManager.retrieve({
      category: 'sensor-readings',
      timeRange: {
        start: new Date(Date.now() - 24 * 60 * 60 * 1000).toISOString(), // Last 24 hours
        end: new Date().toISOString()
      },
      sort: {
        field: 'timestamp',
        order: 'desc'
      }
    });
    
    console.log(`Retrieved ${results.length} results:`);
    console.log(JSON.stringify(results, null, 2));
    
    // Get storage status
    console.log('Getting storage status...');
    const status = await storageManager.getStatus();
    console.log('Storage status:', JSON.stringify(status, null, 2));
    
    // Get local storage status
    console.log('Getting local storage status...');
    const localStatus = await storageManager.getLocalStorageStatus();
    console.log('Local storage status:', JSON.stringify(localStatus, null, 2));
    
    // Force synchronization
    console.log('Forcing synchronization...');
    const syncResult = await storageManager.forceSynchronization();
    console.log('Synchronization result:', JSON.stringify(syncResult, null, 2));
    
    // Get resilience metrics
    console.log('Getting resilience metrics...');
    const metrics = storageManager.getResilienceMetrics();
    console.log('Resilience metrics:', JSON.stringify(metrics, null, 2));
    
    // Close storage manager
    console.log('Closing storage manager...');
    await storageManager.close();
    
    console.log('Example completed successfully!');
  } catch (error) {
    console.error('Error:', error);
  }
}

// Run the example
main().catch(console.error);