navis.js 5.7.0 → 5.8.0

package/README.md

@@ -3,7 +3,7 @@
 A lightweight, serverless-first, microservice API framework designed for AWS Lambda and Node.js.
 
 **Author:** Syed Imran Ali  
-**Version:** 5.7.0  
+**Version:** 5.8.0  
 **License:** MIT
 
 ## Philosophy
@@ -197,7 +197,7 @@ navis metrics
 - ✅ **Complex queries** - Support for JOINs, nested WHERE conditions, GROUP BY, HAVING, ORDER BY
 - ✅ **Database-agnostic** - Automatic SQL dialect handling (PostgreSQL, MySQL, SQLite, SQL Server)
 
-### v5.7 (Current)
+### v5.7 ✅
 - ✅ **ORM-like features** - Model definitions with relationships, hooks, and validation
 - ✅ **Database migrations** - Migration system with up/down support and tracking
 - ✅ **Model relationships** - hasMany, belongsTo, hasOne relationship definitions
@@ -205,6 +205,20 @@ navis metrics
 - ✅ **Change tracking** - isDirty, getChanged for detecting model modifications
 - ✅ **TypeScript support** - Full type definitions for models and migrations
 
+### v5.7.1 ✅
+- 🐛 **Bug fix** - Fixed ServiceClient JSON parsing error handling - now properly rejects on parse failures instead of silently resolving
+- ✅ **Improved error handling** - ServiceClient now provides detailed error information (status code, headers, raw body) when JSON parsing fails
+
+### v5.8.0 ✅ (Current)
+- ✅ **Advanced caching strategies** - Multi-level caching (L1 in-memory + L2 Redis)
+- ✅ **Cache warming** - Pre-populate cache with frequently accessed data
+- ✅ **Cache invalidation** - Tag-based and pattern-based invalidation
+- ✅ **Cache statistics** - Comprehensive hit/miss rates, L1/L2 distribution
+- ✅ **Cache compression** - Automatic compression for large values
+- ✅ **Write strategies** - Write-through, write-back, write-around
+- ✅ **Cache stampede prevention** - Prevents concurrent requests for same key
+- ✅ **Cache versioning** - Support for cache schema migrations
+
 ## API Reference
 
 ### NavisApp
@@ -795,6 +809,10 @@ See the `examples/` directory:
 - `database-adapters-demo.ts` - Extended database adapters example (v5.5) - TypeScript
 - `query-builder-demo.js` - Advanced query builder example (v5.6) - JavaScript
 - `query-builder-demo.ts` - Advanced query builder example (v5.6) - TypeScript
+- `orm-migrations-demo.js` - ORM-like features and migrations example (v5.7) - JavaScript
+- `orm-migrations-demo.ts` - ORM-like features and migrations example (v5.7) - TypeScript
+- `advanced-cache-demo.js` - Advanced caching strategies example (v5.8) - JavaScript
+- `advanced-cache-demo.ts` - Advanced caching strategies example (v5.8) - TypeScript
 - `service-client-demo.js` - ServiceClient usage example
 
 ## Roadmap
@@ -835,17 +853,14 @@ Extended database adapters: SQLite and SQL Server support, enhanced connection p
 
 Future versions may include:
 - gRPC integration
-- Advanced caching strategies
 - Enhanced monitoring and alerting
-- Database migrations
-- ORM-like features
 
 ## Documentation
 
 - [V2 Features Guide](./docs/V2_FEATURES.md) - Complete v2 features documentation
 - [V5.6 Features Guide](./docs/V5.6_FEATURES.md) - Advanced query builders documentation
 - [V5.7 Features Guide](./docs/V5.7_FEATURES.md) - ORM-like features and migrations documentation
-- [V5.7 Features Guide](./docs/V5.7_FEATURES.md) - ORM-like features and migrations documentation
+- [V5.8 Features Guide](./docs/V5.8_FEATURES.md) - Advanced caching strategies documentation
 - [V3 Features Guide](./docs/V3_FEATURES.md) - Complete v3 features documentation
 - [V4 Features Guide](./docs/V4_FEATURES.md) - Complete v4 features documentation
 - [V5 Features Guide](./docs/V5_FEATURES.md) - Complete v5 features documentation

package/examples/advanced-cache-demo.js

