async-queue-runner 0.19.0 → 1.0.0

package/_cjs/action.js

@@ -7,6 +7,13 @@ class Action {
         if (opts.delay)
             this.delay = opts.delay;
     }
+    async onError(error, context) {
+        const logger = context.logger;
+        if (typeof logger?.error === 'function') {
+            logger.error(error);
+        }
+        context.abort();
+    }
 }
 exports.Action = Action;
 class LockingAction extends Action {

package/_cjs/index.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.util = exports.lockingClassFactory = exports.Action = exports.AsyncQueue = exports.QueueRunner = void 0;
+exports.util = exports.LockManager = exports.lockingClassFactory = exports.Action = exports.AsyncQueue = exports.QueueRunner = void 0;
 var runner_js_1 = require("./runner.js");
 Object.defineProperty(exports, "QueueRunner", { enumerable: true, get: function () { return runner_js_1.QueueRunner; } });
 var queue_js_1 = require("./queue.js");
@@ -8,5 +8,7 @@ Object.defineProperty(exports, "AsyncQueue", { enumerable: true, get: function (
 var action_js_1 = require("./action.js");
 Object.defineProperty(exports, "Action", { enumerable: true, get: function () { return action_js_1.Action; } });
 Object.defineProperty(exports, "lockingClassFactory", { enumerable: true, get: function () { return action_js_1.lockingClassFactory; } });
+var locking_js_1 = require("./locking.js");
+Object.defineProperty(exports, "LockManager", { enumerable: true, get: function () { return locking_js_1.LockManager; } });
 var utils_js_1 = require("./utils.js");
 Object.defineProperty(exports, "util", { enumerable: true, get: function () { return utils_js_1.util; } });

package/_cjs/locking.js

@@ -0,0 +1,62 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.assertValidScope = exports.isLockingAction = exports.LockManager = void 0;
+function reversePromiseFactory() {
+    let resolve = () => { };
+    const promise = new Promise((res) => {
+        resolve = res;
+    });
+    return {
+        promise,
+        resolve,
+    };
+}
+class LockManager {
+    lockedScopes = new Map();
+    isLocked(scope) {
+        return this.lockedScopes.has(scope);
+    }
+    lock(scope) {
+        if (this.lockedScopes.has(scope)) {
+            throw new Error(`scope "${scope}" is already locked`);
+        }
+        this.lockedScopes.set(scope, reversePromiseFactory());
+    }
+    unlock(scope) {
+        if (!this.lockedScopes.has(scope)) {
+            return;
+        }
+        this.lockedScopes.get(scope).resolve();
+        this.lockedScopes.delete(scope);
+    }
+    wait(scope) {
+        if (!this.lockedScopes.has(scope)) {
+            return Promise.resolve();
+        }
+        return this.lockedScopes.get(scope).promise;
+    }
+    async runWithLock(scope, fn) {
+        if (this.isLocked(scope)) {
+            await this.wait(scope);
+        }
+        this.lock(scope);
+        try {
+            await fn();
+        }
+        finally {
+            this.unlock(scope);
+        }
+    }
+}
+exports.LockManager = LockManager;
+function isLockingAction(action) {
+    return action.locking === true;
+}
+exports.isLockingAction = isLockingAction;
+function assertValidScope(scope) {
+    if (typeof scope !== 'string' || scope.trim().length === 0) {
+        throw new TypeError('Lock scope must be a non-empty string');
+    }
+    return scope;
+}
+exports.assertValidScope = assertValidScope;

package/_cjs/queue-context.js

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.QueueContextImpl = void 0;
+class QueueContextImpl {
+    pushFn;
+    nameFn;
+    abortFn;
+    constructor(opts) {
+        this.pushFn = opts.push;
+        this.nameFn = opts.name;
+        this.abortFn = opts.abort;
+    }
+    push = (actions) => {
+        this.pushFn(actions);
+    };
+    extend = (obj) => {
+        Object.assign(this, obj);
+    };
+    name = () => {
+        return this.nameFn();
+    };
+    abort = () => {
+        this.abortFn();
+    };
+    initialize = (context) => {
+        Object.assign(this, context);
+    };
+}
+exports.QueueContextImpl = QueueContextImpl;

package/_cjs/queue-executor.js

@@ -0,0 +1,50 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.QueueExecutor = void 0;
+const locking_js_1 = require("./locking.js");
+class QueueExecutor {
+    opts;
+    constructor(opts) {
+        this.opts = opts;
+    }
+    async run(context) {
+        this.opts.context.initialize(context);
+        try {
+            while (true) {
+                if (this.opts.queue.length === 0) {
+                    this.opts.logger.info(`Queue(${this.opts.name}): stopped`);
+                    break;
+                }
+                const item = this.opts.queue.shift();
+                const action = this.opts.processQueueItem(item);
+                const actionName = action.constructor.name || 'some undefined';
+                this.opts.logger.setContext(actionName);
+                this.opts.logger.info(`Queue(${this.opts.name}): running action`);
+                const runAction = async () => {
+                    try {
+                        await this.opts.iterate(action);
+                    }
+                    catch (e) {
+                        await this.opts.handleActionError(action, e);
+                    }
+                };
+                if ((0, locking_js_1.isLockingAction)(action)) {
+                    const scope = (0, locking_js_1.assertValidScope)(action.scope);
+                    if (this.opts.lockManager.isLocked(scope)) {
+                        this.opts.logger.info(`Queue(${this.opts.name}): waiting for scope to unlock`);
+                    }
+                    await this.opts.lockManager.runWithLock(scope, runAction);
+                }
+                else {
+                    await runAction();
+                }
+            }
+            this.opts.end();
+        }
+        catch (e) {
+            this.opts.logger.info(`Queue(${this.opts.name}) failed`);
+            this.opts.logger.error(e);
+        }
+    }
+}
+exports.QueueExecutor = QueueExecutor;

package/_cjs/queue.js

@@ -2,6 +2,8 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.AsyncQueue = void 0;
 const action_js_1 = require("./action.js");
+const queue_context_js_1 = require("./queue-context.js");
+const queue_executor_js_1 = require("./queue-executor.js");
 const logger = {
     info(message) {
         console.log(message);
@@ -14,69 +16,56 @@ class AsyncQueue {
     queue = [];
     end;
     logger;
-    locker;
-    loopAction = false;
-    context = {
-        push: (actions) => this.push(actions),
-        stop: () => { this.loopAction = false; },
-        extend: (obj) => Object.assign(this.context, obj),
-        name: () => this.name,
-        abort: () => {
-            while (this.queue.length > 0) {
-                this.queue.pop();
-            }
-        },
-    };
+    lockManager;
+    context;
     constructor(opts) {
         this.queue = opts.actions;
         this.name = opts.name;
         this.end = opts.end || (() => { });
         this.logger = opts.logger || logger;
-        this.locker = opts.lockingContext;
+        this.lockManager = opts.lockingContext;
+        this.context = new queue_context_js_1.QueueContextImpl({
+            push: (actions) => this.push(actions),
+            name: () => this.name,
+            abort: () => {
+                while (this.queue.length > 0) {
+                    this.queue.pop();
+                }
+            },
+        });
     }
     async delay(timeout) {
         return new Promise((res) => setTimeout(res, timeout));
     }
     async run(context) {
-        this.loopAction = true;
-        Object.assign(this.context, context);
-        try {
-            while (this.loopAction) {
-                if (this.queue.length === 0) {
-                    this.loopAction = false;
-                    this.logger.info(`Queue(${this.name}): stopped`);
-                    break;
-                }
-                const item = this.queue.shift();
-                const action = this.processQueueItem(item);
-                const actionName = action.constructor.name || 'some undefined';
-                this.logger.setContext(actionName);
-                const isLocking = action.locking;
-                const scope = action.scope;
-                if (isLocking) {
-                    if (this.locker.isLocked(scope)) {
-                        this.logger.info(`Queue(${this.name}): waiting for scope to unlock`);
-                        await this.locker.wait(scope);
-                    }
-                    this.locker.lock(scope);
-                }
-                this.logger.info(`Queue(${this.name}): running action`);
-                await this.iterate(action);
-                if (isLocking) {
-                    this.locker.unlock(scope);
-                }
-            }
-            this.end();
-        }
-        catch (e) {
-            this.logger.info(`Queue(${this.name}) failed`);
-            this.logger.error(e);
-        }
+        const executor = new queue_executor_js_1.QueueExecutor({
+            name: this.name,
+            queue: this.queue,
+            logger: this.logger,
+            lockManager: this.lockManager,
+            context: this.context,
+            end: this.end,
+            processQueueItem: (item) => this.processQueueItem(item),
+            iterate: (action) => this.iterate(action),
+            handleActionError: (action, error) => this.handleActionError(action, error),
+        });
+        await executor.run(context);
     }
     async iterate(action) {
         await action.execute(this.context);
         await this.delay(action.delay);
     }
+    async handleActionError(action, error) {
+        const err = error instanceof Error ? error : new Error(String(error));
+        try {
+            await action.onError(err, this.context);
+        }
+        catch (handlerError) {
+            this.logger.info(`Queue(${this.name}) onError failed`);
+            this.logger.error(handlerError);
+            this.context.abort();
+        }
+    }
     push(actions) {
         this.queue.unshift(...actions);
     }

package/_cjs/runner.js

@@ -2,16 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.QueueRunner = void 0;
 const queue_js_1 = require("./queue.js");
-function reversePromiseFactory() {
-    let resolve = (value) => { };
-    const promise = new Promise((res) => {
-        resolve = res;
-    });
-    return {
-        promise,
-        resolve,
-    };
-}
+const locking_js_1 = require("./locking.js");
 class QueueRunner {
     queues = new Map();
     listeners = [];
@@ -24,35 +15,7 @@ class QueueRunner {
         this.locking = this.preparteLockingContext();
     }
     preparteLockingContext() {
-        const lockedScopes = new Map();
-        const unlock = (scope) => {
-            if (!lockedScopes.has(scope)) {
-                return;
-            }
-            lockedScopes.get(scope).resolve();
-            lockedScopes.delete(scope);
-        };
-        const wait = (scope) => {
-            if (!lockedScopes.has(scope)) {
-                return Promise.resolve();
-            }
-            return lockedScopes.get(scope).promise;
-        };
-        const lock = (scope) => {
-            if (lockedScopes.has(scope)) {
-                throw new Error(`scope "${scope}" is already locked`);
-            }
-            lockedScopes.set(scope, reversePromiseFactory());
-        };
-        const isLocked = (scope) => {
-            return lockedScopes.has(scope);
-        };
-        return {
-            isLocked,
-            lock,
-            unlock,
-            wait,
-        };
+        return new locking_js_1.LockManager();
     }
     add(actions, context = {}, name = this.getName()) {
         const queue = new queue_js_1.AsyncQueue({

package/_esm/action.js

@@ -4,6 +4,13 @@ export class Action {
         if (opts.delay)
             this.delay = opts.delay;
     }
+    async onError(error, context) {
+        const logger = context.logger;
+        if (typeof logger?.error === 'function') {
+            logger.error(error);
+        }
+        context.abort();
+    }
 }
 export class LockingAction extends Action {
     locking = true;

package/_esm/index.js

@@ -1,4 +1,5 @@
 export { QueueRunner } from './runner.js';
 export { AsyncQueue } from './queue.js';
 export { Action, lockingClassFactory } from './action.js';
+export { LockManager } from './locking.js';
 export { util } from './utils.js';

package/_esm/locking.js

@@ -0,0 +1,56 @@
+function reversePromiseFactory() {
+    let resolve = () => { };
+    const promise = new Promise((res) => {
+        resolve = res;
+    });
+    return {
+        promise,
+        resolve,
+    };
+}
+export class LockManager {
+    lockedScopes = new Map();
+    isLocked(scope) {
+        return this.lockedScopes.has(scope);
+    }
+    lock(scope) {
+        if (this.lockedScopes.has(scope)) {
+            throw new Error(`scope "${scope}" is already locked`);
+        }
+        this.lockedScopes.set(scope, reversePromiseFactory());
+    }
+    unlock(scope) {
+        if (!this.lockedScopes.has(scope)) {
+            return;
+        }
+        this.lockedScopes.get(scope).resolve();
+        this.lockedScopes.delete(scope);
+    }
+    wait(scope) {
+        if (!this.lockedScopes.has(scope)) {
+            return Promise.resolve();
+        }
+        return this.lockedScopes.get(scope).promise;
+    }
+    async runWithLock(scope, fn) {
+        if (this.isLocked(scope)) {
+            await this.wait(scope);
+        }
+        this.lock(scope);
+        try {
+            await fn();
+        }
+        finally {
+            this.unlock(scope);
+        }
+    }
+}
+export function isLockingAction(action) {
+    return action.locking === true;
+}
+export function assertValidScope(scope) {
+    if (typeof scope !== 'string' || scope.trim().length === 0) {
+        throw new TypeError('Lock scope must be a non-empty string');
+    }
+    return scope;
+}

package/_esm/queue-context.js

@@ -0,0 +1,25 @@
+export class QueueContextImpl {
+    pushFn;
+    nameFn;
+    abortFn;
+    constructor(opts) {
+        this.pushFn = opts.push;
+        this.nameFn = opts.name;
+        this.abortFn = opts.abort;
+    }
+    push = (actions) => {
+        this.pushFn(actions);
+    };
+    extend = (obj) => {
+        Object.assign(this, obj);
+    };
+    name = () => {
+        return this.nameFn();
+    };
+    abort = () => {
+        this.abortFn();
+    };
+    initialize = (context) => {
+        Object.assign(this, context);
+    };
+}

package/_esm/queue-executor.js

@@ -0,0 +1,46 @@
+import { assertValidScope, isLockingAction } from './locking.js';
+export class QueueExecutor {
+    opts;
+    constructor(opts) {
+        this.opts = opts;
+    }
+    async run(context) {
+        this.opts.context.initialize(context);
+        try {
+            while (true) {
+                if (this.opts.queue.length === 0) {
+                    this.opts.logger.info(`Queue(${this.opts.name}): stopped`);
+                    break;
+                }
+                const item = this.opts.queue.shift();
+                const action = this.opts.processQueueItem(item);
+                const actionName = action.constructor.name || 'some undefined';
+                this.opts.logger.setContext(actionName);
+                this.opts.logger.info(`Queue(${this.opts.name}): running action`);
+                const runAction = async () => {
+                    try {
+                        await this.opts.iterate(action);
+                    }
+                    catch (e) {
+                        await this.opts.handleActionError(action, e);
+                    }
+                };
+                if (isLockingAction(action)) {
+                    const scope = assertValidScope(action.scope);
+                    if (this.opts.lockManager.isLocked(scope)) {
+                        this.opts.logger.info(`Queue(${this.opts.name}): waiting for scope to unlock`);
+                    }
+                    await this.opts.lockManager.runWithLock(scope, runAction);
+                }
+                else {
+                    await runAction();
+                }
+            }
+            this.opts.end();
+        }
+        catch (e) {
+            this.opts.logger.info(`Queue(${this.opts.name}) failed`);
+            this.opts.logger.error(e);
+        }
+    }
+}

package/_esm/queue.js

@@ -1,4 +1,6 @@
 import { Action } from './action.js';
+import { QueueContextImpl } from './queue-context.js';
+import { QueueExecutor } from './queue-executor.js';
 const logger = {
     info(message) {
         console.log(message);
@@ -11,69 +13,56 @@ export class AsyncQueue {
     queue = [];
     end;
     logger;
-    locker;
-    loopAction = false;
-    context = {
-        push: (actions) => this.push(actions),
-        stop: () => { this.loopAction = false; },
-        extend: (obj) => Object.assign(this.context, obj),
-        name: () => this.name,
-        abort: () => {
-            while (this.queue.length > 0) {
-                this.queue.pop();
-            }
-        },
-    };
+    lockManager;
+    context;
     constructor(opts) {
         this.queue = opts.actions;
         this.name = opts.name;
         this.end = opts.end || (() => { });
         this.logger = opts.logger || logger;
-        this.locker = opts.lockingContext;
+        this.lockManager = opts.lockingContext;
+        this.context = new QueueContextImpl({
+            push: (actions) => this.push(actions),
+            name: () => this.name,
+            abort: () => {
+                while (this.queue.length > 0) {
+                    this.queue.pop();
+                }
+            },
+        });
     }
     async delay(timeout) {
         return new Promise((res) => setTimeout(res, timeout));
     }
     async run(context) {
-        this.loopAction = true;
-        Object.assign(this.context, context);
-        try {
-            while (this.loopAction) {
-                if (this.queue.length === 0) {
-                    this.loopAction = false;
-                    this.logger.info(`Queue(${this.name}): stopped`);
-                    break;
-                }
-                const item = this.queue.shift();
-                const action = this.processQueueItem(item);
-                const actionName = action.constructor.name || 'some undefined';
-                this.logger.setContext(actionName);
-                const isLocking = action.locking;
-                const scope = action.scope;
-                if (isLocking) {
-                    if (this.locker.isLocked(scope)) {
-                        this.logger.info(`Queue(${this.name}): waiting for scope to unlock`);
-                        await this.locker.wait(scope);
-                    }
-                    this.locker.lock(scope);
-                }
-                this.logger.info(`Queue(${this.name}): running action`);
-                await this.iterate(action);
-                if (isLocking) {
-                    this.locker.unlock(scope);
-                }
-            }
-            this.end();
-        }
-        catch (e) {
-            this.logger.info(`Queue(${this.name}) failed`);
-            this.logger.error(e);
-        }
+        const executor = new QueueExecutor({
+            name: this.name,
+            queue: this.queue,
+            logger: this.logger,
+            lockManager: this.lockManager,
+            context: this.context,
+            end: this.end,
+            processQueueItem: (item) => this.processQueueItem(item),
+            iterate: (action) => this.iterate(action),
+            handleActionError: (action, error) => this.handleActionError(action, error),
+        });
+        await executor.run(context);
     }
     async iterate(action) {
         await action.execute(this.context);
         await this.delay(action.delay);
     }
+    async handleActionError(action, error) {
+        const err = error instanceof Error ? error : new Error(String(error));
+        try {
+            await action.onError(err, this.context);
+        }
+        catch (handlerError) {
+            this.logger.info(`Queue(${this.name}) onError failed`);
+            this.logger.error(handlerError);
+            this.context.abort();
+        }
+    }
     push(actions) {
         this.queue.unshift(...actions);
     }

package/_esm/runner.js

@@ -1,14 +1,5 @@
 import { AsyncQueue } from "./queue.js";
-function reversePromiseFactory() {
-    let resolve = (value) => { };
-    const promise = new Promise((res) => {
-        resolve = res;
-    });
-    return {
-        promise,
-        resolve,
-    };
-}
+import { LockManager } from "./locking.js";
 export class QueueRunner {
     queues = new Map();
     listeners = [];
@@ -21,35 +12,7 @@ export class QueueRunner {
         this.locking = this.preparteLockingContext();
     }
     preparteLockingContext() {
-        const lockedScopes = new Map();
-        const unlock = (scope) => {
-            if (!lockedScopes.has(scope)) {
-                return;
-            }
-            lockedScopes.get(scope).resolve();
-            lockedScopes.delete(scope);
-        };
-        const wait = (scope) => {
-            if (!lockedScopes.has(scope)) {
-                return Promise.resolve();
-            }
-            return lockedScopes.get(scope).promise;
-        };
-        const lock = (scope) => {
-            if (lockedScopes.has(scope)) {
-                throw new Error(`scope "${scope}" is already locked`);
-            }
-            lockedScopes.set(scope, reversePromiseFactory());
-        };
-        const isLocked = (scope) => {
-            return lockedScopes.has(scope);
-        };
-        return {
-            isLocked,
-            lock,
-            unlock,
-            wait,
-        };
+        return new LockManager();
     }
     add(actions, context = {}, name = this.getName()) {
         const queue = new AsyncQueue({

package/_types/action.d.ts

@@ -6,6 +6,7 @@ export declare abstract class Action<C> implements IAction {
     delay: number;
     constructor(opts?: Options);
     abstract execute(context: C & QueueContext): Promise<void>;
+    onError(error: Error, context: QueueContext): Promise<void>;
 }
 export declare abstract class LockingAction<C> extends Action<C> implements ILockingAction {
     locking: boolean;
@@ -16,4 +17,5 @@ export declare function lockingClassFactory<C>(scope: string): abstract new (opt
     locking: boolean;
     delay: number;
     execute(context: C & QueueContext): Promise<void>;
+    onError(error: Error, context: QueueContext): Promise<void>;
 };

package/_types/index.d.ts

@@ -2,4 +2,5 @@ export { IAction, ActionClass, QueueAction, Branches, QueueContext } from './typ
 export { QueueRunner, EndListener } from './runner.js';
 export { AsyncQueue, QueueOpts } from './queue.js';
 export { Action, Options, lockingClassFactory } from './action.js';
+export { LockManager, LockingContext } from './locking.js';
 export { util } from './utils.js';

package/_types/locking.d.ts

@@ -0,0 +1,18 @@
+import { IAction, ILockingAction } from './types.js';
+export type LockingContext = {
+    isLocked: (scope: string) => boolean;
+    lock: (scope: string) => void;
+    unlock: (scope: string) => void;
+    wait: (scope: string) => Promise<void>;
+    runWithLock: (scope: string, fn: () => Promise<void>) => Promise<void>;
+};
+export declare class LockManager implements LockingContext {
+    private lockedScopes;
+    isLocked(scope: string): boolean;
+    lock(scope: string): void;
+    unlock(scope: string): void;
+    wait(scope: string): Promise<void>;
+    runWithLock(scope: string, fn: () => Promise<void>): Promise<void>;
+}
+export declare function isLockingAction(action: IAction): action is IAction & ILockingAction;
+export declare function assertValidScope(scope: unknown): string;

package/_types/queue-context.d.ts

@@ -0,0 +1,18 @@
+import { QueueAction, QueueContext } from './types.js';
+type QueueContextOptions = {
+    push: (actions: QueueAction[]) => void;
+    name: () => string;
+    abort: () => void;
+};
+export declare class QueueContextImpl implements QueueContext {
+    private readonly pushFn;
+    private readonly nameFn;
+    private readonly abortFn;
+    constructor(opts: QueueContextOptions);
+    push: (actions: QueueAction[]) => void;
+    extend: (obj: Partial<object>) => void;
+    name: () => string;
+    abort: () => void;
+    initialize: (context: object) => void;
+}
+export {};

package/_types/queue-executor.d.ts

@@ -0,0 +1,26 @@
+import { LockingContext } from './locking.js';
+import { IAction, QueueAction, QueueContext } from './types.js';
+type QueueContextRuntime = QueueContext & {
+    initialize: (context: object) => void;
+};
+type QueueExecutorOptions = {
+    name: string;
+    queue: QueueAction[];
+    logger: {
+        info: (message: string) => void;
+        setContext: (context: string) => void;
+        error: (e: Error) => void;
+    };
+    lockManager: LockingContext;
+    context: QueueContextRuntime;
+    end: () => void;
+    processQueueItem: (item: QueueAction) => IAction;
+    iterate: (action: IAction) => Promise<void>;
+    handleActionError: (action: IAction, error: unknown) => Promise<void>;
+};
+export declare class QueueExecutor {
+    private readonly opts;
+    constructor(opts: QueueExecutorOptions);
+    run(context: object): Promise<void>;
+}
+export {};

package/_types/queue.d.ts

@@ -1,5 +1,6 @@
-import { LockingContext } from './runner.js';
-import { IAction, QueueAction, QueueContext } from './types.js';
+import { LockingContext } from './locking.js';
+import { QueueContextImpl } from './queue-context.js';
+import { IAction, QueueAction } from './types.js';
 export interface ILogger {
     info: (message: string) => void;
     setContext: (context: string) => void;
@@ -17,13 +18,13 @@ export declare class AsyncQueue {
     queue: QueueAction[];
     end: () => void;
     logger: ILogger;
-    locker: LockingContext;
-    loopAction: boolean;
-    context: QueueContext;
+    lockManager: LockingContext;
+    context: QueueContextImpl;
     constructor(opts: QueueOpts);
     delay(timeout: number): Promise<unknown>;
     run(context: object): Promise<void>;
     iterate(action: IAction): Promise<void>;
+    handleActionError(action: IAction, error: unknown): Promise<void>;
     push(actions: QueueAction[]): void;
     processQueueItem(item: QueueAction): IAction;
 }

package/_types/runner.d.ts

@@ -1,15 +1,11 @@
 import { ILogger } from "./queue.js";
+import { LockingContext as LockingContextType } from "./locking.js";
 import { QueueAction } from "./types.js";
 export type EndListener = (name: string, size: number) => void;
 export type RunnerOpts = {
     logger?: ILogger;
 };
-export type LockingContext = {
-    isLocked: (scope: string) => boolean;
-    lock: (scope: string) => void;
-    unlock: (scope: string) => void;
-    wait: (scope: string) => Promise<unknown>;
-};
+export type LockingContext = LockingContextType;
 export declare class QueueRunner {
     queues: Map<any, any>;
     listeners: EndListener[];

package/_types/types.d.ts

@@ -1,6 +1,7 @@
 export interface IAction {
     delay: number;
     execute: (context: any) => Promise<void>;
+    onError: (error: Error, context: QueueContext) => Promise<void> | void;
 }
 export interface ILockingAction {
     locking: boolean;
@@ -15,7 +16,6 @@ export type Branches = {
 export type QueueContext = {
     push: (actions: QueueAction[]) => void;
     extend: (obj: Partial<object>) => void;
-    stop: () => void;
     name: () => string;
     abort: () => void;
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "async-queue-runner",
-  "version": "0.19.0",
+  "version": "1.0.0",
   "description": "Library to run in parallel extendable queue of tasks",
   "scripts": {
     "compile": "tsc --project ./tsconfig.json",