abstract-level

abstract-level is the base class behind the entire Level ecosystem — the successor to levelup — that defines a single, consistent key-value database interface implemented by concrete backends like memory-level, classic-level (LevelDB), and browser-level (IndexedDB). Rather than hand-rolling storage access per backend, packages extend AbstractLevel and inherit get/put/del/batch operations, iterators, chained batches, and snapshot support for free, while end users get an identical API no matter which storage engine sits underneath.

Beyond basic CRUD, it bakes in features usually left to individual implementations: pluggable per-key/value encodings via level-transcoder, namespaced sublevels for partitioning a single database without extra connections, a prewrite hook for intercepting batches before they hit the backend, and a lifecycle event model (opening/open/closing/closed, write, clear) that deferred operations queue against until the database finishes opening.

What You Get

• A single get/put/del/batch/iterator API that behaves identically across every Level-compatible storage backend
• Pluggable key and value encodings (utf8, json, buffer, or a custom codec) applied consistently across all operations
• Sublevels for partitioning one database into isolated, prefixed namespaces without opening separate connections
• A prewrite hook and lifecycle events (opening, open, write, clear, closing, closed) for intercepting and reacting to database activity
• Explicit and implicit snapshot support for consistent reads across async iteration

Common Use Cases

• Building a new storage backend - a database author implements the private _get/_put/_batch methods on AbstractLevel and instantly inherits encodings, sublevels, iterators, and hooks instead of writing them from scratch.
• Swapping storage engines per environment - an app author uses memory-level in tests and classic-level (LevelDB) in production, changing one constructor call because both share the abstract-level API.
• Namespacing data in one database - a library uses db.sublevel('cache') and db.sublevel('sessions') to keep independent key ranges in a single underlying store instead of managing multiple connections.
• Auditing or validating writes - an application registers a prewrite hook to inspect or transform every batch operation (e.g. stamping timestamps) before it reaches the storage engine.

Under The Hood

Architecture AbstractLevel extends Node’s EventEmitter and composes a handful of focused internal collaborators: DatabaseHooks (lib/hooks.js) for prewrite/newsub/postopen hooks, a DeferredQueue for operations issued before open() resolves, an EventMonitor that only computes event payloads when listeners are actually bound, a Transcoder (from level-transcoder) for key/value encoding, and PrewriteBatch for running batch operations through hooks before dispatch. Sublevels are implemented in lib/abstract-sublevel.js as thin wrappers that prefix keys onto a shared parent database rather than opening a new connection, and iterators (AbstractIterator/AbstractKeyIterator/AbstractValueIterator, plus Deferred variants) provide the same queued-until-open behavior as direct reads/writes. Concrete backends implement only the private _get/_put/_batch/_iterator methods; every other consumer-facing method, encoding, hook, and event lives in this one class, so a change to AbstractLevel’s public contract ripples into every implementation in the Level ecosystem (memory-level, classic-level, browser-level, many-level, and others) simultaneously.

Tech Stack The runtime is plain JavaScript (Node >=18) with no build step — it ships hand-written .d.ts type declarations rather than being authored in TypeScript. Runtime dependencies are narrowly scoped: level-supports for capability-manifest negotiation between an implementation and its consumers, level-transcoder for encodings, module-error for typed, coded errors, maybe-combine-errors for merging multiple close-time errors, and buffer/is-buffer for consistent Buffer behavior across Node and browsers. The devDependency set reflects a cross-runtime test strategy: tape and tap-arc for the assertion/reporting layer, nyc for coverage (published to Codecov), airtap with airtap-electron and airtap-playwright for running the same suite in real browsers and Electron, and babel/babelify only to bundle tests for those browser runs. ESLint (neostandard config) and hallmark lint both code and documentation, wired into GitHub Actions.

Code Quality The test/ directory contains 40+ dedicated suites covering get/put/batch/iterator/hooks/events/clear/encoding/sublevel behavior, and test/self.js runs that entire shared suite against a reference implementation to certify that the abstract class itself behaves correctly — the same suite every concrete Level backend reuses to certify its own compliance. Errors are raised via ModuleError with stable error codes (e.g. LEVEL_DATABASE_NOT_OPEN) rather than generic throws, and encapsulation is enforced with native private class fields (#status, #queue, etc.) instead of underscore-prefixed conventions. CI runs ESLint, hallmark, and the full coverage-instrumented test suite on every push, with coverage tracked via Codecov.

What Makes It Unique Rather than a single storage engine, abstract-level standardizes an interface that a wide set of independent backends (in-memory, LevelDB-backed, IndexedDB-backed, RPC-backed, and more) all implement, letting consumers swap storage engines behind one API. It goes further than a typical adapter interface by folding cross-cutting concerns directly into the shared base class: prefixed sublevels for namespacing without new connections, a prewrite hook for intercepting batches before they reach any backend, and ref-counted explicit/implicit snapshots for consistent reads during async iteration — capabilities that would otherwise have to be reimplemented, inconsistently, by each storage backend on its own.