@@ -0,0 +1,228 @@
+/**
+ * Advanced Caching Strategies Demo
+ * v5.8: Demonstrates multi-level caching, cache warming, invalidation, and statistics
+ */
+
+const { AdvancedCache, Cache, RedisCache } = require('navis.js');
+
+async function demo() {
+  console.log('=== Advanced Caching Strategies Demo ===\n');
+
+  // ============================================
+  // 1. Multi-Level Caching (L1 + L2)
+  // ============================================
+  console.log('1. Multi-Level Caching (L1: In-Memory, L2: Redis)');
+  
+  // Create L1 cache (in-memory)
+  const l1Cache = new Cache({
+    maxSize: 100,
+    defaultTTL: 300000, // 5 minutes
+  });
+
+  // Create L2 cache (Redis - optional, can be null)
+  // Note: Redis requires redis package: npm install redis
+  let l2Cache = null;
+  try {
+    l2Cache = new RedisCache({
+      defaultTTL: 3600, // 1 hour
+      prefix: 'navis:',
+    });
+    await l2Cache.connect();
+    console.log('✅ L2 Cache (Redis) connected');
+  } catch (error) {
+    console.log('⚠️  L2 Cache (Redis) not available, using L1 only');
+  }
+
+  // Create advanced cache with multi-level support
+  const advancedCache = new AdvancedCache({
+    l1Cache,
+    l2Cache,
+    l1MaxSize: 100,
+    l1TTL: 300000, // 5 minutes
+    writeStrategy: 'write-through', // or 'write-back', 'write-around'
+  });
+
+  // Set a value
+  await advancedCache.set('user:1', {
+    id: 1,
+    name: 'John Doe',
+    email: 'john@example.com',
+  }, {
+    ttl: 600000, // 10 minutes
+    tags: ['user', 'user:1'],
+  });
+
+  console.log('✅ Set value in cache');
+
+  // Get value (checks L1 first, then L2)
+  const user = await advancedCache.get('user:1');
+  console.log('✅ Retrieved from cache:', user);
+
+  // ============================================
+  // 2. Cache Warming
+  // ============================================
+  console.log('\n2. Cache Warming (Pre-populate cache)');
+  
+  const warmData = [
+    { key: 'product:1', value: { id: 1, name: 'Product 1', price: 99.99 }, options: { tags: ['product'] } },
+    { key: 'product:2', value: { id: 2, name: 'Product 2', price: 149.99 }, options: { tags: ['product'] } },
+    { key: 'product:3', value: { id: 3, name: 'Product 3', price: 199.99 }, options: { tags: ['product'] } },
+  ];
+
+  await advancedCache.warm(warmData);
+  console.log('✅ Cache warmed with', warmData.length, 'items');
+
+  // ============================================
+  // 3. Cache Invalidation by Tags
+  // ============================================
+  console.log('\n3. Cache Invalidation by Tags');
+  
+  // Set multiple items with tags
+  await advancedCache.set('user:2', { id: 2, name: 'Jane Doe' }, { tags: ['user'] });
+  await advancedCache.set('user:3', { id: 3, name: 'Bob Smith' }, { tags: ['user'] });
+  
+  console.log('✅ Set 2 users with "user" tag');
+  
+  // Invalidate all items with 'user' tag
+  await advancedCache.invalidateByTag('user');
+  console.log('✅ Invalidated all items with "user" tag');
+  
+  // Verify they're gone
+  const user2 = await advancedCache.get('user:2');
+  console.log('User 2 after invalidation:', user2); // Should be null
+
+  // ============================================
+  // 4. Cache Invalidation by Pattern
+  // ============================================
+  console.log('\n4. Cache Invalidation by Pattern');
+  
+  // Set multiple product items
+  await advancedCache.set('product:10', { id: 10, name: 'Product 10' });
+  await advancedCache.set('product:11', { id: 11, name: 'Product 11' });
+  await advancedCache.set('order:1', { id: 1, total: 100 });
+  
+  console.log('✅ Set items with different prefixes');
+  
+  // Invalidate all product:* keys
+  await advancedCache.invalidateByPattern(/^product:/);
+  console.log('✅ Invalidated all keys matching pattern "product:*"');
+  
+  // Verify
+  const product10 = await advancedCache.get('product:10');
+  const order1 = await advancedCache.get('order:1');
+  console.log('Product 10 after invalidation:', product10); // Should be null
+  console.log('Order 1 (not matching pattern):', order1); // Should still exist
+
+  // ============================================
+  // 5. Cache Statistics
+  // ============================================
+  console.log('\n5. Cache Statistics');
+  
+  // Perform some operations
+  await advancedCache.set('stats:1', { data: 'test1' });
+  await advancedCache.set('stats:2', { data: 'test2' });
+  await advancedCache.get('stats:1');
+  await advancedCache.get('stats:2');
+  await advancedCache.get('stats:3'); // Miss
+  
+  const stats = advancedCache.getStats();
+  console.log('Cache Statistics:');
+  console.log('  Hits:', stats.hits);
+  console.log('  Misses:', stats.misses);
+  console.log('  Hit Rate:', stats.hitRate);
+  console.log('  L1 Hits:', stats.l1Hits);
+  console.log('  L2 Hits:', stats.l2Hits);
+  console.log('  L1 Size:', stats.l1Size);
+  console.log('  Sets:', stats.sets);
+  console.log('  Deletes:', stats.deletes);
+
+  // ============================================
+  // 6. Write Strategies
+  // ============================================
+  console.log('\n6. Write Strategies');
+  
+  // Write-through: Write to both L1 and L2 immediately
+  const writeThroughCache = new AdvancedCache({
+    l1Cache: new Cache(),
+    l2Cache: l2Cache,
+    writeStrategy: 'write-through',
+  });
+  console.log('✅ Write-through: Writes to both L1 and L2 immediately');
+  
+  // Write-back: Write to L1, queue for L2
+  const writeBackCache = new AdvancedCache({
+    l1Cache: new Cache(),
+    l2Cache: l2Cache,
+    writeStrategy: 'write-back',
+  });
+  await writeBackCache.set('writeback:1', { data: 'test' });
+  console.log('✅ Write-back: Written to L1, queued for L2');
+  await writeBackCache.flush(); // Flush queue
+  console.log('✅ Write-back queue flushed');
+  
+  // Write-around: Write to L2 only, L1 populated on read
+  const writeAroundCache = new AdvancedCache({
+    l1Cache: new Cache(),
+    l2Cache: l2Cache,
+    writeStrategy: 'write-around',
+  });
+  await writeAroundCache.set('writearound:1', { data: 'test' });
+  console.log('✅ Write-around: Written to L2 only, L1 populated on read');
+
+  // ============================================
+  // 7. Cache Compression
+  // ============================================
+  console.log('\n7. Cache Compression (for large values)');
+  
+  const largeData = {
+    items: Array(1000).fill(0).map((_, i) => ({
+      id: i,
+      name: `Item ${i}`,
+      description: 'This is a long description that repeats many times. '.repeat(10),
+    })),
+  };
+  
+  await advancedCache.set('large:data', largeData, {
+    compress: true, // Enable compression
+  });
+  console.log('✅ Large data cached with compression');
+  
+  const retrieved = await advancedCache.get('large:data');
+  console.log('✅ Retrieved and decompressed:', retrieved.items.length, 'items');
+
+  // ============================================
+  // 8. Cache Versioning
+  // ============================================
+  console.log('\n8. Cache Versioning');
+  
+  const v1Cache = new AdvancedCache({
+    l1Cache: new Cache(),
+    version: '1.0',
+  });
+  
+  const v2Cache = new AdvancedCache({
+    l1Cache: new Cache(),
+    version: '2.0',
+  });
+  
+  await v1Cache.set('versioned:key', { version: '1.0' });
+  await v2Cache.set('versioned:key', { version: '2.0' });
+  
+  const v1Value = await v1Cache.get('versioned:key');
+  const v2Value = await v2Cache.get('versioned:key');
+  
+  console.log('✅ Version 1.0 value:', v1Value);
+  console.log('✅ Version 2.0 value:', v2Value);
+  console.log('✅ Different versions maintain separate caches');
+
+  // Cleanup
+  if (l2Cache) {
+    await l2Cache.disconnect();
+  }
+  
+  console.log('\n=== Demo Complete ===');
+}
+
+// Run demo
+demo().catch(console.error);
+

