npm - @akinon/next - Versions diffs - 1.96.0-snapshot-ZERO-35861-20250908151109 → 1.96.0 - Mend

@akinon/next 1.96.0-snapshot-ZERO-35861-20250908151109 → 1.96.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (14) hide show

package/CHANGELOG.md CHANGED Viewed

@@ -1,11 +1,11 @@
 # @akinon/next
-## 1.96.0-snapshot-ZERO-35861-20250908151109
+## 1.96.0
 ### Minor Changes
-- 5ba63ef: ZERO-3586_1: Commit 3586 to 1.93.0 @akinon/next version.
-- c91a2bc: ZERO-35861: 1.93.0 fix
+- af5c93a: ZERO-3617: Add pre-order middleware instruction file
+- a420947: ZERO-3517: Fix optional chaining for rawData in error logging for category data handlers
 ## 1.95.0

package/api/cache.ts CHANGED Viewed

@@ -21,54 +21,20 @@ async function handleRequest(...args) {
   }
   const formData = await req.formData();
-  const body = {} as {
-    key: string;
-    value?: string;
-    expire?: number;
-    keyValuePairs?: string;
-    compressed?: string;
-  };
+  const body = {} as { key: string; value?: string; expire?: number };
   formData.forEach((value, key) => {
     body[key] = value;
   });
-  const { key, value, expire, keyValuePairs, compressed } = body;
-  let response: any;
+  const { key, value, expire } = body;
+  let response: string | boolean;
   try {
     if (req.method === 'POST') {
-      if (compressed === 'true') {
-        response = await Cache.getCompressed(key);
-      } else {
-        response = await Cache.get(key);
-      }
+      response = await Cache.get(key);
     } else if (req.method === 'PUT') {
-      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);
-        }
-      }
+      response = await Cache.set(key, value, expire);
     }
   } catch (error) {
     logger.error(error);

package/data/server/category.ts CHANGED Viewed

@@ -48,8 +48,8 @@ function getCategoryDataHandler(
       logger.fatal('Error while parsing category data', {
         handler: 'getCategoryDataHandler',
         error,
-        rawData: rawData.startsWith('<!DOCTYPE html>')
-          ? `${rawData.substring(0, 50)}...`
+        rawData: rawData?.startsWith?.('<!DOCTYPE html>')
+          ? `${rawData?.substring(0, 50)}...`
           : rawData
       });
     }
@@ -98,8 +98,7 @@ export const getCategoryData = ({
     locale,
     getCategoryDataHandler(pk, locale, currency, searchParams, headers),
     {
-      expire: 300,
-      compressed: true
+      expire: 300
     }
   );
 };
@@ -139,8 +138,8 @@ function getCategoryBySlugDataHandler(
       logger.fatal('Error while parsing category data', {
         handler: 'getCategoryBySlugDataHandler',
         error,
-        rawData: rawData.startsWith('<!DOCTYPE html>')
-          ? `${rawData.substring(0, 50)}...`
+        rawData: rawData?.startsWith?.('<!DOCTYPE html>')
+          ? `${rawData?.substring(0, 50)}...`
           : rawData
       });
     }
@@ -159,8 +158,7 @@ export const getCategoryBySlugData = async ({
     locale,
     getCategoryBySlugDataHandler(slug, locale, currency),
     {
-      expire: 300,
-      compressed: true
+      expire: 300
     }
   );
 };

package/data/server/flatpage.ts CHANGED Viewed

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

package/data/server/form.ts CHANGED Viewed

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

package/data/server/list.ts CHANGED Viewed

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

package/data/server/menu.ts CHANGED Viewed

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

package/data/server/product.ts CHANGED Viewed

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

package/data/server/widget.ts CHANGED Viewed

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

package/lib/cache-handler.mjs CHANGED Viewed

@@ -3,261 +3,7 @@ import createLruHandler from '@neshca/cache-handler/local-lru';
 import createRedisHandler from '@neshca/cache-handler/redis-strings';
 import { createClient } from 'redis';
-let zstd;
-(async () => {
-  try {
-    const { compress, decompress } = await import('@mongodb-js/zstd');
-    zstd = { compress, decompress, type: 'native' };
-  } catch (_) {
-    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);
-        } else {
-          compressed = zstdLib.compress(inputBuffer, 3);
-        }
-      } 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);
-      } else {
-        compressed = zstdLib.compress(inputBuffer, 3);
-      }
-    } 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 (_) {
-    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');
-          } else {
-            decompressed = zstdLib
-              .decompress(compressedBuffer)
-              .toString('utf8');
-          }
-        } 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');
-          } else {
-            decompressed = zstdLib
-              .decompress(compressedBuffer)
-              .toString('utf8');
-          }
-        } else {
-          throw new Error('zstd not available for decompression');
-        }
-      }
-      return JSON.parse(decompressed);
-    }
-    return compressedData;
-  } catch (error) {
-    return compressedData;
-  }
-};
+// Cache configuration
 const CACHE_CONFIG = {
   lru: {
     maxItemCount: 2000
@@ -276,6 +22,7 @@ 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;
@@ -284,22 +31,42 @@ 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: {
@@ -320,6 +87,7 @@ 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(
@@ -333,10 +101,12 @@ async function getRedisClient() {
     });
     redisClient.on('connect', () => {
+      console_log('Redis connected');
       globalForRedis.hasLoggedConnectionError = false;
     });
     redisClient.on('ready', () => {
+      console_log('Redis ready');
       globalForRedis.hasLoggedConnectionError = false;
     });
@@ -345,6 +115,16 @@ 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;
@@ -355,10 +135,13 @@ 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)]
     };
