@akinon/next 1.95.0-rc.54 → 1.95.0-snapshot-ZERO-3586-20250901140025

package/CHANGELOG.md

@@ -1,5 +1,75 @@
 # @akinon/next
 
+## 1.95.0-snapshot-ZERO-3586-20250901140025
+
+### Minor Changes
+
+- 5dfeea04: ZERO-2801: Revert ZERO-2801
+- 823d82f9: ZERO-3393: Enhance error handling in checkout middleware to ensure errors are checked for existence before processing
+- 412f0e2: ZERO-3586: Enhance caching functionality by adding support for compressed data storage and retrieval, along with a new method for setting multiple key-value pairs.
+- 28c7ea79: ZERO-3427: Refactor redirect utility to handle undefined URL and improve locale handling
+- e1aa030d: ZERO-3473: Refactor locale handling to prioritize cookie value for matched locale
+- 63774a6a: ZERO-3351: Add commerce redirection ignore list functionality and related utility
+- 2d9b2b2c9: 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
+- 68bbcb27: ZERO-3393: Fix error handling in checkout middleware to check for errors array length
+- d8be48fb: ZERO-3422: Update fetch method to use dynamic request method in wallet complete redirection middleware
+- b55acb76: ZERO-2577: Fix pagination bug and update usePagination hook and ensure pagination controls rendering correctly
+- 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
+- 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
+- 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
+- 8645d90: ZERO-3574:Refactor redirect tests: streamline mock setup, enhance locale handling, and improve URL path resolution logic
+- 7eb51ca9: ZERO-3424 :Update package versions
+- 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
+- 65d3b862: ZERO-3054: Update headers in appFetch
+- c39c7000: ZERO-3420: Refactor Modal component
+- bbe18b9ff: ZERO-2575: Fix build error
+- 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
+- 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
+- d99a6a7d: ZERO-3457: Fixed the settings prop and made sure everything is customizable.
+- 9dc7298a: ZERO-3416: Refactor Accordion component to enhance props and improve styling flexibility
+- 33377cfd: ZERO-3267: Refactor import statement for ROUTES in error-page component
+- 43c182ee: ZERO-3054: Update Redis variable checks to conditionally include CACHE_SECRET
+- c480272: ZERO-3531: Refactor checkoutApi: Remove unnecessary invalidatesTags property from POST request from sample products
+- b00a90b1: ZERO-3436: Preserve query params on redirect
+- facf1ada: ZERO-3445: Add SameSite and Secure attributes
+- 26b2d0b: ZERO-3571: Remove test script execution from prebuild and simplify Jest module name mapping
+- eeb20bea: Revert "ZERO-3054: Refactor cache handler to use custom Redis handler and implement key hashing"
+- 99b6e7b9: ZERO-3421: Enhance Sentry error handling by adding network error detection logic and refining initialization options
+- 3bf63c8a: ZERO-3286: Add notFound handling for chunk URLs starting with \_next
+- 9be2c081: ZERO-3243: Improve basket update query handling with optimistic updates
+- 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
+- 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
+- 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
+- 49eeebfa: ZERO-2909: Add deleteCollectionItem query to wishlistApi
+- 3f9b8d7e7: ZERO-2761: Update plugins.js for akinon-next
+- cbdb5c14: ZERO-3448: fix set cookie domain handling for subdomain locale strategy
+- 0e82301: ZERO-3531: Add saveSampleProducts endpoint
+
 ## 1.95.0-rc.54
 
 ### Minor Changes

package/api/cache.ts

@@ -21,20 +21,54 @@ async function handleRequest(...args) {
   }
 
   const formData = await req.formData();
-  const body = {} as { key: string; value?: string; expire?: number };
+  const body = {} as {
+    key: string;
+    value?: string;
+    expire?: number;
+    keyValuePairs?: string;
+    compressed?: string;
+  };
 
   formData.forEach((value, key) => {
     body[key] = value;
   });
 
