@akinon/next 1.93.0-rc.52 → 1.93.0-snapshot-ZERO-3586-20250826205340

package/CHANGELOG.md

@@ -1,5 +1,86 @@
 # @akinon/next
 
+## 1.93.0-snapshot-ZERO-3586-20250826205340
+
+### 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
+- 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
+- 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
+- 0ad91bb: 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
+- 89ce46f: 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
+- c806fad7: ZERO-3422: Add Flow Payment plugin to the defined plugins list
+- 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
+- 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
+- c39c7000: ZERO-3420: Refactor Modal component
+- e7cd3a5e: ZERO-3435: Add Accept-Language to requestHeaders
+- 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
+- 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
+- dfaceffd: ZERO-3356: Add useLoyaltyAvailability hook and update checkout state management
+- 86642cf: ZERO-3531: Add saveSampleProducts endpoint and update URLs in checkout
+- 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
+- 485e8ef8: ZERO-3422: Refactor parameter handling in wallet complete redirection middleware to use forEach
+- 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
+- a420947: 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
+- acd2afd: 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
+- 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
+
 ## 1.93.0-rc.52
 
 ## 1.93.0-rc.51

package/api/cache.ts

@@ -21,20 +21,33 @@ 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 };
 
   formData.forEach((value, key) => {
     body[key] = value;
   });
 
-  const { key, value, expire } = body;
+  const { key, value, expire, keyValuePairs } = body;
   let response: string | boolean;
 
   try {
     if (req.method === 'POST') {
       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 {
+        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 // Compress category data for memory savings
     }
   );
 };

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/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/lib/cache.ts

@@ -3,6 +3,11 @@ import { RedisClientType } from 'redis';
 import Settings from 'settings';
 import { CacheOptions } from '../types';
 import logger from '../utils/log';
+import { gzip, gunzip } from 'zlib';
+import { promisify } from 'util';
+
+const gzipAsync = promisify(gzip);
+const gunzipAsync = promisify(gunzip);
 
 const hashCacheKey = (object?: Record<string, string>) => {
   if (!object) {
@@ -60,6 +65,28 @@ 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}`);
   }
@@ -98,9 +125,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();
@@ -123,14 +150,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 });
@@ -183,7 +209,7 @@ export class Cache {
     logger.debug('Cache wrap', { key, formattedKey, _options });
 
     if (_options.cache) {
-      let cachedValue;
+      let cachedValue: any;
 
       if (_options.useProxy) {
         const body = new URLSearchParams();
@@ -194,7 +220,9 @@ export class Cache {
         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) {
@@ -224,7 +252,11 @@ export class Cache {
           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);
+        }
       }
     }
 
@@ -244,4 +276,183 @@ 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) {
+        logger.warn('Some mset operations failed', {
+          totalOperations: results?.length || 0,
+          failures: failures.length,
+          keys: Object.keys(keyValuePairs)
+        });
+        success = false;
+      } else {
+        success = true;
+        logger.debug('Redis mset success', {
+          keys: Object.keys(keyValuePairs),
+          expire,
+          operationsCount: Object.keys(keyValuePairs).length
+        });
+      }
+    } catch (error) {
+      logger.error('Redis mset error', {
+        keys: Object.keys(keyValuePairs),
+        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)) {
+      logger.error('Invalid key in setCompressed', { key });
+      return false;
+    }
+
+    let success = false;
+    let client: RedisClientType | undefined;
+
+    try {
+      client = await Cache.getClient();
+      const serializedValue = Cache.serializeValue(value);
+
+      if (serializedValue.length > 1024 * 1024) {
+        logger.warn('Large data being compressed', {
+          key,
+          size: serializedValue.length
+        });
+      }
+
+      const compressed = await gzipAsync(Buffer.from(serializedValue, 'utf8'));
+
+      if (expire) {
+        await client.set(key, compressed, { EX: expire });
+      } else {
+        await client.set(key, compressed);
+      }
+
+      success = true;
+      const compressionRatio = (
+        (1 - compressed.length / serializedValue.length) *
+        100
+      ).toFixed(2);
+      logger.debug('Redis setCompressed success', {
+        key,
+        originalSize: serializedValue.length,
+        compressedSize: compressed.length,
+        compressionRatio: `${compressionRatio}%`
+      });
+    } catch (error) {
+      logger.error('Redis setCompressed error', { key, error });
+      success = false;
+    } finally {
+      if (client) {
+        await Cache.clientPool.release(client);
+      }
+    }
+
+    return success;
+  }
+
+  static async getCompressed(
+    key: string,
+    maxDecompressedSize: number = 10 * 1024 * 1024
+  ): Promise<any> {
+    if (!Cache.validateKey(key)) {
+      logger.error('Invalid key in getCompressed', { key });
+      return null;
+    }
+
+    let value: any;
+    let client: RedisClientType | undefined;
+
+    try {
+      client = await Cache.getClient();
+      const compressed = await client.get(key);
+
+      if (compressed) {
+        const compressedBuffer = Buffer.isBuffer(compressed)
+          ? compressed
+          : Buffer.from(compressed, 'binary');
+
+        const decompressed = await gunzipAsync(compressedBuffer as any);
+
+        if (decompressed.length > maxDecompressedSize) {
+          logger.error('Decompressed data exceeds size limit', {
+            key,
+            size: decompressed.length,
+            limit: maxDecompressedSize
+          });
+          throw new Error(
+            `Decompressed data too large: ${decompressed.length} bytes`
+          );
+        }
+
+        value = JSON.parse(decompressed.toString('utf8'));
+
+        logger.debug('Redis getCompressed success', {
+          key,
+          compressedSize: compressedBuffer.length,
+          decompressedSize: decompressed.length
+        });
+      } else {
+        value = null;
+        logger.debug('Redis getCompressed: key not found', { key });
+      }
+    } catch (error) {
+      logger.error('Redis getCompressed error', { key, error });
+      value = null;
+    } finally {
+      if (client) {
+        await Cache.clientPool.release(client);
+      }
+    }
+
+    return value;
+  }
 }

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@akinon/next",
   "description": "Core package for Project Zero Next",
-  "version": "1.93.0-rc.52",
+  "version": "1.93.0-snapshot-ZERO-3586-20250826205340",
   "private": false,
   "license": "MIT",
   "bin": {
@@ -34,7 +34,7 @@
     "set-cookie-parser": "2.6.0"
   },
   "devDependencies": {
-    "@akinon/eslint-plugin-projectzero": "1.93.0-rc.52",
+    "@akinon/eslint-plugin-projectzero": "1.93.0-snapshot-ZERO-3586-20250826205340",
     "@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 {