@raketa-cloud/next 1.0.3 → 1.0.4

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@raketa-cloud/next",
-  "version": "1.0.3",
+  "version": "1.0.4",
   "main": "src/index.js",
   "scripts": {
     "check-types": "tsc --noEmit",
@@ -18,7 +18,6 @@
   "dependencies": {
     "graphql-request": "7.1.2",
     "lru-cache": "11.0.2",
-    "object-sizeof": "^2.6.5",
     "react": "^19.0.0",
     "react-dom": "^19.0.0"
   }

package/src/Cache.js

@@ -1,46 +1,64 @@
 import { LRUCache } from "lru-cache";
-import sizeof from "object-sizeof";
 
 const NULL_SENTINEL = Symbol.for("raketa_cache_null");
 
-function getKeySize(key) {
-  if (typeof key === 'string') {
-    // Account for UTF-16 encoding
-    return Buffer.from(key, 'utf16le').length;
-  }
+function getApproximateMemoryUsage(obj) {
+  // Use a WeakSet to track objects we've already seen to avoid infinite loops on circular references
+  const seen = new WeakSet();
 
-  if (typeof key === 'number') {
-    return 8; // 64-bit number
-  }
+  function sizeOf(value) {
+    // 1. Handle null and undefined explicitly (This fixes your error!)
+    if (value === null || value === undefined) return 0;
+
+    // 2. Handle primitives based on JS specs
+    if (typeof value === 'boolean') return 4;
+    if (typeof value === 'number') return 8; // Double-precision floats
+    if (typeof value === 'string') return value.length * 2; // UTF-16 strings take 2 bytes per char
+
+    // 3. Skip functions and symbols (they live in a shared memory pool)
+    if (typeof value !== 'object') return 0;
 
-  if (typeof key === 'object') {
-    return sizeof(key);
+    // 4. Handle circular references
+    if (seen.has(value)) return 0;
+
+    seen.add(value);
+
+    let bytes = 0;
+
+    // 5. Traverse the object's keys and values
+    for (const key in value) {
+      if (Object.prototype.hasOwnProperty.call(value, key)) {
+        bytes += key.length * 2;     // Add the size of the key itself
+        bytes += sizeOf(value[key]); // Recursively add the size of the value
+      }
+    }
+
+    return bytes;
   }
 
-  return 0;
+  return sizeOf(obj);
 }
 
 export default class Cache {
   constructor(opts = {}) {
+    const self = this;
+
     const cacheOptions = {
       max: opts.max || 5000, // Items count
       ttl: opts.ttl || 1000 * 60 * 5, // 5 minutes
-      maxSize: opts.maxSize || 500 * 1024 * 1024, // 500 MB
       allowStale: true,
       noDeleteOnStaleGet: true,
     };
 
-    cacheOptions.sizeCalculation = (value, key) => {
-      const keySize = getKeySize(key);
+    // Conditionally use the memrory calculation since it is veery flaky and inaccurate...
+    if (opts.maxSize) {
+      cacheOptions.maxSize = opts.maxSize;
 
-      if (value === null || value === undefined) {
-        return keySize;
-      }
+      cacheOptions.sizeCalculation = (value, key) => {
+        return getApproximateMemoryUsage(key) + getApproximateMemoryUsage(value);
+      };
 
-      if (value === NULL_SENTINEL) return keySize + 1;
-
-      return keySize + sizeof(value);
-    };
+    }
 
     this.debugMode = opts.debugMode || false;
     this.cacheInstance = new LRUCache(cacheOptions);