@akinon/next 1.99.0-snapshot-ZERO-3640-20250919140935 → 1.100.0-rc.71

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) {
@@ -31,6 +90,8 @@ 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,
@@ -58,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(
@@ -96,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();
@@ -108,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) {
@@ -121,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 });
@@ -137,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) {
@@ -168,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);
@@ -178,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) {
@@ -200,8 +282,6 @@ export class Cache {
       }
     }
 
-    logger.debug('Redis cache miss. Setting new value...', { key });
-
     const data = await handler();
 
     if (data && _options.cache) {
@@ -215,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);
+        }
       }
     }
 
@@ -234,7 +319,7 @@ export class Cache {
       await fetch(Cache.PROXY_URL, {
         method,
         headers: {
-          authorization: process.env.CACHE_SECRET
+          authorization: process.env.CACHE_SECRET || ''
         },
         body
       })
@@ -242,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/complete-gpay.ts

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

package/middlewares/complete-masterpass.ts

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

package/middlewares/default.ts

@@ -302,19 +302,6 @@ 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,
@@ -352,6 +339,24 @@ 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;
 
@@ -401,6 +406,38 @@ 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,7 +23,15 @@ const getMatchedLocale = (pathname: string, req: PzNextRequest) => {
       );
 
       if (subDomainLocaleMatched && subDomainLocaleMatched[0]) {
-        matchedLocale = subDomainLocaleMatched[0].slice(1);
+        const subdomainLocale = subDomainLocaleMatched[0].slice(1);
+
+        const isValidSubdomainLocale = settings.localization.locales.find(
+          (l) => l.value === subdomainLocale
+        );
+
+        if (isValidSubdomainLocale) {
+          matchedLocale = subdomainLocale;
+        }
       }
     }
   }

package/middlewares/pretty-url.ts

@@ -1,17 +1,33 @@
 import { Cache, CacheKey } from '../lib/cache';
-import { NextFetchEvent, NextMiddleware, NextRequest } from 'next/server';
-import { ROUTES } from 'routes';
+import { NextFetchEvent, NextMiddleware } from 'next/server';
 import { URLS } from '../data/urls';
 import Settings from 'settings';
 import { urlLocaleMatcherRegex } from '../utils';
 import { PzNextRequest } from '.';
 import logger from '../utils/log';
+import { ROUTES } from 'routes';
 
 type PrettyUrlResult = {
   matched: boolean;
   path?: string;
 };
 
+let APP_ROUTES: string[] = [];
+
+const legacyRoutes = Object.values(ROUTES);
+
+try {
+  const generatedRoutes = require('routes/generated-routes');
+  const allRoutes = [...legacyRoutes, ...(generatedRoutes || [])];
+  APP_ROUTES = Array.from(new Set(allRoutes));
+  logger.debug('Loaded merged routes (legacy + generated)', {
+    count: APP_ROUTES.length
+  });
+} catch (error) {
+  APP_ROUTES = legacyRoutes;
+  logger.debug('Loaded only legacy routes', { count: APP_ROUTES.length });
+}
+
 const resolvePrettyUrlHandler =
   (pathname: string, ip: string | null) => async () => {
     let results = <{ old_path: string }[]>[];
@@ -53,7 +69,8 @@ const resolvePrettyUrl = async (
     locale,
     resolvePrettyUrlHandler(pathname, ip),
     {
-      useProxy: true
+      useProxy: true,
+      compressed: true
     }
   );
 };
@@ -73,9 +90,7 @@ const withPrettyUrl =
     const isValidPrettyUrlPath = (pathname: string) => {
       return (
         new RegExp(/^\/[a-zA-Z0-9/]+(?:-[a-zA-Z0-9/]+)*$/).test(pathname) &&
-        !Object.entries(ROUTES).find(([, value]) =>
-          new RegExp(`^${value}$`).test(pathname)
-        )
+        !APP_ROUTES.some((route) => new RegExp(`^${route}$`).test(pathname))
       );
     };
     const ip = req.headers.get('x-forwarded-for') ?? '';