package/examples/advanced-cache-demo.ts

@@ -0,0 +1,273 @@
+/**
+ * Advanced Caching Strategies Demo (TypeScript)
+ * v5.8: Demonstrates multi-level caching, cache warming, invalidation, and statistics
+ */
+
+import {
+  AdvancedCache,
+  Cache,
+  RedisCache,
+  AdvancedCacheOptions,
+  AdvancedCacheSetOptions,
+  AdvancedCacheWarmItem,
+  AdvancedCacheStats,
+} from 'navis.js';
+
+interface User {
+  id: number;
+  name: string;
+  email?: string;
+}
+
+interface Product {
+  id: number;
+  name: string;
+  price: number;
+}
+
+async function demo(): Promise<void> {
+  console.log('=== Advanced Caching Strategies Demo (TypeScript) ===\n');
+
+  // ============================================
+  // 1. Multi-Level Caching (L1 + L2)
+  // ============================================
+  console.log('1. Multi-Level Caching (L1: In-Memory, L2: Redis)');
+  
+  // Create L1 cache (in-memory)
+  const l1Cache = new Cache({
+    maxSize: 100,
+    defaultTTL: 300000, // 5 minutes
+  });
+
+  // Create L2 cache (Redis - optional, can be null)
+  // Note: Redis requires redis package: npm install redis
+  let l2Cache: RedisCache | null = null;
+  try {
+    l2Cache = new RedisCache({
+      defaultTTL: 3600, // 1 hour
+      prefix: 'navis:',
+    });
+    await l2Cache.connect();
+    console.log('✅ L2 Cache (Redis) connected');
+  } catch (error) {
+    console.log('⚠️  L2 Cache (Redis) not available, using L1 only');
+  }
+
+  // Create advanced cache with multi-level support
+  const options: AdvancedCacheOptions = {
+    l1Cache,
+    l2Cache: l2Cache || undefined,
+    l1MaxSize: 100,
+    l1TTL: 300000, // 5 minutes
+    writeStrategy: 'write-through', // or 'write-back', 'write-around'
+  };
+  
+  const advancedCache = new AdvancedCache(options);
+
+  // Set a value with type safety
+  const user: User = {
+    id: 1,
+    name: 'John Doe',
+    email: 'john@example.com',
+  };
+
+  const setOptions: AdvancedCacheSetOptions = {
+    ttl: 600000, // 10 minutes
+    tags: ['user', 'user:1'],
+  };
+
+  await advancedCache.set('user:1', user, setOptions);
+  console.log('✅ Set value in cache');
+
+  // Get value (checks L1 first, then L2)
+  const retrievedUser = await advancedCache.get('user:1') as User | null;
+  console.log('✅ Retrieved from cache:', retrievedUser);
+
+  // ============================================
+  // 2. Cache Warming
+  // ============================================
+  console.log('\n2. Cache Warming (Pre-populate cache)');
+  
+  const warmData: AdvancedCacheWarmItem[] = [
+    {
+      key: 'product:1',
+      value: { id: 1, name: 'Product 1', price: 99.99 } as Product,
+      options: { tags: ['product'] },
+    },
+    {
+      key: 'product:2',
+      value: { id: 2, name: 'Product 2', price: 149.99 } as Product,
+      options: { tags: ['product'] },
+    },
+    {
+      key: 'product:3',
+      value: { id: 3, name: 'Product 3', price: 199.99 } as Product,
+      options: { tags: ['product'] },
+    },
+  ];
+
+  await advancedCache.warm(warmData);
+  console.log('✅ Cache warmed with', warmData.length, 'items');
+
+  // ============================================
+  // 3. Cache Invalidation by Tags
+  // ============================================
+  console.log('\n3. Cache Invalidation by Tags');
+  
+  // Set multiple items with tags
+  await advancedCache.set('user:2', { id: 2, name: 'Jane Doe' } as User, { tags: ['user'] });
+  await advancedCache.set('user:3', { id: 3, name: 'Bob Smith' } as User, { tags: ['user'] });
+  
+  console.log('✅ Set 2 users with "user" tag');
+  
+  // Invalidate all items with 'user' tag
+  await advancedCache.invalidateByTag('user');
+  console.log('✅ Invalidated all items with "user" tag');
+  
+  // Verify they're gone
+  const user2 = await advancedCache.get('user:2') as User | null;
+  console.log('User 2 after invalidation:', user2); // Should be null
+
+  // ============================================
+  // 4. Cache Invalidation by Pattern
+  // ============================================
+  console.log('\n4. Cache Invalidation by Pattern');
+  
+  // Set multiple product items
+  await advancedCache.set('product:10', { id: 10, name: 'Product 10' } as Product);
+  await advancedCache.set('product:11', { id: 11, name: 'Product 11' } as Product);
+  await advancedCache.set('order:1', { id: 1, total: 100 });
+  
+  console.log('✅ Set items with different prefixes');
+  
+  // Invalidate all product:* keys
+  await advancedCache.invalidateByPattern(/^product:/);
+  console.log('✅ Invalidated all keys matching pattern "product:*"');
+  
+  // Verify
+  const product10 = await advancedCache.get('product:10') as Product | null;
+  const order1 = await advancedCache.get('order:1');
+  console.log('Product 10 after invalidation:', product10); // Should be null
+  console.log('Order 1 (not matching pattern):', order1); // Should still exist
+
+  // ============================================
+  // 5. Cache Statistics
+  // ============================================
+  console.log('\n5. Cache Statistics');
+  
+  // Perform some operations
+  await advancedCache.set('stats:1', { data: 'test1' });
+  await advancedCache.set('stats:2', { data: 'test2' });
+  await advancedCache.get('stats:1');
+  await advancedCache.get('stats:2');
+  await advancedCache.get('stats:3'); // Miss
+  
+  const stats: AdvancedCacheStats = advancedCache.getStats();
+  console.log('Cache Statistics:');
+  console.log('  Hits:', stats.hits);
+  console.log('  Misses:', stats.misses);
+  console.log('  Hit Rate:', stats.hitRate);
+  console.log('  L1 Hits:', stats.l1Hits);
+  console.log('  L2 Hits:', stats.l2Hits);
+  console.log('  L1 Size:', stats.l1Size);
+  console.log('  Sets:', stats.sets);
+  console.log('  Deletes:', stats.deletes);
+
+  // ============================================
+  // 6. Write Strategies
+  // ============================================
+  console.log('\n6. Write Strategies');
+  
+  // Write-through: Write to both L1 and L2 immediately
+  const writeThroughCache = new AdvancedCache({
+    l1Cache: new Cache(),
+    l2Cache: l2Cache || undefined,
+    writeStrategy: 'write-through',
+  });
+  console.log('✅ Write-through: Writes to both L1 and L2 immediately');
+  
+  // Write-back: Write to L1, queue for L2
+  const writeBackCache = new AdvancedCache({
+    l1Cache: new Cache(),
+    l2Cache: l2Cache || undefined,
+    writeStrategy: 'write-back',
+  });
+  await writeBackCache.set('writeback:1', { data: 'test' });
+  console.log('✅ Write-back: Written to L1, queued for L2');
+  await writeBackCache.flush(); // Flush queue
+  console.log('✅ Write-back queue flushed');
+  
+  // Write-around: Write to L2 only, L1 populated on read
+  const writeAroundCache = new AdvancedCache({
+    l1Cache: new Cache(),
+    l2Cache: l2Cache || undefined,
+    writeStrategy: 'write-around',
+  });
+  await writeAroundCache.set('writearound:1', { data: 'test' });
+  console.log('✅ Write-around: Written to L2 only, L1 populated on read');
+
+  // ============================================
+  // 7. Cache Compression
+  // ============================================
+  console.log('\n7. Cache Compression (for large values)');
+  
+  interface LargeItem {
+    id: number;
+    name: string;
+    description: string;
+  }
+
+  const largeData: { items: LargeItem[] } = {
+    items: Array(1000).fill(0).map((_, i) => ({
+      id: i,
+      name: `Item ${i}`,
+      description: 'This is a long description that repeats many times. '.repeat(10),
+    })),
+  };
+  
+  await advancedCache.set('large:data', largeData, {
+    compress: true, // Enable compression
+  });
+  console.log('✅ Large data cached with compression');
+  
+  const retrieved = await advancedCache.get('large:data') as { items: LargeItem[] } | null;
+  if (retrieved) {
+    console.log('✅ Retrieved and decompressed:', retrieved.items.length, 'items');
+  }
+
+  // ============================================
+  // 8. Cache Versioning
+  // ============================================
+  console.log('\n8. Cache Versioning');
+  
+  const v1Cache = new AdvancedCache({
+    l1Cache: new Cache(),
+    version: '1.0',
+  });
+  
+  const v2Cache = new AdvancedCache({
+    l1Cache: new Cache(),
+    version: '2.0',
+  });
+  
+  await v1Cache.set('versioned:key', { version: '1.0' });
+  await v2Cache.set('versioned:key', { version: '2.0' });
+  
+  const v1Value = await v1Cache.get('versioned:key');
+  const v2Value = await v2Cache.get('versioned:key');
+  
+  console.log('✅ Version 1.0 value:', v1Value);
+  console.log('✅ Version 2.0 value:', v2Value);
+  console.log('✅ Different versions maintain separate caches');
+
+  // Cleanup
+  if (l2Cache) {
+    await l2Cache.disconnect();
+  }
+  
+  console.log('\n=== Demo Complete ===');
+}
+
+// Run demo
+demo().catch(console.error);
+

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "navis.js",
-  "version": "5.7.0",
+  "version": "5.8.0",
   "description": "A lightweight, serverless-first, microservice API framework designed for AWS Lambda and Node.js",
   "main": "src/index.js",
   "types": "types/index.d.ts",

