@tstdl/base 0.93.99 → 0.93.101

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/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>>;
-}

package/notification/server/services/notification-category.service.js

@@ -1,41 +0,0 @@
-var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
-    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
-    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
-    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
-    return c > 3 && r && Object.defineProperty(target, key, r), r;
-};
-import { injectRepository, Transactional } from '../../../orm/server/index.js';
-import { fromEntries, objectEntries } from '../../../utils/object/index.js';
-import { assertDefinedPass, isUndefined } from '../../../utils/type-guards.js';
-import { NotificationCategory } from '../../models/index.js';
-import { NotificationSingleton } from './singleton.js';
-let NotificationCategoryService = class NotificationCategoryService extends Transactional {
-    repository = injectRepository(NotificationCategory);
-    async initializeCategories(tenantId, categoryData) {
-        const categoryEntries = objectEntries(categoryData);
-        const categoryMap = await this.transaction(async (tx) => {
-            const dbCategories = await this.repository.withTransaction(tx).loadManyByQuery({ tenantId });
-            const enumKeyCategoryMap = new Map(dbCategories.map((category) => [category.key, category]));
-            for (const [key, data] of categoryEntries) {
-                const category = enumKeyCategoryMap.get(key);
-                const throttling = data.throttling ?? null;
-                const escalations = data.escalations ?? null;
-                if (isUndefined(category)) {
-                    const newCategory = await this.repository.withTransaction(tx).insert({ tenantId, key, label: data.label, throttling, escalations });
-                    enumKeyCategoryMap.set(key, newCategory);
-                }
-                else if ((category.label != data.label) || (JSON.stringify(category.throttling) != JSON.stringify(throttling)) || (JSON.stringify(category.escalations) != JSON.stringify(escalations))) {
-                    const updatedCategory = await this.repository.withTransaction(tx).updateByQuery({ tenantId, id: category.id }, { label: data.label, throttling, escalations });
-                    enumKeyCategoryMap.set(key, updatedCategory);
-                }
-            }
-            return enumKeyCategoryMap;
-        });
-        const mappedCategories = categoryEntries.map(([key]) => [key, assertDefinedPass(categoryMap.get(key), 'Could not map notification category.')]);
-        return fromEntries(mappedCategories);
-    }
-};
-NotificationCategoryService = __decorate([
-    NotificationSingleton()
-], NotificationCategoryService);
-export { NotificationCategoryService };

package/notification/server/services/notification-delivery.task.d.ts

@@ -1,9 +0,0 @@
-export type NotificationTaskDefinitions = {
-    'notification/deliver': {
-        data: {
-            notificationId: string;
-        };
-        state: void;
-        result: void;
-    };
-};

package/notification/server/services/notification-delivery.task.js

@@ -1 +0,0 @@
-import { NotificationLog } from '../../models/index.js';

package/notification/server/services/singleton.d.ts

@@ -1,3 +0,0 @@
-export declare const notificationDatabaseConfigFactoryProvider: import("../../../injector/provider.js").FactoryProvider<unknown, unknown, import("../../../types/types.js").Record>;
-export declare const notificationDatabaseConfigProvider: import("../../../injector/injector.js").ProvidersItem<unknown, unknown, import("../../../types/types.js").Record>;
-export declare function NotificationSingleton(): ClassDecorator;

package/notification/server/services/singleton.js

@@ -1,10 +0,0 @@
-import { Singleton } from '../../../injector/decorators.js';
-import { provide } from '../../../injector/injector.js';
-import { factoryProvider } from '../../../injector/provider.js';
-import { DatabaseConfig } from '../../../orm/server/index.js';
-import { NotificationConfiguration } from '../module.js';
-export const notificationDatabaseConfigFactoryProvider = factoryProvider((_, context) => context.resolve(NotificationConfiguration).database ?? context.resolve(DatabaseConfig, undefined, { skipSelf: 2 }));
-export const notificationDatabaseConfigProvider = provide(DatabaseConfig, notificationDatabaseConfigFactoryProvider);
-export function NotificationSingleton() {
-    return Singleton({ providers: [notificationDatabaseConfigProvider] });
-}

package/notification/tests/notification-category.service.test.js

@@ -1,36 +0,0 @@
-import { describe, expect, test } from 'vitest';
-import { runInInjectionContext } from '../../injector/index.js';
-import { setupIntegrationTest, truncateTables } from '../../unit-test/index.js';
-import { NotificationCategoryService } from '../server/services/notification-category.service.js';
-describe('NotificationCategoryService', () => {
-    test('should initialize categories correctly', async () => {
-        const { injector, database } = await setupIntegrationTest({ modules: { notification: true, authentication: true } });
-        // Cleanup
-        await truncateTables(database, 'notification', ['category']);
-        const service = injector.resolve(NotificationCategoryService);
-        const tenantId = '00000000-0000-0000-0000-000000000001';
-        const categoryData = {
-            CAT1: { label: 'Category 1' },
-            CAT2: { label: 'Category 2', throttling: { limit: 1, intervalMs: 1000 } }
-        };
-        await runInInjectionContext(injector, async () => {
-            const result = await service.initializeCategories(tenantId, categoryData);
-            expect(result.CAT1.label).toBe('Category 1');
-            expect(result.CAT2.key).toBe('CAT2');
-            expect(result.CAT2.throttling?.limit).toBe(1);
-            // Verify persistence
-            const dbCategories = await service.repository.loadManyByQuery({ tenantId });
-            expect(dbCategories).toHaveLength(2);
-            // Update
-            const updatedData = {
-                CAT1: { label: 'Category 1 Updated' },
-                CAT2: { label: 'Category 2', throttling: { limit: 1, intervalMs: 1000 } }
-            };
-            const resultUpdated = await service.initializeCategories(tenantId, updatedData);
-            expect(resultUpdated.CAT1.label).toBe('Category 1 Updated');
-            const dbCategoriesUpdated = await service.repository.loadManyByQuery({ tenantId });
-            expect(dbCategoriesUpdated).toHaveLength(2);
-            expect(dbCategoriesUpdated.find((c) => c.key == 'CAT1')?.label).toBe('Category 1 Updated');
-        });
-    });
-});

package/notification/tests/test-notification.model.d.ts

@@ -1,4 +0,0 @@
-import { NotificationLog } from '../models/notification-log.model.js';
-export declare class TestNotification extends NotificationLog {
-    testField: string;
-}

package/notification/tests/test-notification.model.js

@@ -1,25 +0,0 @@
-var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
-    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
-    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
-    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
-    return c > 3 && r && Object.defineProperty(target, key, r), r;
-};
-var __metadata = (this && this.__metadata) || function (k, v) {
-    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
-};
-import { ChildEntity } from '../../orm/index.js';
-import { StringProperty } from '../../schema/index.js';
-import { NotificationLog } from '../models/notification-log.model.js';
-import { NotificationTable } from '../models/notification-table.js';
-let TestNotification = class TestNotification extends NotificationLog {
-    testField;
-};
-__decorate([
-    StringProperty(),
-    __metadata("design:type", String)
-], TestNotification.prototype, "testField", void 0);
-TestNotification = __decorate([
-    NotificationTable({ name: 'test_notification' }),
-    ChildEntity('test')
-], TestNotification);
-export { TestNotification };