@pioneer-platform/pioneer-cache 1.19.3 → 1.21.0

package/.turbo/turbo-build.log

@@ -1,5 +1,5 @@
 
 
-> @pioneer-platform/pioneer-cache@1.19.3 build /Users/highlander/WebstormProjects/keepkey-stack/projects/pioneer/modules/pioneer/pioneer-cache
+> @pioneer-platform/pioneer-cache@1.21.0 build /Users/highlander/WebstormProjects/keepkey-stack/projects/pioneer/modules/pioneer/pioneer-cache
 > tsc
 

package/CHANGELOG.md

@@ -1,5 +1,17 @@
 # @pioneer-platform/pioneer-cache
 
+## 1.21.0
+
+### Minor Changes
+
+- feat(monorepo): production release preparation with strict TypeScript and enhanced swap functionality
+
+## 1.20.0
+
+### Minor Changes
+
+- feat(pioneer-client): add client-side host override for staging/blue testing
+
 ## 1.19.3
 
 ### Patch Changes

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

@@ -38,6 +38,7 @@ export declare class CacheManager {
     private stakingCache?;
     private zapperCache?;
     private workers;
+    private staleScanner?;
     constructor(config: CacheManagerConfig);
     /**
      * Purge all pending jobs from the cache refresh queue

package/dist/core/cache-manager.js

@@ -14,6 +14,7 @@ const transaction_cache_1 = require("../stores/transaction-cache");
 const staking_cache_1 = require("../stores/staking-cache");
 const zapper_cache_1 = require("../stores/zapper-cache");
 const refresh_worker_1 = require("../workers/refresh-worker");
+const stale_balance_scanner_1 = require("../workers/stale-balance-scanner");
 const log = require('@pioneer-platform/loggerdog')();
 const TAG = ' | CacheManager | ';
 /**
@@ -139,6 +140,17 @@ class CacheManager {
                 this.workers.push(worker);
                 log.info(tag, '✅ Refresh worker started for all caches');
             }
+            // Start stale balance scanner if balance cache is enabled
+            if (this.balanceCache) {
+                this.staleScanner = new stale_balance_scanner_1.StaleBalanceScanner(this.redis, this.balanceCache, {
+                    staleThresholdMs: 60 * 60 * 1000, // 1 hour (more aggressive than the 5min reactive threshold)
+                    scanIntervalMs: 10 * 60 * 1000, // Scan every 10 minutes
+                    batchSize: 100,
+                    maxRefreshPerScan: 50
+                });
+                await this.staleScanner.start();
+                log.info(tag, '✅ Stale balance scanner started');
+            }
         }
         catch (error) {
             log.error(tag, '❌ Failed to start workers:', error);
@@ -155,6 +167,10 @@ class CacheManager {
             for (const worker of this.workers) {
                 await worker.stop();
             }
+            if (this.staleScanner) {
+                await this.staleScanner.stop();
+                this.staleScanner = undefined;
+            }
             this.workers = [];
             log.info(tag, '✅ All workers stopped');
         }

package/dist/stores/balance-cache.js

@@ -110,7 +110,15 @@ class BalanceCache extends base_cache_1.BaseCache {
             const owner = { pubkey };
             const balanceInfo = await this.balanceModule.getBalance(asset, owner);
             if (!balanceInfo || !balanceInfo.balance) {
-                log.warn(tag, `No balance returned for ${caip}/${sanitizePubkey(pubkey)}`);
+                // CRITICAL FIX: Distinguish between legitimate zero balance and failed API call
+                // Failed API calls should NOT be cached as valid "0" balance
+                const errorMsg = balanceInfo?.error || 'No balance data returned';
+                log.warn(tag, `No balance returned for ${caip}/${sanitizePubkey(pubkey)} - ${errorMsg}`);
+                // If balanceInfo explicitly indicates an error, throw it instead of caching "0"
+                if (balanceInfo?.error || balanceInfo === null || balanceInfo === undefined) {
+                    throw new Error(`Failed to fetch balance for ${caip}: ${errorMsg}`);
+                }
+                // Otherwise, this is a legitimate zero balance (balanceInfo exists but balance is falsy)
                 const now = Date.now();
                 // Get asset metadata even for zero balances
                 const assetData = require('@pioneer-platform/pioneer-discovery').assetData;
@@ -122,7 +130,8 @@ class BalanceCache extends base_cache_1.BaseCache {
                     decimals: assetInfo.decimals,
                     precision: assetInfo.decimals, // Set precision to decimals for compatibility
                     fetchedAt: now,
-                    fetchedAtISO: new Date(now).toISOString()
+                    fetchedAtISO: new Date(now).toISOString(),
+                    dataSource: 'Zero balance (legitimate)'
                 };
             }
             // Get asset metadata

package/dist/workers/stale-balance-scanner.d.ts

@@ -0,0 +1,35 @@
+import type { BalanceCache } from '../stores/balance-cache';
+export interface StaleScannerConfig {
+    staleThresholdMs: number;
+    scanIntervalMs: number;
+    batchSize: number;
+    maxRefreshPerScan: number;
+}
+export declare class StaleBalanceScanner {
+    private redis;
+    private balanceCache;
+    private config;
+    private isRunning;
+    private scanTimer?;
+    constructor(redis: any, balanceCache: BalanceCache, config?: Partial<StaleScannerConfig>);
+    /**
+     * Start the scanner
+     */
+    start(): Promise<void>;
+    /**
+     * Stop the scanner
+     */
+    stop(): Promise<void>;
+    /**
+     * Schedule next scan
+     */
+    private scheduleNextScan;
+    /**
+     * Scan for stale balances and queue refreshes
+     */
+    private scan;
+    /**
+     * Get scanner statistics
+     */
+    getStats(): any;
+}