package/src/cache/advanced-cache.js

@@ -0,0 +1,502 @@
+/**
+ * Advanced Caching Strategies
+ * v5.8: Multi-level caching, cache warming, invalidation, statistics, and more
+ */
+
+const Cache = require('./cache');
+const zlib = require('zlib');
+const { promisify } = require('util');
+
+const gzip = promisify(zlib.gzip);
+const gunzip = promisify(zlib.gunzip);
+
+/**
+ * Advanced Cache with multiple strategies
+ */
+class AdvancedCache {
+  constructor(options = {}) {
+    // Multi-level cache: L1 (in-memory), L2 (Redis/remote)
+    this.l1Cache = options.l1Cache || new Cache({
+      maxSize: options.l1MaxSize || 1000,
+      defaultTTL: options.l1TTL || 300000, // 5 minutes
+    });
+    
+    this.l2Cache = options.l2Cache || null; // Optional Redis or other remote cache
+    
+    // Cache statistics
+    this.stats = {
+      hits: 0,
+      misses: 0,
+      sets: 0,
+      deletes: 0,
+      errors: 0,
+      l1Hits: 0,
+      l2Hits: 0,
+    };
+    
+    // Cache invalidation tags
+    this.tagStore = new Map(); // tag -> Set of keys
+    this.keyTags = new Map(); // key -> Set of tags
+    
+    // Cache warming
+    this.warmingQueue = [];
+    this.isWarming = false;
+    
+    // Cache compression
+    this.compressThreshold = options.compressThreshold || 1024; // Compress values > 1KB
+    
+    // Cache stampede prevention
+    this.pendingGets = new Map(); // key -> Promise
+    
+    // Write strategy: 'write-through', 'write-back', 'write-around'
+    this.writeStrategy = options.writeStrategy || 'write-through';
+    this.writeBackQueue = [];
+    
+    // Cache versioning
+    this.version = options.version || '1.0';
+    this.versionPrefix = `v${this.version}:`;
+  }
+
+  /**
+   * Get value from cache (multi-level)
+   * @param {string} key - Cache key
+   * @returns {Promise<*>} - Cached value or null
+   */
+  async get(key) {
+    const fullKey = this.versionPrefix + key;
+    
+    // Prevent cache stampede
+    if (this.pendingGets.has(fullKey)) {
+      return this.pendingGets.get(fullKey);
+    }
+    
+    const getPromise = this._getInternal(fullKey);
+    this.pendingGets.set(fullKey, getPromise);
+    
+    try {
+      const result = await getPromise;
+      return result;
+    } finally {
+      this.pendingGets.delete(fullKey);
+    }
+  }
+
+  /**
+   * Internal get with multi-level lookup
+   * @private
+   */
+  async _getInternal(fullKey) {
+    // Try L1 cache first
+    const l1Value = this.l1Cache.get(fullKey);
+    if (l1Value !== null) {
+      this.stats.hits++;
+      this.stats.l1Hits++;
+      return await this._decompress(l1Value);
+    }
+    
+    // Try L2 cache if available
+    if (this.l2Cache) {
+      try {
+        const l2Value = await this.l2Cache.get(fullKey);
+        if (l2Value !== null) {
+          this.stats.hits++;
+          this.stats.l2Hits++;
+          
+          // Promote to L1
+          const ttl = this._getRemainingTTL(fullKey);
+          if (ttl > 0) {
+            this.l1Cache.set(fullKey, l2Value, ttl);
+          }
+          
+          return await this._decompress(l2Value);
+        }
+      } catch (error) {
+        this.stats.errors++;
+        // Continue to miss
+      }
+    }
+    
+    this.stats.misses++;
+    return null;
+  }
+
+  /**
+   * Set value in cache
+   * @param {string} key - Cache key
+   * @param {*} value - Value to cache
+   * @param {Object} options - Options (ttl, tags, compress)
+   */
+  async set(key, value, options = {}) {
+    const fullKey = this.versionPrefix + key;
+    const ttl = options.ttl || null;
+    const tags = options.tags || [];
+    const shouldCompress = options.compress !== false;
+    
+    // Compress if needed (always wrap in object for consistency)
+    const processedValue = shouldCompress ? await this._compress(value) : { compressed: false, data: value };
+    
+    // Apply write strategy
+    switch (this.writeStrategy) {
+      case 'write-through':
+        await this._writeThrough(fullKey, processedValue, ttl);
+        break;
+      case 'write-back':
+        await this._writeBack(fullKey, processedValue, ttl);
+        break;
+      case 'write-around':
+        await this._writeAround(fullKey, processedValue, ttl);
+        break;
+    }
+    
+    // Handle tags
+    if (tags.length > 0) {
+      this._addTags(fullKey, tags);
+    }
+    
+    this.stats.sets++;
+  }
+
+  /**
+   * Write-through: Write to both L1 and L2 immediately
+   * @private
+   */
+  async _writeThrough(key, value, ttl) {
+    // Write to L1
+    this.l1Cache.set(key, value, ttl);
+    
+    // Write to L2 if available
+    if (this.l2Cache) {
+      try {
+        if (this.l2Cache.set) {
+          await this.l2Cache.set(key, value, ttl ? Math.floor(ttl / 1000) : null);
+        } else {
+          this.l2Cache.set(key, value, ttl);
+        }
+      } catch (error) {
+        this.stats.errors++;
+      }
+    }
+  }
+
+  /**
+   * Write-back: Write to L1, queue for L2
+   * @private
+   */
+  async _writeBack(key, value, ttl) {
+    // Write to L1 immediately
+    this.l1Cache.set(key, value, ttl);
+    
+    // Queue for L2 write
+    this.writeBackQueue.push({ key, value, ttl, timestamp: Date.now() });
+    
+    // Flush queue if it gets too large
+    if (this.writeBackQueue.length > 100) {
+      await this._flushWriteBackQueue();
+    }
+  }
+
+  /**
+   * Write-around: Write to L2 only, L1 populated on read
+   * @private
+   */
+  async _writeAround(key, value, ttl) {
+    // Write to L2 only
+    if (this.l2Cache) {
+      try {
+        if (this.l2Cache.set) {
+          await this.l2Cache.set(key, value, ttl ? Math.floor(ttl / 1000) : null);
+        } else {
+          this.l2Cache.set(key, value, ttl);
+        }
+      } catch (error) {
+        this.stats.errors++;
+      }
+    }
+  }
+
+  /**
+   * Flush write-back queue
+   * @private
+   */
+  async _flushWriteBackQueue() {
+    if (!this.l2Cache || this.writeBackQueue.length === 0) {
+      return;
+    }
+    
+    const items = this.writeBackQueue.splice(0);
+    for (const item of items) {
+      try {
+        if (this.l2Cache.set) {
+          await this.l2Cache.set(item.key, item.value, item.ttl ? Math.floor(item.ttl / 1000) : null);
+        } else {
+          this.l2Cache.set(item.key, item.value, item.ttl);
+        }
+      } catch (error) {
+        this.stats.errors++;
+      }
+    }
+  }
+
+  /**
+   * Delete from cache
+   * @param {string} key - Cache key
+   */
+  async delete(key) {
+    const fullKey = this.versionPrefix + key;
+    
+    // Delete from L1
+    this.l1Cache.delete(fullKey);
+    
+    // Delete from L2
+    if (this.l2Cache) {
+      try {
+        if (this.l2Cache.delete) {
+          await this.l2Cache.delete(fullKey);
+        } else {
+          this.l2Cache.delete(fullKey);
+        }
+      } catch (error) {
+        this.stats.errors++;
+      }
+    }
+    
+    // Remove tags
+    this._removeTags(fullKey);
+    
+    this.stats.deletes++;
+  }
+
+  /**
+   * Invalidate by tag
+   * @param {string|Array<string>} tags - Tag(s) to invalidate
+   */
+  async invalidateByTag(tags) {
+    const tagArray = Array.isArray(tags) ? tags : [tags];
+    const keysToDelete = new Set();
+    
+    for (const tag of tagArray) {
+      const keys = this.tagStore.get(tag);
+      if (keys) {
+        for (const key of keys) {
+          keysToDelete.add(key);
+        }
+        this.tagStore.delete(tag);
+      }
+    }
+    
+    // Delete all keys
+    for (const key of keysToDelete) {
+      await this.delete(key.replace(this.versionPrefix, ''));
+    }
+  }
+
+  /**
+   * Invalidate by pattern
+   * @param {string|RegExp} pattern - Pattern to match keys (without version prefix)
+   */
+  async invalidateByPattern(pattern) {
+    const regex = typeof pattern === 'string' ? new RegExp(pattern) : pattern;
+    const keysToDelete = [];
+    
+    // Check L1 cache (keys include version prefix)
+    for (const fullKey of this.l1Cache.keys()) {
+      // Remove version prefix for pattern matching
+      const keyWithoutPrefix = fullKey.replace(this.versionPrefix, '');
+      if (regex.test(keyWithoutPrefix)) {
+        keysToDelete.push(keyWithoutPrefix);
+      }
+    }
+    
+    // Delete matched keys
+    for (const key of keysToDelete) {
+      await this.delete(key);
+    }
+  }
+
+  /**
+   * Add tags to a key
+   * @private
+   */
+  _addTags(key, tags) {
+    if (!this.keyTags.has(key)) {
+      this.keyTags.set(key, new Set());
+    }
+    
+    for (const tag of tags) {
+      this.keyTags.get(key).add(tag);
+      
+      if (!this.tagStore.has(tag)) {
+        this.tagStore.set(tag, new Set());
+      }
+      this.tagStore.get(tag).add(key);
+    }
+  }
+
+  /**
+   * Remove tags from a key
+   * @private
+   */
+  _removeTags(key) {
+    const tags = this.keyTags.get(key);
+    if (tags) {
+      for (const tag of tags) {
+        const keys = this.tagStore.get(tag);
+        if (keys) {
+          keys.delete(key);
+          if (keys.size === 0) {
+            this.tagStore.delete(tag);
+          }
+        }
+      }
+      this.keyTags.delete(key);
+    }
+  }
+
+  /**
+   * Warm cache (pre-populate)
+   * @param {Array<Object>} items - Array of {key, value, options}
+   */
+  async warm(items) {
+    if (this.isWarming) {
+      this.warmingQueue.push(...items);
+      return;
+    }
+    
+    this.isWarming = true;
+    
+    try {
+      for (const item of items) {
+        await this.set(item.key, item.value, item.options || {});
+      }
+      
+      // Process queued items
+      while (this.warmingQueue.length > 0) {
+        const item = this.warmingQueue.shift();
+        await this.set(item.key, item.value, item.options || {});
+      }
+    } finally {
+      this.isWarming = false;
+    }
+  }
+
+  /**
+   * Get cache statistics
+   * @returns {Object} - Cache statistics
+   */
+  getStats() {
+    const total = this.stats.hits + this.stats.misses;
+    const hitRate = total > 0 ? (this.stats.hits / total) * 100 : 0;
+    
+    return {
+      ...this.stats,
+      total,
+      hitRate: hitRate.toFixed(2) + '%',
+      l1Size: this.l1Cache.size(),
+      l2Size: this.l2Cache ? 'N/A' : 0, // Would need async call for Redis
+      writeBackQueueSize: this.writeBackQueue.length,
+    };
+  }
+
+  /**
+   * Reset statistics
+   */
+  resetStats() {
+    this.stats = {
+      hits: 0,
+      misses: 0,
+      sets: 0,
+      deletes: 0,
+      errors: 0,
+      l1Hits: 0,
+      l2Hits: 0,
+    };
+  }
+
+  /**
+   * Clear all cache
+   */
+  async clear() {
+    this.l1Cache.clear();
+    
+    if (this.l2Cache) {
+      try {
+        if (this.l2Cache.clear) {
+          await this.l2Cache.clear();
+        } else {
+          this.l2Cache.clear();
+        }
+      } catch (error) {
+        this.stats.errors++;
+      }
+    }
+    
+    this.tagStore.clear();
+    this.keyTags.clear();
+    this.writeBackQueue = [];
+  }
+
+  /**
+   * Compress value if needed
+   * @private
+   */
+  async _compress(value) {
+    const serialized = JSON.stringify(value);
+    
+    if (serialized.length < this.compressThreshold) {
+      return { compressed: false, data: value };
+    }
+    
+    try {
+      const compressed = await gzip(serialized);
+      return { compressed: true, data: compressed.toString('base64') };
+    } catch (error) {
+      // If compression fails, return uncompressed
+      return { compressed: false, data: value };
+    }
+  }
+
+  /**
+   * Decompress value if needed
+   * @private
+   */
+  async _decompress(value) {
+    // If not an object or doesn't have compressed property, return as-is
+    if (!value || typeof value !== 'object' || value.compressed === undefined) {
+      return value;
+    }
+    
+    // If compressed is false, return the data directly
+    if (!value.compressed) {
+      return value.data;
+    }
+    
+    // Decompress if compressed
+    try {
+      const buffer = Buffer.from(value.data, 'base64');
+      const decompressed = await gunzip(buffer);
+      return JSON.parse(decompressed.toString());
+    } catch (error) {
+      // If decompression fails, return as-is
+      return value;
+    }
+  }
+
+  /**
+   * Get remaining TTL for a key (approximate)
+   * @private
+   */
+  _getRemainingTTL(key) {
+    // This is a simplified version - would need to track TTL in real implementation
+    return this.l1Cache.defaultTTL;
+  }
+
+  /**
+   * Flush write-back queue (public method)
+   */
+  async flush() {
+    await this._flushWriteBackQueue();
+  }
+}
+
+module.exports = AdvancedCache;
+

