flexlock's Introduction

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

flexlock's People

Contributors

Stargazers

Watchers

Forkers

kesla

flexlock's Issues

Implement multiple locks at the same time.

Right now, require('flexlock/createLocker') only allows a single key to lock towards lock(key, ...) but some code requires multiple resources to work, a new API that works like lock([keyA, keyB], ...) would be good. The obvious implementation would be to just use Promise.all to await three locks, but a more-complex implementation that allows other sublocks to receive early might be not a bad idea. In an example:

(A) lock(['users', 'user:11'], ...) → ... processing
(B) lock(['users', 'user:12'], ...) → ... waiting for (A) to finish
(C) lock('user:12') → processing
(A) finished, (B) → waiting for (C) to finish
(C) finished, (B) → processing
(B) finished

In that example (C) can start processing without waiting for (B) to finish because it only uses part of the resources of (B). This would require a more complicated implementation though.

martinheidegger / flexlock Goto Github PK