flexlock

flexlock is a small, memory-concious, flexible, Promise-based locking library without dependencies.

npm i flexlock --save

It is similar to other in-memory locking library like mutexify, mutex-js, await-lock, and many more, but with more flexibility in how to use it. This makes it sturdier and more practical in many cases.

simple API when that suffices

const createLock = require('flexlock/createLock') // require('flexlock').createLock works too

const lock = createLock()

lock(async () => {
  // done before the next block
})
lock(async () => {
  // done after the previous block
})

Timeouts in case anther lock never returns

lock(() => new Promise()) // This never releases the lock
lock(async () => {}, 500)
  .catch(err => {
    err.code === 'ETIMEOUT'
  })

Propagation of errors and results

async function business () {
  try {
    const important = await lock(async () => {
      // do your thing
      return important
    })
    // You can use the important data here.
  } catch (err) {
    // Woops, something happened!
  }
}

Dedicated locks for more readable async code

async function business () {
  const unlock = await lock()
  // do your thing
  unlock()
}

release handlers both once and globally

const lock = createLock(() => {
  // called every time the lock is released
})

lock.released(function () {
  // called once, next time the lock is released
})

await lock.released() // Promise API available as well

Namespace support for multiple lockers

const createLocker = require('flexlock/createLocker') // require('flexlock').createLocker works too

const lock = createLocker()

async function business (id, content) {
  await lock(id, async () => {
    // do your thing, locked to this id!
  })
}

Implementation note: The locker will use createLock per id. It will keep the created lock until all locks for that id are released. Then it will pass the lock to the garbage collector.

License

MIT