package/src/index.js

@@ -50,6 +50,7 @@ const {
 // v5: Enterprise Features
 const Cache = require('./cache/cache');
 const RedisCache = require('./cache/redis-cache');
+const AdvancedCache = require('./cache/advanced-cache');
 const cache = require('./middleware/cache-middleware');
 const cors = require('./middleware/cors');
 const security = require('./middleware/security');
@@ -137,6 +138,7 @@ module.exports = {
   // v5: Enterprise Features
   Cache,
   RedisCache,
+  AdvancedCache,
   cache,
   cors,
   security,

package/src/utils/service-client.js

@@ -79,11 +79,13 @@ class ServiceClient {
               resolve(response);
             }
           } catch (err) {
-            resolve({
-              statusCode: res.statusCode,
-              headers: res.headers,
-              data: body,
-            });
+            // JSON parsing failed - reject with error instead of silently resolving
+            const parseError = new Error(`Failed to parse JSON response: ${err.message}`);
+            parseError.statusCode = res.statusCode;
+            parseError.headers = res.headers;
+            parseError.rawBody = body;
+            parseError.parseError = err;
+            reject(parseError);
           }
         });
       });

package/types/index.d.ts

@@ -358,8 +358,58 @@ export interface RedisCache {
   size(): Promise<number>;
 }
 
