Local Key-Bucket and Directory Database

deputy builds on levelup to provide advanced querying for your embedded key-store. For now, deputy contains buckets and directories.

Buckets get niceties like proper Map-Reduce, key filters, indexes, and other queries.
Directories build on that with directory nodes that provide key-sets within itself.

arguments (
    key,
    value,
    function callback(err)
)

arguments (
    key,
    function callback(err, value)
)

arguments (
    key,
    function callback(err)
)

arguments (
    [key1, key2, ...],
    function callback(err, results)) 
)

arguments (
    key,
    function updater(result, cb),
    function callback(err)
)


// somekey: {description: 'this is a counter', counter: 1}
deputy.update('somekey', function(value, done) {
    value.counter += 1;
    done(value);
});
// somekey: {description: 'this is a counter', counter: 2}

arguments ( 
    function filter({key, data}) { return boolean },
    function callback(err, keys)
)

Calls filter with each key-value in the bucket. Return true to keep the key in the results

mapReduce

arguments (
    {
        map: function ({key, value}) { return [{key: mapkey, value: mapvalue}, ...]; },
        reduce: function (mapkey, [mapvalue, ...]) { return reduced; },
        batch: optional function ({mapkey: reduced, ...}) { return [{key: value}, ...]; },
        keys: optional [key, key, ...]
    },
    function callback(err, {mapkey: reduced, ...})
)

A map is called for each key pair. A map returns an array of key value pairs to be reduced. Key value pairs may be derived keys and values, or database keys and values. Each map call may return any size of key value pair array.

The reduce function is called from the collated mapkey, mapvalue pairs. A reduce function returns a single result to be assigned to that mapkey as a whole.

The optional batch function returns an array of database keys with their values to set in batch, atomic with the rest of the map-reduce. Batches use levelup syntax https://github.com/rvagg/node-levelup#batch

The callback recieves an object of mapkeys, each with their reduced value.

If keys are supplied, those keys will be mapped reduced. In the future, this will be a generator or an array.

arguments (
    function atomic_action(done_callback)
)

While levelup does keep key commands in order, and batches allow atomic batch writes and reads, other javascript events may insert commands outside of batches, for things like a write dependant on the value of a read.

This gives you a function where all commands are locked until execution is finished.

All of Bucket plus...

arguments (
    path,
    function callback(err)
)

arguments (
   start_path,
   end_path,
   function callback(err)
)

arguments (
    start_path,
    type,
    end_path,
    function callback(err)
)

arguments (
    path,
    type,
    data,
    function callback(err)
)

arguments (
    path,
    type,
    function callback(err, result)
)

• EventEmitter (WildEmitter) for key CRUD in buckets and directories.
• Directory tweaked map-reduce to include directory index information.
• Explicit index support in Bucket (queryByIndex, setIndex, etc)
• Generators for key filters