@tstdl/base 0.93.182 → 0.93.184

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

@@ -1,124 +0,0 @@
-import { Subject } from 'rxjs';
-import { afterEach, beforeAll, beforeEach, describe, expect, test, vi } from 'vitest';
-import { SubjectService } from '../../authentication/server/subject.service.js';
-import { clearTenantData, setupIntegrationTest } from '../../testing/index.js';
-import { NotificationChannel } from '../models/index.js';
-import { NotificationApiController } from '../server/api/notification.api-controller.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';
-describe('Notification API (Integration)', () => {
-    let injector;
-    let database;
-    let controller;
-    let notificationService;
-    let sseService;
-    let subjectService;
-    const schema = 'notification';
-    const tenantId = crypto.randomUUID();
-    let userId;
-    beforeAll(async () => {
-        ({ injector, database } = await setupIntegrationTest({
-            orm: { schema },
-            modules: {
-                notification: true,
-                authentication: true,
-                taskQueue: true,
-                rateLimiter: true,
-            },
-        }));
-        controller = injector.resolve(NotificationApiController);
-        notificationService = injector.resolve(NotificationService);
-        sseService = injector.resolve(NotificationSseService);
-        subjectService = injector.resolve(SubjectService);
-    });
-    beforeEach(async () => {
-        vi.clearAllMocks();
-        await clearTenantData(database, 'authentication', ['user', 'subject'], tenantId);
-        // Create a dummy user
-        const user = await subjectService.createUser({
-            tenantId,
-            email: 'api-test@example.com',
-            firstName: 'Api',
-            lastName: 'Test',
-        });
-        userId = user.id;
-    });
-    afterEach(async () => {
-        await clearTenantData(database, schema, ['in_app', 'in_app_archive', 'log', 'preference', 'web_push_subscription'], tenantId);
-        await clearTenantData(database, 'authentication', ['user', 'subject'], tenantId);
-    });
-    const createMockContext = (params = {}) => ({
-        parameters: params,
-        abortSignal: new AbortController().signal,
-        serverSentEvents: {},
-        getToken: async () => ({
-            payload: {
-                tenant: tenantId,
-                subject: userId,
-            },
-        }),
-    }); // Cast to any for controller compatibility if definition is strict
-    test('stream should register sse client', async () => {
-        const registerSpy = vi.spyOn(sseService, 'register');
-        const subject = new Subject();
-        // Mock register to return a dummy source or similar if needed,
-        // but the real one might work if it just returns an object.
-        // Looking at sseService, register returns a ServerSentEventsSource.
-        // We might need to mock implementation if it tries to do something complex
-        registerSpy.mockImplementation(() => subject);
-        const generator = controller.stream(createMockContext());
-        const nextPromise = generator.next();
-        subject.complete();
-        await nextPromise;
-        expect(registerSpy).toHaveBeenCalledWith(tenantId, userId);
-    });
-    test('types should call service', async () => {
-        const notificationTypeService = injector.resolve(NotificationTypeService);
-        const getTypesSpy = vi.spyOn(notificationTypeService, 'getTypes').mockResolvedValue({ test: 'Test' });
-        const result = await controller.types();
-        expect(result).toEqual({ test: 'Test' });
-        expect(getTypesSpy).toHaveBeenCalled();
-    });
-    test('listInApp should call service', async () => {
-        const listInAppSpy = vi.spyOn(notificationService, 'listInApp').mockResolvedValue([]);
-        const params = { limit: 10, offset: 0 };
-        await controller.listInApp(createMockContext(params));
-        expect(listInAppSpy).toHaveBeenCalledWith(tenantId, userId, params);
-    });
-    test('listArchivedInApp should call service', async () => {
-        const listArchivedInAppSpy = vi.spyOn(notificationService, 'listArchivedInApp').mockResolvedValue([]);
-        const params = { limit: 10, offset: 0 };
-        await controller.listArchivedInApp(createMockContext(params));
-        expect(listArchivedInAppSpy).toHaveBeenCalledWith(tenantId, userId, params);
-    });
-    test('markRead should call service', async () => {
-        const markReadSpy = vi.spyOn(notificationService, 'markRead').mockResolvedValue();
-        const params = { id: 'notif-id' };
-        await controller.markRead(createMockContext(params));
-        expect(markReadSpy).toHaveBeenCalledWith(tenantId, userId, 'notif-id');
-    });
-    test('archive should call service', async () => {
-        const archiveSpy = vi.spyOn(notificationService, 'archive').mockResolvedValue();
-        const params = { id: 'notif-id' };
-        await controller.archive(createMockContext(params));
-        expect(archiveSpy).toHaveBeenCalledWith(tenantId, userId, 'notif-id');
-    });
-    test('getPreferences should call service', async () => {
-        const getPreferencesSpy = vi.spyOn(notificationService, 'getPreferences').mockResolvedValue([]);
-        await controller.getPreferences(createMockContext());
-        expect(getPreferencesSpy).toHaveBeenCalledWith(tenantId, userId);
-    });
-    test('updatePreferences should call service', async () => {
-        const updatePreferencesSpy = vi.spyOn(notificationService, 'updatePreferences').mockResolvedValue();
-        const params = [{ type: 'test', channel: NotificationChannel.Email, enabled: true }];
-        await controller.updatePreferences(createMockContext(params));
-        expect(updatePreferencesSpy).toHaveBeenCalledWith(tenantId, userId, params);
-    });
-    test('registerWebPush should call service', async () => {
-        const registerWebPushSpy = vi.spyOn(notificationService, 'registerWebPush').mockResolvedValue();
-        const params = { endpoint: 'url', keys: { p256dhBase64: 'key', authBase64: 'auth' } };
-        await controller.registerWebPush(createMockContext(params));
-        expect(registerWebPushSpy).toHaveBeenCalledWith(tenantId, userId, 'url', expect.any(Uint8Array), expect.any(Uint8Array));
-    });
-});

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

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

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

