@tstdl/base 0.93.100 → 0.93.102

package/task-queue/postgres/task-queue.js

@@ -89,7 +89,7 @@ let PostgresTaskQueue = class PostgresTaskQueue extends TaskQueue {
     #rateLimiter = inject(RateLimiter, {
         resource: this.#namespace,
         burstCapacity: this.#config.rateLimit ?? defaultQueueConfig.rateLimit,
-        refillIntervalMs: this.#config.rateInterval ?? defaultQueueConfig.rateInterval,
+        refillInterval: this.#config.rateInterval ?? defaultQueueConfig.rateInterval,
     });
     #circuitBreaker = inject(CircuitBreaker, {
         key: this.#namespace,

package/task-queue/task-context.d.ts

@@ -2,7 +2,7 @@ import type { CancellationSignal, CancellationToken } from '../cancellation/inde
 import type { Logger } from '../logger/index.js';
 import type { Transaction } from '../orm/server/index.js';
 import { TaskQueue, type EnqueueManyItem, type EnqueueOptions } from './task-queue.js';
-import type { TaskData, TaskDefinitionMap, TaskOfType, TaskResult, TaskState, TaskTypes, TasksStates } from './types.js';
+import type { TaskData, TaskDefinitionMap, TaskOfType, TaskResult, TaskState, TaskTypes } from './types.js';
 export declare class TaskContext<Definitions extends TaskDefinitionMap, Type extends TaskTypes<Definitions>> {
     #private;
     constructor(queue: TaskQueue<Definitions>, task: TaskOfType<Definitions, Type>, signal: CancellationToken, logger: Logger);
@@ -43,16 +43,3 @@ export declare class TaskContext<Definitions extends TaskDefinitionMap, Type ext
         transaction?: Transaction;
     }): Promise<void>;
 }
-export declare class BatchTaskContext<Definitions extends TaskDefinitionMap, Type extends TaskTypes<Definitions>> {
-    #private;
-    constructor(queue: TaskQueue<Definitions>, tasks: TaskOfType<Definitions, Type>[], signal: CancellationToken, logger: Logger);
-    get tasks(): TaskOfType<Definitions, Type>[];
-    get signal(): CancellationSignal;
-    get logger(): Logger;
-    for<Type extends TaskTypes<Definitions>>(task: TaskOfType<Definitions, Type>): TaskContext<Definitions, Type>;
-    checkpointAll(options?: {
-        progresses?: number[];
-        states?: TasksStates<TaskOfType<Definitions, Type>[]>;
-        transaction?: Transaction;
-    }): Promise<void>;
-}

package/task-queue/task-context.js

@@ -92,33 +92,3 @@ export class TaskContext {
         this.#signal.set();
     }
 }
