async-queue-runner 0.15.0 → 0.17.0

package/_cjs/action.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.Action = void 0;
+exports.lockingClassFactory = exports.LockingAction = exports.Action = void 0;
 class Action {
     delay = 0;
     constructor(opts = {}) {
@@ -9,3 +9,19 @@ class Action {
     }
 }
 exports.Action = Action;
+class LockingAction extends Action {
+    locking = true;
+    scope = null;
+}
+exports.LockingAction = LockingAction;
+function lockingClassFactory(scope) {
+    if (typeof scope !== 'string') {
+        throw new TypeError('scope must be a string');
+    }
+    class NoName extends LockingAction {
+        scope = scope;
+    }
+    Object.defineProperty(NoName, 'name', { value: `${LockingAction.constructor.name}(${scope})` });
+    return NoName;
+}
+exports.lockingClassFactory = lockingClassFactory;

package/_cjs/index.js

@@ -1,11 +1,12 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.util = exports.Action = exports.AsyncQueue = exports.QueueRunner = void 0;
+exports.util = 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");
 Object.defineProperty(exports, "AsyncQueue", { enumerable: true, get: function () { return queue_js_1.AsyncQueue; } });
 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 utils_js_1 = require("./utils.js");
 Object.defineProperty(exports, "util", { enumerable: true, get: function () { return utils_js_1.util; } });

package/_cjs/package.json

@@ -1,4 +1,4 @@
-{
-  "type": "commonjs"
-}
-
+{
+  "type": "commonjs"
+}
+

package/_cjs/queue.js

@@ -14,6 +14,7 @@ class AsyncQueue {
     queue = [];
     end;
     logger;
+    locker;
     loopAction = false;
     context = {
         push: (actions) => this.push(actions),
@@ -31,6 +32,7 @@ class AsyncQueue {
         this.name = opts.name;
         this.end = opts.end || (() => { });
         this.logger = opts.logger || logger;
+        this.locker = opts.lockingContext;
     }
     async delay(timeout) {
         return new Promise((res) => setTimeout(res, timeout));
@@ -47,7 +49,18 @@ class AsyncQueue {
                 }
                 const item = this.queue.shift();
                 const action = this.processQueueItem(item);
+                const isLocking = action.locking;
+                const scope = action.scope;
+                if (isLocking) {
+                    if (this.locker.isLocked(scope)) {
+                        await this.locker.wait(scope);
+                    }
+                    this.locker.lock(scope);
+                }
                 await this.iterate(action);
+                if (isLocking) {
+                    this.locker.unlock(scope);
+                }
             }
             this.end();
         }

package/_cjs/runner.js

@@ -2,14 +2,57 @@
 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,
+    };
+}
 class QueueRunner {
     queues = new Map();
     listeners = [];
     logger;
+    locking;
     constructor(opts = {}) {
         if (opts.logger) {
             this.logger = opts.logger;
         }
+        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,
+        };
     }
     add(actions, context = {}, name = this.getName()) {
         const queue = new queue_js_1.AsyncQueue({
@@ -19,6 +62,7 @@ class QueueRunner {
                 this.endEvent(name);
             },
             logger: this.logger,
+            lockingContext: this.locking,
         });
         this.queues.set(name, queue);
         queue.run(context);

package/_cjs/testlib.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.logger = void 0;
+exports.logger = {
+    info: function (message) { },
+    setContext: function (context) { },
+    error: function (e) { }
+};

package/_esm/action.js

@@ -5,3 +5,17 @@ export class Action {
             this.delay = opts.delay;
     }
 }
+export class LockingAction extends Action {
+    locking = true;
+    scope = null;
+}
+export function lockingClassFactory(scope) {
+    if (typeof scope !== 'string') {
+        throw new TypeError('scope must be a string');
+    }
+    class NoName extends LockingAction {
+        scope = scope;
+    }
+    Object.defineProperty(NoName, 'name', { value: `${LockingAction.constructor.name}(${scope})` });
+    return NoName;
+}

package/_esm/index.js

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

package/_esm/package.json

@@ -1,4 +1,4 @@
-{
-  "type": "module"
-}
-
+{
+  "type": "module"
+}
+

package/_esm/queue.js