package/dist/workers/stale-balance-scanner.js

@@ -0,0 +1,180 @@
+"use strict";
+/*
+    Stale Balance Scanner
+
+    Proactively scans for stale balance cache entries and queues them for refresh.
+    This ensures balances that aren't actively accessed still get refreshed.
+
+    Prevents the issue where stale balances sit for days/weeks without being updated.
+*/
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.StaleBalanceScanner = void 0;
+const log = require('@pioneer-platform/loggerdog')();
+const TAG = ' | StaleBalanceScanner | ';
+class StaleBalanceScanner {
+    constructor(redis, balanceCache, config) {
+        this.isRunning = false;
+        this.redis = redis;
+        this.balanceCache = balanceCache;
+        this.config = {
+            staleThresholdMs: config?.staleThresholdMs || 60 * 60 * 1000, // 1 hour
+            scanIntervalMs: config?.scanIntervalMs || 5 * 60 * 1000, // 5 minutes
+            batchSize: config?.batchSize || 100,
+            maxRefreshPerScan: config?.maxRefreshPerScan || 50
+        };
+        log.info(TAG, 'Stale balance scanner initialized', {
+            staleThresholdHours: this.config.staleThresholdMs / (1000 * 60 * 60),
+            scanIntervalMinutes: this.config.scanIntervalMs / (1000 * 60)
+        });
+    }
+    /**
+     * Start the scanner
+     */
+    async start() {
+        const tag = TAG + 'start | ';
+        if (this.isRunning) {
+            log.warn(tag, 'Scanner already running');
+            return;
+        }
+        this.isRunning = true;
+        log.info(tag, '🔍 Starting stale balance scanner');
+        // Run first scan immediately, then schedule recurring
+        await this.scan();
+        this.scheduleNextScan();
+    }
+    /**
+     * Stop the scanner
+     */
+    async stop() {
+        const tag = TAG + 'stop | ';
+        log.info(tag, 'Stopping stale balance scanner');
+        this.isRunning = false;
+        if (this.scanTimer) {
+            clearTimeout(this.scanTimer);
+            this.scanTimer = undefined;
+        }
+        log.info(tag, '✅ Scanner stopped');
+    }
+    /**
+     * Schedule next scan
+     */
+    scheduleNextScan() {
+        if (!this.isRunning)
+            return;
+        this.scanTimer = setTimeout(async () => {
+            await this.scan();
+            this.scheduleNextScan();
+        }, this.config.scanIntervalMs);
+    }
+    /**
+     * Scan for stale balances and queue refreshes
+     */
+    async scan() {
+        const tag = TAG + 'scan | ';
+        const startTime = Date.now();
+        try {
+            log.info(tag, 'Starting stale balance scan...');
+            // Scan balance_v2:* keys in batches
+            const pattern = 'balance_v2:*';
+            const staleKeys = [];
+            const now = Date.now();
+            let cursor = '0';
+            let totalScanned = 0;
+            let refreshCount = 0;
+            do {
+                // SCAN with COUNT for batching
+                const [nextCursor, keys] = await this.redis.scan(cursor, 'MATCH', pattern, 'COUNT', this.config.batchSize);
+                cursor = nextCursor;
+                totalScanned += keys.length;
+                // Check each key for staleness
+                for (const key of keys) {
+                    try {
+                        const cached = await this.redis.get(key);
+                        if (!cached)
+                            continue;
+                        const parsed = JSON.parse(cached);
+                        const age = now - (parsed.timestamp || 0);
+                        // Check if stale
+                        if (age > this.config.staleThresholdMs) {
+                            staleKeys.push(key);
+                            // Stop if we've hit max refresh limit
+                            if (staleKeys.length >= this.config.maxRefreshPerScan) {
+                                log.info(tag, `Reached max refresh limit (${this.config.maxRefreshPerScan}), stopping scan`);
+                                cursor = '0'; // Force exit
+                                break;
+                            }
+                        }
+                    }
+                    catch (error) {
+                        log.error(tag, `Error checking key ${key}:`, error);
+                    }
+                }
+            } while (cursor !== '0' && this.isRunning);
+            // Queue refresh for stale balances
+            if (staleKeys.length > 0) {
+                log.info(tag, `Found ${staleKeys.length} stale balances out of ${totalScanned} scanned`);
+                for (const key of staleKeys) {
+                    try {
+                        // Extract CAIP and pubkey hash from key
+                        // Key format: balance_v2:caip:hashedPubkey
+                        // IMPORTANT: CAIP itself contains colons (e.g., ripple:4109c6f2045fc7eff4cde8f9905d19c2/slip44:144)
+                        // So we must split from the right to get hashedPubkey, then everything else is the CAIP
+                        const withoutPrefix = key.replace('balance_v2:', '');
+                        const lastColonIndex = withoutPrefix.lastIndexOf(':');
+                        if (lastColonIndex === -1)
+                            continue;
+                        const caip = withoutPrefix.substring(0, lastColonIndex);
+                        const pubkeyHash = withoutPrefix.substring(lastColonIndex + 1);
+                        // We need the original pubkey to refresh, but it's hashed in the key
+                        // So we need to get it from the cached value
+                        const cached = await this.redis.get(key);
+                        if (!cached)
+                            continue;
+                        const parsed = JSON.parse(cached);
+                        const pubkey = parsed.value?.pubkey;
+                        if (!pubkey) {
+                            log.warn(tag, `No pubkey found in cache for ${key}, skipping`);
+                            continue;
+                        }
+                        // Trigger refresh by calling getBalance with waitForFresh=true
+                        // This will queue a background refresh job
+                        log.debug(tag, `Queueing refresh for ${caip} (age: ${Math.round((now - parsed.timestamp) / 1000 / 60)}min)`);
+                        // Use setImmediate to avoid blocking the scan
+                        setImmediate(async () => {
+                            try {
+                                await this.balanceCache.getBalance(caip, pubkey, true);
+                                refreshCount++;
+                            }
+                            catch (error) {
+                                log.error(tag, `Failed to refresh ${caip}/${pubkey}:`, error);
+                            }
+                        });
+                    }
+                    catch (error) {
+                        log.error(tag, `Error queueing refresh for ${key}:`, error);
+                    }
+                }
+            }
+            const scanTime = Date.now() - startTime;
+            log.info(tag, `✅ Scan complete: ${totalScanned} scanned, ${staleKeys.length} stale, ${refreshCount} queued in ${scanTime}ms`);
+        }
+        catch (error) {
+            log.error(tag, 'Error during scan:', error);
+        }
+    }
+    /**
+     * Get scanner statistics
+     */
+    getStats() {
+        return {
+            isRunning: this.isRunning,
+            config: {
+                staleThresholdHours: this.config.staleThresholdMs / (1000 * 60 * 60),
+                scanIntervalMinutes: this.config.scanIntervalMs / (1000 * 60),
+                batchSize: this.config.batchSize,
+                maxRefreshPerScan: this.config.maxRefreshPerScan
+            }
+        };
+    }
+}
+exports.StaleBalanceScanner = StaleBalanceScanner;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pioneer-platform/pioneer-cache",
-  "version": "1.19.3",
+  "version": "1.21.0",
   "description": "Unified caching system for Pioneer platform with Redis backend",
   "main": "./dist/index.js",
   "types": "./dist/index.d.ts",
