@pioneer-platform/pioneer-cache 1.0.0

package/src/workers/refresh-worker.ts

@@ -0,0 +1,267 @@
+/*
+    Unified Refresh Worker
+
+    Single worker that processes refresh jobs for ALL cache types (balance, price, etc.)
+    Replaces separate balance-refresh.worker.ts and price-refresh.worker.ts
+*/
+
+import type { RefreshJob } from '../types';
+import type { BaseCache } from '../core/base-cache';
+
+const log = require('@pioneer-platform/loggerdog')();
+const TAG = ' | RefreshWorker | ';
+
+/**
+ * Worker configuration
+ */
+export interface WorkerConfig {
+    queueName: string;
+    maxRetries: number;
+    retryDelay: number;
+    pollInterval?: number;                 // Poll interval in ms (default: 100ms)
+}
+
+/**
+ * Unified refresh worker that processes jobs for any cache type
+ */
+export class RefreshWorker {
+    private redis: any;
+    private redisQueue: any;
+    private cacheRegistry: Map<string, BaseCache<any>> = new Map();
+    private config: WorkerConfig;
+    private isRunning: boolean = false;
+    private isProcessing: boolean = false;
+    private pollTimeoutId: NodeJS.Timeout | null = null;
+
+    constructor(redis: any, config: WorkerConfig) {
+        this.redis = redis;
+        this.config = config;
+
+        try {
+            this.redisQueue = require('@pioneer-platform/redis-queue');
+            log.info(TAG, `✅ RefreshWorker initialized for queue: ${config.queueName}`);
+        } catch (error) {
+            log.error(TAG, '❌ Failed to initialize redis-queue:', error);
+            throw error;
+        }
+    }
+
+    /**
+     * Register a cache instance with this worker
+     * The worker will route jobs to the appropriate cache based on job type
+     */
+    registerCache(cacheName: string, cache: BaseCache<any>): void {
+        this.cacheRegistry.set(cacheName.toLowerCase(), cache);
+        log.info(TAG, `Registered ${cacheName} cache with worker`);
+    }
+
+    /**
+     * Start processing jobs from the queue
+     */
+    async start(): Promise<void> {
+        const tag = TAG + 'start | ';
+
+        if (this.isRunning) {
+            log.warn(tag, 'Worker already running');
+            return;
+        }
+
+        log.info(tag, `🚀 Starting refresh worker for queue: ${this.config.queueName}`);
+        log.info(tag, `Registered caches: ${Array.from(this.cacheRegistry.keys()).join(', ')}`);
+
+        this.isRunning = true;
+        this.poll();
+
+        log.info(tag, '✅ Refresh worker started successfully');
+    }
+
+    /**
+     * Stop the worker gracefully
+     */
+    async stop(): Promise<void> {
+        const tag = TAG + 'stop | ';
+
+        log.info(tag, 'Stopping refresh worker...');
+
+        this.isRunning = false;
+
+        if (this.pollTimeoutId) {
+            clearTimeout(this.pollTimeoutId);
+            this.pollTimeoutId = null;
+        }
+
+        // Wait for current job to finish
+        while (this.isProcessing) {
+            await new Promise(resolve => setTimeout(resolve, 100));
+        }
+
+        log.info(tag, '✅ Refresh worker stopped');
+    }
+
+    /**
+     * Poll for next job from the queue
+     */
+    private async poll(): Promise<void> {
+        const tag = TAG + 'poll | ';
+
+        if (!this.isRunning) {
+            return;
+        }
+
+        try {
+            // Don't poll if already processing
+            if (this.isProcessing) {
+                this.schedulePoll();
+                return;
+            }
+
+            // Get next job from queue
+            const work = await this.redisQueue.getWork(this.config.queueName, 1);
+
+            if (work) {
+                this.isProcessing = true;
+                await this.processJob(work);
+                this.isProcessing = false;
+            }
+
+        } catch (error: any) {
+            log.error(tag, 'Error in poll loop:', error.message);
+            this.isProcessing = false;
+        } finally {
+            // Schedule next poll
+            this.schedulePoll();
+        }
+    }
+
+    /**
+     * Schedule next poll
+     */
+    private schedulePoll(): void {
+        if (this.pollTimeoutId) {
+            clearTimeout(this.pollTimeoutId);
+        }
+
+        const pollInterval = this.config.pollInterval || 100;
+        this.pollTimeoutId = setTimeout(() => {
+            this.poll();
+        }, pollInterval);
+    }
+
+    /**
+     * Process a single refresh job
+     */
+    private async processJob(job: RefreshJob): Promise<void> {
+        const tag = TAG + 'processJob | ';
+        const startTime = Date.now();
+
+        try {
+            const { type, key, params, retryCount = 0 } = job;
+
+            log.info(tag, `Processing ${type} for ${key} (retry: ${retryCount})`);
+
+            // Extract cache name from job type (e.g., "REFRESH_BALANCE" -> "balance")
+            const cacheName = type.replace('REFRESH_', '').toLowerCase();
+
+            // Get the appropriate cache instance
+            const cache = this.cacheRegistry.get(cacheName);
+
+            if (!cache) {
+                log.error(tag, `No cache registered for type: ${type}`);
+                return;
+            }
+
+            // Fetch fresh data using the cache's fetchFresh method
+            await cache.fetchFresh(params);
+
+            const processingTime = Date.now() - startTime;
+            log.info(tag, `✅ Processed ${type} in ${processingTime}ms: ${key}`);
+
+        } catch (error) {
+            const processingTime = Date.now() - startTime;
+            log.error(tag, `❌ Failed to process ${job.type} after ${processingTime}ms:`, error);
+
+            // Retry logic
+            if ((job.retryCount || 0) < this.config.maxRetries) {
+                const newRetryCount = (job.retryCount || 0) + 1;
+                log.info(tag, `Retrying job (attempt ${newRetryCount}/${this.config.maxRetries})`);
+
+                // Re-queue with incremented retry count and delay
+                setTimeout(async () => {
+                    try {
+                        await this.redisQueue.createWork(this.config.queueName, {
+                            ...job,
+                            retryCount: newRetryCount
+                        });
+                    } catch (requeueError) {
+                        log.error(tag, 'Error re-queuing job:', requeueError);
+                    }
+                }, this.config.retryDelay);
+
+            } else {
+                log.error(tag, `Max retries reached for ${job.type}, giving up`);
+            }
+
+            throw error;
+        }
+    }
+
+    /**
+     * Get worker statistics
+     */
+    async getStats(): Promise<any> {
+        const tag = TAG + 'getStats | ';
+
+        try {
+            const queueLength = await this.redisQueue.count(this.config.queueName);
+
+            return {
+                isRunning: this.isRunning,
+                isProcessing: this.isProcessing,
+                queueName: this.config.queueName,
+                queueLength,
+                registeredCaches: Array.from(this.cacheRegistry.keys()),
+                config: {
+                    maxRetries: this.config.maxRetries,
+                    retryDelay: this.config.retryDelay,
+                    pollInterval: this.config.pollInterval || 100
+                }
+            };
+
+        } catch (error) {
+            log.error(tag, 'Error getting worker stats:', error);
+            return {
+                error: error instanceof Error ? error.message : String(error)
+            };
+        }
+    }
+}
+
+/**
+ * Start a unified refresh worker for multiple cache types
+ * Convenience function for common usage
+ */
+export async function startUnifiedWorker(
+    redis: any,
+    caches: Map<string, BaseCache<any>>,
+    queueName: string,
+    config?: Partial<WorkerConfig>
+): Promise<RefreshWorker> {
+    const workerConfig: WorkerConfig = {
+        queueName,
+        maxRetries: config?.maxRetries || 3,
+        retryDelay: config?.retryDelay || 5000,
+        pollInterval: config?.pollInterval || 100
+    };
+
+    const worker = new RefreshWorker(redis, workerConfig);
+
+    // Register all caches
+    for (const [name, cache] of caches) {
+        worker.registerCache(name, cache);
+    }
+
+    // Start worker
+    await worker.start();
+
+    return worker;
+}

package/tsconfig.json

@@ -0,0 +1,18 @@
+{
+  "compilerOptions": {
+    "target": "ES2020",
+    "module": "commonjs",
+    "lib": ["ES2020"],
+    "declaration": true,
+    "outDir": "./dist",
+    "rootDir": "./src",
+    "strict": true,
+    "esModuleInterop": true,
+    "skipLibCheck": true,
+    "forceConsistentCasingInFileNames": true,
+    "resolveJsonModule": true,
+    "moduleResolution": "node"
+  },
+  "include": ["src/**/*"],
+  "exclude": ["node_modules", "dist", "**/*.test.ts"]
+}