@@ -1,101 +0,0 @@
-import { afterEach, beforeEach, describe, expect, test, vi } from 'vitest';
-import { AuthenticationClientService } from '../../authentication/client/authentication.service.js';
-import { Injector } from '../../injector/index.js';
-import { NotificationApiClient } from '../../notification/api/index.js';
-import { NotificationClient } from '../../notification/client/notification-client.js';
-import { configureDefaultSignalsImplementation } from '../../signals/implementation/configure.js';
-import { timeout } from '../../utils/timing.js';
-import { BehaviorSubject, of, Subject } from 'rxjs';
-describe('NotificationClient', () => {
-    let injector;
-    let authenticationServiceMock;
-    let notificationApiClientMock;
-    let notificationClient;
-    const sessionId$ = new BehaviorSubject(undefined);
-    const stream$ = new Subject();
-    beforeEach(() => {
-        configureDefaultSignalsImplementation();
-        injector = new Injector('TestInjector');
-        authenticationServiceMock = {
-            sessionId$,
-        };
-        notificationApiClientMock = {
-            listInApp: vi.fn().mockResolvedValue([]),
-            unreadCount: vi.fn().mockResolvedValue(0),
-            types: vi.fn().mockResolvedValue({}),
-            stream: vi.fn().mockReturnValue(of(stream$)),
-        };
-        injector.register(AuthenticationClientService, { useValue: authenticationServiceMock });
-        injector.register(NotificationApiClient, { useValue: notificationApiClientMock });
-        notificationClient = injector.resolve(NotificationClient);
-    });
-    afterEach(() => {
-        vi.clearAllMocks();
-        sessionId$.next(undefined);
-    });
-    test('should initialize with empty state', () => {
-        expect(notificationClient.notifications()).toEqual([]);
-        expect(notificationClient.unreadCount()).toBe(0);
-        expect(notificationClient.types()).toEqual({});
-    });
-    test('should load notifications on session start', async () => {
-        const notifications = [{ id: '1', type: 'test' }];
-        const unreadCount = 5;
-        const types = { test: 'Test' };
-        notificationApiClientMock.listInApp.mockResolvedValue(notifications);
-        notificationApiClientMock.unreadCount.mockResolvedValue(unreadCount);
-        notificationApiClientMock.types.mockResolvedValue(types);
-        sessionId$.next('session-1');
-        // Wait for async operations (microtasks)
-        await timeout(0);
-        expect(notificationClient.notifications()).toEqual(notifications);
-        expect(notificationClient.unreadCount()).toBe(unreadCount);
-        expect(notificationClient.types()).toEqual(types);
-        expect(notificationApiClientMock.listInApp).toHaveBeenCalledWith({ limit: 20 });
-        expect(notificationApiClientMock.unreadCount).toHaveBeenCalled();
-        expect(notificationApiClientMock.types).toHaveBeenCalled();
-        expect(notificationApiClientMock.stream).toHaveBeenCalled();
-    });
-    test('should clear notifications on session end', async () => {
-        const notifications = [{ id: '1', type: 'test' }];
-        notificationApiClientMock.listInApp.mockResolvedValue(notifications);
-        sessionId$.next('session-1');
-        await timeout(0);
-        expect(notificationClient.notifications()).toHaveLength(1);
-        sessionId$.next(undefined);
-        await timeout(0);
-        expect(notificationClient.notifications()).toEqual([]);
-        expect(notificationClient.unreadCount()).toBe(0);
-    });
-    test('should handle new notification from stream', async () => {
-        const initialNotifications = [{ id: '1', type: 'test' }];
-        notificationApiClientMock.listInApp.mockResolvedValue(initialNotifications);
-        sessionId$.next('session-1');
-        await timeout(0);
-        const newNotification = { id: '2', type: 'test' };
-        stream$.next({ notification: newNotification, unreadCount: 1 });
-        expect(notificationClient.notifications()).toEqual([newNotification, ...initialNotifications]);
-        expect(notificationClient.unreadCount()).toBe(1);
-    });
-    test('should handle unread count update from stream', async () => {
-        notificationApiClientMock.listInApp.mockResolvedValue([]);
-        sessionId$.next('session-1');
-        await timeout(0);
-        stream$.next({ unreadCount: 10 });
-        expect(notificationClient.unreadCount()).toBe(10);
-    });
-    test('should load next page of notifications', async () => {
-        const page1 = [{ id: '2', type: 'test' }];
-        const page2 = [{ id: '1', type: 'test' }];
-        notificationApiClientMock.listInApp
-            .mockResolvedValueOnce(page1) // Initial load
-            .mockResolvedValueOnce(page2); // Pagination
-        sessionId$.next('session-1');
-        await timeout(0);
-        expect(notificationClient.notifications()).toEqual(page1);
-        notificationClient.loadNext(10);
-        await timeout(0);
-        expect(notificationClient.notifications()).toEqual([...page1, ...page2]);
-        expect(notificationApiClientMock.listInApp).toHaveBeenCalledWith({ limit: 10, after: '2' });
-    });
-});

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

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

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