@@ -15,8 +15,8 @@
   "license": "MIT",
   "dependencies": {
     "@pioneer-platform/loggerdog": "8.11.0",
-    "@pioneer-platform/redis-queue": "8.12.17",
-    "@pioneer-platform/default-redis": "8.11.7"
+    "@pioneer-platform/default-redis": "8.11.7",
+    "@pioneer-platform/redis-queue": "8.12.17"
   },
   "devDependencies": {
     "@types/jest": "^29.5.0",

package/src/core/cache-manager.ts

@@ -12,6 +12,7 @@ import { TransactionCache } from '../stores/transaction-cache';
 import { StakingCache } from '../stores/staking-cache';
 import { ZapperCache } from '../stores/zapper-cache';
 import { RefreshWorker, startUnifiedWorker } from '../workers/refresh-worker';
+import { StaleBalanceScanner } from '../workers/stale-balance-scanner';
 import type { BaseCache } from './base-cache';
 import type { HealthCheckResult } from '../types';
 
@@ -53,6 +54,7 @@ export class CacheManager {
     private stakingCache?: StakingCache;
     private zapperCache?: ZapperCache;
     private workers: RefreshWorker[] = [];
+    private staleScanner?: StaleBalanceScanner;
 
     constructor(config: CacheManagerConfig) {
         this.redis = config.redis;
@@ -196,6 +198,19 @@ export class CacheManager {
                 log.info(tag, '✅ Refresh worker started for all caches');
             }
 
+            // Start stale balance scanner if balance cache is enabled
+            if (this.balanceCache) {
+                this.staleScanner = new StaleBalanceScanner(this.redis, this.balanceCache, {
+                    staleThresholdMs: 60 * 60 * 1000,      // 1 hour (more aggressive than the 5min reactive threshold)
+                    scanIntervalMs: 10 * 60 * 1000,        // Scan every 10 minutes
+                    batchSize: 100,
+                    maxRefreshPerScan: 50
+                });
+
+                await this.staleScanner.start();
+                log.info(tag, '✅ Stale balance scanner started');
+            }
+
         } catch (error) {
             log.error(tag, '❌ Failed to start workers:', error);
             throw error;
@@ -215,6 +230,11 @@ export class CacheManager {
                 await worker.stop();
             }
 
+            if (this.staleScanner) {
+                await this.staleScanner.stop();
+                this.staleScanner = undefined;
+            }
+
             this.workers = [];
             log.info(tag, '✅ All workers stopped');
 

package/src/stores/balance-cache.ts

@@ -148,7 +148,18 @@ export class BalanceCache extends BaseCache<BalanceData> {
             const balanceInfo = await this.balanceModule.getBalance(asset, owner);
 
             if (!balanceInfo || !balanceInfo.balance) {
-                log.warn(tag, `No balance returned for ${caip}/${sanitizePubkey(pubkey)}`);
+                // CRITICAL FIX: Distinguish between legitimate zero balance and failed API call
+                // Failed API calls should NOT be cached as valid "0" balance
+                const errorMsg = balanceInfo?.error || 'No balance data returned';
+
+                log.warn(tag, `No balance returned for ${caip}/${sanitizePubkey(pubkey)} - ${errorMsg}`);
+
+                // If balanceInfo explicitly indicates an error, throw it instead of caching "0"
+                if (balanceInfo?.error || balanceInfo === null || balanceInfo === undefined) {
+                    throw new Error(`Failed to fetch balance for ${caip}: ${errorMsg}`);
+                }
+
+                // Otherwise, this is a legitimate zero balance (balanceInfo exists but balance is falsy)
                 const now = Date.now();
 
                 // Get asset metadata even for zero balances
@@ -162,7 +173,8 @@ export class BalanceCache extends BaseCache<BalanceData> {
                     decimals: assetInfo.decimals,
                     precision: assetInfo.decimals,  // Set precision to decimals for compatibility
                     fetchedAt: now,
-                    fetchedAtISO: new Date(now).toISOString()
+                    fetchedAtISO: new Date(now).toISOString(),
+                    dataSource: 'Zero balance (legitimate)'
                 };
             }
 

package/src/workers/stale-balance-scanner.ts

@@ -0,0 +1,223 @@
+/*
+    Stale Balance Scanner
+
+    Proactively scans for stale balance cache entries and queues them for refresh.
+    This ensures balances that aren't actively accessed still get refreshed.
+
+    Prevents the issue where stale balances sit for days/weeks without being updated.
+*/
+
+import type { BalanceCache } from '../stores/balance-cache';
+
+const log = require('@pioneer-platform/loggerdog')();
+const TAG = ' | StaleBalanceScanner | ';
+
+export interface StaleScannerConfig {
+    staleThresholdMs: number;      // Refresh balances older than this (default: 1 hour)
+    scanIntervalMs: number;        // How often to scan (default: 5 minutes)
+    batchSize: number;             // How many keys to scan per batch (default: 100)
+    maxRefreshPerScan: number;     // Max balances to refresh per scan (default: 50)
+}
+
+export class StaleBalanceScanner {
+    private redis: any;
+    private balanceCache: BalanceCache;
+    private config: StaleScannerConfig;
+    private isRunning: boolean = false;
+    private scanTimer?: NodeJS.Timeout;
+
+    constructor(redis: any, balanceCache: BalanceCache, config?: Partial<StaleScannerConfig>) {
+        this.redis = redis;
+        this.balanceCache = balanceCache;
+
+        this.config = {
+            staleThresholdMs: config?.staleThresholdMs || 60 * 60 * 1000,      // 1 hour
+            scanIntervalMs: config?.scanIntervalMs || 5 * 60 * 1000,            // 5 minutes
+            batchSize: config?.batchSize || 100,
+            maxRefreshPerScan: config?.maxRefreshPerScan || 50
+        };
+
+        log.info(TAG, 'Stale balance scanner initialized', {
+            staleThresholdHours: this.config.staleThresholdMs / (1000 * 60 * 60),
+            scanIntervalMinutes: this.config.scanIntervalMs / (1000 * 60)
+        });
+    }
+
+    /**
+     * Start the scanner
+     */
+    async start(): Promise<void> {
+        const tag = TAG + 'start | ';
+
+        if (this.isRunning) {
+            log.warn(tag, 'Scanner already running');
+            return;
+        }
+
+        this.isRunning = true;
+        log.info(tag, '🔍 Starting stale balance scanner');
+
+        // Run first scan immediately, then schedule recurring
+        await this.scan();
+        this.scheduleNextScan();
+    }
+
+    /**
+     * Stop the scanner
+     */
+    async stop(): Promise<void> {
+        const tag = TAG + 'stop | ';
+
+        log.info(tag, 'Stopping stale balance scanner');
+        this.isRunning = false;
+
+        if (this.scanTimer) {
+            clearTimeout(this.scanTimer);
+            this.scanTimer = undefined;
+        }
+
+        log.info(tag, '✅ Scanner stopped');
+    }
+
+    /**
+     * Schedule next scan
+     */
+    private scheduleNextScan(): void {
+        if (!this.isRunning) return;
+
+        this.scanTimer = setTimeout(async () => {
+            await this.scan();
+            this.scheduleNextScan();
+        }, this.config.scanIntervalMs);
+    }
+
+    /**
+     * Scan for stale balances and queue refreshes
+     */
+    private async scan(): Promise<void> {
+        const tag = TAG + 'scan | ';
+        const startTime = Date.now();
+
+        try {
+            log.info(tag, 'Starting stale balance scan...');
+
+            // Scan balance_v2:* keys in batches
+            const pattern = 'balance_v2:*';
+            const staleKeys: string[] = [];
+            const now = Date.now();
+
+            let cursor = '0';
+            let totalScanned = 0;
+            let refreshCount = 0;
+
+            do {
+                // SCAN with COUNT for batching
+                const [nextCursor, keys] = await this.redis.scan(
+                    cursor,
+                    'MATCH', pattern,
+                    'COUNT', this.config.batchSize
+                );
+
+                cursor = nextCursor;
+                totalScanned += keys.length;
+
+                // Check each key for staleness
+                for (const key of keys) {
+                    try {
+                        const cached = await this.redis.get(key);
+                        if (!cached) continue;
+
+                        const parsed = JSON.parse(cached);
+                        const age = now - (parsed.timestamp || 0);
+
+                        // Check if stale
+                        if (age > this.config.staleThresholdMs) {
+                            staleKeys.push(key);
+
+                            // Stop if we've hit max refresh limit
+                            if (staleKeys.length >= this.config.maxRefreshPerScan) {
+                                log.info(tag, `Reached max refresh limit (${this.config.maxRefreshPerScan}), stopping scan`);
+                                cursor = '0'; // Force exit
+                                break;
+                            }
+                        }
+                    } catch (error) {
+                        log.error(tag, `Error checking key ${key}:`, error);
+                    }
+                }
+
+            } while (cursor !== '0' && this.isRunning);
+
+            // Queue refresh for stale balances
+            if (staleKeys.length > 0) {
+                log.info(tag, `Found ${staleKeys.length} stale balances out of ${totalScanned} scanned`);
+
+                for (const key of staleKeys) {
+                    try {
+                        // Extract CAIP and pubkey hash from key
+                        // Key format: balance_v2:caip:hashedPubkey
+                        // IMPORTANT: CAIP itself contains colons (e.g., ripple:4109c6f2045fc7eff4cde8f9905d19c2/slip44:144)
+                        // So we must split from the right to get hashedPubkey, then everything else is the CAIP
+                        const withoutPrefix = key.replace('balance_v2:', '');
+                        const lastColonIndex = withoutPrefix.lastIndexOf(':');
+                        if (lastColonIndex === -1) continue;
+
+                        const caip = withoutPrefix.substring(0, lastColonIndex);
+                        const pubkeyHash = withoutPrefix.substring(lastColonIndex + 1);
+
+                        // We need the original pubkey to refresh, but it's hashed in the key
+                        // So we need to get it from the cached value
+                        const cached = await this.redis.get(key);
+                        if (!cached) continue;
+
+                        const parsed = JSON.parse(cached);
+                        const pubkey = parsed.value?.pubkey;
+
+                        if (!pubkey) {
+                            log.warn(tag, `No pubkey found in cache for ${key}, skipping`);
+                            continue;
+                        }
+
+                        // Trigger refresh by calling getBalance with waitForFresh=true
+                        // This will queue a background refresh job
+                        log.debug(tag, `Queueing refresh for ${caip} (age: ${Math.round((now - parsed.timestamp) / 1000 / 60)}min)`);
+
+                        // Use setImmediate to avoid blocking the scan
+                        setImmediate(async () => {
+                            try {
+                                await this.balanceCache.getBalance(caip, pubkey, true);
+                                refreshCount++;
+                            } catch (error) {
+                                log.error(tag, `Failed to refresh ${caip}/${pubkey}:`, error);
+                            }
+                        });
+
+                    } catch (error) {
+                        log.error(tag, `Error queueing refresh for ${key}:`, error);
+                    }
+                }
+            }
+
+            const scanTime = Date.now() - startTime;
+            log.info(tag, `✅ Scan complete: ${totalScanned} scanned, ${staleKeys.length} stale, ${refreshCount} queued in ${scanTime}ms`);
+
+        } catch (error) {
+            log.error(tag, 'Error during scan:', error);
+        }
+    }
+
+    /**
+     * Get scanner statistics
+     */
+    getStats(): any {
+        return {
+            isRunning: this.isRunning,
+            config: {
+                staleThresholdHours: this.config.staleThresholdMs / (1000 * 60 * 60),
+                scanIntervalMinutes: this.config.scanIntervalMs / (1000 * 60),
+                batchSize: this.config.batchSize,
+                maxRefreshPerScan: this.config.maxRefreshPerScan
+            }
+        };
+    }
+}

package/tsconfig.json

@@ -2,13 +2,12 @@
   "compilerOptions": {
     "target": "ES2020",
     "module": "commonjs",
-    "lib": ["ES2020"],
+    "lib": ["ES2020", "DOM"],
     "declaration": true,
     "outDir": "./dist",
     "rootDir": "./src",
     "strict": true,
     "esModuleInterop": true,
-    "skipLibCheck": true,
     "forceConsistentCasingInFileNames": true,
     "resolveJsonModule": true,
     "moduleResolution": "node"