@pioneer-platform/pioneer-cache 1.0.0 → 1.0.1

package/.turbo/turbo-build.log

@@ -1,2 +1 @@
-
-$ tsc
+$ tsc

package/CHANGELOG.md

@@ -0,0 +1,7 @@
+# @pioneer-platform/pioneer-cache
+
+## 1.0.1
+
+### Patch Changes
+
+- Fix workspace dependencies to use published versions for Docker build compatibility

package/dist/core/base-cache.d.ts

@@ -8,6 +8,7 @@ export declare abstract class BaseCache<T> {
     private cachedStats;
     private cachedStatsTimestamp;
     private readonly STATS_CACHE_TTL;
+    private pendingFetches;
     constructor(redis: any, config: CacheConfig);
     /**
      * Initialize Redis queue for background refresh
@@ -36,6 +37,7 @@ export declare abstract class BaseCache<T> {
     /**
      * Fetch fresh data and update cache
      * FIX #1 & #4: Used for blocking requests and fallback
+     * FIX #6: Request deduplication to prevent thundering herd
      */
     fetchFresh(params: Record<string, any>): Promise<T>;
     /**

package/dist/core/base-cache.js

@@ -15,6 +15,9 @@ class BaseCache {
         this.cachedStats = null;
         this.cachedStatsTimestamp = 0;
         this.STATS_CACHE_TTL = 30000; // 30 seconds
+        // FIX #6: Request deduplication to prevent thundering herd
+        // Tracks in-flight network requests to prevent duplicate API calls
+        this.pendingFetches = new Map();
         this.redis = redis;
         this.config = config;
         this.TAG = ` | ${config.name}Cache | `;
@@ -245,26 +248,43 @@ class BaseCache {
     /**
      * Fetch fresh data and update cache
      * FIX #1 & #4: Used for blocking requests and fallback
+     * FIX #6: Request deduplication to prevent thundering herd
      */
     async fetchFresh(params) {
         const tag = this.TAG + 'fetchFresh | ';
         const startTime = Date.now();
-        try {
-            const key = this.buildKey(params);
-            log.info(tag, `Fetching fresh data: ${key}`);
-            // Call subclass-specific fetch implementation
-            const value = await this.fetchFromSource(params);
-            // Update cache
-            await this.updateCache(key, value);
-            const fetchTime = Date.now() - startTime;
-            log.info(tag, `✅ Fetched fresh data in ${fetchTime}ms: ${key}`);
-            return value;
-        }
-        catch (error) {
-            const fetchTime = Date.now() - startTime;
-            log.error(tag, `Failed to fetch fresh data after ${fetchTime}ms:`, error);
-            return this.config.defaultValue;
+        const key = this.buildKey(params);
+        // FIX #6: Check if there's already a pending fetch for this key
+        const existingFetch = this.pendingFetches.get(key);
+        if (existingFetch) {
+            log.debug(tag, `Coalescing request for: ${key} (fetch already in progress)`);
+            return existingFetch;
         }
+        // Create the fetch promise
+        const fetchPromise = (async () => {
+            try {
+                log.info(tag, `Fetching fresh data: ${key}`);
+                // Call subclass-specific fetch implementation
+                const value = await this.fetchFromSource(params);
+                // Update cache
+                await this.updateCache(key, value);
+                const fetchTime = Date.now() - startTime;
+                log.info(tag, `✅ Fetched fresh data in ${fetchTime}ms: ${key}`);
+                return value;
+            }
+            catch (error) {
+                const fetchTime = Date.now() - startTime;
+                log.error(tag, `Failed to fetch fresh data after ${fetchTime}ms:`, error);
+                return this.config.defaultValue;
+            }
+            finally {
+                // Clean up pending fetch
+                this.pendingFetches.delete(key);
+            }
+        })();
+        // Store the promise so concurrent requests can reuse it
+        this.pendingFetches.set(key, fetchPromise);
+        return fetchPromise;
     }
     /**
      * Migrate legacy cache value to new format

package/dist/stores/price-cache.d.ts

@@ -20,7 +20,8 @@ export declare class PriceCache extends BaseCache<PriceData> {
      */
     protected buildKey(params: Record<string, any>): string;
     /**
-     * Fetch price from markets API
+     * Fetch price from markets API using CAIP-first approach
+     * FIX #7: Throws error on zero price to prevent caching invalid data
      */
     protected fetchFromSource(params: Record<string, any>): Promise<PriceData>;
     /**

package/dist/stores/price-cache.js

@@ -24,7 +24,7 @@ class PriceCache extends base_cache_1.BaseCache {
             enableQueue: true,
             maxRetries: 3,
             retryDelay: 5000,
-            blockOnMiss: false, // Return immediately with $0 (prices less critical)
+            blockOnMiss: true, // MUST wait for price on first request (changed from false)
             enableLegacyFallback: true,
             defaultValue: {
                 caip: '',
@@ -52,49 +52,34 @@ class PriceCache extends base_cache_1.BaseCache {
         return `${this.config.keyPrefix}${normalizedCaip}`;
     }
     /**
-     * Fetch price from markets API
+     * Fetch price from markets API using CAIP-first approach
+     * FIX #7: Throws error on zero price to prevent caching invalid data
      */
     async fetchFromSource(params) {
         const tag = this.TAG + 'fetchFromSource | ';
         try {
             const { caip } = params;
-            // Map CAIP to symbol for markets API
-            const assetData = require('@pioneer-platform/pioneer-discovery').assetData;
-            const asset = assetData[caip.toUpperCase()] || assetData[caip.toLowerCase()];
-            if (!asset || !asset.symbol) {
-                log.warn(tag, `No asset mapping found for ${caip}`);
-                return {
-                    caip,
-                    price: 0
-                };
-            }
-            // Get price from markets module
-            const symbol = asset.symbol.toLowerCase();
-            const priceResult = await this.markets.getPrice(symbol);
-            // Handle different response formats
-            let price = 0;
-            if (typeof priceResult === 'object' && priceResult.price) {
-                price = parseFloat(priceResult.price);
-            }
-            else if (typeof priceResult === 'number') {
-                price = priceResult;
-            }
+            // Use CAIP-first API (no symbol conversion needed!)
+            // This directly queries the markets module with CAIP identifiers
+            const price = await this.markets.getAssetPriceByCaip(caip);
+            // FIX #7: Throw error instead of returning 0 price
+            // This prevents caching invalid $0 prices from rate limits or API failures
             if (isNaN(price) || price <= 0) {
-                log.warn(tag, `Invalid price for ${caip} (${symbol}): ${priceResult}`);
-                return {
-                    caip,
-                    price: 0
-                };
+                const errorMsg = `Price fetch failed for ${caip}: got $${price} (likely API timeout or rate limit)`;
+                log.warn(tag, errorMsg);
+                throw new Error(errorMsg);
             }
-            log.debug(tag, `Fetched price for ${caip} (${symbol}): $${price}`);
+            log.debug(tag, `Fetched price for ${caip}: $${price}`);
             return {
                 caip,
                 price,
-                source: 'markets'
+                source: 'markets-caip'
             };
         }
         catch (error) {
-            log.error(tag, 'Error fetching price:', error);
+            // Re-throw to prevent caching zero prices
+            // BaseCache.fetchFresh() will catch this and return defaultValue
+            // but won't cache the error
             throw error;
         }
     }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pioneer-platform/pioneer-cache",
-  "version": "1.0.0",
+  "version": "1.0.1",
   "description": "Unified caching system for Pioneer platform with Redis backend",
   "main": "./dist/index.js",
   "types": "./dist/index.d.ts",
@@ -20,9 +20,9 @@
   "author": "Pioneer Platform",
   "license": "MIT",
   "dependencies": {
-    "@pioneer-platform/loggerdog": "workspace:*",
-    "@pioneer-platform/redis-queue": "workspace:*",
-    "@pioneer-platform/default-redis": "workspace:*"
+    "@pioneer-platform/loggerdog": "^8.0.0",
+    "@pioneer-platform/redis-queue": "^8.0.0",
+    "@pioneer-platform/default-redis": "^8.0.0"
   },
   "devDependencies": {
     "@types/node": "^20.0.0",

package/src/core/base-cache.ts

@@ -31,6 +31,10 @@ export abstract class BaseCache<T> {
     private cachedStatsTimestamp: number = 0;
     private readonly STATS_CACHE_TTL = 30000; // 30 seconds
 
+    // FIX #6: Request deduplication to prevent thundering herd
+    // Tracks in-flight network requests to prevent duplicate API calls
+    private pendingFetches: Map<string, Promise<T>> = new Map();
+
     constructor(redis: any, config: CacheConfig) {
         this.redis = redis;
         this.config = config;
@@ -290,31 +294,50 @@ export abstract class BaseCache<T> {
     /**
      * Fetch fresh data and update cache
      * FIX #1 & #4: Used for blocking requests and fallback
+     * FIX #6: Request deduplication to prevent thundering herd
      */
     async fetchFresh(params: Record<string, any>): Promise<T> {
         const tag = this.TAG + 'fetchFresh | ';
         const startTime = Date.now();
+        const key = this.buildKey(params);
 
-        try {
-            const key = this.buildKey(params);
-            log.info(tag, `Fetching fresh data: ${key}`);
+        // FIX #6: Check if there's already a pending fetch for this key
+        const existingFetch = this.pendingFetches.get(key);
+        if (existingFetch) {
+            log.debug(tag, `Coalescing request for: ${key} (fetch already in progress)`);
+            return existingFetch;
+        }
 
-            // Call subclass-specific fetch implementation
-            const value = await this.fetchFromSource(params);
+        // Create the fetch promise
+        const fetchPromise = (async () => {
+            try {
+                log.info(tag, `Fetching fresh data: ${key}`);
 
-            // Update cache
-            await this.updateCache(key, value);
+                // Call subclass-specific fetch implementation
+                const value = await this.fetchFromSource(params);
 
-            const fetchTime = Date.now() - startTime;
-            log.info(tag, `✅ Fetched fresh data in ${fetchTime}ms: ${key}`);
+                // Update cache
+                await this.updateCache(key, value);
 
-            return value;
+                const fetchTime = Date.now() - startTime;
+                log.info(tag, `✅ Fetched fresh data in ${fetchTime}ms: ${key}`);
 
-        } catch (error) {
-            const fetchTime = Date.now() - startTime;
-            log.error(tag, `Failed to fetch fresh data after ${fetchTime}ms:`, error);
-            return this.config.defaultValue;
-        }
+                return value;
+
+            } catch (error) {
+                const fetchTime = Date.now() - startTime;
+                log.error(tag, `Failed to fetch fresh data after ${fetchTime}ms:`, error);
+                return this.config.defaultValue;
+            } finally {
+                // Clean up pending fetch
+                this.pendingFetches.delete(key);
+            }
+        })();
+
+        // Store the promise so concurrent requests can reuse it
+        this.pendingFetches.set(key, fetchPromise);
+
+        return fetchPromise;
     }
 
     /**

package/src/stores/price-cache.ts

@@ -36,7 +36,7 @@ export class PriceCache extends BaseCache<PriceData> {
             enableQueue: true,
             maxRetries: 3,
             retryDelay: 5000,
-            blockOnMiss: false,                    // Return immediately with $0 (prices less critical)
+            blockOnMiss: true,                     // MUST wait for price on first request (changed from false)
             enableLegacyFallback: true,
             defaultValue: {
                 caip: '',
@@ -68,7 +68,8 @@ export class PriceCache extends BaseCache<PriceData> {
     }
 
     /**
-     * Fetch price from markets API
+     * Fetch price from markets API using CAIP-first approach
+     * FIX #7: Throws error on zero price to prevent caching invalid data
      */
     protected async fetchFromSource(params: Record<string, any>): Promise<PriceData> {
         const tag = this.TAG + 'fetchFromSource | ';
@@ -76,48 +77,30 @@ export class PriceCache extends BaseCache<PriceData> {
         try {
             const { caip } = params;
 
-            // Map CAIP to symbol for markets API
-            const assetData = require('@pioneer-platform/pioneer-discovery').assetData;
-            const asset = assetData[caip.toUpperCase()] || assetData[caip.toLowerCase()];
-
-            if (!asset || !asset.symbol) {
-                log.warn(tag, `No asset mapping found for ${caip}`);
-                return {
-                    caip,
-                    price: 0
-                };
-            }
-
-            // Get price from markets module
-            const symbol = asset.symbol.toLowerCase();
-            const priceResult = await this.markets.getPrice(symbol);
-
-            // Handle different response formats
-            let price = 0;
-            if (typeof priceResult === 'object' && priceResult.price) {
-                price = parseFloat(priceResult.price);
-            } else if (typeof priceResult === 'number') {
-                price = priceResult;
-            }
+            // Use CAIP-first API (no symbol conversion needed!)
+            // This directly queries the markets module with CAIP identifiers
+            const price = await this.markets.getAssetPriceByCaip(caip);
 
+            // FIX #7: Throw error instead of returning 0 price
+            // This prevents caching invalid $0 prices from rate limits or API failures
             if (isNaN(price) || price <= 0) {
-                log.warn(tag, `Invalid price for ${caip} (${symbol}): ${priceResult}`);
-                return {
-                    caip,
-                    price: 0
-                };
+                const errorMsg = `Price fetch failed for ${caip}: got $${price} (likely API timeout or rate limit)`;
+                log.warn(tag, errorMsg);
+                throw new Error(errorMsg);
             }
 
-            log.debug(tag, `Fetched price for ${caip} (${symbol}): $${price}`);
+            log.debug(tag, `Fetched price for ${caip}: $${price}`);
 
             return {
                 caip,
                 price,
-                source: 'markets'
+                source: 'markets-caip'
             };
 
         } catch (error) {
-            log.error(tag, 'Error fetching price:', error);
+            // Re-throw to prevent caching zero prices
+            // BaseCache.fetchFresh() will catch this and return defaultValue
+            // but won't cache the error
             throw error;
         }
     }