package/middlewares/redirection-payment.ts

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

package/middlewares/saved-card-redirection.ts

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

package/middlewares/three-d-redirection.ts

@@ -4,7 +4,6 @@ import { Buffer } from 'buffer';
 import logger from '../utils/log';
 import { getUrlPathWithLocale } from '../utils/localization';
 import { PzNextRequest } from '.';
-import { ServerVariables } from '../utils/server-variables';
 
 const streamToString = async (stream: ReadableStream<Uint8Array> | null) => {
   if (stream) {
@@ -149,7 +148,8 @@ const withThreeDRedirection =
       logger.info('Redirecting to order success page', {
         middleware: 'three-d-redirection',
         redirectUrlWithLocale,
-        ip
+        ip,
+        setCookie: request.headers.get('set-cookie')
       });
 
       // Using POST method while redirecting causes an error,

package/middlewares/url-redirection.ts

@@ -4,6 +4,7 @@ import { PzNextRequest } from '.';
 import logger from '../utils/log';
 import { urlLocaleMatcherRegex } from '../utils';
 import { getUrlPathWithLocale } from '../utils/localization';
+import { shouldIgnoreRedirect } from '../utils/redirect-ignore';
 import { ROUTES } from 'routes';
 
 // This middleware is used to handle url redirections set in Omnitron
@@ -60,20 +61,13 @@ const withUrlRedirection =
 
         const setCookies = request.headers.getSetCookie();
 
-        if (settings.commerceRedirectionIgnoreList) {
-          const shouldIgnoreRedirect =
-            settings.commerceRedirectionIgnoreList.some((ignorePath) =>
-              redirectUrl.pathname.startsWith(
-                getUrlPathWithLocale(
-                  ignorePath,
-                  req.middlewareParams.rewrites.locale
-                )
-              )
-            );
-
-          if (shouldIgnoreRedirect) {
-            return middleware(req, event);
-          }
+        if (
+          shouldIgnoreRedirect(
+            url.pathname,
+            req.middlewareParams.rewrites.locale
+          )
+        ) {
+          return middleware(req, event);
         }
 
         const response = NextResponse.redirect(redirectUrl.toString(), {

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@akinon/next",
   "description": "Core package for Project Zero Next",
-  "version": "1.99.0-snapshot-ZERO-3640-20250919140935",
+  "version": "1.100.0-rc.71",
   "private": false,
   "license": "MIT",
   "bin": {
@@ -17,7 +17,8 @@
     "test": "jest"
   },
   "dependencies": {
-    "@neshca/cache-handler": "1.5.1",
+    "@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",
@@ -34,7 +35,7 @@
     "set-cookie-parser": "2.6.0"
   },
   "devDependencies": {
-    "@akinon/eslint-plugin-projectzero": "1.99.0-snapshot-ZERO-3640-20250919140935",
+    "@akinon/eslint-plugin-projectzero": "1.100.0-rc.71",
     "@babel/core": "7.26.10",
     "@babel/preset-env": "7.26.9",
     "@babel/preset-typescript": "7.27.0",

package/plugins.d.ts

@@ -30,11 +30,14 @@ declare module '@akinon/pz-saved-card' {
   export const SavedCardOption: any;
 }
 
-declare module '@akinon/pz-iyzico-saved-card' {
-  export const iyzicoSavedCardReducer: any;
-  export const iyzicoSavedCardMiddleware: any;
-}
-
 declare module '@akinon/pz-apple-pay' {}
 
 declare module '@akinon/pz-flow-payment' {}
+
+declare module '@akinon/pz-similar-products' {
+  export const SimilarProductsModal: any;
+  export const SimilarProductsFilterSidebar: any;
+  export const SimilarProductsResultsGrid: any;
+  export const SimilarProductsPlugin: any;
+  export const SimilarProductsButtonPlugin: any;
+}