memdown
In-memory abstract-leveldown
store for Node.js and browsers.
Example
If you are upgrading: please see the upgrade guide.
const levelup = require('levelup')
const memdown = require('memdown')
const db = levelup(memdown())
db.put('hey', 'you', (err) => {
if (err) throw err
db.get('hey', { asBuffer: false }, (err, value) => {
if (err) throw err
console.log(value)
})
})
Your data is discarded when the process ends or you release a reference to the store. Note as well, though the internals of memdown
operate synchronously - levelup
does not.
Browser support
memdown
requires a ES5-capable browser. If you're using one that's isn't (e.g. PhantomJS, Android < 4.4, IE < 10) then you will need es5-shim.
Data types
Unlike leveldown
, memdown
does not stringify keys or values. This means that in addition to Buffers, you can store any JS type without the need for encoding-down
. For keys for example, you could use Buffers or strings, which sort lexicographically, or numbers, even Dates, which sort naturally. The only exceptions are null
and undefined
. Keys of that type are rejected; values of that type are converted to empty strings.
const db = levelup(memdown())
db.put(12, true, (err) => {
if (err) throw err
db.createReadStream({
keyAsBuffer: false,
valueAsBuffer: false
}).on('data', (entry) => {
console.log(typeof entry.key)
console.log(typeof entry.value)
})
})
If you desire normalization for keys and values (e.g. to stringify numbers), wrap memdown
with encoding-down
. Alternatively install level-mem
which conveniently bundles levelup
, memdown
and encoding-down
. Such an approach is also recommended if you want to achieve universal (isomorphic) behavior. For example, you could have leveldown
in a backend and memdown
in the frontend.
const encode = require('encoding-down')
const db = levelup(encode(memdown()))
db.put(12, true, (err) => {
if (err) throw err
db.createReadStream({
keyAsBuffer: false,
valueAsBuffer: false
}).on('data', (entry) => {
console.log(typeof entry.key)
console.log(typeof entry.value)
})
})
Snapshot guarantees
A memdown
store is backed by a fully persistent data structure and thus has snapshot guarantees. Meaning that reads operate on a snapshot in time, unaffected by simultaneous writes. Do note memdown
cannot uphold this guarantee for (copies of) object references. If you store object values, be mindful of mutating referenced objects:
const db = levelup(memdown())
const obj = { thing: 'original' }
db.put('key', obj, (err) => {
obj.thing = 'modified'
db.get('key', { asBuffer: false }, (err, value) => {
console.log(value === obj)
console.log(value.thing)
})
})
Conversely, when memdown
is wrapped with encoding-down
it stores representations rather than references.
const encode = require('encoding-down')
const db = levelup(encode(memdown(), { valueEncoding: 'json' }))
const obj = { thing: 'original' }
db.put('key', obj, (err) => {
obj.thing = 'modified'
db.get('key', { asBuffer: false }, (err, value) => {
console.log(value === obj)
console.log(value.thing)
})
})
Test
In addition to the regular npm test
, you can test memdown
in a browser of choice with:
npm run test-browser-local
To check code coverage:
npm run coverage
License
memdown
is Copyright (c) 2013-2017 Rod Vagg @rvagg and licensed under the MIT license. All rights not explicitly granted in the MIT license are reserved. See the included LICENSE file for more details.