Simplified Cache Library Usage

The cache library has been simplified to only use Redis/Dragonfly with a connection manager for better performance and easier management.

Quick Start

import { createCache, createTradingCache, createMarketDataCache, RedisConnectionManager } from '@stock-bot/cache';

// Create different cache instances
const generalCache = createCache({ keyPrefix: 'app:' });
const tradingCache = createTradingCache(); // Uses 'trading:' prefix
const marketCache = createMarketDataCache(); // Uses 'market:' prefix with 5min TTL

// All cache instances share connections by default for better performance

Connection Management

The library now uses a connection manager that allows you to control whether services share connections or get unique ones:

import { RedisConnectionManager } from '@stock-bot/cache';

const connectionManager = RedisConnectionManager.getInstance();

// For shared connections (recommended for most cases)
const sharedRedis = connectionManager.getConnection({
  name: 'BATCH-PROCESSOR',
  singleton: true  // All instances share this connection
});

// For unique connections (when you need isolation)
const uniqueRedis = connectionManager.getConnection({
  name: 'DATA-FETCHER',
  singleton: false  // Each instance gets its own connection
});

Cache Usage Examples

Basic Operations

import { createCache } from '@stock-bot/cache';

const cache = createCache({ keyPrefix: 'myapp:' });

// Set data with default TTL (1 hour)
await cache.set('user:123', { name: 'John', email: 'john@example.com' });

// Set data with custom TTL (5 minutes)
await cache.set('session:abc', sessionData, 300);

// Get data
const user = await cache.get('user:123');

// Check if key exists
const exists = await cache.exists('user:123');

// Delete data
await cache.del('user:123');

// Clear all data with this prefix
await cache.clear();

Trading-Specific Caches

import { createTradingCache, createMarketDataCache, createIndicatorCache } from '@stock-bot/cache';

// Trading cache (1 hour TTL)
const tradingCache = createTradingCache();
await tradingCache.set('position:AAPL', { shares: 100, price: 150.00 });

// Market data cache (5 minute TTL)
const marketCache = createMarketDataCache();
await marketCache.set('quote:AAPL', { price: 151.25, volume: 1000000 });

// Indicator cache (30 minute TTL)
const indicatorCache = createIndicatorCache();
await indicatorCache.set('sma:AAPL:20', [150.1, 150.3, 150.8, 151.2]);

Connection Names in Redis

When you create cache instances, they will appear in Redis with clean, identifiable names:

TRADING-SERVICE - For trading cache
MARKET-SERVICE - For market data cache
INDICATORS-SERVICE - For indicator cache
CACHE-SERVICE - For general cache

You can monitor all connections using:

# TypeScript version (more detailed)
bun run scripts/get-redis-connections.ts

# Bash version (quick check)
./scripts/get-redis-connections.sh

Health Monitoring

// Check if cache is ready
if (cache.isReady()) {
  console.log('Cache is ready for operations');
}

// Wait for cache to be ready
await cache.waitForReady(5000); // Wait up to 5 seconds

// Health check
const isHealthy = await cache.health();

// Get performance statistics
const stats = cache.getStats();
console.log(`Hit rate: ${stats.hitRate}%, Total operations: ${stats.total}`);

Batch Processor Example

Here's how to set up a batch processor with a shared connection:

import { RedisConnectionManager } from '@stock-bot/cache';
import Redis from 'ioredis';

export class BatchProcessor {
  private redis: Redis;

  constructor() {
    const connectionManager = RedisConnectionManager.getInstance();
    
    // All batch processor instances share this connection
    this.redis = connectionManager.getConnection({
      name: 'BATCH-PROCESSOR',
      singleton: true
    });
  }

  async processItems(items: any[]): Promise<void> {
    await this.redis.set('batch:status', 'processing');
    
    for (const item of items) {
      await this.redis.lpush('batch:queue', JSON.stringify(item));
    }
    
    await this.redis.set('batch:status', 'completed');
  }

  async getBatchStatus(): Promise<string> {
    return await this.redis.get('batch:status') || 'idle';
  }
}

Key Benefits

✅ Simplified: Only Redis-based caching, no complex hybrid logic
✅ Connection Management: Shared connections for better performance
✅ Clean Monitoring: Easy to identify connections in Redis
✅ Trading Optimized: Pre-configured caches for different data types
✅ Type Safe: Full TypeScript support
✅ Error Handling: Graceful fallbacks and comprehensive logging

Removed Features

❌ Memory Cache: Removed to avoid consistency issues
❌ Hybrid Cache: Removed unnecessary complexity
❌ Auto-detection: Always uses Redis/Dragonfly now

This simplified approach provides better performance, easier debugging, and more predictable behavior for your trading application.

5 KiB Raw Blame History