@@ -1,296 +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 { afterEach, beforeAll, beforeEach, describe, expect, test, vi } from 'vitest';
-import { SubjectService } from '../../authentication/server/subject.service.js';
-import { Singleton } from '../../injector/index.js';
-import { MailService } from '../../mail/mail.service.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, EmailChannelProvider, InAppChannelProvider, NotificationAncillaryService, NotificationDeliveryWorker, NotificationService, NotificationSseService, NotificationTypeService } from '../server/index.js';
-let MockNotificationAncillaryService = class MockNotificationAncillaryService extends NotificationAncillaryService {
-    async getViewData(_tenantId, notifications) {
-        return notifications.map(() => ({}));
-    }
-};
-MockNotificationAncillaryService = __decorate([
-    Singleton()
-], MockNotificationAncillaryService);
-describe('Notification Flow (Integration)', () => {
-    let injector;
-    let database;
-    let notificationService;
-    let worker;
-    let typeService;
-    let subjectService;
-    let mailServiceMock;
-    let logRepo;
-    let inAppRepo;
-    let webPushRepo;
-    const schema = 'notification';
-    let tenantId;
-    beforeAll(async () => {
-        ({ injector, database } = await setupIntegrationTest({
-            orm: { schema },
-            modules: {
-                taskQueue: true,
-                rateLimiter: true,
-                authentication: true,
-                messageBus: true,
-                signals: true,
-                notification: true,
-            },
-        }));
-        // 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
-        notificationService = injector.resolve(NotificationService);
-        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));
-        worker.registerProvider(NotificationChannel.InApp, injector.resolve(InAppChannelProvider));
-    });
-    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 () => {
-        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 () => {
-        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 () => {
-        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 () => {
-        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 () => {
-        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 () => {
-        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 () => {
-        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 () => {
-        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 () => {
-        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 () => {
-        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 () => {
-        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.d.ts

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

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

@@ -1,43 +0,0 @@
-import { describe, expect, test } from 'vitest';
-import { setupIntegrationTest } from '../../testing/index.js';
-import { NotificationSseService } from '../server/services/notification-sse.service.js';
-describe('NotificationSseService', () => {
-    test('should register and publish to bus', async () => {
-        const { injector } = await setupIntegrationTest({ modules: { messageBus: true, signals: true } });
-        const service = injector.resolve(NotificationSseService);
-        const tenantId = 't1';
-        const userId = 'u1';
-        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';
-        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';
-        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 });
-    });
-});

package/notification/tests/notification-type.service.test.d.ts

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

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

@@ -1,41 +0,0 @@
-import { afterEach, beforeEach, describe, expect, test } from 'vitest';
-import { setupIntegrationTest, truncateTables } from '../../testing/index.js';
-import { NotificationTypeService } from '../server/services/notification-type.service.js';
-describe('NotificationTypeService', () => {
-    let injector;
-    let database;
-    beforeEach(async () => {
-        ({ injector, database } = await setupIntegrationTest({ modules: { notification: true, authentication: true } }));
-        await truncateTables(database, 'notification', ['type']);
-    });
-    afterEach(async () => {
-        await injector?.dispose();
-    });
-    test('should initialize types correctly', async () => {
-        const service = injector.resolve(NotificationTypeService);
-        const prefix = crypto.randomUUID();
-        const type1 = `${prefix}_TYPE1`;
-        const type2 = `${prefix}_TYPE2`;
-        const typeData = {
-            [type1]: { label: 'Type 1' },
-            [type2]: { label: 'Type 2', throttling: { limit: 1, interval: 1000 } },
-        };
-        const result = await service.initializeTypes(typeData);
-        expect(result[type1]?.label).toBe('Type 1');
-        expect(result[type2]?.key).toBe(type2);
-        expect(result[type2]?.throttling?.limit).toBe(1);
-        // Verify persistence
-        const dbTypes = await service.repository.loadManyByQuery({ key: { $in: [type1, type2] } });
-        expect(dbTypes).toHaveLength(2);
-        // Update
-        const updatedData = {
-            [type1]: { label: 'Type 1 Updated' },
-            [type2]: { label: 'Type 2', throttling: { limit: 1, interval: 1000 } },
-        };
-        const resultUpdated = await service.initializeTypes(updatedData);
-        expect(resultUpdated[type1]?.label).toBe('Type 1 Updated');
-        const dbTypesUpdated = await service.repository.loadManyByQuery({ key: { $in: [type1, type2] } });
-        expect(dbTypesUpdated).toHaveLength(2);
-        expect(dbTypesUpdated.find((c) => c.key == type1)?.label).toBe('Type 1 Updated');
-    });
-});

package/object-storage/s3/tests/s3.object-storage.integration.test.d.ts

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