better-lock 1.0.2 → 2.0.2-beta

package/README.md

@@ -6,6 +6,7 @@ A (better) node.js lock library.
 
 ### Features
 
+- Typescript-ready
 - Named and keyed locks
 - Queue and execution timeouts
 - Queue size limit
@@ -21,6 +22,8 @@ A (better) node.js lock library.
 
 ```bash
 npm install --save better-lock
+# or
+yarn add better-lock
 ```
 
 ### Usage examples
@@ -29,28 +32,25 @@ npm install --save better-lock
 
 ```javascript
 const lock = new BetterLock();
-//...
-lock
-  .acquire(() => {
-    // Inside the lock. Just make sure you return a promise
-    return doSomethingThatReturnsPromise()
-      .then(() => {
-         return 'my result';
-      });
-  })
-  .then(
-    res => {
-      // Outside the lock. You will get whatever the promise chain has returned.
-      console.log(res); // my result		
-    },
-    err => {
-      // Either your or BetterLock's error 
+
+try {
+  const res = await lock.acquire(async () => {
+    // Inside the lock. It will stay closed until the promise you return resolves or rejects.
+    await doSomeAsyncTask();
+    return 'my result';
   });
+
+  // Outside the lock. You will get whatever the promise chain has returned.
+  console.log(res); // "my result"
+}
+catch (err) {
+  // Either your or BetterLock's error
+}
 ```
 
 ##### Advanced example
 
