@nxtedition/cache 2.0.2 → 2.0.3

package/lib/index.d.ts

@@ -17,9 +17,34 @@ export type CacheResult<V> = {
     value: Promise<V>;
     async: true;
 };
+declare global {
+    var __nxt_cache: {
+        stats: Cache['stats'];
+    }[];
+}
 export declare class Cache<V = unknown, A extends unknown[] = unknown[]> {
     #private;
     constructor(location: string, valueSelector: (...args: A) => V | PromiseLike<V>, keySelector: (...args: A) => string, opts?: CacheOptions<V>);
+    get stats(): {
+        lock: {
+            timeout: number;
+            mean: number;
+            stddev: number;
+        };
+        dedupe: {
+            size: number;
+        };
+        memory: {
+            size: number;
+            maxSize: number;
+            count: number;
+            maxCount: number;
+        } | undefined;
+        database: {
+            location: string;
+            size: number | undefined;
+        } | undefined;
+    };
     close(): void;
     get(...args: A): CacheResult<V>;
     peek(...args: A): CacheResult<V>;

package/lib/index.js

@@ -54,10 +54,17 @@ const dbs = new Set                            ()
                             
                                           
                                       
+
+                
+                                    
+                                              
+ 
 
 const VERSION = 4
 const MAX_DURATION = 365000000e3
 
+globalThis.__nxt_cache ??= []
+
 export class Cache                                               {
   #memory                       
   #dedupe = new Map                    ()
@@ -74,6 +81,7 @@ export class Cache                                               {
   #lockTimeout = 10
   #lockId = randomUUID()
 
+  #location        
   #database                      = null
   #getQuery                       = null
   #setQuery                       = null
@@ -84,6 +92,8 @@ export class Cache                                               {
   #lockStealQuery                       = null
   #lockGetQuery                       = null
   #lockPurgeQuery                       = null
+  #pageCountQuery                       = null
+  #pageSizeQuery                       = null
 
   constructor(
     location        ,
@@ -94,6 +104,7 @@ export class Cache                                               {
     if (typeof location !== 'string') {
       throw new TypeError('location must be a string')
     }
+    this.#location = location
 
     if (typeof valueSelector !== 'function') {
       throw new TypeError('valueSelector must be a function')
@@ -189,6 +200,8 @@ export class Cache                                               {
         this.#lockPurgeQuery = this.#database.prepare(
           `DELETE FROM cache_lock_v${VERSION} WHERE lock_acquired <= ?`,
         )
+        this.#pageCountQuery = this.#database.prepare('PRAGMA page_count')
+        this.#pageSizeQuery = this.#database.prepare('PRAGMA page_size')
         break
       } catch (err) {
         if (n >= 16) {
@@ -204,6 +217,8 @@ export class Cache                                               {
           this.#lockStealQuery = null
           this.#lockGetQuery = null
           this.#lockPurgeQuery = null
+          this.#pageCountQuery = null
+          this.#pageSizeQuery = null
 
           process.emitWarning(err         )
           break
@@ -212,6 +227,34 @@ export class Cache                                               {
     }
 
     dbs.add(this)
+
+    globalThis.__nxt_cache.push(this)
+  }
+
+  get stats() {
+    let database                                                            
+    if (this.#database) {
+      let size                    
+      try {
+        const { page_count } = this.#pageCountQuery .get()                          
+        const { page_size } = this.#pageSizeQuery .get()                         
+        size = page_count * page_size
+      } catch (err) {
+        process.emitWarning(err         )
+      }
+      database = { location: this.#location, size }
+    }
+
+    return {
+      lock: {
+        timeout: this.#lockTimeout,
+        mean: this.#lockMean,
+        stddev: Math.sqrt(this.#lockVar),
+      },
+      dedupe: { size: this.#dedupe.size },
+      memory: this.#memory?.stats,
+      database,
+    }
   }
 
   close()       {
@@ -228,8 +271,15 @@ export class Cache                                               {
     this.#lockStealQuery = null
     this.#lockGetQuery = null
     this.#lockPurgeQuery = null
+    this.#pageCountQuery = null
+    this.#pageSizeQuery = null
     this.#database?.close()
     this.#database = null
+
+    const idx = globalThis.__nxt_cache.indexOf(this)
+    if (idx !== -1) {
+      globalThis.__nxt_cache.splice(idx, 1)
+    }
   }
 
   get(...args   )                 {

package/lib/memory.d.ts

@@ -18,4 +18,10 @@ export declare class MemoryCache<V> {
     get(key: string): MemoryCacheEntry<V> | undefined;
     delete(key: string): void;
     purgeStale(now: number): void;
+    get stats(): {
+        size: number;
+        maxSize: number;
+        count: number;
+        maxCount: number;
+    };
 }

package/lib/memory.js

@@ -97,6 +97,15 @@ export class MemoryCache    {
     }
   }
 
+  get stats() {
+    return {
+      size: this.#size,
+      maxSize: this.#maxSize,
+      count: this.#count,
+      maxCount: this.#maxCount,
+    }
+  }
+
   #prune() {
     while (this.#size > this.#maxSize || this.#count > this.#maxCount) {
       const e1 = this.#arr[(Math.random() * this.#arr.length) | 0]

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nxtedition/cache",
-  "version": "2.0.2",
+  "version": "2.0.3",
   "type": "module",
   "main": "lib/index.js",
   "types": "lib/index.d.ts",
@@ -30,5 +30,5 @@
     "tsd": "^0.33.0",
     "typescript": "^5.9.3"
   },
-  "gitHead": "f6592f0be62fecc161237610ae6454ec6585548b"
+  "gitHead": "cfc529e921c93a1fb0292018e2026f2b326ec998"
 }