@@ -367,161 +150,98 @@ CacheHandler.onCreation(async () => {
   const redisHandler = createRedisHandler({
     client,
     timeoutMs: CACHE_CONFIG.redis.timeoutMs,
-    keyExpirationStrategy: 'EXPIREAT'
+    keyExpirationStrategy: 'EXAT'
   });
   const localHandler = createLruHandler(CACHE_CONFIG.lru);
-  const CACHE_VERSION = 'v2';
-  const versionPrefix = `${CACHE_VERSION}_`;
+  // Pre-compute version prefix if exists
+  const versionPrefix = CACHE_CONFIG.version ? `${CACHE_CONFIG.version}:` : '';
-  const versionKeyString = (key) => `${versionPrefix}${key}`;
-  const versionKeyObject = (key) => ({
-    ...key,
-    key: `${versionPrefix}${key.key}`
-  });
+  // Create optimized functions for each scenario
+  const versionKeyString = versionPrefix
+    ? (key) => `${versionPrefix}${key}`
+    : (key) => key;
+  const versionKeyObject = versionPrefix
+    ? (key) => ({ ...key, key: `${versionPrefix}${key.key}` })
+    : (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) {
-        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 (_) {
-            return localResult;
-          }
-        }
+        console_log('Found in local cache');
         return localResult;
       }
+      console_log('Not found in local, checking Redis...');
       try {
         const redisResult = await redisHandler.get(vKey, context);
         if (redisResult) {
-          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 (_) {
-              return finalResult;
-            }
-          }
+          console_log('Found in Redis');
+          // Sync back to local cache for faster future access
           try {
-            await localHandler.set(vKey, finalResult, context);
-          } catch (_) {
-            return finalResult;
+            await localHandler.set(vKey, redisResult, context);
+            console_log('Synced to local cache');
+          } catch (error) {
+            console_log('Failed to sync to local:', error.message);
           }
-          return finalResult;
+          return redisResult;
         }
-      } catch (_) {
-        return undefined;
+      } catch (error) {
+        console_log('Redis error:', error.message);
       }
+      console_log('Not found in any cache');
       return undefined;
     },
     set: async (key, value, context) => {
       const vKey = versionKey(key);
-      let compressedValue;
-      let shouldUseCompressed = false;
-      try {
-        compressedValue = await compressValue(value);
-        shouldUseCompressed =
-          compressedValue !== value &&
-          (compressedValue?.__compressed ||
-            compressedValue?.value?.__compressed);
-      } catch (error) {
-        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 };
-          return redisSetResult;
-        }
-      }
-      let localSetResult;
-      try {
-        await localHandler.set(vKey, value, context);
-        localSetResult = { status: 'fulfilled' };
-      } catch (error) {
-        localSetResult = { status: 'rejected', reason: error };
-        return localSetResult;
-      }
+      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))
+      ]);
     },
     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)
@@ -529,6 +249,8 @@ CacheHandler.onCreation(async () => {
     }
   };
+  console_log('[Cache Handler] Handlers initialized successfully');
   return {
     handlers: [customHandler]
   };

package/lib/cache.ts CHANGED Viewed

@@ -3,65 +3,6 @@ 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) {
@@ -90,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,
@@ -119,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(
@@ -181,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();
@@ -193,7 +108,9 @@ 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) {
@@ -204,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 });
@@ -219,7 +137,9 @@ 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) {
@@ -248,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);
@@ -259,22 +178,21 @@ export class Cache {
       _options.expire = 120;
     }
+    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) {
@@ -282,6 +200,8 @@ export class Cache {
       }
     }
+    logger.debug('Redis cache miss. Setting new value...', { key });
     const data = await handler();
     if (data && _options.cache) {
@@ -295,19 +215,14 @@ 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 {
-        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);
       }
     }
@@ -319,7 +234,7 @@ export class Cache {
       await fetch(Cache.PROXY_URL, {
         method,
         headers: {
-          authorization: process.env.CACHE_SECRET || ''
+          authorization: process.env.CACHE_SECRET
         },
         body
       })
@@ -327,148 +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) {
-        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 CHANGED Viewed

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

package/package.json CHANGED Viewed

@@ -1,7 +1,7 @@
 {
   "name": "@akinon/next",
   "description": "Core package for Project Zero Next",
-  "version": "1.96.0-snapshot-ZERO-35861-20250908151109",
+  "version": "1.96.0",
   "private": false,
   "license": "MIT",
   "bin": {
@@ -17,8 +17,7 @@
     "test": "jest"
   },
   "dependencies": {
-    "@mongodb-js/zstd": "^2.0.1",
-    "@neshca/cache-handler": "1.9.0",
+    "@neshca/cache-handler": "1.5.1",
     "@opentelemetry/exporter-trace-otlp-http": "0.46.0",
     "@opentelemetry/resources": "1.19.0",
     "@opentelemetry/sdk-node": "0.46.0",
@@ -35,7 +34,7 @@
     "set-cookie-parser": "2.6.0"
   },
   "devDependencies": {
-    "@akinon/eslint-plugin-projectzero": "1.96.0-snapshot-ZERO-35861-20250908151109",
+    "@akinon/eslint-plugin-projectzero": "1.96.0",
     "@babel/core": "7.26.10",
     "@babel/preset-env": "7.26.9",
     "@babel/preset-typescript": "7.27.0",

package/types/index.ts CHANGED Viewed

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