@akinon/next 1.93.0-snapshot-ZERO-3586-20250828143733 → 1.94.0

package/lib/cache.ts

@@ -3,127 +3,6 @@ import { RedisClientType } from 'redis';
 import Settings from 'settings';
 import { CacheOptions } from '../types';
 import logger from '../utils/log';
-const CACHE_VERSION = 'v2';
-
-const colors = {
-  red: '\x1b[31m',
-  green: '\x1b[32m',
-  yellow: '\x1b[33m',
-  blue: '\x1b[34m',
-  magenta: '\x1b[35m',
-  cyan: '\x1b[36m',
-  white: '\x1b[37m',
-  reset: '\x1b[0m',
-  bright: '\x1b[1m'
-};
-
-const colorLog = (color: string, prefix: string, ...args: any[]) => {
-  // eslint-disable-next-line no-console
-  console.log(`${colors.bright}${color}${prefix}${colors.reset}`, ...args);
-};
-
-colorLog(
-  colors.green,
-  '[Cache] 🚀 ',
-  'Web API compression initialized successfully at module load'
-);
-logger.debug('Web API compression initialized successfully at module load');
-
-const extractUrlFromKey = (key: string): string => {
-  try {
-    const decoded = decodeURIComponent(key);
-    const urlMatch =
-      decoded.match(/https?:\/\/[^\s]+/) || decoded.match(/\/[^\s]*/);
-    return urlMatch ? urlMatch[0] : 'unknown';
-  } catch {
-    return 'unknown';
-  }
-};
-
-// Web API compression for edge runtime compatibility
-const compressData = async (data: string): Promise<Uint8Array> => {
-  if (typeof CompressionStream !== 'undefined') {
-    // Use Web API compression (edge runtime)
-    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;
-  } else {
-    // Node.js fallback (server runtime)
-    const { deflate } = await import('zlib');
-    const { promisify } = await import('util');
-    const deflateAsync = promisify(deflate);
-    const inputBuffer = Buffer.from(data, 'utf8');
-    const compressed = await deflateAsync(inputBuffer);
-    return new Uint8Array(
-      compressed.buffer,
-      compressed.byteOffset,
-      compressed.byteLength
-    );
-  }
-};
-
-// Web API decompression for edge runtime compatibility
-const decompressData = async (compressed: Uint8Array): Promise<string> => {
-  if (typeof DecompressionStream !== 'undefined') {
-    // Use Web API decompression (edge runtime)
-    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);
-  } else {
-    // Node.js fallback (server runtime)
-    const { inflate } = await import('zlib');
-    const { promisify } = await import('util');
-    const inflateAsync = promisify(inflate);
-    const decompressed = await inflateAsync(Buffer.from(compressed));
-    return decompressed.toString('utf8');
-  }
-};
 
 const hashCacheKey = (object?: Record<string, string>) => {
   if (!object) {
@@ -152,8 +31,6 @@ export const CacheKey = {
     `category_${pk}_${encodeURIComponent(
       JSON.stringify(searchParams)
     )}${hashCacheKey(headers)}`,
-  Basket: (namespace?: string) => `basket${namespace ? `_${namespace}` : ''}`,
-  AllBaskets: () => 'all_baskets',
   CategorySlug: (slug: string) => `category_${slug}`,
   SpecialPage: (
     pk: number,
@@ -181,32 +58,8 @@ 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(
-      `${CACHE_VERSION}_${Settings.commerceUrl}_${locale}_${key}`
-    );
+    return encodeURIComponent(`${Settings.commerceUrl}_${locale}_${key}`);
   }
 
   static clientPool: Pool<RedisClientType> = createPool(
@@ -243,9 +96,9 @@ export class Cache {
     return await Cache.clientPool.acquire();
   }
 
-  static async get(key: string): Promise<any> {
-    let value: any;
-    let client: RedisClientType | undefined;
+  static async get(key: string) {
+    let value;
+    let client;
 
     try {
       client = await Cache.getClient();
@@ -268,13 +121,14 @@ export class Cache {
     return value;
   }
 
-  static async set(key: string, value: any, expire?: number): Promise<boolean> {
+  static async set(key: string, value: any, expire?: number) {
     let success = false;
-    let client: RedisClientType | undefined;
+    let client;
 
     try {
       client = await Cache.getClient();
-      const serializedValue = Cache.serializeValue(value);
+      const serializedValue =
+        typeof value === 'object' ? JSON.stringify(value) : value;
 
       if (expire) {
         await client.set(key, serializedValue, { EX: expire });
@@ -314,8 +168,7 @@ export class Cache {
 
     const defaultOptions: CacheOptions = {
       cache: true,
-      expire: Settings.redis.defaultExpirationTime,
-      compressed: process.env.CACHE_COMPRESSION_ENABLED !== 'false'
+      expire: Settings.redis.defaultExpirationTime
     };
 
     const _options = Object.assign(defaultOptions, options);
@@ -328,23 +181,18 @@ export class Cache {
     logger.debug('Cache wrap', { key, formattedKey, _options });
 
     if (_options.cache) {
-      let cachedValue: any;
+      let cachedValue;
 
       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 = _options.compressed
-          ? await Cache.getCompressed(formattedKey)
-          : await Cache.get(formattedKey);
+        cachedValue = await Cache.get(formattedKey);
       }
 
       if (cachedValue) {
@@ -367,9 +215,6 @@ 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() });
@@ -377,11 +222,7 @@ export class Cache {
           logger.error('Cache proxy error', error);
         }
       } else {
-        if (_options.compressed) {
-          await Cache.setCompressed(formattedKey, data, _options?.expire);
-        } else {
-          await Cache.set(formattedKey, JSON.stringify(data), _options?.expire);
-        }
+        await Cache.set(formattedKey, JSON.stringify(data), _options?.expire);
       }
     }
 
@@ -393,7 +234,7 @@ export class Cache {
       await fetch(Cache.PROXY_URL, {
         method,
         headers: {
-          authorization: process.env.CACHE_SECRET || ''
+          authorization: process.env.CACHE_SECRET
         },
         body
       })
@@ -401,264 +242,4 @@ 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 url = extractUrlFromKey(key);
-
-      logger.debug('setCompressed called', {
-        key,
-        url,
-        dataSize: serializedValue.length
-      });
-
-      try {
-        colorLog(
-          colors.magenta,
-          '[Cache] 🟣 ',
-          `Using GZIP compression for: ${url}`
-        );
-        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;
-        const compressionRatio = (
-          (1 - compressed.length / serializedValue.length) *
-          100
-        ).toFixed(1);
-        colorLog(
-          colors.magenta,
-          '[Cache] 🟣 ',
-          `Compressed ${serializedValue.length} → ${compressed.length} bytes (${compressionRatio}% reduction) for: ${url}`
-        );
-        logger.debug('Redis setCompressed success', {
-          key,
-          url,
-          originalSize: serializedValue.length,
-          compressedSize: compressed.length,
-          compressionRatio: `${compressionRatio}%`,
-          method: 'gzip'
-        });
-      } catch (compressionError) {
-        colorLog(
-          colors.yellow,
-          '[Cache] ⚠️ ',
-          `Compression failed, storing uncompressed for: ${url}`
-        );
-        logger.warn('Compression failed, storing uncompressed', {
-          key,
-          url,
-          error: compressionError
-        });
-
-        if (expire) {
-          await client.set(key, serializedValue, { EX: expire });
-        } else {
-          await client.set(key, serializedValue);
-        }
-
-        success = true;
-        logger.debug('Redis set success (uncompressed)', {
-          key,
-          url,
-          size: serializedValue.length
-        });
-      }
-    } 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<unknown> {
-    if (!Cache.validateKey(key)) {
-      logger.error('Invalid key in getCompressed', { 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');
-
-        const url = extractUrlFromKey(key);
-
-        try {
-          colorLog(
-            colors.magenta,
-            '[Cache] 🟣 ',
-            `Using GZIP decompression for: ${url}`
-          );
-          const decompressedString = await decompressData(
-            new Uint8Array(compressedBuffer)
-          );
-          value = JSON.parse(decompressedString);
-          colorLog(
-            colors.magenta,
-            '[Cache] 🟣 ',
-            `Decompressed ${compressedBuffer.length} → ${decompressedString.length} bytes for: ${url}`
-          );
-          logger.debug('Redis getCompressed success', {
-            key,
-            url,
-            compressedSize: compressedBuffer.length,
-            decompressedSize: decompressedString.length,
-            method: 'gzip'
-          });
-          return value;
-        } catch (decompressionError) {
-          colorLog(
-            colors.yellow,
-            '[Cache] ⚠️ ',
-            `Decompression failed, trying uncompressed for: ${url}`
-          );
-          logger.debug('Decompression failed, trying direct JSON parse', {
-            key,
-            url,
-            error: decompressionError
-          });
-
-          try {
-            const rawString = compressed;
-            const parsedData = JSON.parse(rawString);
-            logger.debug('Data read as uncompressed', {
-              key,
-              url
-            });
-            return parsedData;
-          } catch (jsonError) {
-            logger.error('Failed to parse data in all formats', {
-              key,
-              url,
-              decompressionError,
-              jsonError
-            });
-            return null;
-          }
-        }
-      } 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/middlewares/checkout-provider.ts

@@ -64,7 +64,7 @@ const withCheckoutProvider =
           const location = request.headers.get('location');
           const redirectUrl = new URL(
             request.headers.get('location'),
-            location.startsWith('http') ? '' : url.origin
+            location.startsWith('http') ? '' : process.env.NEXT_PUBLIC_URL
           );
 
           redirectUrl.pathname = getUrlPathWithLocale(

package/middlewares/complete-gpay.ts

@@ -148,8 +148,7 @@ const withCompleteGpay =
       logger.info('Redirecting to order success page', {
         middleware: 'complete-gpay',
         redirectUrlWithLocale,
-        ip,
-        setCookie: request.headers.get('set-cookie')
+        ip
       });
 
       // Using POST method while redirecting causes an error,

package/middlewares/complete-masterpass.ts

@@ -149,8 +149,7 @@ const withCompleteMasterpass =
       logger.info('Redirecting to order success page', {
         middleware: 'complete-masterpass',
         redirectUrlWithLocale,
-        ip,
-        setCookie: request.headers.get('set-cookie')
+        ip
       });
 
       // Using POST method while redirecting causes an error,

package/middlewares/default.ts

@@ -302,6 +302,19 @@ const withPzDefault =
                                     )}`;
                                 }
 
+                                if (
+                                  !req.middlewareParams.found &&
+                                  Settings.customNotFoundEnabled
+                                ) {
+                                  const pathname = url.pathname
+                                    .replace(/\/+$/, '')
+                                    .split('/');
+                                  url.pathname = url.pathname.replace(
+                                    pathname.pop(),
+                                    'pz-not-found'
+                                  );
+                                }
+
                                 Settings.rewrites.forEach((rewrite) => {
                                   url.pathname = url.pathname.replace(
                                     rewrite.source,
@@ -339,24 +352,6 @@ const withPzDefault =
                                   middlewareResult = NextResponse.rewrite(url);
                                 }
 
-                                if (
-                                  !req.middlewareParams.found &&
-                                  Settings.customNotFoundEnabled
-                                ) {
-                                  const pathSegments = url.pathname
-                                    .replace(/\/+$/, '')
-                                    .split('/');
-                                  if (pathSegments.length >= 3) {
-                                    url.pathname = `/${pathSegments[1]}/${pathSegments[2]}/pz-not-found`;
-                                  } else {
-                                    url.pathname = '/pz-not-found';
-                                  }
-
-                                  middlewareResult = NextResponse.rewrite(url, {
-                                    status: 404
-                                  });
-                                }
-
                                 const { localeUrlStrategy } =
                                   Settings.localization;
 
@@ -406,38 +401,6 @@ const withPzDefault =
                                   }
                                 );
 
-                                if (
-                                  !url.pathname.startsWith(
-                                    `/${currency}/orders`
-                                  )
-                                ) {
-                                  const currentCookieLocale =
-                                    req.cookies.get('pz-locale')?.value;
-
-                                  const urlHasExplicitLocale =
-                                    url.pathname.match(urlLocaleMatcherRegex);
-                                  const shouldUpdateCookie =
-                                    !currentCookieLocale ||
-                                    urlHasExplicitLocale;
-
-                                  if (shouldUpdateCookie) {
-                                    middlewareResult.cookies.set(
-                                      'pz-locale',
-                                      locale?.length > 0
-                                        ? locale
-                                        : defaultLocaleValue,
-                                      {
-                                        domain: rootHostname,
-                                        sameSite: 'none',
-                                        secure: true,
-                                        expires: new Date(
-                                          Date.now() + 1000 * 60 * 60 * 24 * 7
-                                        ) // 7 days
-                                      }
-                                    );
-                                  }
-                                }
-
                                 if (
                                   req.cookies.get('pz-locale') &&
                                   req.cookies.get('pz-locale').value !== locale

package/middlewares/locale.ts

@@ -23,15 +23,7 @@ const getMatchedLocale = (pathname: string, req: PzNextRequest) => {
       );
 
       if (subDomainLocaleMatched && subDomainLocaleMatched[0]) {
-        const subdomainLocale = subDomainLocaleMatched[0].slice(1);
-
-        const isValidSubdomainLocale = settings.localization.locales.find(
-          (l) => l.value === subdomainLocale
-        );
-
-        if (isValidSubdomainLocale) {
-          matchedLocale = subdomainLocale;
-        }
+        matchedLocale = subDomainLocaleMatched[0].slice(1);
       }
     }
   }

package/middlewares/pretty-url.ts

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

package/middlewares/redirection-payment.ts

@@ -149,8 +149,7 @@ const withRedirectionPayment =
       logger.info('Redirecting to order success page', {
         middleware: 'redirection-payment',
         redirectUrlWithLocale,
-        ip,
-        setCookie: request.headers.get('set-cookie')
+        ip
       });
 
       // Using POST method while redirecting causes an error,

package/middlewares/saved-card-redirection.ts

@@ -149,8 +149,7 @@ const withSavedCardRedirection =
       logger.info('Redirecting to order success page', {
         middleware: 'saved-card-redirection',
         redirectUrlWithLocale,
-        ip,
-        setCookie: request.headers.get('set-cookie')
+        ip
       });
 
       // Using POST method while redirecting causes an error,