offheap 0.1.0 → 0.2.0

package/index.js

@@ -1,316 +1,186 @@
-/* tslint:disable */
-/* eslint-disable */
-/* prettier-ignore */
+const { Cache: NativeCache, CacheManager: NativeCacheManager } = require('./binding');
 
-/* auto-generated by NAPI-RS */
+const activePromises = new Map();
+const finalizer = new FinalizationRegistry((nativeCache) => {
+  try {
+    nativeCache.dispose();
+  } catch (e) {
+    // Ignore errors during GC finalization
+  }
+});
 
-const { existsSync, readFileSync } = require('fs')
-const { join } = require('path')
+class Cache {
+  constructor(nativeCache) {
+    this._native = nativeCache;
+    this._id = Math.random().toString(36).substring(2);
+    finalizer.register(this, nativeCache, this);
+  }
 
-const { platform, arch } = process
+  get(key) {
+    return this._native.get(key);
+  }
 
-let nativeBinding = null
-let localFileExisted = false
-let loadError = null
+  peek(key) {
+    return this._native.peek(key);
+  }
 
-function isMusl() {
-  // For Node 10
-  if (!process.report || typeof process.report.getReport !== 'function') {
-    try {
-      const lddPath = require('child_process').execSync('which ldd').toString().trim()
-      return readFileSync(lddPath, 'utf8').includes('musl')
-    } catch (e) {
-      return true
-    }
-  } else {
-    const { glibcVersionRuntime } = process.report.getReport().header
-    return !glibcVersionRuntime
+  has(key) {
+    return this._native.has(key);
   }
-}
 
-switch (platform) {
-  case 'android':
-    switch (arch) {
-      case 'arm64':
-        localFileExisted = existsSync(join(__dirname, 'offheap.android-arm64.node'))
-        try {
-          if (localFileExisted) {
-            nativeBinding = require('./offheap.android-arm64.node')
-          } else {
-            nativeBinding = require('offheap-android-arm64')
-          }
-        } catch (e) {
-          loadError = e
-        }
-        break
-      case 'arm':
-        localFileExisted = existsSync(join(__dirname, 'offheap.android-arm-eabi.node'))
-        try {
-          if (localFileExisted) {
-            nativeBinding = require('./offheap.android-arm-eabi.node')
-          } else {
-            nativeBinding = require('offheap-android-arm-eabi')
-          }
-        } catch (e) {
-          loadError = e
-        }
-        break
-      default:
-        throw new Error(`Unsupported architecture on Android ${arch}`)
+  set(key, value, ttlMs) {
+    return this._native.set(key, value, ttlMs);
+  }
+
+  touch(key, ttlMs) {
+    return this._native.touch(key, ttlMs);
+  }
+
+  delete(key) {
+    return this._native.delete(key);
+  }
+
+  clear() {
+    this._native.clear();
+  }
+
+  stats() {
+    const rawStats = this._native.stats();
+    return {
+      hits: rawStats.hits,
+      misses: rawStats.misses,
+      capacity: rawStats.capacity,
+      size: rawStats.size,
+      bytesUsed: rawStats.bytesUsed,
+    };
+  }
+
+  keys() {
+    return this._native.keys();
+  }
+
+  increment(key, delta = 1, ttlMs) {
+    return this._native.increment(key, delta, ttlMs);
+  }
+
+  decrement(key, delta = 1, ttlMs) {
+    return this._native.decrement(key, delta, ttlMs);
+  }
+
+  mget(keys) {
+    return this._native.mget(keys);
+  }
+
+  mset(entries, ttlMs) {
+    if (typeof entries !== 'object' || entries === null) {
+      throw new Error('mset requires an object of key-value entries');
     }
-    break
-  case 'win32':
-    switch (arch) {
-      case 'x64':
-        localFileExisted = existsSync(
-          join(__dirname, 'offheap.win32-x64-msvc.node')
-        )
-        try {
-          if (localFileExisted) {
-            nativeBinding = require('./offheap.win32-x64-msvc.node')
-          } else {
-            nativeBinding = require('offheap-win32-x64-msvc')
-          }
-        } catch (e) {
-          loadError = e
-        }
-        break
-      case 'ia32':
-        localFileExisted = existsSync(
-          join(__dirname, 'offheap.win32-ia32-msvc.node')
-        )
-        try {
-          if (localFileExisted) {
-            nativeBinding = require('./offheap.win32-ia32-msvc.node')
-          } else {
-            nativeBinding = require('offheap-win32-ia32-msvc')
-          }
-        } catch (e) {
-          loadError = e
-        }
-        break
-      case 'arm64':
-        localFileExisted = existsSync(
-          join(__dirname, 'offheap.win32-arm64-msvc.node')
-        )
-        try {
-          if (localFileExisted) {
-            nativeBinding = require('./offheap.win32-arm64-msvc.node')
-          } else {
-            nativeBinding = require('offheap-win32-arm64-msvc')
-          }
-        } catch (e) {
-          loadError = e
-        }
-        break
-      default:
-        throw new Error(`Unsupported architecture on Windows: ${arch}`)
+    this._native.mset(entries, ttlMs);
+  }
+
+  mdelete(keys) {
+    if (!Array.isArray(keys)) {
+      throw new Error('mdelete requires an array of keys');
     }
-    break
-  case 'darwin':
-    localFileExisted = existsSync(join(__dirname, 'offheap.darwin-universal.node'))
-    try {
-      if (localFileExisted) {
-        nativeBinding = require('./offheap.darwin-universal.node')
-      } else {
-        nativeBinding = require('offheap-darwin-universal')
-      }
-      break
-    } catch {}
-    switch (arch) {
-      case 'x64':
-        localFileExisted = existsSync(join(__dirname, 'offheap.darwin-x64.node'))
-        try {
-          if (localFileExisted) {
-            nativeBinding = require('./offheap.darwin-x64.node')
-          } else {
-            nativeBinding = require('offheap-darwin-x64')
-          }
-        } catch (e) {
-          loadError = e
-        }
-        break
-      case 'arm64':
-        localFileExisted = existsSync(
-          join(__dirname, 'offheap.darwin-arm64.node')
-        )
-        try {
-          if (localFileExisted) {
-            nativeBinding = require('./offheap.darwin-arm64.node')
-          } else {
-            nativeBinding = require('offheap-darwin-arm64')
-          }
-        } catch (e) {
-          loadError = e
-        }
-        break
-      default:
-        throw new Error(`Unsupported architecture on macOS: ${arch}`)
+    return this._native.mdelete(keys);
+  }
+
+  dispose() {
+    finalizer.unregister(this);
+    this._native.dispose();
+  }
+
+  getOrSet(key, factory, ttlMs) {
+    const val = this.get(key);
+    if (val !== undefined) {
+      return val;
     }
-    break
-  case 'freebsd':
-    if (arch !== 'x64') {
-      throw new Error(`Unsupported architecture on FreeBSD: ${arch}`)
+
+    const promiseKey = `${this._id}:${key}`;
+    if (activePromises.has(promiseKey)) {
+      return activePromises.get(promiseKey);
     }
-    localFileExisted = existsSync(join(__dirname, 'offheap.freebsd-x64.node'))
+
     try {
-      if (localFileExisted) {
-        nativeBinding = require('./offheap.freebsd-x64.node')
-      } else {
-        nativeBinding = require('offheap-freebsd-x64')
-      }
-    } catch (e) {
-      loadError = e
-    }
-    break
-  case 'linux':
-    switch (arch) {
-      case 'x64':
-        if (isMusl()) {
-          localFileExisted = existsSync(
-            join(__dirname, 'offheap.linux-x64-musl.node')
-          )
-          try {
-            if (localFileExisted) {
-              nativeBinding = require('./offheap.linux-x64-musl.node')
-            } else {
-              nativeBinding = require('offheap-linux-x64-musl')
-            }
-          } catch (e) {
-            loadError = e
-          }
-        } else {
-          localFileExisted = existsSync(
-            join(__dirname, 'offheap.linux-x64-gnu.node')
-          )
-          try {
-            if (localFileExisted) {
-              nativeBinding = require('./offheap.linux-x64-gnu.node')
-            } else {
-              nativeBinding = require('offheap-linux-x64-gnu')
-            }
-          } catch (e) {
-            loadError = e
-          }
-        }
-        break
-      case 'arm64':
-        if (isMusl()) {
-          localFileExisted = existsSync(
-            join(__dirname, 'offheap.linux-arm64-musl.node')
-          )
-          try {
-            if (localFileExisted) {
-              nativeBinding = require('./offheap.linux-arm64-musl.node')
-            } else {
-              nativeBinding = require('offheap-linux-arm64-musl')
-            }
-          } catch (e) {
-            loadError = e
-          }
-        } else {
-          localFileExisted = existsSync(
-            join(__dirname, 'offheap.linux-arm64-gnu.node')
-          )
-          try {
-            if (localFileExisted) {
-              nativeBinding = require('./offheap.linux-arm64-gnu.node')
-            } else {
-              nativeBinding = require('offheap-linux-arm64-gnu')
-            }
-          } catch (e) {
-            loadError = e
-          }
-        }
-        break
-      case 'arm':
-        if (isMusl()) {
-          localFileExisted = existsSync(
-            join(__dirname, 'offheap.linux-arm-musleabihf.node')
-          )
-          try {
-            if (localFileExisted) {
-              nativeBinding = require('./offheap.linux-arm-musleabihf.node')
-            } else {
-              nativeBinding = require('offheap-linux-arm-musleabihf')
-            }
-          } catch (e) {
-            loadError = e
-          }
-        } else {
-          localFileExisted = existsSync(
-            join(__dirname, 'offheap.linux-arm-gnueabihf.node')
-          )
-          try {
-            if (localFileExisted) {
-              nativeBinding = require('./offheap.linux-arm-gnueabihf.node')
-            } else {
-              nativeBinding = require('offheap-linux-arm-gnueabihf')
-            }
-          } catch (e) {
-            loadError = e
-          }
-        }
-        break
-      case 'riscv64':
-        if (isMusl()) {
-          localFileExisted = existsSync(
-            join(__dirname, 'offheap.linux-riscv64-musl.node')
-          )
-          try {
-            if (localFileExisted) {
-              nativeBinding = require('./offheap.linux-riscv64-musl.node')
-            } else {
-              nativeBinding = require('offheap-linux-riscv64-musl')
-            }
-          } catch (e) {
-            loadError = e
-          }
-        } else {
-          localFileExisted = existsSync(
-            join(__dirname, 'offheap.linux-riscv64-gnu.node')
-          )
-          try {
-            if (localFileExisted) {
-              nativeBinding = require('./offheap.linux-riscv64-gnu.node')
-            } else {
-              nativeBinding = require('offheap-linux-riscv64-gnu')
+      const res = factory();
+      if (res instanceof Promise) {
+        const p = res
+          .then((resolvedVal) => {
+            activePromises.delete(promiseKey);
+            if (resolvedVal !== undefined) {
+              this.set(key, resolvedVal, ttlMs);
             }
-          } catch (e) {
-            loadError = e
-          }
-        }
-        break
-      case 's390x':
-        localFileExisted = existsSync(
-          join(__dirname, 'offheap.linux-s390x-gnu.node')
-        )
-        try {
-          if (localFileExisted) {
-            nativeBinding = require('./offheap.linux-s390x-gnu.node')
-          } else {
-            nativeBinding = require('offheap-linux-s390x-gnu')
-          }
-        } catch (e) {
-          loadError = e
+            return resolvedVal;
+          })
+          .catch((err) => {
+            activePromises.delete(promiseKey);
+            throw err;
+          });
+        activePromises.set(promiseKey, p);
+        return p;
+      } else {
+        if (res !== undefined) {
+          this.set(key, res, ttlMs);
         }
-        break
-      default:
-        throw new Error(`Unsupported architecture on Linux: ${arch}`)
+        return res;
+      }
+    } catch (err) {
+      activePromises.delete(promiseKey);
+      throw err;
     }
-    break
-  default:
-    throw new Error(`Unsupported OS: ${platform}, architecture: ${arch}`)
+  }
 }
 
-if (!nativeBinding) {
-  if (loadError) {
-    throw loadError
+const activeManagers = new Set();
+
+class CacheManager {
+  constructor() {
+    this._native = new NativeCacheManager();
+    activeManagers.add(this);
+  }
+
+  createCache(name, config) {
+    const rawConfig = {
+      policy: config.policy,
+      capacity: config.capacity,
+      shards: config.shards,
+      maxBytes: config.maxBytes,
+    };
+    const nativeCache = this._native.createCache(name, rawConfig);
+    return new Cache(nativeCache);
+  }
+
+  getCache(name) {
+    const nativeCache = this._native.getCache(name);
+    if (!nativeCache) return null;
+    return new Cache(nativeCache);
+  }
+
+  deleteCache(name) {
+    return this._native.deleteCache(name);
+  }
+
+  clear() {
+    this._native.clear();
+  }
+
+  dispose() {
+    activeManagers.delete(this);
+    this._native.clear();
   }
-  throw new Error(`Failed to load native binding`)
 }
 
-const { Cache, CacheManager } = nativeBinding
+process.on('exit', () => {
+  for (const manager of activeManagers) {
+    try {
+      manager.dispose();
+    } catch (e) {
+      // Ignore cleanup failures on process exit
+    }
+  }
+});
 
-module.exports.Cache = Cache
-module.exports.CacheManager = CacheManager
+module.exports = {
+  Cache,
+  CacheManager,
+};

package/package.json

@@ -1,35 +1,44 @@
 {
   "name": "offheap",
-  "version": "0.1.0",
+  "version": "0.2.0",
   "description": "High-performance off-heap caching framework for Node.js written in Rust",
   "main": "index.js",
   "types": "index.d.ts",
   "napi": {
     "name": "offheap",
-    "triple": {
-      "defaults": true,
-      "additional": []
-    }
+    "targets": [
+      "x86_64-pc-windows-msvc",
+      "x86_64-unknown-linux-gnu",
+      "x86_64-unknown-linux-musl",
+      "x86_64-apple-darwin",
+      "aarch64-apple-darwin",
+      "aarch64-unknown-linux-musl"
+    ]
   },
   "scripts": {
     "artifacts": "napi artifacts",
-    "build": "napi build --platform --release",
-    "build:debug": "napi build --platform",
+    "build": "napi build --platform --release --js binding.js --dts binding.d.ts",
+    "build:debug": "napi build --platform --js binding.js --dts binding.d.ts",
     "prepublishOnly": "napi prepublish -t npm --skip-gh-release",
     "test": "node --test tests/index.test.js",
-    "benchmark": "node benchmarks/js_bench.js"
+    "benchmark": "node benchmarks/js_bench.js",
+    "docs:dev": "vitepress dev docs",
+    "docs:build": "vitepress build docs",
+    "docs:preview": "vitepress preview docs"
   },
   "devDependencies": {
     "@napi-rs/cli": "^2.18.4",
-    "tinybench": "^2.9.0"
+    "lru-cache": "^11.5.2",
+    "tinybench": "^2.9.0",
+    "vitepress": "^1.0.2"
   },
   "engines": {
     "node": ">= 18"
   },
   "license": "MIT OR Apache-2.0",
   "optionalDependencies": {
-    "offheap-win32-x64-msvc": "0.1.0",
-    "offheap-darwin-x64": "0.1.0",
-    "offheap-linux-x64-gnu": "0.1.0"
+    "offheap-win32-x64-msvc": "0.2.0",
+    "offheap-darwin-x64": "0.2.0",
+    "offheap-linux-x64-gnu": "0.2.0"
   }
 }