-```javascript
+```typescript
 const lock = new BetterLock({
   name: 'FileLock',                  // To be used in error reporting and logging
   log: winstonLogger.debug,          // Give it your logger with appropeiate level
@@ -59,28 +59,30 @@ const lock = new BetterLock({
   queue_size: 1,                     // At most one pending job
 });
 
-function processFile(filename, callback) {
-  lock.acquire(filename, () => {
-    return appendToFile(filename)
-      .then(result => {
-        return updateDb(result);
-      });
-  }).then(result => {
-    callback(null, {
-      status: true,
-      result,
+async function processFile(filename) {
+  try {
+    const result = await lock.acquire(filename, async () => {
+      const appended = await appendToFile(filename);
+      return updateDb(appended);
     });
-  }).catch(err => {
+    return {
+      status: true,
+      result
+    };
+  }
+  catch (err) {
     if (err instanceof BetterLock.QueueOverflowError) {
-      return callback(null, {
-        status: false, // The job was discarded
-      });
+      // The job was discarded
+      return {
+        status: false
+      };
     }
+
     if (err instanceof BetterLock.ExecutionTimeoutError) {
       winstonLogger.warn('Potential swallowed callback! Stack trace to the entry site:', err.stack);
     }
-    return callback(err);
-  });
+    throw err;
+  }
 }
 
 ```
@@ -129,7 +131,7 @@ lock.acquire(done => {
   // Outside the lock
   if (err) {
     // Either your or BetterLock's error
-    console.error(err); 
+    console.error(err);
   }
 });
 ```
@@ -139,16 +141,17 @@ You can see a bunch more usage examples in the spec file, [here](spec/better_loc
 ### API
 
 - `new BetterLock(options)`  
-  Create a new instance of `BetterLock`. Options should match interface of `BetterLockOptions`. See below for details.
+  Create a new instance of `BetterLock`. Options should match interface `BetterLockOptions`. See below for details.
 
 - `BetterLock.acquire([key], executor, [callback], [jobOptions])`  
-  The main method you'll want to call. For each `key`, given `executor` will be called only one at a time. Returns a promise that will be resolved with whatever `executor` returns.
+  The main method you'll want to call. For each `key`, given `executor` will be called only one at a time. If you don't provide `callback`, it will return a promise that will be resolved with whatever `executor` returns.
+
   - `key`: Arbitrary string under which to lock. It allows you to use the same lock instance for multiple parallel concerns. Eg. this might be a database record id or filename.
   - `executor`: Function that will be called within the lock. This function should have one of two forms.
-    1. *Without arguments*, in which case it should return a promise. Lock will remain locked until the promise resolves.
-    2. *With single `done`* argument. In this case, the executor should call `done(err, res)` once it is done. Arguments passed to done will be passed to the callback of the lock.
+    1. _Without arguments_, in which case it should return a promise. Lock will remain locked until the promise resolves.
+    2. _With single `done`_ argument. In this case, the executor should call `done(err, res)` once it is done. Arguments passed to done will be passed to the callback of the lock.
   - `callback`: Optional callback that will be called once executor exits. Results from executor (resolved/rejected value or arguments given to `done`) will be passed along. This can be used in addition to the returned promise.
-  - `jobOptions`: An object that should match interface of `LockJobOptions`. A subset of main options that will serve as overrides for this particular job (for example, timeout settings).
+  - `jobOptions`: An object that should match interface `BetterLockJobOptions`. A subset of main options that will serve as overrides for this particular job (for example, timeout settings).
 
 - `BetterLock.canAcquire([key])`  
   Returns true if given key can be acquired.
@@ -159,10 +162,9 @@ You can see a bunch more usage examples in the spec file, [here](spec/better_loc
 - `BetterLock.abortAll()`  
   Abort all jobs for all keys. This is suitable to be called during shutdown of your app.
 
-
 ### Options
 
-All available options with defaults can be seen [here](src/options.js).
+All available options can be seen [here](src/options.ts).
 
 `BetterLockOptions` are provided when you construct a lock instance. A subset of options given in `LockJobOptions` can be provided when you call `lock.acquire`, as the last argument.
 
@@ -186,58 +188,96 @@ Most commonly used options are:
 - `queue_size`  
   Max queue size for waiting jobs.
 
-Options are presented using `snake_case`, but you can also provide them using `camelCase` keys, if that better suits your code style (eg. `extend_stack_traces` becomes `extendStackTraces`).
-
-During runtime, you can change the defaults like this:
+Default options are a static member `DEFAULT_OPTIONS` on the `BetterLock` class. That can be seen [here](src/better_lock.ts). During runtime, you can change the defaults like this:
 
 ```javascript
-const BetterLock = require('better-lock');
+import BetterLock from 'better-lock';
 
 BetterLock.DEFAULT_OPTIONS.wait_timeout = 1000;
-``` 
+```
 
-### Motivation
+### When to use
 
-I needed something like [async-lock](https://github.com/rogierschouten/async-lock), but a bit easier to debug.
+This library is a good fit if:
 
-This library improves upon `async-lock` in following ways:
+- You need a local lock in your node.js application.
+- You have some advanced needs, like multiple keys per lock, timeouts, aborting...
+- You like good error messages, with full stack traces.
+- You like good types, either through typescript or JSDoc comments
 
-- Good error messages and log facility
-- Added features (execution timeout, abort jobs...)
-- Extended stack traces (so when you get an error, you have a full stack trace of the original calling code)
-- JSDoc comments (helps if you're using an IDE)
+The library is not a good fit if:
 
-Following features are present in both libraries:
+- **You need lock reentrancy.**  
+  There is no good solution for this in node.js that I know of. And this library doesn't offer any.
 
-- Multiple keys per lock instance
-- Acquire multiple keys in a single call
-- Interface, with executor and the callback function
-- Promises
-- Timeout and queue limit
+- **You need a shared lock between different nodes**  
+  This library is a single process only. If you need to coordinate multiple apps or services, you need a different library.
 
-Following features are present in `async-lock`, but not here:
+### Change log
 
-- Domain reentrancy (domains are going away)
+#### **2.0.0** (_2021/05/30_)
 
-**NOTE:** If you want to sync multiple node instances doing the same operation, this library will not help you. You need something that works over network and can use a shared arbiter of who gets the lock (eg. redis).
+Major update. The entire library was rewritten in typescript, so you should now get typings in most editors. We also had to switch tests from mocha + chai to jest (easier ts integration).
 
-### Change log
+The API and features have remained largely the same, just a bit of a refresh.
+
+Non-breaking and internal changes:
+
+- We now export all error names as a type script type. A few other types as well.
+- Errors now have `name` parameter, which matches these names.
+
+Breaking changes:
 
-Date|Version|Change
-----|-------|------
-2018/06/04|0.1.1|You can now use a Number as job name
-2018/09/27|0.2.0|Code reformat, better pattern for loading options. No feature upgrades.
-2018/09/27|0.2.1|Better and customizable Promise detection. Restored DEFAULT_OPTIONS.
-2018/10/01|0.3.0|Can abort jobs waiting in queue.
-2018/10/01|0.3.1|Updated CI to use the current node versions (0.8 & 0.10). Older node versions should continue to work, but are no longer tested. Also, README updates.
-2019/01/28|1.0.0|Major update. Added multi-key locks and refactored a bunch of internals. Removed `OVERFLOW_STRATEGIES` and related options, which is mostly the reason for the major version bump. The library should otherwise work the same.
-2019/01/28|1.0.1|Handle empty key list
+- You can no longer use camel case versions of external-facing objects. Eg. you can no longer pass `waitTimeout` instead of `wait_timeout`. In retrospect, this was a pretty flaky API to maintain.
+
+- Internal `LockJob` class is no longer exported.
+
+- Also, errors no longer expose internal `LockJob` instances (`err.job`). We now instead provide the most important fields from the job (`id` and `keys`).
+
+- Error names have been renamed to have `BetterLock` prefix. Eg. `WaitTimeoutError` -> `BetterLockWaitTimeoutError`. This will influence `err.name` and `err.message` parameters. The idea here is, if you see `BetterLock` error in the wild, you will know what generated it.
+
+- We have renamed `BetterLock.BetterLockError` to `BetterLock.BaseError` and `BetterLock.BetterLockInternalError` to `BetterLock.InternalError` to better match the naming scheme.
+
+- Since Options are no longer a class but interface, we are no longer exporting them under `BetterLock.Options`. You can do `import {BetterLockOptions} from 'better-lock';` to get the typescript type.
+
+#### **1.0.1** (_2019/01/28_)
+
+Handle empty key list
+
+#### **1.0.0** (_2019/01/28_)
+
+Major version bump.
+
+- Added multi-key locks and refactored a bunch of internals.
+- Removed `OVERFLOW_STRATEGIES` and related options, which is mostly the reason for the major version bump. The library should otherwise work the same.
+
+#### **0.3.1** (_2018/10/01_)
+
+Updated CI to use the current node versions (0.8 & 0.10). Older node versions should continue to work, but are no longer tested. Also, README updates.
+
+#### **0.3.0** (_2018/10/01_)
+
+Can abort jobs waiting in queue.
+
+#### **0.2.1** (_2018/09/27_)
+
+- Better and customizable Promise detection.
+- Restored DEFAULT_OPTIONS.
+
+#### **0.2.0** (_2018/09/27_)
+
+Code reformat, better pattern for loading options. No feature upgrades.
+
+#### **0.1.1** (_2018/06/04_)
+
+You can now use a Number as job name
 
 ### Development
 
 Fork, then git clone. The project is already set up with a WebStorm project, if that's your cup of tee.
 
 To run tests, with coverage:
+
 ```
 npm run test
 ```
@@ -246,4 +286,4 @@ If you want to contribute, create a branch off master, do your work and then mak
 
 ## License
 
-[MIT](./LICENSE)
+[MIT](./LICENSE)

package/dist/better_lock.d.ts

@@ -0,0 +1,50 @@
+import { ILockJobOptions, IOptions } from './options';
+import { ICallback, ICallbackExecutor, ILockKey, IPromiseExecutor } from './types';
+/**
+ * Create a better lock object.
+ */
+export declare class BetterLock {
+    /**
+     * Default options to be used when creating BetterLock instances.
+     */
+    static DEFAULT_OPTIONS: IOptions;
+    private options;
+    private log;
+    private queues;
+    constructor(options?: IOptions);
+    /**
+     * Return or create a key queue for given key
+     */
+    private getQueue;
+    /**
+     * Returns true if the caller can *immediately* acquire the lock. There is nothing holding the key and nothing in the queue.
+     */
+    canAcquire(key?: string): boolean;
+    private normalizeAndValidateKey;
+    acquire<TResult>(executor: IPromiseExecutor<TResult>, jobOptions?: ILockJobOptions): Promise<TResult>;
+    acquire<TResult>(executor: ICallbackExecutor<TResult>, jobOptions?: ILockJobOptions): Promise<TResult>;
+    acquire<TResult>(executor: ICallbackExecutor<TResult>, callback: ICallback<TResult>, jobOptions?: ILockJobOptions): void;
+    acquire<TResult>(key: ILockKey | Array<ILockKey>, executor: IPromiseExecutor<TResult>, jobOptions?: ILockJobOptions): Promise<TResult>;
+    acquire<TResult>(key: ILockKey | Array<ILockKey>, executor: ICallbackExecutor<TResult>, jobOptions?: ILockJobOptions): Promise<TResult>;
+    acquire<TResult>(key: ILockKey | Array<ILockKey>, executor: ICallbackExecutor<TResult>, callback: ICallback<TResult>, jobOptions?: ILockJobOptions): void;
+    /**
+     * Update state of given list of queues.
+     */
+    private update;
+    private executeJob;
+    private onWaitTimeout;
+    private onExecutionTimeout;
+    private endJob;
+    /**
+     * Abort all jobs for a given key (or from the default job queue, if no key is given).
+     * Job executors will not be called. Callbacks will be called with JobAbortedError.
+     * Currently executing job will not be interrupted.
+     * @param [key]
+     */
+    abort(key?: ILockKey): void;
+    /**
+     * Abort all pending jobs from all queues.
+     * Currently executing jobs will not be interrupted.
+     */
+    abortAll(): void;
+}

package/dist/better_lock.js

@@ -0,0 +1,317 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BetterLock = void 0;
+var errors_1 = require("./errors");
+var internals_1 = require("./internals");
+var tools = require("./tools");
+/**
+ * Create a better lock object.
+ */
+var BetterLock = /** @class */ (function () {
+    function BetterLock(options) {
+        this.options = tools.assign({}, [BetterLock.DEFAULT_OPTIONS, options]);
+        this.log = tools.makeLog(this.options.name, this.options.log);
+        this.queues = {};
+    }
+    /**
+     * Return or create a key queue for given key
+     */
+    BetterLock.prototype.getQueue = function (key) {
+        if (key === undefined || key === null) {
+            key = internals_1.KeyQueue.DEFAULT_QUEUE_KEY;
+        }
+        var queue = this.queues[key];
+        if (!queue) {
+            queue = this.queues[key] = new internals_1.KeyQueue(String(key));
+        }
+        return queue;
+    };
+    /**
+     * Returns true if the caller can *immediately* acquire the lock. There is nothing holding the key and nothing in the queue.
+     */
+    BetterLock.prototype.canAcquire = function (key) {
+        var queue = this.getQueue(key);
+        return !queue.active && !queue.jobs.length;
+    };
+    BetterLock.prototype.normalizeAndValidateKey = function (key) {
+        if (key === undefined) {
+            return null;
+        }
+        if (key === null) {
+            return null;
+        }
+        if (tools.isString(key)) {
+            return key;
+        }
+        if (tools.isNumber(key)) {
+            return String(key);
+        }
+        // Invalid key value
+        throw new errors_1.BetterLockInvalidArgumentError(this.options.name, 'key', 'an instance of ILockKey: string, number, undefined or null', key);
+    };
+    /**
+     * Acquire the lock for given key or list of keys. If waiting on a list, keys will be acquired in order,
+     * as they become free. Any deadlock prevention must be handled by the caller.
+     *
+     * Once the lock is acquired, we will call the executor function, with a "done" method.
+     * You must call "done" to release the lock. Alternatively, return a Promise; lock will be released
+     * once promise resolves or rejects.
+     *
+     * Return values from your executor will be passed to callback (or the resulting promise).
+     *
+     * @param key Named key or array of keys for this particular call. Calls with different keys will be run in parallel. Not required.
+     * @param executor Function that will run inside the lock. Required.
+     * @param callback Function to be called after the executor finishes or if we never enter the lock (timeout, queue depletion). Leave out to use promises.
+     * @param jobOptions Options to be applied on this job only
+     */
+    BetterLock.prototype.acquire = function (key, executor, callback, jobOptions) {
+        var _this = this;
+        if (tools.isFunction(key) || tools.isObject(key)) {
+            // Presume we weren't given a key (first form)
+            jobOptions = callback;
+            callback = executor;
+            executor = key;
+            key = null;
+        }
+        // Repackage "key" into an array of keys
+        var keys = [];
+        if (Array.isArray(key)) {
+            var arrayOfKeys = key;
+            // Make sure we don't add duplicates
+            var seenKeys = new Set();
+            for (var i = 0; i < arrayOfKeys.length; i++) {
+                var normalizedKey = this.normalizeAndValidateKey(arrayOfKeys[i]);
+                if (!seenKeys.has(normalizedKey)) {
+                    keys.push(normalizedKey);
+                    seenKeys.add(normalizedKey);
+                }
+            }
+        }
+        else {
+            keys.push(this.normalizeAndValidateKey(key));
+        }
+        // Create callback wrapper for promise interface
+        if (!tools.isFunction(callback)) {
+            if (jobOptions === undefined) {
+                jobOptions = callback;
+            }
+            callback = tools.callbackWithPromise();
+        }
+        // Validate other options
+        if (!tools.isFunction(executor)) {
+            throw new errors_1.BetterLockInvalidArgumentError(this.options.name, 'executor', 'a function', executor);
+        }
+        if (!tools.isFunction(callback)) {
+            throw new errors_1.BetterLockInvalidArgumentError(this.options.name, 'callback', 'a function', callback);
+        }
+        // Prepare job options
+        var effectiveJobOptions = jobOptions
+            ? tools.assign({}, [this.options, jobOptions])
+            : // No need to create new object since these will be read-only and are subset of global options
+                this.options;
+        var job = new internals_1.LockJob(keys, executor, callback, effectiveJobOptions);
+        // Set incoming stack
+        if (effectiveJobOptions.extend_stack_traces) {
+            var tempErr = new Error();
+            Error.captureStackTrace(tempErr, this.acquire);
+            job.incoming_stack = tempErr.stack;
+        }
+        // Add job to its key queues
+        var queuesToUpdate = [];
+        for (var i = 0; i < keys.length; i++) {
+            var queue = this.getQueue(keys[i]);
+            queue.jobs.push(job);
+            queuesToUpdate.push(queue);
+        }
+        // Start wait timer, if enabled
+        if (tools.isNumber(job.options.wait_timeout)) {
+            job.wait_timeout_id = setTimeout(function () { return _this.onWaitTimeout(job); }, job.options.wait_timeout);
+            // NOTE: timeout of 0 will NOT trigger error if lock can be acquired immediately.
+        }
+        this.log("Enqueued " + job);
+        // Perform update of queues this job has modified. We don't do this in next tick or something,
+        // because we want canAcquire to immediately return false
+        if (queuesToUpdate.length) {
+            this.update(queuesToUpdate);
+        }
+        else {
+            // Special case. We are given empty list of keys. We will immediately execute jobs like this.
+            this.executeJob(job);
+        }
+        return callback.promise;
+    };
+    /**
+     * Update state of given list of queues.
+     */
+    BetterLock.prototype.update = function (queues) {
+        for (var i = 0; i < queues.length; i++) {
+            var queue = queues[i];
+            // If key is available, have next job grab it
+            if (!queue.active && queue.jobs.length) {
+                var job = queue.jobs.splice(0, 1)[0];
+                queue.active = job;
+                job.waiting_count--;
+                if (job.waiting_count <= 0) {
+                    // This job can be executed now.
+                    this.executeJob(job);
+                }
+            }
+            // Handle wait queue overflow
+            if (tools.isNumber(this.options.queue_size) && this.options.queue_size < queue.jobs.length) {
+                // Overflow. Reject the most recent job
+                var mostRecentJob = queue.jobs[queue.jobs.length - 1];
+                this.log(queue.toString() + " has overflown, so most recent job (" + mostRecentJob + ") was kicked out");
+                this.endJob(mostRecentJob, [
+                    new errors_1.BetterLockQueueOverflowError(this.options.name, queue.key, queue.jobs.length, mostRecentJob),
+                ]);
+            }
+        }
+    };
+    BetterLock.prototype.executeJob = function (job) {
+        var _this = this;
+        this.log("Executing " + job);
+        // Clear wait timeout
+        clearTimeout(job.wait_timeout_id);
+        job.wait_timeout_id = null;
+        // We want to do the rest of this in a separate context, because we don't want user executor code
+        // to ever interfere with the code calling acquire().
+        setImmediate(function () {
+            // Make sure job hasn't been ended in the meantime
+            if (job.executed_at || job.ended_at) {
+                return;
+            }
+            // Validate this job is holding all queues it needs
+            for (var i = 0; i < job.keys.length; i++) {
+                var queue = _this.getQueue(job.keys[i]);
+                if (queue.active !== job) {
+                    // This should never happen
+                    return _this.endJob(job, [
+                        new errors_1.BetterLockInternalError(_this.options.name, "Corrupted wait queue state for " + queue.key),
+                    ]);
+                }
+            }
+            // Mark job as having started executing
+            job.executed_at = new Date();
+            if (tools.isNumber(job.options.execution_timeout)) {
+                job.execution_timeout_id = setTimeout(function () { return _this.onExecutionTimeout(job); }, job.options.execution_timeout);
+            }
+            var lockDone = function () {
+                var args = [];
+                for (var _i = 0; _i < arguments.length; _i++) {
+                    args[_i] = arguments[_i];
+                }
+                _this.log("Done called for " + job);
+                _this.endJob(job, args);
+            };
+            if (job.executor.length > 0) {
+                // Callback interface
+                job.executor(lockDone);
+                return;
+            }
+            // Promise interface
+            var executorResult;
+            try {
+                executorResult = job.executor();
+            }
+            catch (err) {
+                // Error thrown directly from executor
+                lockDone(err);
+            }
+            // Promise sniffing
+            if (_this.options.promise_tester(executorResult)) {
+                executorResult.then(function (res) { return lockDone(null, res); }, function (err) { return lockDone(err); });
+            }
+            else {
+                // "promise" is just some random value. We don't have to wait
+                lockDone(null, executorResult);
+            }
+        });
+    };
+    BetterLock.prototype.onWaitTimeout = function (job) {
+        this.log(job + " has timed out after waiting in queue for " + (new Date().valueOf() - job.enqueued_at.valueOf()) + "ms");
+        this.endJob(job, [new errors_1.BetterLockWaitTimeoutError(this.options.name, job)]);
+    };
+    BetterLock.prototype.onExecutionTimeout = function (job) {
+        this.log(job + " has timed out after executing for " + (new Date().valueOf() - job.executed_at.valueOf()) + "ms");
+        this.endJob(job, [new errors_1.BetterLockExecutionTimeoutError(this.options.name, job)]);
+    };
+    BetterLock.prototype.endJob = function (job, callbackArgs) {
+        var _this = this;
+        if (job.ended_at) {
+            this.log("WARNING: " + job + " is trying to end, but it has already ended at " + job.ended_at.toISOString() + ". Called with arguments: " + callbackArgs);
+            return;
+        }
+        clearTimeout(job.wait_timeout_id);
+        job.wait_timeout_id = null;
+        clearTimeout(job.execution_timeout_id);
+        job.execution_timeout_id = null;
+        job.ended_at = new Date();
+        var queuesToUpdate = [];
+        for (var i = 0; i < job.keys.length; i++) {
+            var queue = this.getQueue(job.keys[i]);
+            queuesToUpdate.push(queue);
+            if (queue.active === job) {
+                // This job was holding on the queue's key
+                queue.active = null;
+            }
+            else {
+                // This job was still in wait list for this queue
+                var index = queue.jobs.indexOf(job);
+                if (index >= 0) {
+                    // Remove from queue
+                    queue.jobs.splice(index, 1);
+                }
+                else {
+                    // Something is wrong. Where did this job come from?
+                    this.log("WARNING: " + job + " is ending, but it is not found anywhere in the queue for " + queue.key);
+                }
+            }
+        }
+        // Call the callback
+        try {
+            job.callback.apply(null, callbackArgs);
+        }
+        finally {
+            // Whatever happens, schedule a queue update
+            setImmediate(function () { return _this.update(queuesToUpdate); });
+        }
+    };
+    /**
+     * Abort all jobs for a given key (or from the default job queue, if no key is given).
+     * Job executors will not be called. Callbacks will be called with JobAbortedError.
+     * Currently executing job will not be interrupted.
+     * @param [key]
+     */
+    BetterLock.prototype.abort = function (key) {
+        var _this = this;
+        var queue = this.getQueue(key);
+        queue.jobs.slice().forEach(function (job) {
+            _this.endJob(job, [new errors_1.BetterLockJobAbortedError(_this.options.name, job)]);
+        });
+        if (queue.active && !queue.active.executed_at) {
+            // If we have a job holding this queue that hasn't been executed yet, abort it as well
+            this.endJob(queue.active, [new errors_1.BetterLockJobAbortedError(this.options.name, queue.active)]);
+        }
+    };
+    /**
+     * Abort all pending jobs from all queues.
+     * Currently executing jobs will not be interrupted.
+     */
+    BetterLock.prototype.abortAll = function () {
+        this.abort(null);
+        for (var key in this.queues) {
+            // noinspection JSUnfilteredForInLoop
+            this.abort(key);
+        }
+    };
+    /**
+     * Default options to be used when creating BetterLock instances.
+     */
+    BetterLock.DEFAULT_OPTIONS = {
+        extend_stack_traces: true,
+        promise_tester: function (p) { return p && typeof p.then === 'function'; },
+    };
+    return BetterLock;
+}());
+exports.BetterLock = BetterLock;
+//# sourceMappingURL=better_lock.js.map