Skip to content

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


Notifications You must be signed in to change notification settings


Repository files navigation


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

npm install level-hookdown

level badge npm Build Status dependencies Status devDependencies Status


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')

function posthook (operation, cb) {
  console.log('this should run after the db operation')


db.put('beep', 'boop', function (err) {
  if (err) throw err
  db.del('beep', function (err) {
    if (err) throw err
      { type: 'put', key: 'father', value: 'gloop' },
      { type: 'put', key: 'another', value: 'heep' }
    ], function (err) {
      if (err) throw err


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).



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.


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).


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: