@akinon/next 1.93.0-snapshot-ZERO-3586-20250827144743 → 1.93.0-snapshot-ZERO-3586-20250827165044

package/CHANGELOG.md

@@ -1,6 +1,6 @@
 # @akinon/next
 
-## 1.93.0-snapshot-ZERO-3586-20250827144743
+## 1.93.0-snapshot-ZERO-3586-20250827165044
 
 ### Minor Changes
 
@@ -11,7 +11,7 @@
 - e1aa030d: ZERO-3473: Refactor locale handling to prioritize cookie value for matched locale
 - 6e6b0a9e: ZERO-3422: Add pz-flow-payment package
 - 63774a6a: ZERO-3351: Add commerce redirection ignore list functionality and related utility
-- 2d9b2b2c9: ZERO-2816: Add segment to headers
+- 2d9b2b2c: ZERO-2816: Add segment to headers
 - 5e1feca6: Revert "ZERO-3286: Add notFound handling for chunk URLs starting with \_next"
 - 40a46853: ZERO-3182: Optimize basket update mutation with optimistic update
 - 5f7edd6: ZERO-3571: Enhance Jest configuration by adding base directory resolution and module name mapping
@@ -21,13 +21,13 @@
 - f49bb74f: ZERO-3097: Add setCookie to logging in payment redirection middlewares
 - 0ad91bbd: ZERO-3489: Improve error handling in data fetching across multiple pages and server functions
 - 143be2b9: ZERO-3457: Crop styles are customizable and logic improved for rendering similar products modal
-- e9541a13d: ZERO-2816: Add headers to url
+- e9541a13: ZERO-2816: Add headers to url
 - 9b7d0de6: ZERO-3393: Improve error handling in checkout middleware to support both object and array error formats
 - 72fd4d67: ZERO-3084: Fix URL search parameters encoding in default middleware
 - c53ef7b95: ZERO-2668: The Link component has been updated to improve the logic for handling href values. Previously, if the href was not a string or started with 'http', it would return the href as is. Now, if the href is not provided, it will default to '#' to prevent any potential errors. Additionally, if the href is a string and does not start with 'http', it will be formatted with the locale and pathname, based on the localeUrlStrategy and defaultLocaleValue. This ensures that the correct href is generated based on the localization settings.
 - a8539c8c: ZERO-3439: Enhance locale handling in middleware and redirect utility
 - 16aff543: ZERO-3431: Add test script for redirect utility in package.json
-- 64699d3ff: ZERO-2761: Fix invalid import for plugin module
+- 64699d3f: ZERO-2761: Fix invalid import for plugin module
 - 9f8cd3bc: ZERO-3449: AI Search Active Filters & Crop Style changes have been implemented
 - e974d8e8: ZERO-3406: Fix rc build
 - 89ce46fc: ZERO-3493: return 404 status code for pz-not-found pages
@@ -37,7 +37,7 @@
 - 7727ae55: ZERO-3073: Refactor basket page to use server-side data fetching and simplify component structure
 - 8b1d24eb: ZERO-3422: Update fetch method to use dynamic request method in wallet complete redirection middleware
 - d552629f: ZERO-3182: Refactor basketApi to use invalidatesTags and comment out onQueryStarted logic
-- 17f87524e: ZERO-2816: Make the incoming currency lowercase
+- 17f87524: ZERO-2816: Make the incoming currency lowercase
 - 65d3b862: ZERO-3054: Update headers in appFetch
 - 0abde6bb: ZERO-3422: Update fetch method to use dynamic request method in wallet complete redirection middleware
 - 72ad7bb1: ZERO-3422: Add Flow Payment to the list of available plugins
@@ -46,7 +46,7 @@
 - bbe18b9ff: ZERO-2575: Fix build error
 - 17bfadc4: ZERO-3275: Disable OpenTelemetry monitoring in production environment
 - 35dfb8f8: ZERO-3363: Refactor URL handling in checkout and redirection middlewares to use url.origin instead of process.env.NEXT_PUBLIC_URL
-- 4920742c2: Disable getCachedTranslations
+- 4920742c: Disable getCachedTranslations
 - b6e5b624: ZERO-3257: Enhance locale middleware to redirect using existing or default locale and support 303 status for POST requests
 - 0de55738: ZERO-3418: Update remotePatterns hostname to allow all subdomains
 - 7e56d6b6: ZERO-2841: Update api tagTypes