+export interface AdvancedCacheOptions {
+  l1Cache?: Cache;
+  l2Cache?: RedisCache | any;
+  l1MaxSize?: number;
+  l1TTL?: number;
+  compressThreshold?: number;
+  writeStrategy?: 'write-through' | 'write-back' | 'write-around';
+  version?: string;
+}
+
+export interface AdvancedCacheSetOptions {
+  ttl?: number;
+  tags?: string[];
+  compress?: boolean;
+}
+
+export interface AdvancedCacheStats {
+  hits: number;
+  misses: number;
+  sets: number;
+  deletes: number;
+  errors: number;
+  l1Hits: number;
+  l2Hits: number;
+  total: number;
+  hitRate: string;
+  l1Size: number;
+  l2Size: number | string;
+  writeBackQueueSize: number;
+}
+
+export interface AdvancedCacheWarmItem {
+  key: string;
+  value: any;
+  options?: AdvancedCacheSetOptions;
+}
+
+export interface AdvancedCache {
+  get(key: string): Promise<any>;
+  set(key: string, value: any, options?: AdvancedCacheSetOptions): Promise<void>;
+  delete(key: string): Promise<void>;
+  invalidateByTag(tags: string | string[]): Promise<void>;
+  invalidateByPattern(pattern: string | RegExp): Promise<void>;
+  warm(items: AdvancedCacheWarmItem[]): Promise<void>;
+  getStats(): AdvancedCacheStats;
+  resetStats(): void;
+  clear(): Promise<void>;
+  flush(): Promise<void>;
+}
+
 export interface CacheMiddlewareOptions {
-  cacheStore: Cache | RedisCache;
+  cacheStore: Cache | RedisCache | AdvancedCache;
   ttl?: number;
   keyGenerator?: (req: NavisRequest) => string;
   skipCache?: (req: NavisRequest, res: NavisResponse) => boolean;
@@ -698,6 +748,10 @@ export const RedisCache: {
   new (options?: RedisCacheOptions): RedisCache;
 };
 
+export const AdvancedCache: {
+  new (options?: AdvancedCacheOptions): AdvancedCache;
+};
+
 export const HealthChecker: {
   new (options?: HealthCheckOptions): HealthChecker;
 };