@stamhoofd/queues 2.1.1

package/package.json

@@ -0,0 +1,17 @@
+{
+    "name": "@stamhoofd/queues",
+    "version": "2.1.1",
+    "main": "./dist/index.js",
+    "types": "./dist/index.d.ts",
+    "license": "UNLICENCED",
+    "sideEffects": false,
+    "files": [
+        "src"
+    ],
+    "scripts": {
+        "build": "tsc -b",
+        "build:full": "rm -rf ./dist && yarn build",
+        "test": "jest --runInBand",
+        "test:reset": "yarn build:full && jest --runInBand"
+    }
+}

package/src/QueueHandler.test.ts

@@ -0,0 +1,84 @@
+import { AsyncLocalStorage } from 'node:async_hooks';
+import { QueueHandler } from './QueueHandler';
+
+describe('QueueHandler', () => {
+    it('Guards against deadlocks', async () => {
+        const result = await QueueHandler.schedule('test', async () => {
+            return QueueHandler.schedule('test', async () => {
+                return 'test';
+            });
+        })
+
+        expect(result).toBe('test');
+    });
+
+    it('Guards against deep deadlocks', async () => {
+        const result = await QueueHandler.schedule('test', async () => {
+            return QueueHandler.schedule('other', async () => {
+                return QueueHandler.schedule('test', async () => {
+                    return QueueHandler.schedule('other', async () => {
+                        return QueueHandler.schedule('test', async () => {
+                            return 'test';
+                        });
+                    });
+                });
+            });
+        })
+
+        expect(result).toBe('test');
+    });
+
+    it('Inherits the right AsyncLocalStorage context', async () => {
+        const context = new AsyncLocalStorage<string>();
+
+        const ranContexts: string[] = [];
+        const promises: Promise<void>[] = [];
+
+        // Do some quick scheduling
+        for (let i = 0; i < 20; i++) {
+            context.run(i.toString(), async () => {
+                promises.push(QueueHandler.schedule('test', async () => {
+                    await new Promise<void>(resolve => {
+                        setTimeout(() => {
+                            resolve();
+                        }, 100);
+                    });
+
+                    ranContexts.push(context.getStore() ?? '');
+                }));
+            });
+        }
+
+        await Promise.allSettled(promises);
+
+        expect(ranContexts).toHaveLength(20);
+        expect(ranContexts.sort()).toEqual(['0', '1', '2', '3', '4', '5', '6', '7', '8', '9', '10', '11', '12', '13', '14', '15', '16', '17', '18', '19'].sort());
+    });
+
+    it('Inherits the right AsyncLocalStorage context with parallel execution', async () => {
+        const context = new AsyncLocalStorage<string>();
+
+        const ranContexts: string[] = [];
+        const promises: Promise<void>[] = [];
+
+        // Do some quick scheduling
+        for (let i = 0; i < 50; i++) {
+            context.run(i.toString(), async () => {
+                promises.push(QueueHandler.schedule('test', async () => {
+                    await new Promise<void>(resolve => {
+                        setTimeout(() => {
+                            resolve();
+                        }, 100);
+                    });
+
+                    ranContexts.push(context.getStore() ?? '');
+                }, 5));
+            });
+        }
+
+        await Promise.allSettled(promises);
+
+        expect(ranContexts).toHaveLength(50);
+        expect(ranContexts.sort()).toEqual(['0', '1', '2', '3', '4', '5', '6', '7', '8', '9', '10', '11', '12', '13', '14', '15', '16', '17', '18', '19', '20', '21', '22', '23', '24', '25', '26', '27', '28', '29', '30', '31', '32', '33', '34', '35', '36', '37', '38', '39', '40', '41', '42', '43', '44', '45', '46', '47', '48', '49'].sort());
+    });
+});

package/src/QueueHandler.ts

@@ -0,0 +1,108 @@
+
+import { AsyncLocalStorage } from 'node:async_hooks';
+
+class Queue {
+    name: string
+    items: QueueItem<any>[] = []
+    parallel = 1
+    runCount = 0
+
+    constructor(name: string, parallel = 1) {
+        this.name = name
+        this.parallel = parallel
+    }
+
+    addItem(item: QueueItem<any>) {
+        this.items.push(item)
+    }
+}
+
+class QueueItem<T> {
+    handler: () => Promise<T>
+    resolve: (value: T) => void
+    reject: (reason?: any) => void
+}
+
+/**
+ * Force the usage of a queue to prevent concurrency issues
+ */
+export class QueueHandler {
+    static queues = new Map<string, Queue>()
+    static asyncLocalStorage = new AsyncLocalStorage<string[]>();
+
+    static async schedule<T>(queue: string, handler: () => Promise<T>, parallel = 1): Promise<T> {
+        // console.log("[QUEUE] Schedule "+queue)
+
+        const currentQueues = this.asyncLocalStorage.getStore();
+        if (currentQueues !== undefined && currentQueues.includes(queue)) {
+            console.warn('Recursive usage of queues detected. Ignored running in queue', queue, currentQueues);
+            return await handler();
+        }
+
+        // We need to save the current AsyncLocalStorage context
+        // otherwise we could run items on the queue with the wrong context
+        const snapshot = AsyncLocalStorage.snapshot()
+
+        const item = new QueueItem<T>()
+        item.handler = () => snapshot(async () => {
+            const currentQueues = this.asyncLocalStorage.getStore() ?? [];
+            return await this.asyncLocalStorage.run([...currentQueues, queue], async () => {
+                return await handler();
+            });
+        })
+        
+        const promise = new Promise<T>((resolve, reject) => {
+            item.resolve = resolve
+            item.reject = reject
+
+            // We only add it here because resolve and reject is required
+            const q = this.queues.get(queue) ?? new Queue(queue, parallel)
+            q.addItem(item)
+            this.queues.set(queue, q)
+
+            // Run the next item if not already running
+            this.runNext(queue).catch(e => {
+                console.error("[QUEUE] Fatal error in queue logic", e)
+            })
+        })
+
+        return promise
+    }
+
+    private static async runNext(queue: string) {
+        const q = this.queues.get(queue)
+        if (!q) {
+            // console.warn("[QUEUE] Queue not found (no items left)", queue)
+            return
+        }
+
+        if (q.runCount >= q.parallel) {
+            //  console.log("[QUEUE] Queue", queue, 'reached maximum of', q.parallel)
+            return
+        }
+
+        const next = q.items.shift()
+
+        if (next === undefined) {
+            this.queues.delete(queue)
+            return
+        }
+
+        q.runCount += 1
+        // console.log("[QUEUE] ("+q.runCount+"/"+q.parallel+") Executing "+queue+" ("+q.items.length+" remaining)")
+
+        try {
+            next.resolve(await next.handler())
+            // console.log("[QUEUE] ("+(q.runCount-1)+"/"+q.parallel+") Resolved "+queue+" ("+q.items.length+" remaining)")
+        } catch (e) {
+            next.reject(e)
+            if (STAMHOOFD.environment !== 'test') {
+                console.log("[QUEUE] ("+(q.runCount-1)+"/"+q.parallel+") Rejected "+queue+" ("+q.items.length+" remaining)")
+                console.error(e)
+            }
+        }
+
+        q.runCount -= 1
+        await this.runNext(queue)
+    }
+}