@@ -11,6 +11,7 @@ export class AsyncQueue {
     queue = [];
     end;
     logger;
+    locker;
     loopAction = false;
     context = {
         push: (actions) => this.push(actions),
@@ -28,6 +29,7 @@ export class AsyncQueue {
         this.name = opts.name;
         this.end = opts.end || (() => { });
         this.logger = opts.logger || logger;
+        this.locker = opts.lockingContext;
     }
     async delay(timeout) {
         return new Promise((res) => setTimeout(res, timeout));
@@ -44,7 +46,18 @@ export class AsyncQueue {
                 }
                 const item = this.queue.shift();
                 const action = this.processQueueItem(item);
+                const isLocking = action.locking;
+                const scope = action.scope;
+                if (isLocking) {
+                    if (this.locker.isLocked(scope)) {
+                        await this.locker.wait(scope);
+                    }
+                    this.locker.lock(scope);
+                }
                 await this.iterate(action);
+                if (isLocking) {
+                    this.locker.unlock(scope);
+                }
             }
             this.end();
         }

package/_esm/runner.js

@@ -1,12 +1,55 @@
 import { AsyncQueue } from "./queue.js";
+function reversePromiseFactory() {
+    let resolve = (value) => { };
+    const promise = new Promise((res) => {
+        resolve = res;
+    });
+    return {
+        promise,
+        resolve,
+    };
+}
 export class QueueRunner {
     queues = new Map();
     listeners = [];
     logger;
+    locking;
     constructor(opts = {}) {
         if (opts.logger) {
             this.logger = opts.logger;
         }
+        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,
+        };
     }
     add(actions, context = {}, name = this.getName()) {
         const queue = new AsyncQueue({
@@ -16,6 +59,7 @@ export class QueueRunner {
                 this.endEvent(name);
             },
             logger: this.logger,
+            lockingContext: this.locking,
         });
         this.queues.set(name, queue);
         queue.run(context);

package/_esm/testlib.js

@@ -0,0 +1,5 @@
+export const logger = {
+    info: function (message) { },
+    setContext: function (context) { },
+    error: function (e) { }
+};

package/_types/action.d.ts

@@ -1,4 +1,4 @@
-import { IAction, QueueContext } from "./types.js";
+import { IAction, ILockingAction, QueueContext } from "./types.js";
 export type Options = {
     delay?: number;
 };
@@ -7,3 +7,13 @@ export declare abstract class Action<C> implements IAction {
     constructor(opts?: Options);
     abstract execute(context: C & QueueContext): Promise<void>;
 }
+export declare abstract class LockingAction<C> extends Action<C> implements ILockingAction {
+    locking: boolean;
+    scope: string | null;
+}
+export declare function lockingClassFactory<C>(scope: string): abstract new (opts?: Options) => {
+    scope: string;
+    locking: boolean;
+    delay: number;
+    execute(context: C & QueueContext): Promise<void>;
+};

package/_types/index.d.ts

@@ -1,5 +1,5 @@
 export { IAction, ActionClass, QueueAction, Branches, QueueContext } from './types.js';
 export { QueueRunner, EndListener } from './runner.js';
 export { AsyncQueue, QueueOpts } from './queue.js';
-export { Action, Options } from './action.js';
+export { Action, Options, lockingClassFactory } from './action.js';
 export { util } from './utils.js';

package/_types/queue.d.ts

@@ -1,3 +1,4 @@
+import { LockingContext } from './runner.js';
 import { IAction, QueueAction, QueueContext } from './types.js';
 export interface ILogger {
     info: (message: string) => void;
@@ -9,12 +10,14 @@ export type QueueOpts = {
     name: string;
     end?: () => void;
     logger?: ILogger;
+    lockingContext: LockingContext;
 };
 export declare class AsyncQueue {
     name: string;
     queue: QueueAction[];
     end: () => void;
     logger: ILogger;
+    locker: LockingContext;
     loopAction: boolean;
     context: QueueContext;
     constructor(opts: QueueOpts);

package/_types/runner.d.ts

@@ -4,11 +4,19 @@ 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 declare class QueueRunner {
     queues: Map<any, any>;
     listeners: EndListener[];
     logger?: ILogger;
+    locking: LockingContext;
     constructor(opts?: RunnerOpts);
+    preparteLockingContext(): LockingContext;
     add(actions: QueueAction[], context?: object, name?: string): void;
     addEndListener(listener: EndListener): void;
     endEvent(name: string): void;

package/_types/testlib.d.ts

@@ -0,0 +1,2 @@
+import { ILogger } from "./queue";
+export declare const logger: ILogger;

package/_types/types.d.ts

@@ -2,8 +2,12 @@ export interface IAction {
     delay: number;
     execute: (context: any) => Promise<void>;
 }
+export interface ILockingAction {
+    locking: boolean;
+    scope: string | null;
+}
 export type ActionClass = new (...args: any[]) => IAction;
-export type QueueAction = IAction | ActionClass;
+export type QueueAction = IAction | ActionClass | Partial<ILockingAction>;
 export type Branches = {
     then: QueueAction[];
     else?: QueueAction[];

package/package.json

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