@@ -68,18 +68,18 @@
 - f7fd459b: ZERO-3445: Refactor setCookie function to include domain handling and improve cookie string construction
 - 4de5303c: ZERO-2504: add cookie filter to api client request
 - dc678c3: ZERO-3523: Enhance redirect tests with dynamic locale handling and settings integration
-- f2c92d5c7: ZERO-2816: Update cookie name
+- f2c92d5c: ZERO-2816: Update cookie name
 - a420947d: ZERO-3517: Fix optional chaining for rawData in error logging for category data handlers
-- 7bd3d9928: ZERO-2801: Refactor locale middleware to handle single locale configuration
+- 7bd3d992: ZERO-2801: Refactor locale middleware to handle single locale configuration
 - acd2afdf: ZERO-3431: Fix import statement for findBaseDir in next-config test
 - 2d3f1788: ZERO-3417: Enhance FileInput component with additional props for customization
 - fdd255ee: ZERO-3054: Refactor cache handler to use custom Redis handler and implement key hashing
 - b434ac8: ZERO-3545: Update fetchCheckout API URL to include page parameter
 - 49eeebfa: ZERO-2909: Add deleteCollectionItem query to wishlistApi
-- 3f9b8d7e7: ZERO-2761: Update plugins.js for akinon-next
+- 3f9b8d7e: ZERO-2761: Update plugins.js for akinon-next
 - fee608dd: ZERO-3422: Refactor body handling in wallet complete redirection middleware
 - cbdb5c14: ZERO-3448: fix set cookie domain handling for subdomain locale strategy
-- 0e82301: ZERO-3531: Add saveSampleProducts endpoint
+- 0e823010: ZERO-3531: Add saveSampleProducts endpoint
 
 ## 1.93.0-rc.52
 

package/lib/cache-handler.mjs

@@ -3,6 +3,179 @@ import createLruHandler from '@neshca/cache-handler/local-lru';
 import createRedisHandler from '@neshca/cache-handler/redis-strings';
 import { createClient } from 'redis';
 
