@pioneer-platform/pioneer-cache 1.0.0

package/dist/workers/refresh-worker.js

@@ -0,0 +1,212 @@
+"use strict";
+/*
+    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
+*/
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RefreshWorker = void 0;
+exports.startUnifiedWorker = startUnifiedWorker;
+const log = require('@pioneer-platform/loggerdog')();
+const TAG = ' | RefreshWorker | ';
+/**
+ * Unified refresh worker that processes jobs for any cache type
+ */
+class RefreshWorker {
+    constructor(redis, config) {
+        this.cacheRegistry = new Map();
+        this.isRunning = false;
+        this.isProcessing = false;
+        this.pollTimeoutId = null;
+        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, cache) {
+        this.cacheRegistry.set(cacheName.toLowerCase(), cache);
+        log.info(TAG, `Registered ${cacheName} cache with worker`);
+    }
+    /**
+     * Start processing jobs from the queue
+     */
+    async start() {
+        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() {
+        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
+     */
+    async poll() {
+        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) {
+            log.error(tag, 'Error in poll loop:', error.message);
+            this.isProcessing = false;
+        }
+        finally {
+            // Schedule next poll
+            this.schedulePoll();
+        }
+    }
+    /**
+     * Schedule next poll
+     */
+    schedulePoll() {
+        if (this.pollTimeoutId) {
+            clearTimeout(this.pollTimeoutId);
+        }
+        const pollInterval = this.config.pollInterval || 100;
+        this.pollTimeoutId = setTimeout(() => {
+            this.poll();
+        }, pollInterval);
+    }
+    /**
+     * Process a single refresh job
+     */
+    async processJob(job) {
+        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() {
+        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)
+            };
+        }
+    }
+}
+exports.RefreshWorker = RefreshWorker;
+/**
+ * Start a unified refresh worker for multiple cache types
+ * Convenience function for common usage
+ */
+async function startUnifiedWorker(redis, caches, queueName, config) {
+    const 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/package.json

@@ -0,0 +1,31 @@
+{
+  "name": "@pioneer-platform/pioneer-cache",
+  "version": "1.0.0",
+  "description": "Unified caching system for Pioneer platform with Redis backend",
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "scripts": {
+    "build": "tsc",
+    "dev": "tsc --watch",
+    "test": "jest",
+    "lint": "eslint src/**/*.ts"
+  },
+  "keywords": [
+    "pioneer",
+    "cache",
+    "redis",
+    "balance",
+    "price"
+  ],
+  "author": "Pioneer Platform",
+  "license": "MIT",
+  "dependencies": {
+    "@pioneer-platform/loggerdog": "workspace:*",
+    "@pioneer-platform/redis-queue": "workspace:*",
+    "@pioneer-platform/default-redis": "workspace:*"
+  },
+  "devDependencies": {
+    "@types/node": "^20.0.0",
+    "typescript": "^5.0.0"
+  }
+}