keyv-lmdb 1.0.0

package/lib/index.d.ts

@@ -0,0 +1,30 @@
+import { type RootDatabaseOptionsWithPath } from 'lmdb';
+import EventEmitter from 'events';
+import type { KeyvStoreAdapter } from 'keyv';
+export interface Options extends RootDatabaseOptionsWithPath {
+    /** LMDB database name (for multiple DBs under one root) */
+    name?: string;
+    /** @internal Required by keyv for iterable adapter detection */
+    dialect: string;
+}
+export declare const defaultOpts: Options;
+export declare class KeyvLmdb extends EventEmitter implements KeyvStoreAdapter {
+    ttlSupport: boolean;
+    namespace?: string;
+    opts: Options;
+    private _db;
+    private _root;
+    constructor(options?: Options);
+    private _prefixKey;
+    private _unwrapKey;
+    get<Value>(key: string): Promise<Value | undefined>;
+    getMany<Value>(keys: string[]): Promise<Array<Value | undefined>>;
+    set(key: string, value: any, _ttl?: number): Promise<void>;
+    delete(key: string): Promise<boolean>;
+    deleteMany(keys: string[]): Promise<boolean>;
+    clear(): Promise<void>;
+    has(key: string): Promise<boolean>;
+    disconnect(): Promise<void>;
+    iterator(namespace?: string): AsyncGenerator<any[], void, unknown>;
+}
+export default KeyvLmdb;

package/lib/index.js

@@ -0,0 +1,99 @@
+'use strict';
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.KeyvLmdb = exports.defaultOpts = void 0;
+const lmdb_1 = require("lmdb");
+const events_1 = __importDefault(require("events"));
+exports.defaultOpts = {
+    path: `${process.cwd()}/keyv-lmdb-data`,
+    dialect: 'redis',
+};
+class KeyvLmdb extends events_1.default {
+    ttlSupport = false;
+    namespace;
+    opts;
+    _db;
+    _root;
+    constructor(options) {
+        super();
+        this.opts = Object.assign({}, exports.defaultOpts, options);
+        const { name, dialect: _, ...lmdbOpts } = this.opts;
+        if (name) {
+            this._root = (0, lmdb_1.open)(this.opts.path, lmdbOpts);
+            this._db = this._root.openDB({ name });
+        }
+        else {
+            this._root = (0, lmdb_1.open)(this.opts.path, lmdbOpts);
+            this._db = this._root;
+        }
+    }
+    _prefixKey(key) {
+        return this.namespace ? `${this.namespace}:${key}` : key;
+    }
+    _unwrapKey(prefixedKey) {
+        if (this.namespace && prefixedKey.startsWith(this.namespace + ':')) {
+            return prefixedKey.slice(this.namespace.length + 1);
+        }
+        return prefixedKey;
+    }
+    async get(key) {
+        try {
+            return this._db.get(this._prefixKey(key));
+        }
+        catch {
+            return undefined;
+        }
+    }
+    async getMany(keys) {
+        return Promise.all(keys.map((key) => this.get(key)));
+    }
+    async set(key, value, _ttl) {
+        await this._db.put(this._prefixKey(key), value);
+    }
+    async delete(key) {
+        const prefixedKey = this._prefixKey(key);
+        const existed = this._db.doesExist(prefixedKey);
+        await this._db.remove(prefixedKey);
+        return existed;
+    }
+    async deleteMany(keys) {
+        let allDeleted = true;
+        for (const key of keys) {
+            const deleted = await this.delete(key);
+            if (!deleted)
+                allDeleted = false;
+        }
+        return allDeleted;
+    }
+    async clear() {
+        const prefix = this.namespace ? this.namespace + ':' : '';
+        const keysToDelete = [];
+        for (const { key } of this._db.getRange({
+            start: prefix,
+            end: prefix ? prefix + '\xFF' : undefined,
+        })) {
+            keysToDelete.push(key);
+        }
+        for (const k of keysToDelete) {
+            await this._db.remove(k);
+        }
+    }
+    async has(key) {
+        return this._db.doesExist(this._prefixKey(key));
+    }
+    async disconnect() {
+        this._db.close();
+    }
+    async *iterator(namespace) {
+        const prefix = namespace ? namespace : '';
+        const end = prefix ? prefix + '\xFF' : undefined;
+        for (const { key, value } of this._db.getRange({ start: prefix, end })) {
+            const unwrappedKey = this._unwrapKey(key);
+            yield [unwrappedKey, value];
+        }
+    }
+}
+exports.KeyvLmdb = KeyvLmdb;
+exports.default = KeyvLmdb;

package/package.json

@@ -0,0 +1,37 @@
+{
+  "name": "keyv-lmdb",
+  "version": "1.0.0",
+  "description": "LMDB storage adapter for Keyv, using lmdb-js for fast and reliable key-value storage.",
+  "main": "lib/index.js",
+  "typings": "lib/index",
+  "types": "./lib/index",
+  "scripts": {
+    "build": "tsc",
+    "test": "tsc && rm -rf ./node_modules/.cache && vitest run",
+    "preversion": "pnpm test",
+    "postversion": "git add -A && git push origin master --tags"
+  },
+  "files": [
+    "lib"
+  ],
+  "keywords": [
+    "keyv",
+    "lmdb",
+    "storage",
+    "cache",
+    "fast"
+  ],
+  "author": "zaaack",
+  "license": "MIT",
+  "devDependencies": {
+    "@keyv/test-suite": "^2.1.2",
+    "@types/node": "^24.5.2",
+    "keyv": "^5.6.0",
+    "typescript": "^5.9.3",
+    "vitest": "^3.2.4"
+  },
+  "dependencies": {
+    "lmdb": "^3.0.0"
+  },
+  "packageManager": "pnpm@9.6.0+sha512.38dc6fba8dba35b39340b9700112c2fe1e12f10b17134715a4aa98ccf7bb035e76fd981cf0bb384dfa98f8d6af5481c2bef2f4266a24bfa20c34eb7147ce0b5e"
+}