+// Compression utilities for route cache
+let zstd = null;
+let isInitialized = false;
+
+const getZstd = async () => {
+  if (zstd === null) {
+    try {
+      zstd = await import('@bokuweb/zstd-wasm');
+      if (!isInitialized) {
+        await zstd.init();
+        isInitialized = true;
+      }
+    } catch (error) {
+      console.warn('[Cache Handler] ZSTD compression failed to initialize, will use edge runtime fallback');
+      zstd = false;
+    }
+  }
+  return zstd;
+};
+
+// Edge runtime compatible compression fallback
+const edgeCompress = async (data) => {
+  if (typeof CompressionStream !== 'undefined') {
+    const stream = new CompressionStream('gzip');
+    const writer = stream.writable.getWriter();
+    const reader = stream.readable.getReader();
+    
+    writer.write(new TextEncoder().encode(data));
+    writer.close();
+    
+    const chunks = [];
+    let done = false;
+    
+    while (!done) {
+      const { value, done: readerDone } = await reader.read();
+      done = readerDone;
+      if (value) chunks.push(value);
+    }
+    
+    const totalLength = chunks.reduce((sum, chunk) => sum + chunk.length, 0);
+    const result = new Uint8Array(totalLength);
+    let offset = 0;
+    
+    for (const chunk of chunks) {
+      result.set(chunk, offset);
+      offset += chunk.length;
+    }
+    
+    return result;
+  }
+  
+  // Node.js fallback
+  const { deflate } = await import('zlib');
+  const { promisify } = await import('util');
+  const deflateAsync = promisify(deflate);
+  const inputBuffer = new TextEncoder().encode(data);
+  const compressed = await deflateAsync(inputBuffer);
+  return new Uint8Array(compressed.buffer, compressed.byteOffset, compressed.byteLength);
+};
+
+const edgeDecompress = async (compressed) => {
+  if (typeof DecompressionStream !== 'undefined') {
+    const stream = new DecompressionStream('gzip');
+    const writer = stream.writable.getWriter();
+    const reader = stream.readable.getReader();
+    
+    writer.write(compressed);
+    writer.close();
+    
+    const chunks = [];
+    let done = false;
+    
+    while (!done) {
+      const { value, done: readerDone } = await reader.read();
+      done = readerDone;
+      if (value) chunks.push(value);
+    }
+    
+    const totalLength = chunks.reduce((sum, chunk) => sum + chunk.length, 0);
+    const result = new Uint8Array(totalLength);
+    let offset = 0;
+    
+    for (const chunk of chunks) {
+      result.set(chunk, offset);
+      offset += chunk.length;
+    }
+    
+    return new TextDecoder().decode(result);
+  }
+  
+  // Node.js fallback
+  const { inflate } = await import('zlib');
+  const { promisify } = await import('util');
+  const inflateAsync = promisify(inflate);
+  const inputBuffer = new Uint8Array(compressed.buffer, compressed.byteOffset, compressed.byteLength);
+  const decompressed = await inflateAsync(inputBuffer);
+  return decompressed.toString('utf8');
+};
+
+// Compression/decompression functions for cache values
+const compressValue = async (value) => {
+  try {
+    const serializedValue = typeof value === 'string' ? value : JSON.stringify(value);
+    const originalSize = Buffer.byteLength(serializedValue, 'utf8');
+    
+    // Only compress if larger than 1KB to avoid overhead for small values
+    if (originalSize < 1024) {
+      return { compressed: false, data: serializedValue };
+    }
+    
+    const zstdLib = await getZstd();
+    let compressed;
+    let method = 'none';
+    
+    if (zstdLib && zstdLib !== false) {
+      // Use zstd compression in Node.js
+      compressed = zstdLib.compress(Buffer.from(serializedValue, 'utf8'), 3);
+      method = 'zstd';
+    } else {
+      // Use Edge runtime fallback compression
+      compressed = await edgeCompress(serializedValue);
+      method = 'gzip';
+    }
+    
+    const compressedBase64 = Buffer.from(compressed).toString('base64');
+    const compressionRatio = ((originalSize - compressed.length) / originalSize * 100);
+    
+    console_log(`[Cache Handler] Compressed ${originalSize} → ${compressed.length} bytes (${compressionRatio.toFixed(1)}% reduction, method: ${method})`);
+    
+    return {
+      compressed: true,
+      data: compressedBase64,
+      originalSize,
+      compressedSize: compressed.length,
+      method
+    };
+  } catch (error) {
+    console.warn('[Cache Handler] Compression failed, storing uncompressed:', error.message);
+    const serializedValue = typeof value === 'string' ? value : JSON.stringify(value);
+    return { compressed: false, data: serializedValue };
+  }
+};
+
+const decompressValue = async (compressedData) => {
+  try {
+    if (!compressedData.compressed) {
+      return typeof compressedData.data === 'string' ? compressedData.data : JSON.stringify(compressedData.data);
+    }
+    
+    const compressedBuffer = Buffer.from(compressedData.data, 'base64');
+    let decompressed;
+    
+    if (compressedData.method === 'zstd') {
+      const zstdLib = await getZstd();
+      if (zstdLib && zstdLib !== false) {
+        decompressed = zstdLib.decompress(compressedBuffer).toString('utf8');
+      } else {
+        throw new Error('zstd not available for decompression');
+      }
+    } else {
+      // Use edge runtime fallback decompression
+      decompressed = await edgeDecompress(new Uint8Array(compressedBuffer));
+    }
+    
+    console_log(`[Cache Handler] Decompressed ${compressedBuffer.length} → ${decompressed.length} bytes`);
+    return decompressed;
+  } catch (error) {
+    console.warn('[Cache Handler] Decompression failed:', error.message);
+    // Return original data if decompression fails
+    return typeof compressedData.data === 'string' ? compressedData.data : JSON.stringify(compressedData.data);
+  }
+};
+
 // Cache configuration
 const CACHE_CONFIG = {
   lru: {
@@ -188,6 +361,16 @@ CacheHandler.onCreation(async () => {
 
       if (localResult) {
         console_log('Found in local cache');
+        // Check if it's compressed data
+        if (localResult && typeof localResult === 'object' && localResult.compressed !== undefined) {
+          try {
+            const decompressed = await decompressValue(localResult);
+            return JSON.parse(decompressed);
+          } catch (error) {
+            console.warn('[Cache Handler] Failed to decompress local cache value:', error.message);
+            return localResult;
+          }
+        }
         return localResult;
       }
 
@@ -197,14 +380,28 @@ CacheHandler.onCreation(async () => {
 
         if (redisResult) {
           console_log('Found in Redis');
+          
+          let finalResult = redisResult;
+          
+          // Check if it's compressed data and decompress
+          if (redisResult && typeof redisResult === 'object' && redisResult.compressed !== undefined) {
+            try {
+              const decompressed = await decompressValue(redisResult);
+              finalResult = JSON.parse(decompressed);
+            } catch (error) {
+              console.warn('[Cache Handler] Failed to decompress Redis cache value:', error.message);
+              finalResult = redisResult;
+            }
+          }
+          
           // Sync back to local cache for faster future access
           try {
-            await localHandler.set(vKey, redisResult, context);
+            await localHandler.set(vKey, finalResult, context);
             console_log('Synced to local cache');
           } catch (error) {
             console_log('Failed to sync to local:', error.message);
           }
-          return redisResult;
+          return finalResult;
         }
       } catch (error) {
         console_log('Redis error:', error.message);
@@ -219,11 +416,21 @@ CacheHandler.onCreation(async () => {
         'SET called for key:',
         typeof vKey === 'string' ? vKey : vKey?.key
       );
-      // Set to both caches
+      
+      // Compress the value before storing in Redis
+      let compressedValue;
+      try {
+        compressedValue = await compressValue(value);
+      } catch (error) {
+        console.warn('[Cache Handler] Compression failed, using original value:', error.message);
+        compressedValue = { compressed: false, data: value };
+      }
+      
+      // Set to both caches - local gets original, Redis gets compressed
       await Promise.allSettled([
-        localHandler.set(vKey, value, context),
+        localHandler.set(vKey, value, context), // Local cache uses original value for speed
         redisHandler
-          .set(vKey, value, context)
+          .set(vKey, compressedValue, context)
           .catch((error) => console_log('Redis SET error:', error.message))
       ]);
     },

package/lib/cache.ts

@@ -8,6 +8,85 @@ const CACHE_VERSION = 'v2';
 let zstd: any = null;
 let isInitialized = false;
 
+// Edge runtime compatible compression fallback
+const edgeCompress = async (data: string): Promise<Uint8Array> => {
+  if (typeof CompressionStream !== 'undefined') {
+    const stream = new CompressionStream('gzip');
+    const writer = stream.writable.getWriter();
+    const reader = stream.readable.getReader();
+    
+    writer.write(new TextEncoder().encode(data));
+    writer.close();
+    
+    const chunks: Uint8Array[] = [];
+    let done = false;
+    
+    while (!done) {
+      const { value, done: readerDone } = await reader.read();
+      done = readerDone;
+      if (value) chunks.push(value);
+    }
+    
+    const totalLength = chunks.reduce((sum, chunk) => sum + chunk.length, 0);
+    const result = new Uint8Array(totalLength);
+    let offset = 0;
+    
+    for (const chunk of chunks) {
+      result.set(chunk, offset);
+      offset += chunk.length;
+    }
+    
+    return result;
+  }
+  
+  // Node.js fallback
+  const { deflate } = await import('zlib');
+  const { promisify } = await import('util');
+  const deflateAsync = promisify(deflate);
+  const inputBuffer = new TextEncoder().encode(data);
+  const compressed = await deflateAsync(inputBuffer);
+  return new Uint8Array(compressed.buffer, compressed.byteOffset, compressed.byteLength);
+};
+
+const edgeDecompress = async (compressed: Uint8Array): Promise<string> => {
+  if (typeof DecompressionStream !== 'undefined') {
+    const stream = new DecompressionStream('gzip');
+    const writer = stream.writable.getWriter();
+    const reader = stream.readable.getReader();
+    
+    writer.write(compressed);
+    writer.close();
+    
+    const chunks: Uint8Array[] = [];
+    let done = false;
+    
+    while (!done) {
+      const { value, done: readerDone } = await reader.read();
+      done = readerDone;
+      if (value) chunks.push(value);
+    }
+    
+    const totalLength = chunks.reduce((sum, chunk) => sum + chunk.length, 0);
+    const result = new Uint8Array(totalLength);
+    let offset = 0;
+    
+    for (const chunk of chunks) {
+      result.set(chunk, offset);
+      offset += chunk.length;
+    }
+    
+    return new TextDecoder().decode(result);
+  }
+  
+  // Node.js fallback
+  const { inflate } = await import('zlib');
+  const { promisify } = await import('util');
+  const inflateAsync = promisify(inflate);
+  const inputBuffer = new Uint8Array(compressed.buffer, compressed.byteOffset, compressed.byteLength);
+  const decompressed = await inflateAsync(inputBuffer);
+  return decompressed.toString('utf8');
+};
+
 const getZstd = async () => {
   if (zstd === null) {
     try {
@@ -18,7 +97,7 @@ const getZstd = async () => {
         logger.debug('ZSTD compression initialized successfully');
       }
     } catch (error) {
-      logger.warn('ZSTD compression failed to initialize', { error });
+      logger.warn('ZSTD compression failed to initialize, will use edge runtime fallback', { error });
       zstd = false;
     }
   }
@@ -403,21 +482,48 @@ export class Cache {
       });
 
       if (!zstdModule) {
-        // Compression not available, store uncompressed
-        if (expire) {
-          await client.set(key, serializedValue, { EX: expire });
-        } else {
-          await client.set(key, serializedValue);
-        }
+        // Use Edge runtime fallback compression
+        try {
+          const compressed = await edgeCompress(serializedValue);
+          const compressedBase64 = Buffer.from(compressed).toString('base64');
 
-        success = true;
-        logger.debug(
-          'Redis set success (uncompressed - compression unavailable)',
-          {
+          if (expire) {
+            await client.set(key, compressedBase64, { EX: expire });
+          } else {
+            await client.set(key, compressedBase64);
+          }
+
+          success = true;
+          const compressionRatio = (
+            (1 - compressed.length / serializedValue.length) *
+            100
+          ).toFixed(2);
+          logger.debug('Redis setCompressed success (edge runtime fallback)', {
             key,
-            size: serializedValue.length
+            originalSize: serializedValue.length,
+            compressedSize: compressed.length,
+            compressionRatio: `${compressionRatio}%`,
+            method: 'edge-runtime'
+          });
+        } catch (edgeError) {
+          // If edge compression also fails, store uncompressed
+          logger.warn('Edge runtime compression failed, storing uncompressed', {
+            key,
+            error: edgeError
+          });
+
+          if (expire) {
+            await client.set(key, serializedValue, { EX: expire });
+          } else {
+            await client.set(key, serializedValue);
           }
-        );
+
+          success = true;
+          logger.debug('Redis set success (uncompressed fallback)', {
+            key,
+            size: serializedValue.length
+          });
+        }
       } else {
         try {
           // Use @bokuweb/zstd-wasm API
@@ -501,16 +607,40 @@ export class Cache {
           const zstdModule = await getZstd();
 
           if (!zstdModule) {
-            // Failed to decompress, try direct JSON parse
-            const rawString = compressed;
-            const parsedData = JSON.parse(rawString);
-            logger.debug(
-              'Data read as uncompressed (no compression available)',
-              {
-                key
+            // Try edge runtime decompression first
+            try {
+              const decompressedString = await edgeDecompress(new Uint8Array(compressedBuffer));
+              value = JSON.parse(decompressedString);
+              logger.debug('Redis getCompressed success (edge runtime fallback)', {
+                key,
+                compressedSize: compressedBuffer.length,
+                decompressedSize: decompressedString.length,
+                method: 'edge-runtime'
+              });
+              return value;
+            } catch (edgeError) {
+              // Failed to decompress with edge runtime, try direct JSON parse
+              logger.debug('Edge runtime decompression failed, trying direct JSON parse', {
+                key,
+                error: edgeError
+              });
+              
+              try {
+                const rawString = compressed;
+                const parsedData = JSON.parse(rawString);
+                logger.debug('Data read as uncompressed (no compression available)', {
+                  key
+                });
+                return parsedData;
+              } catch (jsonError) {
+                logger.error('Failed to parse data in all formats', {
+                  key,
+                  edgeError,
+                  jsonError
+                });
+                return null;
               }
-            );
-            return parsedData;
+            }
           }
 
           // Use @bokuweb/zstd-wasm API

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@akinon/next",
   "description": "Core package for Project Zero Next",
-  "version": "1.93.0-snapshot-ZERO-3586-20250827144743",
+  "version": "1.93.0-snapshot-ZERO-3586-20250827165044",
   "private": false,
   "license": "MIT",
   "bin": {
@@ -35,7 +35,7 @@
     "set-cookie-parser": "2.6.0"
   },
   "devDependencies": {
-    "@akinon/eslint-plugin-projectzero": "1.93.0-snapshot-ZERO-3586-20250827144743",
+    "@akinon/eslint-plugin-projectzero": "1.93.0-snapshot-ZERO-3586-20250827165044",
     "@babel/core": "7.26.10",
     "@babel/preset-env": "7.26.9",
     "@babel/preset-typescript": "7.27.0",