@raketa-cloud/next 1.0.2 → 1.0.4

package/package.json

@@ -1,9 +1,10 @@
 {
   "name": "@raketa-cloud/next",
-  "version": "1.0.2",
+  "version": "1.0.4",
   "main": "src/index.js",
   "scripts": {
-    "check-types": "tsc --noEmit"
+    "check-types": "tsc --noEmit",
+    "format": "prettier --write src/**/*.js"
   },
   "devDependencies": {
     "@repo/typescript-config": "*",
@@ -11,12 +12,13 @@
     "@types/node": "^20.11.24",
     "@types/react": "18.3.0",
     "@types/react-dom": "18.3.1",
+    "prettier": "^3.8.3",
     "typescript": "5.5.4"
   },
   "dependencies": {
-    "react": "^19.0.0",
-    "react-dom": "^19.0.0",
     "graphql-request": "7.1.2",
-    "lru-cache": "11.0.2"
+    "lru-cache": "11.0.2",
+    "react": "^19.0.0",
+    "react-dom": "^19.0.0"
   }
 }

package/src/Cache.js

@@ -1,20 +1,67 @@
 import { LRUCache } from "lru-cache";
 
-const UNDEFINED_VALUE = Symbol("udef");
+const NULL_SENTINEL = Symbol.for("raketa_cache_null");
+
+function getApproximateMemoryUsage(obj) {
+  // Use a WeakSet to track objects we've already seen to avoid infinite loops on circular references
+  const seen = new WeakSet();
+
+  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;
+
+    // 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 sizeOf(obj);
+}
 
 export default class Cache {
   constructor(opts = {}) {
+    const self = this;
+
     const cacheOptions = {
-      max: opts.max || 5000,
-      ttl: opts.ttl || 1000 * 60 * 2,
+      max: opts.max || 5000, // Items count
+      ttl: opts.ttl || 1000 * 60 * 5, // 5 minutes
       allowStale: true,
       noDeleteOnStaleGet: true,
     };
 
+    // Conditionally use the memrory calculation since it is veery flaky and inaccurate...
+    if (opts.maxSize) {
+      cacheOptions.maxSize = opts.maxSize;
+
+      cacheOptions.sizeCalculation = (value, key) => {
+        return getApproximateMemoryUsage(key) + getApproximateMemoryUsage(value);
+      };
+
+    }
+
     this.debugMode = opts.debugMode || false;
-    this.cacheInstance = new LRUCache({
-      ...cacheOptions,
-    });
+    this.cacheInstance = new LRUCache(cacheOptions);
   }
 
   _debug(msg) {
@@ -29,12 +76,22 @@ export default class Cache {
     const cachedValue = this.cacheInstance.get(key, { status });
 
     return {
-      cachedValue: cachedValue === UNDEFINED_VALUE ? null : cachedValue,
+      cachedValue: cachedValue === NULL_SENTINEL ? null : cachedValue,
       status,
     };
   }
 
   _cloneObject(obj) {
+    if (obj === null || obj === undefined) {
+      return obj;
+    }
+
+    const type = typeof obj;
+
+    if (type !== "function" || type !== "obj") {
+      return obj;
+    }
+
     // Ah the JS world! See the official docs https://developer.mozilla.org/en-US/docs/Glossary/Deep_copy.
     // Important note - this works only for objects with primitive types to copy. If an object property is
     // a function - well it will not work correctly...
@@ -44,10 +101,30 @@ export default class Cache {
   _setInCache(key, value) {
     this.cacheInstance.set(
       key,
-      value ? this._cloneObject(value) : UNDEFINED_VALUE
+      value ? this._cloneObject(value) : NULL_SENTINEL
     );
   }
 
+  clear() {
+    this.cacheInstance.clear();
+  }
+
+  forEach(callback) {
+    this.cacheInstance.forEach(callback);
+  }
+
+  getRemainingTTL(key) {
+    return this.cacheInstance.getRemainingTTL(key);
+  }
+
+  get calculatedSize() {
+    return this.cacheInstance.calculatedSize;
+  }
+
+  get maxSize() {
+    return this.cacheInstance.maxSize;
+  }
+
   async fetch(cacheKey, fetcher) {
     const { cachedValue, status } = this._fetchFromCache(cacheKey);