Nanoprogrammed Penultimate Musicianship

    level-hookdown

    3.1.2 • Public • Published

    level-hookdown

    Simple levelup hooks implemented using instance method override of arbitrary levelups.

    npm install level-hookdown
    

    level badge npm Build Status dependencies Status devDependencies Status

    Usage

    var hook = require('level-hookdown')
    var mem = require('level-mem')  // or 'level' or other levelup factory
    var mdb = mem()
    var db = hook(mdb)
     
    function prehook (operation, cb) {
      console.log('this should run before the db operation')
      console.log(operation)
      cb()
    }
     
    function posthook (operation, cb) {
      console.log('this should run after the db operation')
      console.log(operation)
      cb()
    }
     
    db.prehooks.push(prehook)
    db.posthooks.push(posthook)
     
    db.put('beep', 'boop', function (err) {
      if (err) throw err
      db.del('beep', function (err) {
        if (err) throw err
        db.batch([
          { type: 'put', key: 'father', value: 'gloop' },
          { type: 'put', key: 'another', value: 'heep' }
        ], function (err) {
          if (err) throw err
          console.log('done')
        })
      })
    })
     

    API

    hookdb = hook(db, [options])

    Returns a levelup instance that executes a series of pre and post hook functions before put, del, and batch method calls. Composes well with mafintosh/subleveldown. Conflicts with dominictarr/level-sublevel.

    The following options can be set when wrapping a level with hook:

    {
      type: 'parallel' | 'series' | 'limit',
      limit: 5,
      protectHook: false
    }
    • The type determines if the hook functions are run in series, parallel or parallel-limit. Default is parallel.
    • The limit option is passed to run-parallel-limit when type is set to limit. The default is 5.
    • protectHook performs a deep copy on the operation array in batches to preserve values if the levelup mutates them (like subleveldown does).

    Hooks

    hookdb.prehooks

    An array of hook functions that are run before put, del, and batch method calls to the hookdb instance. If a hook function in the prehook array returns an err object to its callback, the originating put, del or batch operation will not be run on the contained db that hookdb is wrapping. A prehook veto convetion could be built on top of this behavior via error handling and retry.

    hookdb.posthooks

    An array of functions that are run after sucessful put, del, and batch method calls on the wrapped db instance inside a hookdb instance.

    hookFn(operation, callback)

    Hook functions receive an operation object that describes the level operation and a callback function.

    hookdb.prehooks and hookdb.posthooks are arrays that you can add, rearrange, and delete hook functions from using standard array methods like hookdb.prehooks.push(fn) and hookdb.posthooks.pop(fn).

    operation

    The operation argument can contain an object that looks like:

    • {type:'put', key: 'key', value: 'value', opts}
    • {type: 'del', key: 'key', opts}
    • {type: 'batch', array: [operationArray], opts}

    The opts object in the level operation object are the options that get passed through to the wrapped level.

    See Also

    This module is basically an alternative implementation of:

    but aimed at a subleveldown workflow. These were also influential:

    Install

    npm i level-hookdown

    DownloadsWeekly Downloads

    10

    Version

    3.1.2

    License

    MIT

    Unpacked Size

    18.6 kB

    Total Files

    8

    Last publish

    Collaborators

    • bret
    • ungoldman