-
-
Notifications
You must be signed in to change notification settings - Fork 267
Modules
🐔 Note. We are in the process of moving this list of modules to Level/awesome. If you'd like to add yours, please consider making a PR to
Level/awesome(see Contributing) instead of editing this wiki. We welcome all contributions. Thanks for sharing your work! ❤️
- ORMs - Object Relational Models
- Plugins - extending LevelUP
- Modules - using LevelUP or providing external utilities for LevelUP
Dulcimer allows you define JSON models and then helps you manage indexes, children, foreign keys, and much more.
skeyma turns a ES6-like template string (like ${forumId}/${postId}) into parse/serialize stream transforms that convert objects like {forumId, postId, text} into KV objects like {key, text} and back.
Plugins extend LevelUP in some way, providing additional functionality beyond that provided by the core.
Adds the awesome bytewise sortable javascript type encoding as a native encoding for LevelUP.
Library to diff JSON objects into atomic put and delete operations, and apply change sets to objects. Useful with Levelup/LevelDB object synchronization.
Query your levelup instances with node.js streams with the mongodb query API.
myJSONStream()
.pipe(jsonquery({ val: { $and: [ { $gt: 970 }, { $gt: 950 } ] } })
.on('data', console.log);A full MongoDB query language implementation with INDEXES for querying your levelup/leveldb database.
// uses indexes
db.ensureIndex('tags');
db.ensureIndex('num');
db.query({ $and: [ { tags: 'tag1' }, { num: { $lt: 100 } } ] }); // results streamAdds typical atomic operations, like insert, replace and counter (increment/decrement) to LevelDB, and adds capacity to multiple parallel operations, like multi gets, multi inserts, and so on.
Auto incrementing keys. Read, write, delete fields in a record individually. Read, write, delete records.
A caching module you can place in front of a levelup database. It will cache a subset of the database in an in-memory LRU cache based on configuration. It has an optional synchronous API which will return from the cache only.
level-cache also doubles as in memory implementation of the LevelUP interface so that it can be used in unit tests or other situations where you want mocks.
Capped collections.
Provides a chainable API for db.batch()
db.cbatch()
.put('foo', 'bar')
.del('hello')
.exec(callback)Note: this functionality is now provided by LevelUP core*
Delete a continuous range of keys on a LevelDB.
deleteRange(db, {
start: "foo:"
, end: "foo;"
}, cb)Implements a hook mechanism that allows you to intercept put, delete and batch operations on a db. You can then turn those operations into batches.
Useful if you want to turn a put into an atomic batch for say an automatic map operation.
It is recommended that you use use level-sublevel instead of level-hooks directly
Yet another indexing plugin for your LevelDB. By providing only a low-level querying mechanism it gives you the power to build more complicated and optimized queries on top of it.
Create an inverted index for full-text search.
A live query of a range in LevelDB. Returns a streams2 stream
var stream = livefeed(db, { start: "foo:", end: "foo;" })Like db.createReadStream() except it's live / tailable. i.e. instead of ending, it will stay open and stream changes to the database as they are inserted.
Like a map-reduce but simpler. Has a batch component that runs periodically, and a real-time component that fills in the gaps. Good for generating inverted indexes.
Indexes for LevelUP built on map-reduce. Uses a custom indexing function for each index to parse and record index values for each entry. Provides getBy(index, value, function (err, data) {}) and createIndexedStream(index, value) methods on your LevelUP instance which return lists of the original entries indexed for those index/value combinations.
Overload LevelUP's get(), put() and del() so they also accept multiple keys & values:
db.put({ foo: 'bar', boom: 'bang', whoa: 'dude' }, function (err) { /* .. */ })
db.get([ 'foo', 'boom', 'whoa', 'wha' ], function (err, data) { /* .. */ })
db.del([ 'foo', 'boom', 'whoa', 'wha' ], function (err) { /* .. */ })Split your db up into multiple namespaces. Returns a LevelUP style db object put every key is automatically namespaced.
Saves JSON to your LevelDB using level-set with auto-generated UUID.
A generic pluggable query-engine system (that supports indexes) for levelup/leveldb databases.
Find all K/V-pairs prefixed by a certain key.
range(db, 'bucket:%s:', 'bucket-name').pipe(...)A durable job scheduler.
Persists and query scuttlebutt documents in LevelDB.
Saves JSON to your LevelDB. Converting your JSON to LevelDB key-value pair data structure.
Use LevelDB as a static file server.
An alternative approach to storing scuttlebutts in LevelDB.
A streaming storage engine based on LevelDB.
The level-subkey use the path to separate sections of levelup, with hooks! these sublevels are called dynamic subkey. The level-subkey is modified from level-sublevel.
var db = require('level-subkey')(require('levelup')('/tmp/db'))
var stuff = db.subkey('stuff') //sublevel() function is deprecated, use subkey() instead.
var animal = stuff.subkey('animal')
var plant = stuff.subkey('plant')
animal.put("pig", value, function () {})
db.put("/stuff/animal/pig", value, function(err){}) //=animal.put("pig",...
animal.put("../plant/cucumber", value, function (err) {}) //=plant.put("cucumber",Adds the ability to create subsections that present the same API as LevelUP, but only write/read to a prefixed section, or bucket, of the key-space. Each section also has level-hooks installed.
Sublevel partitions the database. Superlevel adds a super level to the root partition that allows accessing the entire database. This allows things like discovering sublevels and browsing the database content without knowledge of the sublevel structure.
Triggers for LevelUP. Runs an async job when a key changes. All jobs will eventually run, even across restarts!
Update keys without overlapping changes - makes it possible to implement an "atomic" incrementer, JSON merger, etc.
Automatically versioned data on put. Either specify the version going in or allow it to be timestamped. By default operations act on the most recent data, or you can stream the history of a single key.
Adds atomic updates, increments, array pushes, set additions, and user-defined atomic operations to LevelUP.
levels is a light-weight LevelDB full text search for node.js (Port of TJ's reds redis search engine to levelup)
A map reduce implementation on top of LevelDB. Allows you to define a map reduce query that will run on top of your db.
The map reduces are incremental, and you can query the results in real-time
Extends map-reduce and level-mapped-index to provide easy to setup chained map reduce. An example use case is to find the top 10 values after a reduce.
Adds the msgpack more efficient JSON serialization format as a native encoding for LevelUP.
Query your levelup/leveldb engine using a javascript property path array syntax with INDEXES.
db.ensureIndex('car.make');
db.query(['car', 'make', 'Toyota']); // results streamlevelup with Q promises
db.batch([
{ type: 'put', key: 'a', value: 1 },
{ type: 'put', key: 'b', value: 2 },
{ type: 'put', key: 'c', value: 3 }
])
.then(function() {
return db.createReadStream()
})
.progress(function(data) {
console.log(data)
})
.then(function() {
return db.close()
})Generic pluggable indexing system for leveldb/levelup.
db.ensureIndex('car.make');
db.getBy('car.make', 'Toyota');
db.dropIndex('car.make');A levelup plugin that enforces a time to live (TTL) on a given (sub)database. Supports level-sublevel 5 & 6, and level-spaces. Also respects level-lock locks.
Modules use LevelUP in some way, or provide useful external functionality, rather than specifically extending it.
stream cursor to iterate through a ReadStream / KeyStream / ValueStream. e.g. db.createReadStream().pipe(cursor.all(function (e, data) {}))
Sync graph-style data real-time between browsers and servers.
Inverted index built upon LevelUP
The array datatype inside leveldb.
Calculate rolling averages in a LevelDB.
LevelUP wrappers for co.
A deleteStream for LevelUp.
Implements the encoding logic of a LevelUP-style database interface.
Check if a datum exists without reading its value.
Node's fs module with leveldb as backend
Store key values pairs with lat/lon coordinates, and query using a radius.
A module to remove the old indexes in the same batch as the new ones are inserted
Job Queue in LevelDB for Node.js.
Map lists of data stored in a LevelDB to DOM elements.
An in-memory cache that keeps up to date with its source.
Simple LRU cache
Useful meta information about levelup methods.
Mirror and optionally transform data from one sublevel into another.
Move a value to another key, inside a LevelDB.
Stream in nearby places using the browser's geolocation and level-places.
Store objects in leveldb.
Streaming pagination for leveldb.
Open a leveldb handle multiple times.
Index properties of items that live in a tree of materialized paths
Store and retrieve places near a lat/long pair.
The queue datatype inside leveldb.
Reactive templating for data stored in a LevelDB.
High-level API for creating secondary indexes.
Create and query secondary indexes.
Streaming static file server based on LevelDB.
Framework-agnostic, LevelDB-backed web server session manager.
Backend server that exposes a level over authenticated cross domain websockets
An SQL front end for level-* databases.
Find all the sublevels of a given database, not requiring them to be in memory already.
Generate a tree from the sublevels of a leveldb, useful when there is no manifest.
Calculate sums in a LevelDB and get live updates.
Geospatial indexing for GeoJSON in LevelDB
The TRIE data structure and search algorithm, on top of leveldb.
Client side library for authenticating with and moving data over a level-socket
Use async iterators instead of readable streams to traverse the database.
A pass-through cache for arbitrary objects or binary data using LevelDB, expired by a TTL.
LevelUp + MemDown.
Expose a LevelDB over the network.
Access a LevelDB instance from multiple processes via HTTP.
pull-stream interface to LevelDB. (implement read streams, write streams, and realtime (tail/live) reads)
Small module to define a range of keys to use a LevelDB keys.
Range indexes for LevelDB
Manipulate string ranges for db.createReadStream()
Stream data into LevelDB via level-store over HTTP.