offheap 0.1.0 → 0.2.0

package/.github/workflows/CI.yml

@@ -18,6 +18,12 @@ jobs:
           - host: ubuntu-latest
             target: x86_64-unknown-linux-gnu
             architecture: x64
+          - host: ubuntu-latest
+            target: x86_64-unknown-linux-musl
+            architecture: x64
+          - host: ubuntu-latest
+            target: aarch64-unknown-linux-musl
+            architecture: arm64
           - host: windows-latest
             target: x86_64-pc-windows-msvc
             architecture: x64
@@ -41,6 +47,16 @@ jobs:
           node-version: 20
           cache: npm
 
+      - name: Install musl-tools
+        if: matrix.settings.target == 'x86_64-unknown-linux-musl'
+        run: sudo apt-get update && sudo apt-get install -y musl-tools
+
+      - name: Install Zig
+        if: matrix.settings.target == 'aarch64-unknown-linux-musl'
+        uses: goto-bus-stop/setup-zig@v2
+        with:
+          version: 0.11.0
+
       - name: Install Rust
         uses: dtolnay/rust-toolchain@stable
         with:
@@ -61,7 +77,12 @@ jobs:
         run: npm ci
 
       - name: Build
-        run: npm run build -- --target ${{ matrix.settings.target }}
+        run: |
+          if [[ "${{ matrix.settings.target }}" == "aarch64-unknown-linux-musl" ]]; then
+            npm run build -- --target ${{ matrix.settings.target }} --zig
+          else
+            npm run build -- --target ${{ matrix.settings.target }}
+          fi
         shell: bash
 
       - name: Upload artifact

package/Cargo.toml

@@ -1,8 +1,8 @@
 [package]
 name = "offheap"
-version = "0.1.0"
+version = "0.2.0"
 edition = "2021"
-authors = ["Ryan Gustav"]
+authors = ["Ryan Gustavo"]
 license = "MIT OR Apache-2.0"
 
 [lib]

package/artifacts/bindings-aarch64-apple-darwin/index.d.ts

@@ -1,30 +1,42 @@
-/* tslint:disable */
-/* eslint-disable */
-
-/* auto-generated by NAPI-RS */
-
 export interface CacheConfig {
-  policy: string
-  capacity: number
+  policy: 'lru' | 'arc' | 'tinylfu';
+  capacity: number;
+  shards?: number;
+  maxBytes?: number;
 }
-export interface CacheStatsJs {
-  hits: number
-  misses: number
-  capacity: number
-  size: number
+
+export interface CacheStats {
+  hits: number;
+  misses: number;
+  capacity: number;
+  size: number;
+  bytesUsed: number;
 }
-export declare class Cache {
-  get(key: string): unknown
-  set(key: string, value: unknown, ttlMs?: number | undefined | null): unknown
-  delete(key: string): boolean
-  clear(): void
-  stats(): CacheStatsJs
-  keys(): Array<string>
+
+export class Cache {
+  get<T = any>(key: string): T | undefined;
+  peek<T = any>(key: string): T | undefined;
+  has(key: string): boolean;
+  set<T = any>(key: string, value: T, ttlMs?: number): T | undefined;
+  touch(key: string, ttlMs?: number): boolean;
+  delete(key: string): boolean;
+  clear(): void;
+  stats(): CacheStats;
+  keys(): string[];
+  increment(key: string, delta?: number, ttlMs?: number): number;
+  decrement(key: string, delta?: number, ttlMs?: number): number;
+  mget(keys: string[]): Record<string, any>;
+  mset(entries: Record<string, any>, ttlMs?: number): void;
+  mdelete(keys: string[]): number;
+  dispose(): void;
+  getOrSet<T = any>(key: string, factory: () => T | Promise<T>, ttlMs?: number): T | Promise<T>;
 }
-export declare class CacheManager {
-  constructor()
-  createCache(name: string, config: CacheConfig): Cache
-  getCache(name: string): Cache | null
-  deleteCache(name: string): boolean
-  clear(): void
+
+export class CacheManager {
+  constructor();
+  createCache(name: string, config: CacheConfig): Cache;
+  getCache(name: string): Cache | null;
+  deleteCache(name: string): boolean;
+  clear(): void;
+  dispose(): void;
 }

package/artifacts/bindings-aarch64-apple-darwin/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/artifacts/bindings-aarch64-unknown-linux-musl/index.d.ts

@@ -0,0 +1,42 @@
+export interface CacheConfig {
+  policy: 'lru' | 'arc' | 'tinylfu';
+  capacity: number;
+  shards?: number;
+  maxBytes?: number;
+}
+
+export interface CacheStats {
+  hits: number;
+  misses: number;
+  capacity: number;
+  size: number;
+  bytesUsed: number;
+}
+
+export class Cache {
+  get<T = any>(key: string): T | undefined;
+  peek<T = any>(key: string): T | undefined;
+  has(key: string): boolean;
+  set<T = any>(key: string, value: T, ttlMs?: number): T | undefined;
+  touch(key: string, ttlMs?: number): boolean;
+  delete(key: string): boolean;
+  clear(): void;
+  stats(): CacheStats;
+  keys(): string[];
+  increment(key: string, delta?: number, ttlMs?: number): number;
+  decrement(key: string, delta?: number, ttlMs?: number): number;
+  mget(keys: string[]): Record<string, any>;
+  mset(entries: Record<string, any>, ttlMs?: number): void;
+  mdelete(keys: string[]): number;
+  dispose(): void;
+  getOrSet<T = any>(key: string, factory: () => T | Promise<T>, ttlMs?: number): T | Promise<T>;
+}
+
+export class CacheManager {
+  constructor();
+  createCache(name: string, config: CacheConfig): Cache;
+  getCache(name: string): Cache | null;
+  deleteCache(name: string): boolean;
+  clear(): void;
+  dispose(): void;
+}