-export class BatchTaskContext {
-    #queue;
-    #tasks;
-    #logger;
-    #signal;
-    constructor(queue, tasks, signal, logger) {
-        this.#queue = queue;
-        this.#tasks = tasks;
-        this.#signal = signal;
-        this.#logger = logger.fork('Batch');
-    }
-    get tasks() {
-        return this.#tasks;
-    }
-    get signal() {
-        return this.#signal.signal;
-    }
-    get logger() {
-        return this.#logger;
-    }
-    for(task) {
-        return new TaskContext(this.#queue, task, this.#signal, this.#logger);
-    }
-    async checkpointAll(options) {
-        const validIds = await this.#queue.touchMany(this.#tasks, options);
-        if (validIds.length < this.#tasks.length) {
-            this.#logger.warn(`${this.#tasks.length - validIds.length} tasks in batch lost their lease during checkpoint`);
-        }
-    }
-}

package/task-queue/task-queue.d.ts

@@ -6,14 +6,14 @@ import type { Transaction } from '../orm/server/transaction.js';
 import { Transactional } from '../orm/server/transactional.js';
 import type { OneOrMany, Record, UndefinableJson } from '../types/types.js';
 import { TaskQueueEnqueueBatch } from './enqueue-batch.js';
-import type { ProcessBatchWorker, ProcessWorker, TaskData, TaskDefinitionMap, TaskOfType, TaskProcessResultPayload, TaskResult, TasksResults, TasksStates, TaskState, TaskTypes } from './types.js';
+import type { ProcessWorker, TaskData, TaskDefinitionMap, TaskOfType, TaskProcessResultPayload, TaskResult, TasksResults, TasksStates, TaskState, TaskTypes } from './types.js';
 export declare class TaskProcessResult<Result = unknown> {
     readonly payload: TaskProcessResultPayload<Result>;
     private constructor();
     static Complete<Result>(result?: Result): TaskProcessResult<Result>;
-    static Fail(error: unknown, fatal?: boolean): TaskProcessResult;
-    static RescheduleTo(timestamp: number): TaskProcessResult;
-    static RescheduleBy(milliseconds: number): TaskProcessResult;
+    static Fail<R>(error: unknown, fatal?: boolean): TaskProcessResult<R>;
+    static RescheduleTo<R>(timestamp: number): TaskProcessResult<R>;
+    static RescheduleBy<R>(milliseconds: number): TaskProcessResult<R>;
 }
 export declare const TaskStatus: {
     /**
@@ -299,16 +299,8 @@ export declare abstract class TaskQueue<Definitions extends TaskDefinitionMap =
         types?: Type[];
         forceDequeue?: boolean;
     }, handler: ProcessWorker<Definitions, Type>): void;
-    processBatch<Type extends TaskTypes<Definitions>>({ batchSize, concurrency, cancellationSignal, types, forceDequeue }: {
-        batchSize?: number;
-        concurrency?: number;
-        cancellationSignal: CancellationSignal;
-        types?: Type[];
-        forceDequeue?: boolean;
-    }, handler: ProcessBatchWorker<Definitions, Type>): void;
     protected getTransactionalContextData(): QueueConfig & {
         namespace: string;
     };
     private processWorker;
-    private processBatchWorker;
 }

package/task-queue/task-queue.js

@@ -2,13 +2,12 @@ import { defineEnum } from '../enumeration/enumeration.js';
 import { inject, injectArgument } from '../injector/index.js';
 import { Logger } from '../logger/logger.js';
 import { Transactional } from '../orm/server/transactional.js';
-import { createArray } from '../utils/array/array.js';
 import { currentTimestamp } from '../utils/date-time.js';
 import { cancelableTimeout } from '../utils/timing.js';
-import { isDefined, isString } from '../utils/type-guards.js';
+import { isDefined, isString, isUndefined } from '../utils/type-guards.js';
 import { millisecondsPerDay, millisecondsPerMinute, millisecondsPerSecond } from '../utils/units.js';
 import { TaskQueueEnqueueBatch } from './enqueue-batch.js';
-import { BatchTaskContext } from './task-context.js';
+import { TaskContext } from './task-context.js';
 export class TaskProcessResult {
     payload;
     constructor(payload) {
@@ -89,114 +88,64 @@ export class TaskQueue extends Transactional {
             void this.processWorker(cancellationSignal, handler, { types, forceDequeue });
         }
     }
-    processBatch({ batchSize = 10, concurrency = 1, cancellationSignal, types, forceDequeue }, handler) {
-        for (let i = 0; i < concurrency; i++) {
-            void this.processBatchWorker(batchSize, cancellationSignal, handler, { types, forceDequeue });
-        }
-    }
     getTransactionalContextData() {
         return this.config;
     }
     async processWorker(cancellationSignal, handler, options) {
-        await this.processBatchWorker(1, cancellationSignal, async (batchContext) => {
-            const task = batchContext.tasks[0];
-            const context = batchContext.for(task);
-            const result = await handler(context);
-            return [result];
-        }, options);
-    }
-    async processBatchWorker(size, cancellationSignal, handler, options) {
-        for await (const tasks of this.getBatchConsumer(size, cancellationSignal, options)) {
-            const batchToken = cancellationSignal.createChild();
-            const context = new BatchTaskContext(this, tasks, batchToken, this.logger);
-            let activeTaskIds = new Set(tasks.map((t) => t.id));
-            context.logger.verbose(`Processing batch of ${tasks.length}`);
+        for await (const task of this.getConsumer(cancellationSignal, options)) {
+            const taskToken = cancellationSignal.createChild();
+            const context = new TaskContext(this, task, taskToken, this.logger);
+            let isTaskActive = true;
+            context.logger.verbose(`Processing task`);
             void (async () => {
-                while (batchToken.isUnset) {
-                    await cancelableTimeout(Math.min(this.visibilityTimeout / 2, 5000), batchToken);
-                    if (batchToken.isSet) {
+                while (taskToken.isUnset) {
+                    await cancelableTimeout(Math.min(this.visibilityTimeout / 2, 5000), taskToken);
+                    if (taskToken.isSet) {
                         break;
                     }
                     try {
-                        const tasksToTouch = tasks.filter((t) => activeTaskIds.has(t.id));
-                        if (tasksToTouch.length > 0) {
-                            const touchedIds = await this.touchMany(tasksToTouch);
-                            if (touchedIds.length != tasksToTouch.length) {
-                                const lostCount = tasksToTouch.length - touchedIds.length;
-                                context.logger.warn(`Batch integrity compromised: ${lostCount} tasks lost lease. Aborting batch.`);
-                                activeTaskIds = new Set(touchedIds);
-                                batchToken.set();
-                            }
-                            else {
-                                activeTaskIds = new Set(touchedIds);
-                            }
-                        }
-                        if (activeTaskIds.size == 0 && batchToken.isUnset) {
-                            context.logger.warn(`All tasks in batch lost lease. Stopping worker.`);
-                            batchToken.set();
+                        const touchedTask = await this.touch(task);
+                        if (isUndefined(touchedTask)) {
+                            context.logger.warn(`Task lost lease. Aborting.`);
+                            isTaskActive = false;
+                            taskToken.set();
                         }
                     }
                     catch (error) {
-                        context.logger.error('Error touching tasks', error);
+                        context.logger.error('Error touching task', error);
                     }
                 }
             })();
             try {
-                if (batchToken.isSet) {
-                    throw new Error('Tasks cancelled before start');
+                if (taskToken.isSet) {
+                    throw new Error('Task cancelled before start');
                 }
-                const results = await handler(context);
-                if (isDefined(results)) {
-                    const completions = [];
-                    const failures = [];
-                    const reschedules = [];
-                    for (let i = 0; i < tasks.length; i++) {
-                        const task = tasks[i];
-                        const result = results[i];
-                        switch (result.payload.action) {
-                            case 'complete':
-                                completions.push({ task, result: result.payload.result });
-                                break;
-                            case 'fail':
-                                failures.push({ task, error: result.payload.error, fatal: result.payload.fatal });
-                                break;
-                            case 'reschedule':
-                                reschedules.push({ task, timestamp: result.payload.timestamp });
-                                break;
-                            default:
-                                throw new Error(`Unsupported task result action.`);
-                        }
-                    }
-                    if (completions.length > 0) {
-                        context.logger.verbose(`Completing ${completions.length} tasks`);
-                        await this.completeMany(completions.map((c) => c.task), { results: completions.map((c) => c.result) });
-                    }
-                    if (failures.length > 0) {
-                        context.logger.verbose(`Failing ${failures.length} tasks`);
-                        for (const item of failures) {
-                            await this.fail(item.task, item.error, { fatal: item.fatal });
-                        }
-                    }
-                    if (reschedules.length > 0) {
-                        context.logger.verbose(`Rescheduling ${reschedules.length} tasks`);
-                        const reschedulesByTimestamp = new Map();
-                        for (const item of reschedules) {
-                            const ids = reschedulesByTimestamp.get(item.timestamp) ?? [];
-                            ids.push(item.task.id);
-                            reschedulesByTimestamp.set(item.timestamp, ids);
-                        }
-                        for (const [timestamp, ids] of reschedulesByTimestamp) {
-                            await this.rescheduleMany(ids, timestamp);
-                        }
+                const result = await handler(context);
+                if (isDefined(result) && isTaskActive) {
+                    switch (result.payload.action) {
+                        case 'complete':
+                            context.logger.verbose(`Completing task`);
+                            await this.complete(task, { result: result.payload.result });
+                            break;
+                        case 'fail':
+                            context.logger.verbose(`Failing task`);
+                            await this.fail(task, result.payload.error, { fatal: result.payload.fatal });
+                            break;
+                        case 'reschedule':
+                            context.logger.verbose(`Rescheduling task`);
+                            await this.reschedule(task.id, result.payload.timestamp);
+                            break;
+                        default:
+                            throw new Error(`Unsupported task result action.`);
                     }
                 }
             }
             catch (error) {
-                context.logger.error('Error processing tasks', error);
-                await this.failMany(tasks, createArray(tasks.length, () => error));
+                context.logger.error('Error processing task', error);
+                await this.fail(task, error);
             }
             finally {
-                batchToken.set();
+                taskToken.set();
             }
         }
     }

package/task-queue/tests/extensive-dependencies.test.d.ts

@@ -0,0 +1 @@
+export {};

package/task-queue/tests/extensive-dependencies.test.js

@@ -0,0 +1,234 @@
+import { afterAll, afterEach, beforeAll, beforeEach, describe, expect, it } from 'vitest';
+import { DependencyJoinMode, TaskQueueProvider, TaskStatus } from '../../task-queue/index.js';
+import { setupIntegrationTest } from '../../unit-test/index.js';
+import { timeout } from '../../utils/timing.js';
+describe('Extensive Task Queue Dependency Tests', () => {
+    let injector;
+    let queue;
+    beforeAll(async () => {
+        ({ injector } = await setupIntegrationTest({ modules: { taskQueue: true } }));
+    });
+    beforeEach(() => {
+        const queueProvider = injector.resolve(TaskQueueProvider);
+        const queueName = `extensive-dep-queue-${Date.now()}-${Math.random()}`;
+        queue = queueProvider.get(queueName, {
+            visibilityTimeout: 1000,
+        });
+    });
+    afterEach(async () => {
+        await queue.clear();
+    });
+    afterAll(async () => {
+        await injector?.dispose();
+    });
+    async function waitForStatus(id, status) {
+        for (let i = 0; i < 100; i++) {
+            const task = await queue.getTask(id);
+            if (task?.status === status)
+                return;
+            await queue.processPendingFanIn();
+            await timeout(50);
+        }
+        const finalTask = await queue.getTask(id);
+        throw new Error(`Task ${id} did not reach status ${status}. Current status: ${finalTask?.status}`);
+    }
+    async function completeTask(type) {
+        const dequeued = await queue.dequeue({ types: [type] });
+        if (!dequeued)
+            throw new Error(`Could not dequeue task of type ${type}`);
+        await queue.complete(dequeued);
+        await queue.processPendingFanIn();
+    }
+    it('should handle complex mixed chain: A -> (B -> D, C -> E) -> F', async () => {
+        // F depends on D and E
+        const taskF = await queue.enqueue('F', {}, { scheduleAfterTags: ['mc-d', 'mc-e'] });
+        // D depends on B, E depends on C
+        const taskD = await queue.enqueue('D', {}, { tags: ['mc-d'], scheduleAfterTags: ['mc-b'] });
+        const taskE = await queue.enqueue('E', {}, { tags: ['mc-e'], scheduleAfterTags: ['mc-c'] });
+        // B and C depend on A
+        const taskB = await queue.enqueue('B', {}, { tags: ['mc-b'], scheduleAfterTags: ['mc-a'] });
+        const taskC = await queue.enqueue('C', {}, { tags: ['mc-c'], scheduleAfterTags: ['mc-a'] });
+        // A is the root
+        const taskA = await queue.enqueue('A', {}, { tags: ['mc-a'] });
+        expect(taskA.status).toBe(TaskStatus.Pending);
+        expect(taskB.status).toBe(TaskStatus.Waiting);
+        expect(taskC.status).toBe(TaskStatus.Waiting);
+        expect(taskD.status).toBe(TaskStatus.Waiting);
+        expect(taskE.status).toBe(TaskStatus.Waiting);
+        expect(taskF.status).toBe(TaskStatus.Waiting);
+        // 1. Complete A
+        await completeTask('A');
+        await waitForStatus(taskB.id, TaskStatus.Pending);
+        await waitForStatus(taskC.id, TaskStatus.Pending);
+        // 2. Complete B
+        await completeTask('B');
+        await waitForStatus(taskD.id, TaskStatus.Pending);
+        // 3. Complete C
+        await completeTask('C');
+        await waitForStatus(taskE.id, TaskStatus.Pending);
+        // F should still be waiting
+        const uF = await queue.getTask(taskF.id);
+        expect(uF?.status).toBe(TaskStatus.Waiting);
+        // 4. Complete D
+        await completeTask('D');
+        // F still waiting for E
+        expect((await queue.getTask(taskF.id))?.status).toBe(TaskStatus.Waiting);
+        // 5. Complete E
+        await completeTask('E');
+        await waitForStatus(taskF.id, TaskStatus.Pending);
+    });
+    it('should handle requested pattern: A -> B & C -> D', async () => {
+        const taskD = await queue.enqueue('D', {}, { scheduleAfterTags: ['B', 'C'] });
+        const taskB = await queue.enqueue('B', {}, { tags: ['B'], scheduleAfterTags: ['A'] });
+        const taskC = await queue.enqueue('C', {}, { tags: ['C'], scheduleAfterTags: ['A'] });
+        const taskA = await queue.enqueue('A', {}, { tags: ['A'] });
+        // Initial check
+        expect(taskA.status).toBe(TaskStatus.Pending);
+        expect(taskB.status).toBe(TaskStatus.Waiting);
+        expect(taskC.status).toBe(TaskStatus.Waiting);
+        expect(taskD.status).toBe(TaskStatus.Waiting);
+        // Complete A
+        await completeTask('A');
+        await waitForStatus(taskB.id, TaskStatus.Pending);
+        await waitForStatus(taskC.id, TaskStatus.Pending);
+        // B and C can be dequeued now (in any order)
+        const dB = await queue.dequeue({ types: ['B'] });
+        const dC = await queue.dequeue({ types: ['C'] });
+        expect(dB).toBeDefined();
+        expect(dC).toBeDefined();
+        // D still waiting
+        expect((await queue.getTask(taskD.id))?.status).toBe(TaskStatus.Waiting);
+        // Complete B
+        await queue.complete(dB);
+        await queue.processPendingFanIn();
+        expect((await queue.getTask(taskD.id))?.status).toBe(TaskStatus.Waiting);
+        // Complete C
+        await queue.complete(dC);
+        await waitForStatus(taskD.id, TaskStatus.Pending);
+    });
+    it('should strictly adhere to order: A -> B -> C', async () => {
+        const taskC = await queue.enqueue('C', {}, { tags: ['C'], scheduleAfterTags: ['B'] });
+        const taskB = await queue.enqueue('B', {}, { tags: ['B'], scheduleAfterTags: ['A'] });
+        const taskA = await queue.enqueue('A', {}, { tags: ['A'] });
+        // Try to dequeue B and C - should fail
+        const dC = await queue.dequeue({ types: ['C'] });
+        const dB = await queue.dequeue({ types: ['B'] });
+        expect(dC).toBeUndefined();
+        expect(dB).toBeUndefined();
+        // Complete A
+        const dA = await queue.dequeue({ types: ['A'] });
+        expect(dA?.id).toBe(taskA.id);
+        await queue.complete(dA);
+        await queue.processPendingFanIn();
+        // Now B should be available, but C still not
+        const dC_2 = await queue.dequeue({ types: ['C'] });
+        expect(dC_2).toBeUndefined();
+        const dB_2 = await queue.dequeue({ types: ['B'] });
+        expect(dB_2?.id).toBe(taskB.id);
+        await queue.complete(dB_2);
+        await queue.processPendingFanIn();
+        // Now C should be available
+        const dC_3 = await queue.dequeue({ types: ['C'] });
+        expect(dC_3?.id).toBe(taskC.id);
+        await queue.complete(dC_3);
+    });
+    it('should handle large fan-in: (T1, T2, T3, T4, T5) -> Result', async () => {
+        const tags = ['t1', 't2', 't3', 't4', 't5'];
+        const taskResult = await queue.enqueue('Result', {}, { scheduleAfterTags: tags });
+        for (const tag of tags) {
+            await queue.enqueue(`Task-${tag}`, {}, { tags: [tag] });
+        }
+        // Complete all but one
+        for (let i = 0; i < 4; i++) {
+            await completeTask(`Task-${tags[i]}`);
+            expect((await queue.getTask(taskResult.id))?.status).toBe(TaskStatus.Waiting);
+        }
+        // Complete the last one
+        await completeTask(`Task-${tags[4]}`);
+        await waitForStatus(taskResult.id, TaskStatus.Pending);
+    });
+    it('should handle large fan-in with OR: (T1, T2, T3, T4, T5) -> Result', async () => {
+        const tags = ['o1', 'o2', 'o3', 'o4', 'o5'];
+        const taskResult = await queue.enqueue('Result', {}, {
+            scheduleAfterTags: tags,
+            dependencyJoinMode: DependencyJoinMode.Or
+        });
+        for (const tag of tags) {
+            await queue.enqueue(`Task-${tag}`, {}, { tags: [tag] });
+        }
+        // Complete one
+        await completeTask(`Task-${tags[2]}`);
+        await waitForStatus(taskResult.id, TaskStatus.Pending);
+    });
+    it('should handle Diamond of Diamonds: A -> (B1, B2) -> C -> (D1, D2) -> E', async () => {
+        const taskE = await queue.enqueue('E', {}, { scheduleAfterTags: ['tag-d1', 'tag-d2'] });
+        const taskD1 = await queue.enqueue('D1', {}, { tags: ['tag-d1'], scheduleAfterTags: ['tag-c'] });
+        const taskD2 = await queue.enqueue('D2', {}, { tags: ['tag-d2'], scheduleAfterTags: ['tag-c'] });
+        const taskC = await queue.enqueue('C', {}, { tags: ['tag-c'], scheduleAfterTags: ['tag-b1', 'tag-b2'] });
+        const taskB1 = await queue.enqueue('B1', {}, { tags: ['tag-b1'], scheduleAfterTags: ['tag-a'] });
+        const taskB2 = await queue.enqueue('B2', {}, { tags: ['tag-b2'], scheduleAfterTags: ['tag-a'] });
+        const taskA = await queue.enqueue('A', {}, { tags: ['tag-a'] });
+        // Step by step completion
+        await completeTask('A');
+        await waitForStatus(taskB1.id, TaskStatus.Pending);
+        await waitForStatus(taskB2.id, TaskStatus.Pending);
+        await completeTask('B1');
+        expect((await queue.getTask(taskC.id))?.status).toBe(TaskStatus.Waiting);
+        await completeTask('B2');
+        await waitForStatus(taskC.id, TaskStatus.Pending);
+        await completeTask('C');
+        await waitForStatus(taskD1.id, TaskStatus.Pending);
+        await waitForStatus(taskD2.id, TaskStatus.Pending);
+        await completeTask('D1');
+        expect((await queue.getTask(taskE.id))?.status).toBe(TaskStatus.Waiting);
+        await completeTask('D2');
+        await waitForStatus(taskE.id, TaskStatus.Pending);
+    });
+    it('should fail-fast entire branch if one dependency fails fatal', async () => {
+        // A -> B -> C
+        //   -> D -> E
+        // (C & E) -> F
+        const taskF = await queue.enqueue('F', {}, { scheduleAfterTags: ['C', 'E'], failFast: true });
+        const taskC = await queue.enqueue('C', {}, { tags: ['C'], scheduleAfterTags: ['B'], failFast: true });
+        const taskE = await queue.enqueue('E', {}, { tags: ['E'], scheduleAfterTags: ['D'], failFast: true });
+        const taskB = await queue.enqueue('B', {}, { tags: ['B'], scheduleAfterTags: ['A'], failFast: true });
+        const taskD = await queue.enqueue('D', {}, { tags: ['D'], scheduleAfterTags: ['A'], failFast: true });
+        const taskA = await queue.enqueue('A', {}, { tags: ['A'] });
+        await completeTask('A');
+        await waitForStatus(taskB.id, TaskStatus.Pending);
+        await waitForStatus(taskD.id, TaskStatus.Pending);
+        // Fail B fatally
+        const dB = await queue.dequeue({ types: ['B'] });
+        await queue.fail(dB, new Error('fatal B'), { fatal: true });
+        await queue.processPendingFanIn();
+        // B failed fatally -> C should die -> F should die
+        await waitForStatus(taskC.id, TaskStatus.Dead);
+        await waitForStatus(taskF.id, TaskStatus.Dead);
+        // D and E should be unaffected (except E is still waiting for D)
+        const uD = await queue.getTask(taskD.id);
+        expect(uD?.status).toBe(TaskStatus.Pending);
+    });
+    it('should handle many-to-many dependencies', async () => {
+        // {A, B} -> {C, D} -> {E, F}
+        // Each of C, D depends on BOTH A and B.
+        // Each of E, F depends on BOTH C and D.
+        const taskE = await queue.enqueue('E', {}, { scheduleAfterTags: ['C', 'D'] });
+        const taskF = await queue.enqueue('F', {}, { scheduleAfterTags: ['C', 'D'] });
+        const taskC = await queue.enqueue('C', {}, { tags: ['C'], scheduleAfterTags: ['A', 'B'] });
+        const taskD = await queue.enqueue('D', {}, { tags: ['D'], scheduleAfterTags: ['A', 'B'] });
+        const taskA = await queue.enqueue('A', {}, { tags: ['A'] });
+        const taskB = await queue.enqueue('B', {}, { tags: ['B'] });
+        await completeTask('A');
+        expect((await queue.getTask(taskC.id))?.status).toBe(TaskStatus.Waiting);
+        expect((await queue.getTask(taskD.id))?.status).toBe(TaskStatus.Waiting);
+        await completeTask('B');
+        await waitForStatus(taskC.id, TaskStatus.Pending);
+        await waitForStatus(taskD.id, TaskStatus.Pending);
+        await completeTask('C');
+        expect((await queue.getTask(taskE.id))?.status).toBe(TaskStatus.Waiting);
+        expect((await queue.getTask(taskF.id))?.status).toBe(TaskStatus.Waiting);
+        await completeTask('D');
+        await waitForStatus(taskE.id, TaskStatus.Pending);
+        await waitForStatus(taskF.id, TaskStatus.Pending);
+    });
+});

package/task-queue/tests/worker.test.js

@@ -61,27 +61,6 @@ describe('Worker & Base Class Tests', () => {
         expect(updated?.tries).toBe(1);
         expect(updated?.error?.message).toBe('worker error');
     });
-    it('should process batch of tasks', async () => {
-        await queue.enqueueMany([
-            { type: 'batch', data: { v: 1 } },
-            { type: 'batch', data: { v: 2 } },
-            { type: 'batch', data: { v: 3 } },
-        ]);
-        const processedBatch = [];
-        const token = new CancellationToken();
-        queue.processBatch({ batchSize: 2, cancellationSignal: token }, async (context) => {
-            expect(context.tasks.length).toBeLessThanOrEqual(2);
-            context.tasks.forEach(t => processedBatch.push(t.data['v']));
-            return context.tasks.map(() => TaskProcessResult.Complete());
-        });
-        for (let i = 0; i < 20; i++) {
-            if (processedBatch.length === 3)
-                break;
-            await timeout(100);
-        }
-        token.set();
-        expect(processedBatch.sort()).toEqual([1, 2, 3]);
-    });
     it('should extend lease (heartbeat) during long processing', async () => {
         const task = await queue.enqueue('long', {});
         const token = new CancellationToken();

package/task-queue/types.d.ts

@@ -1,4 +1,4 @@
-import type { BatchTaskContext, TaskContext } from './task-context.js';
+import type { TaskContext } from './task-context.js';
 import type { Task, TaskProcessResult } from './task-queue.js';
 export type TaskDefinition<Data = unknown, State = unknown, Result = unknown> = {
     data: Data;
@@ -39,10 +39,3 @@ export interface ProcessWorker<Definitions extends TaskDefinitionMap, Type exten
      */
     (context: TaskContext<Definitions, Type>): TaskProcessResult<Definitions[Type]['result']> | Promise<TaskProcessResult<Definitions[Type]['result']>>;
 }
-export interface ProcessBatchWorker<Definitions extends TaskDefinitionMap, Type extends TaskTypes<Definitions>> {
-    /**
-     * A worker function that processes a batch of tasks.
-     * @param context The batch context providing tasks and helpers.
-     */
-    (context: BatchTaskContext<Definitions, Type>): TaskProcessResult<Definitions[Type]['result']>[] | Promise<TaskProcessResult<Definitions[Type]['result']>[]>;
-}

package/notification/enums.d.ts

@@ -1,22 +0,0 @@
-import { type EnumType } from '../enumeration/index.js';
-export declare const NotificationChannel: {
-    readonly InApp: "in-app";
-    readonly Email: "email";
-    readonly WebPush: "web-push";
-};
-export type NotificationChannel = EnumType<typeof NotificationChannel>;
-export declare const NotificationPriority: {
-    readonly Low: "low";
-    readonly Medium: "medium";
-    readonly High: "high";
-    readonly Urgent: "urgent";
-};
-export type NotificationPriority = EnumType<typeof NotificationPriority>;
-export declare const NotificationStatus: {
-    readonly Pending: "pending";
-    readonly Sent: "sent";
-    readonly Delivered: "delivered";
-    readonly Read: "read";
-    readonly Failed: "failed";
-};
-export type NotificationStatus = EnumType<typeof NotificationStatus>;

package/notification/enums.js

@@ -1,19 +0,0 @@
-import { defineEnum } from '../enumeration/index.js';
-export const NotificationChannel = defineEnum('NotificationChannel', {
-    InApp: 'in-app',
-    Email: 'email',
-    WebPush: 'web-push',
-});
-export const NotificationPriority = defineEnum('NotificationPriority', {
-    Low: 'low',
-    Medium: 'medium',
-    High: 'high',
-    Urgent: 'urgent',
-});
-export const NotificationStatus = defineEnum('NotificationStatus', {
-    Pending: 'pending',
-    Sent: 'sent',
-    Delivered: 'delivered',
-    Read: 'read',
-    Failed: 'failed',
-});

package/notification/models/notification-category.model.d.ts

@@ -1,17 +0,0 @@
-import { TenantEntity } from '../../orm/index.js';
-import { NotificationChannel } from '../enums.js';
-export type ThrottlingConfig = {
-    limit: number;
-    intervalMs: number;
-};
-export type EscalationRule = {
-    delayMs: number;
-    channel: NotificationChannel;
-};
-export declare class NotificationCategory extends TenantEntity {
-    static readonly entityName = "NotificationCategory";
-    label: string;
-    key: string;
-    throttling: ThrottlingConfig | null;
-    escalations: EscalationRule[] | null;
-}

package/notification/server/services/notification-category.service.d.ts

@@ -1,11 +0,0 @@
-import { Transactional } from '../../../orm/server/index.js';
-import { NotificationCategory, type EscalationRule, type ThrottlingConfig } from '../../models/index.js';
-export type CategoryInitializationData = {
-    label: string;
-    throttling?: ThrottlingConfig;
-    escalations?: EscalationRule[];
-};
-export declare class NotificationCategoryService extends Transactional {
-    readonly repository: import("../../../orm/server/index.js").EntityRepository<NotificationCategory>;
-    initializeCategories<T extends string>(tenantId: string, categoryData: Record<T, CategoryInitializationData>): Promise<Record<T, NotificationCategory>>;
-}