-  const { key, value, expire } = body;
-  let response: string | boolean;
+  const { key, value, expire, keyValuePairs, compressed } = body;
+  let response: any;
 
   try {
     if (req.method === 'POST') {
-      response = await Cache.get(key);
+      if (compressed === 'true') {
+        response = await Cache.getCompressed(key);
+      } else {
+        response = await Cache.get(key);
+      }
     } else if (req.method === 'PUT') {
-      response = await Cache.set(key, value, expire);
+      if (keyValuePairs) {
+        try {
+          const parsedKeyValuePairs = JSON.parse(keyValuePairs);
+          if (
+            typeof parsedKeyValuePairs !== 'object' ||
+            parsedKeyValuePairs === null ||
+            Array.isArray(parsedKeyValuePairs)
+          ) {
+            throw new Error('Invalid keyValuePairs format - must be an object');
+          }
+          response = await Cache.mset(parsedKeyValuePairs, expire);
+        } catch (error) {
+          logger.error('Invalid keyValuePairs in mset request', { error });
+          return NextResponse.json(
+            { error: 'Invalid keyValuePairs format' },
+            { status: 400 }
+          );
+        }
+      } else {
+        if (compressed === 'true') {
+          response = await Cache.setCompressed(key, value, expire);
+        } else {
+          response = await Cache.set(key, value, expire);
+        }
+      }
     }
   } catch (error) {
     logger.error(error);

package/data/server/category.ts

@@ -118,7 +118,8 @@ export const getCategoryData = ({
     locale,
     getCategoryDataHandler(pk, locale, currency, searchParams, headers),
     {
-      expire: 300
+      expire: 300,
+      compressed: true
     }
   );
 };
@@ -178,7 +179,8 @@ export const getCategoryBySlugData = async ({
     locale,
     getCategoryBySlugDataHandler(slug, locale, currency),
     {
-      expire: 300
+      expire: 300,
+      compressed: true
     }
   );
 };

package/data/server/flatpage.ts

@@ -46,6 +46,9 @@ export const getFlatPageData = ({
   return Cache.wrap(
     CacheKey.FlatPage(pk),
     locale,
-    getFlatPageDataHandler(pk, locale, currency, headers)
+    getFlatPageDataHandler(pk, locale, currency, headers),
+    {
+      compressed: true
+    }
   );
 };

package/data/server/form.ts

@@ -43,6 +43,9 @@ export const getFormData = ({
   return Cache.wrap(
     CacheKey.Form(pk),
     locale,
-    getFormDataHandler(pk, locale, currency, headers)
+    getFormDataHandler(pk, locale, currency, headers),
+    {
+      compressed: true
+    }
   );
 };

package/data/server/landingpage.ts

@@ -46,6 +46,9 @@ export const getLandingPageData = ({
   return Cache.wrap(
     CacheKey.LandingPage(pk),
     locale,
-    getLandingPageHandler(pk, locale, currency, headers)
+    getLandingPageHandler(pk, locale, currency, headers),
+    {
+      compressed: true
+    }
   );
 };

package/data/server/list.ts

@@ -81,7 +81,8 @@ export const getListData = async ({
     locale,
     getListDataHandler(locale, currency, searchParams, headers),
     {
-      expire: 300
+      expire: 300,
+      compressed: true
     }
   );
 };

package/data/server/menu.ts

@@ -48,6 +48,9 @@ export const getMenu = async (params?: MenuHandlerParams) => {
   return Cache.wrap(
     CacheKey.Menu(params?.depth ?? DEFAULT_DEPTH, params?.parent),
     params?.locale ?? ServerVariables.locale,
-    getMenuHandler(params)
+    getMenuHandler(params),
+    {
+      compressed: true
+    }
   );
 };

package/data/server/product.ts

@@ -143,7 +143,8 @@ export const getProductData = async ({
       headers
     }),
     {
-      expire: 300
+      expire: 300,
+      compressed: true
     }
   );
 };

package/data/server/seo.ts

@@ -43,6 +43,9 @@ export const getSeoData = async (
   return Cache.wrap(
     CacheKey.Seo(url),
     locale,
-    getSeoDataHandler({ url, locale, currency, headers })
+    getSeoDataHandler({ url, locale, currency, headers }),
+    {
+      compressed: true
+    }
   );
 };

package/data/server/special-page.ts

@@ -54,7 +54,8 @@ export const getSpecialPageData = async ({
     locale,
     getSpecialPageDataHandler(pk, locale, currency, searchParams, headers),
     {
-      expire: 300
+      expire: 300,
+      compressed: true
     }
   );
 };

package/data/server/widget.ts

@@ -44,6 +44,9 @@ export const getWidgetData = async <T>({
     CacheKey.Widget(slug),
     locale,
     getWidgetDataHandler(slug, locale, currency, headers),
-    cacheOptions
+    {
+      compressed: true,
+      ...cacheOptions
+    }
   );
 };

package/lib/cache-handler.mjs

@@ -3,7 +3,304 @@ import createLruHandler from '@neshca/cache-handler/local-lru';
 import createRedisHandler from '@neshca/cache-handler/redis-strings';
 import { createClient } from 'redis';
 
-// Cache configuration
+let zstd;
+
+(async () => {
+  try {
+    const { compress, decompress } = await import('@mongodb-js/zstd');
+    zstd = { compress, decompress, type: 'native' };
+    console.log(
+      '[Cache Handler] ✅ Native @mongodb-js/zstd loaded successfully'
+    );
+  } catch (error) {
+    try {
+      const zstdWasm = await import('@bokuweb/zstd-wasm');
+      await zstdWasm.init();
+      zstd = { ...zstdWasm, type: 'wasm' };
+      console.log('[Cache Handler] ⚠️ Fallback to WASM @bokuweb/zstd-wasm');
+    } catch (wasmError) {
+      console.warn(
+        '[Cache Handler] ❌ Both native and WASM zstd failed to load:',
+        error.message,
+        wasmError.message
+      );
+      zstd = false;
+    }
+  }
+})();
+
+const getZstd = () => {
+  return zstd;
+};
+
+const compressValue = async (value) => {
+  try {
+    if (value && typeof value === 'object' && value.value !== undefined) {
+      const nestedValue = value.value;
+      const serializedNestedValue =
+        typeof nestedValue === 'string'
+          ? nestedValue
+          : JSON.stringify(nestedValue);
+      const originalSize = Buffer.byteLength(serializedNestedValue, 'utf8');
+
+      if (originalSize < 1024) {
+        const result = {
+          ...value,
+          tags: Array.isArray(value.tags) ? value.tags : []
+        };
+        return result;
+      }
+
+      const zstdLib = getZstd();
+      let compressed;
+
+      if (zstdLib && zstdLib !== false) {
+        const inputBuffer = Buffer.from(serializedNestedValue, 'utf8');
+
+        if (
+          typeof zstdLib.compress === 'function' &&
+          zstdLib.compress.constructor.name === 'AsyncFunction'
+        ) {
+          compressed = await zstdLib.compress(inputBuffer, 3);
+          console.log(
+            `[Cache Handler] 🚀 Compressed with native zstd: ${inputBuffer.length} → ${compressed.length} bytes`
+          );
+        } else {
+          compressed = zstdLib.compress(inputBuffer, 3);
+          console.log(
+            `[Cache Handler] 🌐 Compressed with WASM zstd: ${inputBuffer.length} → ${compressed.length} bytes`
+          );
+        }
+      } else {
+        return {
+          ...value,
+          tags: Array.isArray(value.tags) ? value.tags : []
+        };
+      }
+
+      const compressedBase64 = Buffer.from(compressed).toString('base64');
+
+      const result = {
+        ...value,
+        tags: Array.isArray(value.tags) ? value.tags : [],
+        lifespan: {
+          ...value.lifespan,
+          expireAge: value.lifespan?.revalidate || value.lifespan?.expireAge,
+          expireAt:
+            value.lifespan?.lastModifiedAt && value.lifespan?.revalidate
+              ? value.lifespan.lastModifiedAt + value.lifespan.revalidate
+              : value.lifespan?.expireAt
+        },
+        value: {
+          __compressed: true,
+          __method: 'zstd',
+          __originalSize: originalSize,
+          __compressedSize: compressed.length,
+          __data: compressedBase64
+        }
+      };
+
+      return result;
+    }
+
+    const serializedValue =
+      typeof value === 'string' ? value : JSON.stringify(value);
+    const originalSize = Buffer.byteLength(serializedValue, 'utf8');
+
+    if (originalSize < 1024) {
+      if (
+        value &&
+        typeof value === 'object' &&
+        value.lastModified === undefined &&
+        value.lifespan === undefined &&
+        value.value === undefined
+      ) {
+        return {
+          ...value,
+          tags: value.tags || [],
+          lastModified: Date.now(),
+          lifespan: {
+            expireAt: Math.floor(Date.now() / 1000) + 3600
+          }
+        };
+      }
+      if (
+        value &&
+        typeof value === 'object' &&
+        value.lifespan &&
+        value.lifespan.revalidate
+      ) {
+        return {
+          ...value,
+          lifespan: {
+            ...value.lifespan,
+            expireAge: value.lifespan.revalidate,
+            expireAt:
+              value.lifespan.lastModifiedAt && value.lifespan.revalidate
+                ? value.lifespan.lastModifiedAt + value.lifespan.revalidate
+                : value.lifespan.expireAt
+          }
+        };
+      }
+      return value;
+    }
+
+    const zstdLib = getZstd();
+    let compressed;
+
+    if (zstdLib && zstdLib !== false) {
+      const inputBuffer = Buffer.from(serializedValue, 'utf8');
+
+      if (
+        typeof zstdLib.compress === 'function' &&
+        zstdLib.compress.constructor.name === 'AsyncFunction'
+      ) {
+        compressed = await zstdLib.compress(inputBuffer, 3);
+        console.log(
+          `[Cache Handler] 🚀 Compressed with native zstd: ${inputBuffer.length} → ${compressed.length} bytes`
+        );
+      } else {
+        compressed = zstdLib.compress(inputBuffer, 3);
+        console.log(
+          `[Cache Handler] 🌐 Compressed with WASM zstd: ${inputBuffer.length} → ${compressed.length} bytes`
+        );
+      }
+    } else {
+      if (
+        value &&
+        typeof value === 'object' &&
+        value.lastModified === undefined &&
+        value.lifespan === undefined &&
+        value.value === undefined
+      ) {
+        return {
+          ...value,
+          tags: value.tags || [],
+          lastModified: Date.now(),
+          lifespan: {
+            expireAt: Math.floor(Date.now() / 1000) + 3600
+          }
+        };
+      }
+      return value;
+    }
+
+    const compressedBase64 = Buffer.from(compressed).toString('base64');
+
+    const compressedResult = {
+      __compressed: true,
+      __method: 'zstd',
+      __originalSize: originalSize,
+      __compressedSize: compressed.length,
+      __data: compressedBase64,
+      tags: [],
+      lastModified: Date.now(),
+      lifespan: { expireAt: Math.floor(Date.now() / 1000) + 3600 }
+    };
+
+    return compressedResult;
+  } catch (error) {
+    console.warn(
+      '[Cache Handler] Compression failed, storing uncompressed:',
+      error.message
+    );
+    return value;
+  }
+};
+
+const decompressValue = async (compressedData) => {
+  try {
+    if (
+      compressedData &&
+      typeof compressedData === 'object' &&
+      compressedData.value &&
+      typeof compressedData.value === 'object' &&
+      compressedData.value.__compressed
+    ) {
+      const compressedNestedValue = compressedData.value;
+      const compressedBuffer = Buffer.from(
+        compressedNestedValue.__data,
+        'base64'
+      );
+      let decompressed;
+
+      if (compressedNestedValue.__method === 'zstd') {
+        const zstdLib = getZstd();
+        if (zstdLib && zstdLib !== false) {
+          if (
+            typeof zstdLib.decompress === 'function' &&
+            zstdLib.decompress.constructor.name === 'AsyncFunction'
+          ) {
+            const decompressedBuffer = await zstdLib.decompress(
+              compressedBuffer
+            );
+            decompressed = decompressedBuffer.toString('utf8');
+            console.log(
+              `[Cache Handler] 🚀 Decompressed with native zstd: ${compressedBuffer.length} → ${decompressedBuffer.length} bytes`
+            );
+          } else {
+            decompressed = zstdLib
+              .decompress(compressedBuffer)
+              .toString('utf8');
+            console.log(
+              `[Cache Handler] 🌐 Decompressed with WASM zstd: ${compressedBuffer.length} → ${decompressed.length} bytes`
+            );
+          }
+        } else {
+          throw new Error('zstd not available for decompression');
+        }
+      }
+
+      return {
+        ...compressedData,
+        value: JSON.parse(decompressed)
+      };
+    }
+
+    if (
+      compressedData &&
+      typeof compressedData === 'object' &&
+      compressedData.__compressed
+    ) {
+      const compressedBuffer = Buffer.from(compressedData.__data, 'base64');
+      let decompressed;
+
+      if (compressedData.__method === 'zstd') {
+        const zstdLib = getZstd();
+        if (zstdLib && zstdLib !== false) {
+          if (
+            typeof zstdLib.decompress === 'function' &&
+            zstdLib.decompress.constructor.name === 'AsyncFunction'
+          ) {
+            const decompressedBuffer = await zstdLib.decompress(
+              compressedBuffer
+            );
+            decompressed = decompressedBuffer.toString('utf8');
+            console.log(
+              `[Cache Handler] 🚀 Decompressed with native zstd: ${compressedBuffer.length} → ${decompressedBuffer.length} bytes`
+            );
+          } else {
+            decompressed = zstdLib
+              .decompress(compressedBuffer)
+              .toString('utf8');
+            console.log(
+              `[Cache Handler] 🌐 Decompressed with WASM zstd: ${compressedBuffer.length} → ${decompressed.length} bytes`
+            );
+          }
+        } else {
+          throw new Error('zstd not available for decompression');
+        }
+      }
+
+      return JSON.parse(decompressed);
+    }
+
+    return compressedData;
+  } catch (error) {
+    return compressedData;
+  }
+};
+
 const CACHE_CONFIG = {
   lru: {
     maxItemCount: 2000
@@ -22,7 +319,6 @@ const CACHE_CONFIG = {
   version: process.env.ACC_APP_VERSION || ''
 };
 
-// Use global to persist across module reloads in development
 const globalForRedis = global;
 if (!globalForRedis.redisClient) {
   globalForRedis.redisClient = null;
@@ -31,42 +327,22 @@ if (!globalForRedis.redisClient) {
   globalForRedis.connectionAttempts = 0;
 }
 
-// Logging configuration
-const debugValue = process.env.NEXT_PRIVATE_DEBUG_CACHE;
-const debug = debugValue === 'true' || debugValue === '1';
-
-let console_log;
-if (debug) {
-  // eslint-disable-next-line no-console
-  console_log = (...args) => console.log('[Cache Handler]', ...args);
-} else {
-  console_log = () => {};
-}
-
 async function getRedisClient() {
-  // If client exists and is ready, return it
   if (globalForRedis.redisClient?.isReady) {
-    console_log('Reusing existing Redis connection');
     return globalForRedis.redisClient;
   }
 
-  // If we're already connecting, wait a bit and retry
   if (globalForRedis.isConnecting) {
     await new Promise((resolve) => setTimeout(resolve, 100));
     return getRedisClient();
   }
 
-  // Start new connection
   globalForRedis.isConnecting = true;
   globalForRedis.connectionAttempts++;
 
   try {
     const redisUrl = `redis://${CACHE_CONFIG.host}:${CACHE_CONFIG.port}/${CACHE_CONFIG.bucket}`;
 
-    if (globalForRedis.connectionAttempts === 1) {
-      console_log('Creating Redis connection:', redisUrl);
-    }
-
     const redisClient = createClient({
       url: redisUrl,
       socket: {
@@ -87,7 +363,6 @@ async function getRedisClient() {
     });
 
     redisClient.on('error', (error) => {
-      // Only log the first connection error to avoid spam
       if (!globalForRedis.hasLoggedConnectionError) {
         if (error.code === 'ECONNREFUSED') {
           console.warn(
@@ -101,12 +376,10 @@ async function getRedisClient() {
     });
 
     redisClient.on('connect', () => {
-      console_log('Redis connected');
       globalForRedis.hasLoggedConnectionError = false;
     });
 
     redisClient.on('ready', () => {
-      console_log('Redis ready');
       globalForRedis.hasLoggedConnectionError = false;
     });
 
@@ -115,16 +388,6 @@ async function getRedisClient() {
     return redisClient;
   } catch (error) {
     if (!globalForRedis.hasLoggedConnectionError) {
-      if (error.code === 'ECONNREFUSED') {
-        console.warn(
-          '[Cache Handler] Could not connect to Redis - using local cache only'
-        );
-      } else {
-        console.error(
-          '[Cache Handler] Failed to connect to Redis:',
-          error.message
-        );
-      }
       globalForRedis.hasLoggedConnectionError = true;
     }
     globalForRedis.redisClient = null;
@@ -135,13 +398,10 @@ async function getRedisClient() {
 }
 
 CacheHandler.onCreation(async () => {
-  console_log('Initializing cache handlers...');
-
   let client;
   try {
     client = await getRedisClient();
   } catch (error) {
-    // Error already logged in getRedisClient, just return local handler
     return {
       handlers: [createLruHandler(CACHE_CONFIG.lru)]
     };
@@ -150,98 +410,183 @@ CacheHandler.onCreation(async () => {
   const redisHandler = createRedisHandler({
     client,
     timeoutMs: CACHE_CONFIG.redis.timeoutMs,
-    keyExpirationStrategy: 'EXAT'
+    keyExpirationStrategy: 'EXPIREAT'
   });
 
   const localHandler = createLruHandler(CACHE_CONFIG.lru);
 
-  // Pre-compute version prefix if exists
-  const versionPrefix = CACHE_CONFIG.version ? `${CACHE_CONFIG.version}:` : '';
-
-  // Create optimized functions for each scenario
-  const versionKeyString = versionPrefix
-    ? (key) => `${versionPrefix}${key}`
-    : (key) => key;
+  const CACHE_VERSION = 'v2';
+  const versionPrefix = `${CACHE_VERSION}_`;
 
-  const versionKeyObject = versionPrefix
-    ? (key) => ({ ...key, key: `${versionPrefix}${key.key}` })
-    : (key) => key;
+  const versionKeyString = (key) => `${versionPrefix}${key}`;
+  const versionKeyObject = (key) => ({
+    ...key,
+    key: `${versionPrefix}${key.key}`
+  });
 
-  // Main version key function that routes to optimized paths
   const versionKey = (key) => {
     return typeof key === 'string'
       ? versionKeyString(key)
       : versionKeyObject(key);
   };
 
-  // Create a custom handler that checks local first, then Redis
   const customHandler = {
     name: 'custom-local-then-redis',
     get: async (key, context) => {
       const vKey = versionKey(key);
-      console_log(
-        'GET called for key:',
-        typeof vKey === 'string' ? vKey : vKey?.key
-      );
 
-      // Check local cache first
-      console_log('Checking local cache...');
       const localResult = await localHandler.get(vKey, context);
 
       if (localResult) {
-        console_log('Found in local cache');
+        if (
+          localResult &&
+          typeof localResult === 'object' &&
+          (localResult.__compressed ||
+            (localResult.value && localResult.value.__compressed) ||
+            localResult.compressed !== undefined)
+        ) {
+          try {
+            const decompressed = await decompressValue(localResult);
+            return typeof decompressed === 'string'
+              ? JSON.parse(decompressed)
+              : decompressed;
+          } catch (error) {
+            console.warn(
+              '[Cache Handler] Failed to decompress local cache value:',
+              error.message
+            );
+            return localResult;
+          }
+        }
+
         return localResult;
       }
 
-      console_log('Not found in local, checking Redis...');
       try {
         const redisResult = await redisHandler.get(vKey, context);
 
         if (redisResult) {
-          console_log('Found in Redis');
-          // Sync back to local cache for faster future access
+          let finalResult = redisResult;
+
+          if (typeof redisResult === 'string') {
+            try {
+              finalResult = JSON.parse(redisResult);
+            } catch (parseError) {
+              finalResult = redisResult;
+            }
+          }
+
+          if (
+            finalResult &&
+            typeof finalResult === 'object' &&
+            (finalResult.__compressed ||
+              (finalResult.value && finalResult.value.__compressed) ||
+              finalResult.compressed !== undefined)
+          ) {
+            try {
+              const decompressed = await decompressValue(finalResult);
+              finalResult =
+                typeof decompressed === 'string'
+                  ? JSON.parse(decompressed)
+                  : decompressed;
+            } catch (error) {
+              console.warn(
+                '[Cache Handler] Failed to decompress Redis cache value:',
+                error.message
+              );
+            }
+          }
+
           try {
-            await localHandler.set(vKey, redisResult, context);
-            console_log('Synced to local cache');
+            await localHandler.set(vKey, finalResult, context);
           } catch (error) {
-            console_log('Failed to sync to local:', error.message);
+            console.warn(
+              '[Cache Handler] Failed to sync to local:',
+              error.message
+            );
           }
-          return redisResult;
+          return finalResult;
         }
       } catch (error) {
-        console_log('Redis error:', error.message);
+        console.warn('[Cache Handler] Redis error:', error.message);
       }
 
-      console_log('Not found in any cache');
       return undefined;
     },
     set: async (key, value, context) => {
       const vKey = versionKey(key);
-      console_log(
-        'SET called for key:',
-        typeof vKey === 'string' ? vKey : vKey?.key
-      );
-      // Set to both caches
-      await Promise.allSettled([
-        localHandler.set(vKey, value, context),
-        redisHandler
-          .set(vKey, value, context)
-          .catch((error) => console_log('Redis SET error:', error.message))
-      ]);
+
+      let compressedValue;
+      let shouldUseCompressed = false;
+
+      try {
+        compressedValue = await compressValue(value);
+
+        shouldUseCompressed =
+          compressedValue !== value &&
+          (compressedValue?.__compressed ||
+            compressedValue?.value?.__compressed);
+      } catch (error) {
+        console.warn(
+          '[Cache Handler] Compression failed, using original value:',
+          error.message
+        );
+        compressedValue = value;
+        shouldUseCompressed = false;
+      }
+
+      let redisSetResult;
+
+      if (shouldUseCompressed) {
+        try {
+          await redisHandler.set(vKey, compressedValue, context);
+
+          redisSetResult = { status: 'fulfilled' };
+        } catch (compressionError) {
+          try {
+            await redisHandler.set(vKey, value, context);
+
+            redisSetResult = { status: 'fulfilled' };
+          } catch (fallbackError) {
+            redisSetResult = { status: 'rejected', reason: fallbackError };
+          }
+        }
+      } else {
+        try {
+          await redisHandler.set(vKey, value, context);
+          redisSetResult = { status: 'fulfilled' };
+        } catch (error) {
+          redisSetResult = { status: 'rejected', reason: error };
+        }
+      }
+
+      let localSetResult;
+      try {
+        await localHandler.set(vKey, value, context);
+        localSetResult = { status: 'fulfilled' };
+      } catch (error) {
+        localSetResult = { status: 'rejected', reason: error };
+      }
+
+      const results = [localSetResult, redisSetResult];
+
+      console.warn('SET Results:', {
+        local: results[0].status,
+        redis: results[1].status,
+        localError: results[0].reason?.message,
+        redisError: results[1].reason?.message,
+        compressionUsed: shouldUseCompressed
+      });
     },
     delete: async (key, context) => {
       const vKey = versionKey(key);
-      console_log(
-        'DELETE called for key:',
-        typeof vKey === 'string' ? vKey : vKey?.key
-      );
+
       await Promise.allSettled([
         localHandler.delete?.(vKey, context),
         redisHandler.delete?.(vKey, context)
       ]);
     },
     revalidateTag: async (tags, context) => {
-      console_log('REVALIDATE_TAG called for tags:', tags);
       await Promise.allSettled([
         localHandler.revalidateTag?.(tags, context),
         redisHandler.revalidateTag?.(tags, context)
@@ -249,8 +594,6 @@ CacheHandler.onCreation(async () => {
     }
   };
 
-  console_log('[Cache Handler] Handlers initialized successfully');
-
   return {
     handlers: [customHandler]
   };

package/lib/cache.ts

@@ -3,6 +3,65 @@ import { RedisClientType } from 'redis';
 import Settings from 'settings';
 import { CacheOptions } from '../types';
 import logger from '../utils/log';
+const CACHE_VERSION = 'v2';
+
+const compressData = async (data: string): Promise<Uint8Array> => {
+  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;
+};
+
+const decompressData = async (compressed: Uint8Array): Promise<string> => {
+  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);
+};
 
 const hashCacheKey = (object?: Record<string, string>) => {
   if (!object) {
@@ -60,8 +119,32 @@ export const CacheKey = {
 export class Cache {
   static PROXY_URL = `${process.env.NEXT_PUBLIC_URL}/api/cache`;
 
+  private static serializeValue(value: any): string {
+    return typeof value === 'object' ? JSON.stringify(value) : String(value);
+  }
+
+  private static validateKey(key: string): boolean {
+    return !(!key || key.trim() === '');
+  }
+
+  private static validateKeyValuePairs(keyValuePairs: Record<string, any>): {
+    isValid: boolean;
+    invalidKeys: string[];
+  } {
+    if (!keyValuePairs || Object.keys(keyValuePairs).length === 0) {
+      return { isValid: false, invalidKeys: [] };
+    }
+
+    const invalidKeys = Object.keys(keyValuePairs).filter(
+      (key) => !this.validateKey(key)
+    );
+    return { isValid: invalidKeys.length === 0, invalidKeys };
+  }
+
   static formatKey(key: string, locale: string) {
-    return encodeURIComponent(`${Settings.commerceUrl}_${locale}_${key}`);
+    return encodeURIComponent(
+      `${CACHE_VERSION}_${Settings.commerceUrl}_${locale}_${key}`
+    );
   }
 
   static clientPool: Pool<RedisClientType> = createPool(
@@ -98,9 +181,9 @@ export class Cache {
     return await Cache.clientPool.acquire();
   }
 
-  static async get(key: string) {
-    let value;
-    let client;
+  static async get(key: string): Promise<any> {
+    let value: any;
+    let client: RedisClientType | undefined;
 
     try {
       client = await Cache.getClient();
@@ -110,9 +193,7 @@ export class Cache {
       } else {
         value = null;
       }
-      logger.debug('Redis get success', { key, value });
     } catch (error) {
-      logger.error('Redis get error', { key, error });
       value = null;
     } finally {
       if (client) {
@@ -123,14 +204,13 @@ export class Cache {
     return value;
   }
 
-  static async set(key: string, value: any, expire?: number) {
+  static async set(key: string, value: any, expire?: number): Promise<boolean> {
     let success = false;
-    let client;
+    let client: RedisClientType | undefined;
 
     try {
       client = await Cache.getClient();
-      const serializedValue =
-        typeof value === 'object' ? JSON.stringify(value) : value;
+      const serializedValue = Cache.serializeValue(value);
 
       if (expire) {
         await client.set(key, serializedValue, { EX: expire });
@@ -139,9 +219,7 @@ export class Cache {
       }
 
       success = true;
-      logger.debug('Redis set success', { key, value });
     } catch (error) {
-      logger.error('Redis set error', { key, error });
       success = false;
     } finally {
       if (client) {
@@ -170,7 +248,8 @@ export class Cache {
 
     const defaultOptions: CacheOptions = {
       cache: true,
-      expire: Settings.redis.defaultExpirationTime
+      expire: Settings.redis.defaultExpirationTime,
+      compressed: process.env.CACHE_COMPRESSION_ENABLED !== 'false'
     };
 
     const _options = Object.assign(defaultOptions, options);
@@ -180,21 +259,22 @@ export class Cache {
       _options.expire = 120;
     }
 
-    logger.debug('Cache wrap', { key, formattedKey, _options });
-
     if (_options.cache) {
-      let cachedValue;
+      let cachedValue: any;
 
       if (_options.useProxy) {
         const body = new URLSearchParams();
 
         body.append('key', formattedKey);
+        if (_options.compressed) {
+          body.append('compressed', 'true');
+        }
 
         cachedValue = await Cache.proxyRequest('POST', body);
-        logger.debug('Cache proxy request success', { key });
-        logger.trace('Cache proxy request', { key, cachedValue });
       } else {
-        cachedValue = await Cache.get(formattedKey);
+        cachedValue = _options.compressed
+          ? await Cache.getCompressed(formattedKey)
+          : await Cache.get(formattedKey);
       }
 
       if (cachedValue) {
@@ -202,8 +282,6 @@ export class Cache {
       }
     }
 
-    logger.debug('Redis cache miss. Setting new value...', { key });
-
     const data = await handler();
 
     if (data && _options.cache) {
@@ -217,14 +295,19 @@ export class Cache {
             'expire',
             String(_options?.expire ?? Settings.redis.defaultExpirationTime)
           );
+          if (_options.compressed) {
+            body.append('compressed', 'true');
+          }
           await Cache.proxyRequest('PUT', body);
-
-          logger.debug('Cache proxy request', { key, body: body.toString() });
         } catch (error) {
           logger.error('Cache proxy error', error);
         }
       } else {
-        await Cache.set(formattedKey, JSON.stringify(data), _options?.expire);
+        if (_options.compressed) {
+          await Cache.setCompressed(formattedKey, data, _options?.expire);
+        } else {
+          await Cache.set(formattedKey, JSON.stringify(data), _options?.expire);
+        }
       }
     }
 
@@ -236,7 +319,7 @@ export class Cache {
       await fetch(Cache.PROXY_URL, {
         method,
         headers: {
-          authorization: process.env.CACHE_SECRET
+          authorization: process.env.CACHE_SECRET || ''
         },
         body
       })
@@ -244,4 +327,148 @@ export class Cache {
 
     return response;
   }
+
+  static async mset(
+    keyValuePairs: Record<string, any>,
+    expire?: number
+  ): Promise<boolean> {
+    const validation = Cache.validateKeyValuePairs(keyValuePairs);
+    if (!validation.isValid) {
+      if (validation.invalidKeys.length > 0) {
+        logger.error('Invalid keys in mset', {
+          invalidKeys: validation.invalidKeys
+        });
+      } else {
+        logger.warn('mset called with empty keyValuePairs');
+      }
+      return false;
+    }
+
+    let success = false;
+    let client: RedisClientType | undefined;
+
+    try {
+      client = await Cache.getClient();
+      const pipeline = client.multi();
+
+      Object.entries(keyValuePairs).forEach(([key, value]) => {
+        const serializedValue = Cache.serializeValue(value);
+        if (expire) {
+          pipeline.set(key, serializedValue, { EX: expire });
+        } else {
+          pipeline.set(key, serializedValue);
+        }
+      });
+
+      const results = await pipeline.exec();
+
+      const failures =
+        results?.filter((result) => result instanceof Error) || [];
+
+      if (failures.length > 0) {
+        success = false;
+      } else {
+        success = true;
+      }
+    } catch (error) {
+      success = false;
+    } finally {
+      if (client) {
+        await Cache.clientPool.release(client);
+      }
+    }
+
+    return success;
+  }
+
+  static async setCompressed(
+    key: string,
+    value: any,
+    expire?: number
+  ): Promise<boolean> {
+    if (!Cache.validateKey(key)) {
+      return false;
+    }
+
+    let success = false;
+    let client: RedisClientType | undefined;
+
+    try {
+      client = await Cache.getClient();
+      const serializedValue = Cache.serializeValue(value);
+
+      try {
+        const compressed = await compressData(serializedValue);
+        const compressedBase64 = Buffer.from(compressed).toString('base64');
+
+        if (expire) {
+          await client.set(key, compressedBase64, { EX: expire });
+        } else {
+          await client.set(key, compressedBase64);
+        }
+
+        success = true;
+      } catch (compressionError) {
+        if (expire) {
+          await client.set(key, serializedValue, { EX: expire });
+        } else {
+          await client.set(key, serializedValue);
+        }
+
+        success = true;
+      }
+    } catch (error) {
+      success = false;
+    } finally {
+      if (client) {
+        await Cache.clientPool.release(client);
+      }
+    }
+
+    return success;
+  }
+
+  static async getCompressed(key: string): Promise<unknown> {
+    if (!Cache.validateKey(key)) {
+      return null;
+    }
+
+    let value: unknown;
+    let client: RedisClientType | undefined;
+
+    try {
+      client = await Cache.getClient();
+      const compressed = await client.get(key);
+
+      if (compressed) {
+        const compressedBuffer = Buffer.from(compressed, 'base64');
+
+        try {
+          const decompressedString = await decompressData(
+            new Uint8Array(compressedBuffer)
+          );
+          value = JSON.parse(decompressedString);
+          return value;
+        } catch (decompressionError) {
+          try {
+            const rawString = compressed;
+            const parsedData = JSON.parse(rawString);
+            return parsedData;
+          } catch (jsonError) {
+            return null;
+          }
+        }
+      } else {
+        value = null;
+      }
+    } catch (error) {
+      value = null;
+    } finally {
+      if (client) {
+        await Cache.clientPool.release(client);
+      }
+    }
+
+    return value;
+  }
 }

package/middlewares/pretty-url.ts

@@ -53,7 +53,8 @@ const resolvePrettyUrl = async (
     locale,
     resolvePrettyUrlHandler(pathname, ip),
     {
-      useProxy: true
+      useProxy: true,
+      compressed: true
     }
   );
 };

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@akinon/next",
   "description": "Core package for Project Zero Next",
-  "version": "1.95.0-rc.54",
+  "version": "1.95.0-snapshot-ZERO-3586-20250901140025",
   "private": false,
   "license": "MIT",
   "bin": {
@@ -17,13 +17,15 @@
     "test": "jest"
   },
   "dependencies": {
+    "@bokuweb/zstd-wasm": "^0.0.27",
+    "@mongodb-js/zstd": "^2.0.1",
+    "@neshca/cache-handler": "1.9.0",
     "@opentelemetry/exporter-trace-otlp-http": "0.46.0",
     "@opentelemetry/resources": "1.19.0",
     "@opentelemetry/sdk-node": "0.46.0",
     "@opentelemetry/sdk-trace-node": "1.19.0",
     "@opentelemetry/semantic-conventions": "1.19.0",
     "@reduxjs/toolkit": "1.9.7",
-    "@neshca/cache-handler": "1.9.0",
     "@sentry/nextjs": "9.5.0",
     "cross-spawn": "7.0.3",
     "generic-pool": "3.9.0",
@@ -34,7 +36,7 @@
     "set-cookie-parser": "2.6.0"
   },
   "devDependencies": {
-    "@akinon/eslint-plugin-projectzero": "1.95.0-rc.54",
+    "@akinon/eslint-plugin-projectzero": "1.95.0-snapshot-ZERO-3586-20250901140025",
     "@babel/core": "7.26.10",
     "@babel/preset-env": "7.26.9",
     "@babel/preset-typescript": "7.27.0",

package/types/index.ts

@@ -222,6 +222,7 @@ export interface CacheOptions {
   cache?: boolean;
   expire?: number;
   useProxy?: boolean;
+  compressed?: boolean;
 }
 
 export interface SetCookieOptions {

package/with-pz-config.js

@@ -17,7 +17,7 @@ const defaultConfig = {
       {
         protocol: 'https',
         hostname: '**'
-      },
+      }
     ]
   },
   modularizeImports: {
@@ -57,6 +57,7 @@ const defaultConfig = {
       }, {}),
       translations: false
     };
+
     return config;
   },
   sentry: {