@tstdl/base 0.93.145 → 0.93.147

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

@@ -6,15 +6,16 @@ var __decorate = (this && this.__decorate) || function (decorators, target, key,
 };
 import { afterEach, beforeAll, beforeEach, describe, expect, test, vi } from 'vitest';
 import { SubjectService } from '../../authentication/server/subject.service.js';
-import { runInInjectionContext, Singleton } from '../../injector/index.js';
+import { Singleton } from '../../injector/index.js';
 import { MailService } from '../../mail/mail.service.js';
-import { injectRepository } from '../../orm/server/index.js';
+import { getRepository } from '../../orm/server/index.js';
 import { clearTenantData, setupIntegrationTest } from '../../testing/index.js';
 import { InAppNotification, NotificationChannel, NotificationLogEntity, NotificationStatus, WebPushSubscription } from '../models/index.js';
 import { configureNotification } from '../server/module.js';
 import { EmailChannelProvider } from '../server/providers/email-channel-provider.js';
 import { NotificationAncillaryService } from '../server/services/notification-ancillary.service.js';
 import { NotificationDeliveryWorker } from '../server/services/notification-delivery.worker.js';
+import { NotificationSseService } from '../server/services/notification-sse.service.js';
 import { NotificationTypeService } from '../server/services/notification-type.service.js';
 import { NotificationService } from '../server/services/notification.service.js';
 let MockNotificationAncillaryService = class MockNotificationAncillaryService extends NotificationAncillaryService {
@@ -33,6 +34,9 @@ describe('Notification Flow (Integration)', () => {
     let typeService;
     let subjectService;
     let mailServiceMock;
+    let logRepo;
+    let inAppRepo;
+    let webPushRepo;
     const schema = 'notification';
     let tenantId;
     beforeAll(async () => {
@@ -50,6 +54,8 @@ describe('Notification Flow (Integration)', () => {
         // Mock MailService
         mailServiceMock = { send: vi.fn() };
         injector.register(MailService, { useValue: mailServiceMock });
+        // Mock NotificationSseService
+        injector.register(NotificationSseService, { useValue: { dispatch: vi.fn() } });
         // Mock NotificationAncillaryService
         configureNotification({ injector, ancillaryService: MockNotificationAncillaryService });
         // Resolve Services
@@ -57,6 +63,9 @@ describe('Notification Flow (Integration)', () => {
         worker = injector.resolve(NotificationDeliveryWorker);
         typeService = injector.resolve(NotificationTypeService);
         subjectService = injector.resolve(SubjectService);
+        logRepo = injector.resolve(getRepository(NotificationLogEntity));
+        inAppRepo = injector.resolve(getRepository(InAppNotification));
+        webPushRepo = injector.resolve(getRepository(WebPushSubscription));
         // Register providers
         worker.registerProvider(NotificationChannel.Email, injector.resolve(EmailChannelProvider));
         const InAppChannelProvider = (await import('../server/providers/in-app-channel-provider.js')).InAppChannelProvider;
@@ -65,273 +74,230 @@ describe('Notification Flow (Integration)', () => {
     beforeEach(async () => {
         tenantId = crypto.randomUUID();
         vi.clearAllMocks();
+        await typeService.initializeTypes({
+            test: {
+                label: 'Test Category',
+                escalations: [{ delay: 1000, channel: NotificationChannel.Email }],
+            },
+            throttled: {
+                label: 'Throttled Category',
+                throttling: { limit: 1, interval: 60000 },
+            },
+            readTest: {
+                label: 'Read Test',
+                escalations: [{ delay: 1000, channel: NotificationChannel.Email }],
+            },
+            prefTest: { label: 'Preference Test' },
+            unknownTest: { label: 'Unknown Test' },
+            manageTest: { label: 'Manage Test' },
+            testType: { label: 'Test Type' },
+            auto: { label: 'Auto Test' },
+            archive: { label: 'Archive All Test' },
+        });
     });
     afterEach(async () => {
         await clearTenantData(database, schema, ['in_app', 'in_app_archive', 'log', 'preference', 'web_push_subscription'], tenantId);
         await clearTenantData(database, 'authentication', ['user', 'subject'], tenantId);
     });
     test('should execute full notification flow with escalation', async () => {
-        await runInInjectionContext(injector, async () => {
-            const logRepo = injectRepository(NotificationLogEntity);
-            const inAppRepo = injectRepository(InAppNotification);
-            const user = await subjectService.createUser({
-                tenantId,
-                email: 'test@example.com',
-                firstName: 'Test',
-                lastName: 'User',
-            });
-            await typeService.initializeTypes({
-                test: {
-                    label: 'Test Category',
-                    escalations: [{ delay: 1000, channel: NotificationChannel.Email }],
-                },
-            });
-            await notificationService.send(tenantId, user.id, {
-                type: 'test',
-                priority: 'high',
-                triggerSubjectId: user.id,
-                payload: { message: 'Hello', testField: 'Test Value' },
-            });
-            const logs = await logRepo.loadManyByQuery({ tenantId });
-            expect(logs).toHaveLength(1);
-            const log = logs[0];
-            expect(log.status).toBe(NotificationStatus.Pending);
-            expect(log.currentStep).toBe(0);
-            // Step 0 (In-App)
-            const result0 = await worker.deliver(log.id);
-            expect(result0.payload.action).toBe('reschedule');
-            const inApps = await inAppRepo.loadManyByQuery({ tenantId });
-            expect(inApps).toHaveLength(1);
-            expect(inApps[0].logId).toBe(log.id);
-            const logAfterStep0 = await logRepo.load(log.id);
-            expect(logAfterStep0.status).toBe(NotificationStatus.Sent);
-            expect(logAfterStep0.currentStep).toBe(1);
-            // Step 1 (Email Escalation)
-            const result1 = await worker.deliver(log.id);
-            expect(result1.payload.action).toBe('complete');
-            expect(mailServiceMock.send).toHaveBeenCalled();
-            const mailArgs = mailServiceMock.send.mock.calls[0][0];
-            expect(mailArgs.to).toBe('test@example.com');
-            const logAfterStep1 = await logRepo.load(log.id);
-            expect(logAfterStep1.currentStep).toBe(2);
+        const user = await subjectService.createUser({
+            tenantId,
+            email: 'test@example.com',
+            firstName: 'Test',
+            lastName: 'User',
         });
+        await notificationService.send(tenantId, user.id, {
+            type: 'test',
+            priority: 'high',
+            triggerSubjectId: user.id,
+            payload: { message: 'Hello', testField: 'Test Value' },
+        });
+        const logs = await logRepo.loadManyByQuery({ tenantId });
+        expect(logs).toHaveLength(1);
+        const log = logs[0];
+        expect(log.status).toBe(NotificationStatus.Pending);
+        expect(log.currentStep).toBe(0);
+        // Step 0 (In-App)
+        const result0 = await worker.deliver(log.id);
+        expect(result0.payload.action).toBe('reschedule');
+        const inApps = await inAppRepo.loadManyByQuery({ tenantId });
+        expect(inApps).toHaveLength(1);
+        expect(inApps[0].logId).toBe(log.id);
+        const logAfterStep0 = await logRepo.load(log.id);
+        expect(logAfterStep0.status).toBe(NotificationStatus.Sent);
+        expect(logAfterStep0.currentStep).toBe(1);
+        // Step 1 (Email Escalation)
+        const result1 = await worker.deliver(log.id);
+        expect(result1.payload.action).toBe('complete');
+        expect(mailServiceMock.send).toHaveBeenCalled();
+        const mailArgs = mailServiceMock.send.mock.calls[0][0];
+        expect(mailArgs.to).toBe('test@example.com');
+        const logAfterStep1 = await logRepo.load(log.id);
+        expect(logAfterStep1.currentStep).toBe(2);
     });
     test('should handle throttling correctly', async () => {
-        await runInInjectionContext(injector, async () => {
-            const logRepo = injectRepository(NotificationLogEntity);
-            const user = await subjectService.createUser({ tenantId, email: 'throttled@example.com', firstName: 'Throttled', lastName: 'User' });
-            await typeService.initializeTypes({
-                throttled: {
-                    label: 'Throttled Category',
-                    throttling: { limit: 1, interval: 60000 },
-                },
-            });
-            await notificationService.send(tenantId, user.id, {
-                type: 'throttled', priority: 'medium', triggerSubjectId: user.id, payload: {},
-            });
-            await notificationService.send(tenantId, user.id, {
-                type: 'throttled', priority: 'medium', triggerSubjectId: user.id, payload: {},
-            });
-            const logs = await logRepo.loadManyByQuery({ tenantId });
-            logs.sort((a, b) => Number(a.timestamp) - Number(b.timestamp));
-            // First one should pass
-            const result1 = await worker.deliver(logs[0].id);
-            expect(result1.payload.action).toBe('complete'); // No escalations
-            // Second one should be throttled
-            const result2 = await worker.deliver(logs[1].id);
-            expect(result2.payload.action).toBe('reschedule');
+        const user = await subjectService.createUser({ tenantId, email: 'throttled@example.com', firstName: 'Throttled', lastName: 'User' });
+        await notificationService.send(tenantId, user.id, {
+            type: 'throttled', priority: 'medium', triggerSubjectId: user.id, payload: {},
+        });
+        await notificationService.send(tenantId, user.id, {
+            type: 'throttled', priority: 'medium', triggerSubjectId: user.id, payload: {},
         });
+        const logs = await logRepo.loadManyByQuery({ tenantId });
+        logs.sort((a, b) => Number(a.timestamp) - Number(b.timestamp));
+        // First one should pass
+        const result1 = await worker.deliver(logs[0].id);
+        expect(result1.payload.action).toBe('complete'); // No escalations
+        // Second one should be throttled
+        const result2 = await worker.deliver(logs[1].id);
+        expect(result2.payload.action).toBe('reschedule');
     });
     test('should skip escalation if notification is read', async () => {
-        await runInInjectionContext(injector, async () => {
-            const logRepo = injectRepository(NotificationLogEntity);
-            const user = await subjectService.createUser({ tenantId, email: 'read@example.com', firstName: 'Read', lastName: 'User' });
-            await typeService.initializeTypes({
-                readTest: {
-                    label: 'Read Test',
-                    escalations: [{ delay: 1000, channel: NotificationChannel.Email }],
-                },
-            });
-            await notificationService.send(tenantId, user.id, {
-                type: 'readTest', priority: 'medium', triggerSubjectId: user.id, payload: {},
-            });
-            const logs = await logRepo.loadManyByQuery({ tenantId });
-            const log = logs[0];
-            // Step 0: Deliver In-App
-            await worker.deliver(log.id);
-            // Mark as Read
-            const inAppNotifications = await notificationService.listInApp(tenantId, user.id);
-            expect(inAppNotifications).toHaveLength(1);
-            await notificationService.markRead(tenantId, user.id, inAppNotifications[0].id);
-            // Step 1: Attempt Escalation
-            const result = await worker.deliver(log.id);
-            expect(result.payload.action).toBe('complete');
-            expect(mailServiceMock.send).not.toHaveBeenCalled();
+        const user = await subjectService.createUser({ tenantId, email: 'read@example.com', firstName: 'Read', lastName: 'User' });
+        await notificationService.send(tenantId, user.id, {
+            type: 'readTest', priority: 'medium', triggerSubjectId: user.id, payload: {},
         });
+        const logs = await logRepo.loadManyByQuery({ tenantId });
+        const log = logs[0];
+        // Step 0: Deliver In-App
+        await worker.deliver(log.id);
+        // Mark as Read
+        const inAppNotifications = await notificationService.listInApp(tenantId, user.id);
+        expect(inAppNotifications).toHaveLength(1);
+        await notificationService.markRead(tenantId, user.id, inAppNotifications[0].id);
+        // Step 1: Attempt Escalation
+        const result = await worker.deliver(log.id);
+        expect(result.payload.action).toBe('complete');
+        expect(mailServiceMock.send).not.toHaveBeenCalled();
     });
     test('should respect user preferences', async () => {
-        await runInInjectionContext(injector, async () => {
-            const logRepo = injectRepository(NotificationLogEntity);
-            const user = await subjectService.createUser({ tenantId, email: 'pref@example.com', firstName: 'Pref', lastName: 'User' });
-            await typeService.initializeTypes({
-                prefTest: { label: 'Preference Test' },
-            });
-            // Disable InApp, Enable Email (even though not default)
-            await notificationService.updatePreference(tenantId, user.id, 'prefTest', NotificationChannel.InApp, false);
-            await notificationService.updatePreference(tenantId, user.id, 'prefTest', NotificationChannel.Email, true);
-            await notificationService.send(tenantId, user.id, {
-                type: 'prefTest', priority: 'medium', triggerSubjectId: user.id, payload: {},
-            });
-            const logs = await logRepo.loadManyByQuery({ tenantId });
-            const log = logs[0];
-            // Deliver
-            await worker.deliver(log.id);
-            // Should have sent Email but NOT InApp
-            expect(mailServiceMock.send).toHaveBeenCalled();
-            const inAppNotifications = await notificationService.listInApp(tenantId, user.id);
-            expect(inAppNotifications).toHaveLength(0);
+        const user = await subjectService.createUser({ tenantId, email: 'pref@example.com', firstName: 'Pref', lastName: 'User' });
+        // Disable InApp, Enable Email (even though not default)
+        await notificationService.updatePreference(tenantId, user.id, 'prefTest', NotificationChannel.InApp, false);
+        await notificationService.updatePreference(tenantId, user.id, 'prefTest', NotificationChannel.Email, true);
+        await notificationService.send(tenantId, user.id, {
+            type: 'prefTest', priority: 'medium', triggerSubjectId: user.id, payload: {},
         });
+        const logs = await logRepo.loadManyByQuery({ tenantId });
+        const log = logs[0];
+        // Deliver
+        await worker.deliver(log.id);
+        // Should have sent Email but NOT InApp
+        expect(mailServiceMock.send).toHaveBeenCalled();
+        const inAppNotifications = await notificationService.listInApp(tenantId, user.id);
+        expect(inAppNotifications).toHaveLength(0);
     });
     test('should handle unknown channels gracefully', async () => {
-        await runInInjectionContext(injector, async () => {
-            const logRepo = injectRepository(NotificationLogEntity);
-            const user = await subjectService.createUser({ tenantId, email: 'unknown@example.com', firstName: 'Unknown', lastName: 'User' });
-            await typeService.initializeTypes({
-                unknownTest: { label: 'Unknown Test' },
-            });
-            // Force a preference for an unknown channel/unregistered provider (e.g., WebPush if not registered or some random string if type allowed)
-            // Since NotificationChannel is an enum, we use WebPush which we haven't registered in the test setup (wait, we didn't register WebPush)
-            await notificationService.updatePreference(tenantId, user.id, 'unknownTest', NotificationChannel.WebPush, true);
-            // Disable InApp so only WebPush is attempted
-            await notificationService.updatePreference(tenantId, user.id, 'unknownTest', NotificationChannel.InApp, false);
-            await notificationService.send(tenantId, user.id, {
-                type: 'unknownTest', priority: 'medium', triggerSubjectId: user.id, payload: {},
-            });
-            const logs = await logRepo.loadManyByQuery({ tenantId });
-            const log = logs[0];
-            // Deliver
-            const result = await worker.deliver(log.id);
-            // Should complete without error, just logging a warning (which we can't easily assert on unless we spy logger)
-            expect(result.payload.action).toBe('complete');
+        const user = await subjectService.createUser({ tenantId, email: 'unknown@example.com', firstName: 'Unknown', lastName: 'User' });
+        // Force a preference for an unknown channel/unregistered provider (e.g., WebPush if not registered or some random string if type allowed)
+        // Since NotificationChannel is an enum, we use WebPush which we haven't registered in the test setup (wait, we didn't register WebPush)
+        await notificationService.updatePreference(tenantId, user.id, 'unknownTest', NotificationChannel.WebPush, true);
+        // Disable InApp so only WebPush is attempted
+        await notificationService.updatePreference(tenantId, user.id, 'unknownTest', NotificationChannel.InApp, false);
+        await notificationService.send(tenantId, user.id, {
+            type: 'unknownTest', priority: 'medium', triggerSubjectId: user.id, payload: {},
         });
+        const logs = await logRepo.loadManyByQuery({ tenantId });
+        const log = logs[0];
+        // Deliver
+        const result = await worker.deliver(log.id);
+        // Should complete without error, just logging a warning (which we can't easily assert on unless we spy logger)
+        expect(result.payload.action).toBe('complete');
     });
     test('should manage notification lists and status (markRead, archive)', async () => {
-        await runInInjectionContext(injector, async () => {
-            const logRepo = injectRepository(NotificationLogEntity);
-            const inAppRepo = injectRepository(InAppNotification);
-            const user = await subjectService.createUser({ tenantId, email: 'manage@example.com', firstName: 'Manage', lastName: 'User' });
-            await typeService.initializeTypes({ manageTest: { label: 'Manage Test' } });
-            await notificationService.send(tenantId, user.id, {
-                type: 'manageTest', priority: 'medium', triggerSubjectId: user.id, payload: {},
-            });
-            const logs = await logRepo.loadManyByQuery({ tenantId });
-            await worker.deliver(logs[0].id);
-            // List
-            let list = await notificationService.listInApp(tenantId, user.id);
-            expect(list).toHaveLength(1);
-            expect(list[0].readTimestamp).toBeNull();
-            expect(list[0].notification).toBeDefined();
-            // Mark Read
-            await notificationService.markRead(tenantId, user.id, list[0].id);
-            list = await notificationService.listInApp(tenantId, user.id);
-            expect(list[0].readTimestamp).not.toBeNull();
-            // Archive
-            await notificationService.archive(tenantId, user.id, list[0].id);
-            // List (excludes archived)
-            list = await notificationService.listInApp(tenantId, user.id);
-            expect(list).toHaveLength(0);
-            // List archived
-            list = await notificationService.listArchivedInApp(tenantId, user.id);
-            expect(list).toHaveLength(1);
-            expect(list[0].archiveTimestamp).not.toBeNull();
+        const user = await subjectService.createUser({ tenantId, email: 'manage@example.com', firstName: 'Manage', lastName: 'User' });
+        await notificationService.send(tenantId, user.id, {
+            type: 'manageTest', priority: 'medium', triggerSubjectId: user.id, payload: {},
         });
+        const logs = await logRepo.loadManyByQuery({ tenantId });
+        await worker.deliver(logs[0].id);
+        // List
+        let list = await notificationService.listInApp(tenantId, user.id);
+        expect(list).toHaveLength(1);
+        expect(list[0].readTimestamp).toBeNull();
+        expect(list[0].notification).toBeDefined();
+        // Mark Read
+        await notificationService.markRead(tenantId, user.id, list[0].id);
+        list = await notificationService.listInApp(tenantId, user.id);
+        expect(list[0].readTimestamp).not.toBeNull();
+        // Archive
+        await notificationService.archive(tenantId, user.id, list[0].id);
+        // List (excludes archived)
+        list = await notificationService.listInApp(tenantId, user.id);
+        expect(list).toHaveLength(0);
+        // List archived
+        list = await notificationService.listArchivedInApp(tenantId, user.id);
+        expect(list).toHaveLength(1);
+        expect(list[0].archiveTimestamp).not.toBeNull();
     });
     test('should register web push subscription', async () => {
-        await runInInjectionContext(injector, async () => {
-            const webPushRepo = injectRepository(WebPushSubscription);
-            const user = await subjectService.createUser({ tenantId, email: 'push@example.com', firstName: 'Push', lastName: 'User' });
-            await notificationService.registerWebPush(tenantId, user.id, 'https://endpoint.com', new Uint8Array(32), new Uint8Array(32));
-            const subs = await webPushRepo.loadManyByQuery({ tenantId, userId: user.id });
-            expect(subs).toHaveLength(1);
-            expect(subs[0].endpoint).toBe('https://endpoint.com');
-        });
+        const user = await subjectService.createUser({ tenantId, email: 'push@example.com', firstName: 'Push', lastName: 'User' });
+        await notificationService.registerWebPush(tenantId, user.id, 'https://endpoint.com', new Uint8Array(32), new Uint8Array(32));
+        const subs = await webPushRepo.loadManyByQuery({ tenantId, userId: user.id });
+        expect(subs).toHaveLength(1);
+        expect(subs[0].endpoint).toBe('https://endpoint.com');
     });
     test('should retrieve user preferences', async () => {
-        await runInInjectionContext(injector, async () => {
-            const user = await subjectService.createUser({ tenantId, email: 'getpref@example.com', firstName: 'GetPref', lastName: 'User' });
-            await typeService.initializeTypes({ testType: { label: 'Test Type' } });
-            await notificationService.updatePreference(tenantId, user.id, 'testType', NotificationChannel.Email, true);
-            const prefs = await notificationService.getPreferences(tenantId, user.id);
-            expect(prefs).toHaveLength(1);
-            expect(prefs[0].type).toBe('testType');
-            expect(prefs[0].channel).toBe(NotificationChannel.Email);
-            expect(prefs[0].enabled).toBe(true);
-        });
+        const user = await subjectService.createUser({ tenantId, email: 'getpref@example.com', firstName: 'GetPref', lastName: 'User' });
+        await notificationService.updatePreference(tenantId, user.id, 'testType', NotificationChannel.Email, true);
+        const prefs = await notificationService.getPreferences(tenantId, user.id);
+        expect(prefs).toHaveLength(1);
+        prefs.sort((a, b) => a.type.localeCompare(b.type));
+        expect(prefs[0].type).toBe('testType');
+        expect(prefs[0].channel).toBe(NotificationChannel.Email);
+        expect(prefs[0].enabled).toBe(true);
     });
     test('should support keyset pagination with after and orderBy', async () => {
-        await runInInjectionContext(injector, async () => {
-            const logRepo = injectRepository(NotificationLogEntity);
-            const user = await subjectService.createUser({ tenantId, email: 'pagination@example.com', firstName: 'Pagination', lastName: 'User' });
-            await typeService.initializeTypes({ test: { label: 'Pagination Test' } });
-            // Create 3 notifications
-            await notificationService.send(tenantId, user.id, { type: 'test', triggerSubjectId: user.id, payload: { index: 1 } });
-            await notificationService.send(tenantId, user.id, { type: 'test', triggerSubjectId: user.id, payload: { index: 2 } });
-            await notificationService.send(tenantId, user.id, { type: 'test', triggerSubjectId: user.id, payload: { index: 3 } });
-            const logs = await logRepo.loadManyByQuery({ tenantId });
-            for (const log of logs) {
-                await worker.deliver(log.id);
-            }
-            // Default list (desc timestamp, then desc id)
-            const list = await notificationService.listInApp(tenantId, user.id);
-            expect(list).toHaveLength(3);
-            const firstId = list[0].id;
-            const secondId = list[1].id;
-            // After first
-            const afterFirst = await notificationService.listInApp(tenantId, user.id, { after: firstId });
-            expect(afterFirst).toHaveLength(2);
-            expect(afterFirst[0].id).toBe(secondId);
-            // After second
-            const afterSecond = await notificationService.listInApp(tenantId, user.id, { after: secondId });
-            expect(afterSecond).toHaveLength(1);
-            expect(afterSecond[0].id).toBe(list[2].id);
-        });
+        const user = await subjectService.createUser({ tenantId, email: 'pagination@example.com', firstName: 'Pagination', lastName: 'User' });
+        // Create 3 notifications
+        await notificationService.send(tenantId, user.id, { type: 'test', triggerSubjectId: user.id, payload: { index: 1 } });
+        await notificationService.send(tenantId, user.id, { type: 'test', triggerSubjectId: user.id, payload: { index: 2 } });
+        await notificationService.send(tenantId, user.id, { type: 'test', triggerSubjectId: user.id, payload: { index: 3 } });
+        const logs = await logRepo.loadManyByQuery({ tenantId });
+        for (const log of logs) {
+            await worker.deliver(log.id);
+        }
+        // Default list (desc timestamp, then desc id)
+        const list = await notificationService.listInApp(tenantId, user.id);
+        expect(list).toHaveLength(3);
+        const firstId = list[0].id;
+        const secondId = list[1].id;
+        // After first
+        const afterFirst = await notificationService.listInApp(tenantId, user.id, { after: firstId });
+        expect(afterFirst).toHaveLength(2);
+        expect(afterFirst[0].id).toBe(secondId);
+        // After second
+        const afterSecond = await notificationService.listInApp(tenantId, user.id, { after: secondId });
+        expect(afterSecond).toHaveLength(1);
+        expect(afterSecond[0].id).toBe(list[2].id);
     });
     test('should auto-archive old notifications', async () => {
-        await runInInjectionContext(injector, async () => {
-            const logRepo = injectRepository(NotificationLogEntity);
-            const inAppRepo = injectRepository(InAppNotification);
-            const user = await subjectService.createUser({ tenantId, email: 'auto@example.com', firstName: 'Auto', lastName: 'User' });
-            await typeService.initializeTypes({ test: { label: 'Auto Test' } });
-            await notificationService.send(tenantId, user.id, { type: 'test', triggerSubjectId: user.id, payload: {} });
-            const logs = await logRepo.loadManyByQuery({ tenantId });
-            await worker.deliver(logs[0].id);
-            // Verify active
-            expect(await notificationService.listInApp(tenantId, user.id)).toHaveLength(1);
-            // Manually update timestamp to be old (31 days ago)
-            const oldTimestamp = Date.now() - 31 * 24 * 60 * 60 * 1000;
-            await logRepo.updateByQuery({ id: logs[0].id }, { timestamp: oldTimestamp });
-            await inAppRepo.updateByQuery({ tenantId, logId: logs[0].id }, { timestamp: oldTimestamp });
-            await notificationService.runAutoArchive();
-            // Verify archived
-            expect(await notificationService.listInApp(tenantId, user.id)).toHaveLength(0);
-            expect(await notificationService.listArchivedInApp(tenantId, user.id)).toHaveLength(1);
-        });
+        const user = await subjectService.createUser({ tenantId, email: 'auto@example.com', firstName: 'Auto', lastName: 'User' });
+        await notificationService.send(tenantId, user.id, { type: 'test', triggerSubjectId: user.id, payload: {} });
+        const logs = await logRepo.loadManyByQuery({ tenantId });
+        await worker.deliver(logs[0].id);
+        // Verify active
+        expect(await notificationService.listInApp(tenantId, user.id)).toHaveLength(1);
+        // Manually update timestamp to be old (31 days ago)
+        const oldTimestamp = Date.now() - 31 * 24 * 60 * 60 * 1000;
+        await logRepo.updateByQuery({ id: logs[0].id }, { timestamp: oldTimestamp });
+        await inAppRepo.updateByQuery({ tenantId, logId: logs[0].id }, { timestamp: oldTimestamp });
+        await notificationService.runAutoArchive();
+        // Verify archived
+        expect(await notificationService.listInApp(tenantId, user.id)).toHaveLength(0);
+        expect(await notificationService.listArchivedInApp(tenantId, user.id)).toHaveLength(1);
     });
     test('should archive all notifications for a user', async () => {
-        await runInInjectionContext(injector, async () => {
-            const logRepo = injectRepository(NotificationLogEntity);
-            const user = await subjectService.createUser({ tenantId, email: 'archiveall@example.com', firstName: 'Archive', lastName: 'All' });
-            await typeService.initializeTypes({ test: { label: 'Archive All Test' } });
-            await notificationService.send(tenantId, user.id, { type: 'test', triggerSubjectId: user.id, payload: {} });
-            await notificationService.send(tenantId, user.id, { type: 'test', triggerSubjectId: user.id, payload: {} });
-            const logs = await logRepo.loadManyByQuery({ tenantId });
-            for (const log of logs) {
-                await worker.deliver(log.id);
-            }
-            expect(await notificationService.listInApp(tenantId, user.id)).toHaveLength(2);
-            await notificationService.archiveAll(tenantId, user.id);
-            expect(await notificationService.listInApp(tenantId, user.id)).toHaveLength(0);
-            expect(await notificationService.listArchivedInApp(tenantId, user.id)).toHaveLength(2);
-        });
+        const user = await subjectService.createUser({ tenantId, email: 'archiveall@example.com', firstName: 'Archive', lastName: 'All' });
+        await notificationService.send(tenantId, user.id, { type: 'test', triggerSubjectId: user.id, payload: {} });
+        await notificationService.send(tenantId, user.id, { type: 'test', triggerSubjectId: user.id, payload: {} });
+        const logs = await logRepo.loadManyByQuery({ tenantId });
+        for (const log of logs) {
+            await worker.deliver(log.id);
+        }
+        expect(await notificationService.listInApp(tenantId, user.id)).toHaveLength(2);
+        await notificationService.archiveAll(tenantId, user.id);
+        expect(await notificationService.listInApp(tenantId, user.id)).toHaveLength(0);
+        expect(await notificationService.listArchivedInApp(tenantId, user.id)).toHaveLength(2);
     });
 });

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

@@ -1,5 +1,4 @@
 import { describe, expect, test } from 'vitest';
-import { runInInjectionContext } from '../../injector/index.js';
 import { setupIntegrationTest } from '../../testing/index.js';
 import { NotificationSseService } from '../server/services/notification-sse.service.js';
 describe('NotificationSseService', () => {
@@ -8,43 +7,37 @@ describe('NotificationSseService', () => {
         const service = injector.resolve(NotificationSseService);
         const tenantId = 't1';
         const userId = 'u1';
-        await runInInjectionContext(injector, async () => {
-            const source = service.register(tenantId, userId);
-            expect(source).toBeDefined();
-            // We can't easily spy on the LocalMessageBus internals without more complex setup,
-            // but we can verify that sending doesn't throw.
-            const msg = { id: 'l1', tenantId, userId, logId: 'l1' };
-            await expect(service.dispatch(tenantId, userId, { notification: msg, unreadCount: 1 })).resolves.not.toThrow();
-        });
+        const source = service.register(tenantId, userId);
+        expect(source).toBeDefined();
+        // We can't easily spy on the LocalMessageBus internals without more complex setup,
+        // but we can verify that sending doesn't throw.
+        const msg = { id: 'l1', tenantId, userId, logId: 'l1' };
+        await expect(service.dispatch(tenantId, userId, { notification: msg, unreadCount: 1 })).resolves.not.toThrow();
     });
     test('should dispatch unread count update', async () => {
         const { injector } = await setupIntegrationTest({ modules: { messageBus: true, signals: true } });
         const service = injector.resolve(NotificationSseService);
         const tenantId = 't1';
         const userId = 'u1';
-        await runInInjectionContext(injector, async () => {
-            const source = service.register(tenantId, userId);
-            const messages = [];
-            source.subscribe((msg) => messages.push(msg));
-            await service.dispatch(tenantId, userId, { unreadCount: 5 });
-            expect(messages).toHaveLength(1);
-            expect(messages[0]).toEqual({ unreadCount: 5 });
-        });
+        const source = service.register(tenantId, userId);
+        const messages = [];
+        source.subscribe((msg) => messages.push(msg));
+        await service.dispatch(tenantId, userId, { unreadCount: 5 });
+        expect(messages).toHaveLength(1);
+        expect(messages[0]).toEqual({ unreadCount: 5 });
     });
     test('should dispatch mark read and mark all read', async () => {
         const { injector } = await setupIntegrationTest({ modules: { messageBus: true, signals: true } });
         const service = injector.resolve(NotificationSseService);
         const tenantId = 't1';
         const userId = 'u1';
-        await runInInjectionContext(injector, async () => {
-            const source = service.register(tenantId, userId);
-            const messages = [];
-            source.subscribe((msg) => messages.push(msg));
-            await service.dispatch(tenantId, userId, { readId: 'n1', unreadCount: 2 });
-            await service.dispatch(tenantId, userId, { readAll: true, unreadCount: 0 });
-            expect(messages).toHaveLength(2);
-            expect(messages[0]).toEqual({ readId: 'n1', unreadCount: 2 });
-            expect(messages[1]).toEqual({ readAll: true, unreadCount: 0 });
-        });
+        const source = service.register(tenantId, userId);
+        const messages = [];
+        source.subscribe((msg) => messages.push(msg));
+        await service.dispatch(tenantId, userId, { readId: 'n1', unreadCount: 2 });
+        await service.dispatch(tenantId, userId, { readAll: true, unreadCount: 0 });
+        expect(messages).toHaveLength(2);
+        expect(messages[0]).toEqual({ readId: 'n1', unreadCount: 2 });
+        expect(messages[1]).toEqual({ readAll: true, unreadCount: 0 });
     });
 });