@tstdl/base 0.93.100 → 0.93.102

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

@@ -4,15 +4,16 @@ var __decorate = (this && this.__decorate) || function (decorators, target, key,
     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 { inject } from '../../../injector/index.js';
+import { and, desc, eq, isNull } from 'drizzle-orm';
+import { BadRequestError } from '../../../errors/bad-request.error.js';
+import { inject, Singleton } from '../../../injector/index.js';
+import { TRANSACTION_TIMESTAMP } from '../../../orm/index.js';
 import { injectRepository, Transactional } from '../../../orm/server/index.js';
 import { TaskQueue } from '../../../task-queue/task-queue.js';
-import { currentTimestamp } from '../../../utils/date-time.js';
-import { NotificationStatus } from '../../enums.js';
-import { InAppNotification, NotificationLog, NotificationPreference, WebPushSubscription } from '../../models/index.js';
-import { NotificationSingleton } from './singleton.js';
+import { InAppNotification, NotificationLogEntity, NotificationPreference, NotificationStatus, toInAppNotificationView, WebPushSubscription } from '../../models/index.js';
+import { inAppNotification, notificationLog } from '../schemas.js';
 let NotificationService = class NotificationService extends Transactional {
-    #notificationLogRepository = injectRepository(NotificationLog);
+    #notificationLogRepository = injectRepository(NotificationLogEntity);
     #inAppNotificationRepository = injectRepository(InAppNotification);
     #preferenceRepository = injectRepository(NotificationPreference);
     #webPushSubscriptionRepository = injectRepository(WebPushSubscription);
@@ -29,42 +30,58 @@ let NotificationService = class NotificationService extends Transactional {
         });
     }
     async listInApp(tenantId, userId, options = {}) {
-        const inAppNotifications = await this.#inAppNotificationRepository.loadManyByQuery({
-            tenantId,
-            userId,
-            archivedAt: options.includeArchived ? undefined : null,
-        }, {
-            limit: options.limit,
-            offset: options.offset,
-            order: { 'metadata.createTimestamp': 'desc' },
+        const rows = await this.#notificationLogRepository.session
+            .select({
+            notification: notificationLog,
+            inApp: inAppNotification,
+        })
+            .from(notificationLog)
+            .innerJoin(inAppNotification, eq(inAppNotification.logId, notificationLog.id))
+            .where(and(eq(inAppNotification.tenantId, tenantId), eq(notificationLog.userId, userId), options.includeArchived ? undefined : isNull(inAppNotification.archiveTimestamp)))
+            .limit(options.limit ?? 50)
+            .offset(options.offset ?? 0)
+            .orderBy(desc(notificationLog.createTimestamp));
+        const inAppRows = rows.map((row) => row.inApp);
+        const notificationRows = rows.map((row) => row.notification);
+        const notificationEntities = await this.#notificationLogRepository.mapManyToEntity(notificationRows);
+        const inAppEntities = await this.#inAppNotificationRepository.mapManyToEntity(inAppRows);
+        const views = notificationEntities.map((notification, index) => {
+            const inApp = inAppEntities[index];
+            return toInAppNotificationView(inApp, notification);
         });
-        const logIds = inAppNotifications.map((n) => n.logId);
-        const logs = await this.#notificationLogRepository.loadMany(logIds);
-        const logsMap = new Map(logs.map((log) => [log.id, log]));
-        return inAppNotifications.map((n) => ({
-            ...n,
-            log: logsMap.get(n.logId),
-        }));
+        return views;
     }
     async markRead(tenantId, userId, id) {
-        await this.#inAppNotificationRepository.updateByQuery({ tenantId, id, userId }, { readAt: currentTimestamp() });
+        await this.#inAppNotificationRepository.updateByQuery({ tenantId, id, userId }, { readTimestamp: TRANSACTION_TIMESTAMP });
     }
     async archive(tenantId, userId, id) {
-        await this.#inAppNotificationRepository.updateByQuery({ tenantId, id, userId }, { archivedAt: currentTimestamp() });
+        await this.#inAppNotificationRepository.updateByQuery({ tenantId, id, userId }, { archiveTimestamp: TRANSACTION_TIMESTAMP });
     }
     async getPreferences(tenantId, userId) {
         return await this.#preferenceRepository.loadManyByQuery({ tenantId, userId });
     }
-    async updatePreference(tenantId, userId, categoryId, channel, enabled) {
-        await this.#preferenceRepository.upsert(['tenantId', 'userId', 'categoryId', 'channel'], {
+    async updatePreference(tenantId, userId, type, channel, enabled) {
+        await this.#preferenceRepository.upsert(['tenantId', 'userId', 'type', 'channel'], {
             tenantId,
             userId,
-            categoryId,
+            type,
             channel,
             enabled,
         });
     }
     async registerWebPush(tenantId, userId, endpoint, p256dh, auth) {
+        try {
+            new URL(endpoint);
+        }
+        catch {
+            throw new BadRequestError('Invalid Web Push endpoint');
+        }
+        if (p256dh.length < 20) {
+            throw new BadRequestError('Invalid Web Push p256dh key');
+        }
+        if (auth.length < 10) {
+            throw new BadRequestError('Invalid Web Push auth secret');
+        }
         await this.#webPushSubscriptionRepository.upsert(['tenantId', 'userId', 'endpoint'], {
             tenantId,
             userId,
@@ -75,6 +92,6 @@ let NotificationService = class NotificationService extends Transactional {
     }
 };
 NotificationService = __decorate([
-    NotificationSingleton()
+    Singleton()
 ], NotificationService);
 export { NotificationService };

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

@@ -0,0 +1,95 @@
+import { beforeAll, describe, expect, test, vi } from 'vitest';
+import { SubjectService } from '../../authentication/server/subject.service.js';
+import {} from '../../injector/index.js';
+import { setupIntegrationTest } from '../../unit-test/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 { NotificationService } from '../server/services/notification.service.js';
+describe('Notification API (Integration)', () => {
+    let injector;
+    let controller;
+    let notificationService;
+    let sseService;
+    let subjectService;
+    const schema = 'notification';
+    const tenantId = '00000000-0000-0000-0000-000000000000';
+    let userId;
+    beforeAll(async () => {
+        ({ injector } = 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);
+        // Create a dummy user
+        const user = await subjectService.createUser({
+            tenantId,
+            email: 'api-test@example.com',
+            firstName: 'Api',
+            lastName: 'Test',
+        });
+        userId = user.id;
+    });
+    const createMockContext = (params = {}) => ({
+        parameters: params,
+        getToken: async () => ({
+            payload: {
+                tenant: tenantId,
+                subject: userId,
+            },
+        }),
+    });
+    test('stream should register sse client', async () => {
+        const registerSpy = vi.spyOn(sseService, 'register');
+        // 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(() => ({}));
+        await controller.stream(createMockContext());
+        expect(registerSpy).toHaveBeenCalledWith(tenantId, userId);
+    });
+    test('listInApp should call service', async () => {
+        const listInAppSpy = vi.spyOn(notificationService, 'listInApp').mockResolvedValue([]);
+        const params = { limit: 10, offset: 0, includeArchived: false };
+        await controller.listInApp(createMockContext(params));
+        expect(listInAppSpy).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('updatePreference should call service', async () => {
+        const updatePreferenceSpy = vi.spyOn(notificationService, 'updatePreference').mockResolvedValue();
+        const params = { type: 'test', channel: NotificationChannel.Email, enabled: true };
+        await controller.updatePreference(createMockContext(params));
+        expect(updatePreferenceSpy).toHaveBeenCalledWith(tenantId, userId, 'test', NotificationChannel.Email, true);
+    });
+    test('registerWebPush should call service', async () => {
+        const registerWebPushSpy = vi.spyOn(notificationService, 'registerWebPush').mockResolvedValue();
+        const params = { endpoint: 'url', keys: { p256dh: 'key', auth: 'auth' } };
+        await controller.registerWebPush(createMockContext(params));
+        expect(registerWebPushSpy).toHaveBeenCalledWith(tenantId, userId, 'url', 'key', 'auth');
+    });
+});

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

@@ -1,21 +1,20 @@
-import { beforeAll, describe, expect, test, vi } from 'vitest';
+import { beforeAll, beforeEach, describe, expect, test, vi } from 'vitest';
 import { SubjectService } from '../../authentication/server/subject.service.js';
 import { runInInjectionContext } from '../../injector/index.js';
 import { MailService } from '../../mail/mail.service.js';
 import { injectRepository } from '../../orm/server/index.js';
 import { setupIntegrationTest, truncateTables } from '../../unit-test/index.js';
-import { NotificationChannel, NotificationStatus } from '../enums.js';
-import { InAppNotification, NotificationLog } from '../models/index.js';
+import { InAppNotification, NotificationChannel, NotificationLogEntity, NotificationStatus, WebPushSubscription } from '../models/index.js';
 import { EmailChannelProvider } from '../server/providers/email-channel-provider.js';
-import { NotificationCategoryService } from '../server/services/notification-category.service.js';
 import { NotificationDeliveryWorker } from '../server/services/notification-delivery.worker.js';
+import { NotificationTypeService } from '../server/services/notification-type.service.js';
 import { NotificationService } from '../server/services/notification.service.js';
 describe('Notification Flow (Integration)', () => {
     let injector;
     let database;
     let notificationService;
     let worker;
-    let categoryService;
+    let typeService;
     let subjectService;
     let mailServiceMock;
     const schema = 'notification';
@@ -38,75 +37,222 @@ describe('Notification Flow (Integration)', () => {
         // Resolve Services
         notificationService = injector.resolve(NotificationService);
         worker = injector.resolve(NotificationDeliveryWorker);
-        categoryService = injector.resolve(NotificationCategoryService);
+        typeService = injector.resolve(NotificationTypeService);
         subjectService = injector.resolve(SubjectService);
         // Register providers
         worker.registerProvider(NotificationChannel.Email, injector.resolve(EmailChannelProvider));
         const InAppChannelProvider = (await import('../server/providers/in-app-channel-provider.js')).InAppChannelProvider;
         worker.registerProvider(NotificationChannel.InApp, injector.resolve(InAppChannelProvider));
+    });
+    beforeEach(async () => {
         await truncateTables(database, 'authentication', ['user', 'subject']);
-        await truncateTables(database, 'notification', ['log', 'in_app', 'category', 'preference', 'web_push_subscription']);
+        await truncateTables(database, 'notification', ['log', 'in_app', 'type', 'preference', 'web_push_subscription']);
+        vi.clearAllMocks();
     });
     test('should execute full notification flow with escalation', async () => {
         await runInInjectionContext(injector, async () => {
-            // Resolve Dependencies synchronously at start
-            const logRepo = injectRepository(NotificationLog);
+            const logRepo = injectRepository(NotificationLogEntity);
             const inAppRepo = injectRepository(InAppNotification);
-            // 1. Setup Data
             const user = await subjectService.createUser({
                 tenantId,
                 email: 'test@example.com',
                 firstName: 'Test',
                 lastName: 'User',
             });
-            // Initialize Category with Escalation
-            const categories = await categoryService.initializeCategories(tenantId, {
-                TEST_CAT: {
+            await typeService.initializeTypes({
+                test: {
                     label: 'Test Category',
-                    escalations: [{ delayMs: 1000, channel: NotificationChannel.Email }],
+                    escalations: [{ delay: 1000, channel: NotificationChannel.Email }],
                 },
             });
-            const category = categories.TEST_CAT;
-            // 2. Send Notification
-            const notification = Object.assign(new NotificationLog(), {
+            const notification = Object.assign(new NotificationLogEntity(), {
                 tenantId,
                 userId: user.id,
-                categoryId: category.id,
                 type: 'test',
                 priority: 'high',
                 payload: { message: 'Hello', testField: 'Test Value' },
             });
             await notificationService.send(notification);
-            // Verify Log Created
             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);
-            expect(log.payload.testField).toBe('Test Value');
-            // 3. Worker Execution - Step 0 (In-App)
+            // Step 0 (In-App)
             const result0 = await worker.deliver(log.id);
-            // Verify Result
             expect(result0.payload.action).toBe('reschedule');
-            // Verify In-App Created
             const inApps = await inAppRepo.loadManyByQuery({ tenantId });
             expect(inApps).toHaveLength(1);
             expect(inApps[0].logId).toBe(log.id);
-            // Verify Log Updated
             const logAfterStep0 = await logRepo.load(log.id);
             expect(logAfterStep0.status).toBe(NotificationStatus.Sent);
             expect(logAfterStep0.currentStep).toBe(1);
-            // 4. Worker Execution - Step 1 (Email Escalation)
+            // Step 1 (Email Escalation)
             const result1 = await worker.deliver(log.id);
-            // Verify Result
             expect(result1.payload.action).toBe('complete');
-            // Verify Email Sent
             expect(mailServiceMock.send).toHaveBeenCalled();
             const mailArgs = mailServiceMock.send.mock.calls[0][0];
             expect(mailArgs.to).toBe('test@example.com');
-            // Verify Log Updated
             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 },
+                },
+            });
+            const notification1 = Object.assign(new NotificationLogEntity(), {
+                tenantId, userId: user.id, type: 'throttled', priority: 'medium', payload: {},
+            });
+            const notification2 = Object.assign(new NotificationLogEntity(), {
+                tenantId, userId: user.id, type: 'throttled', priority: 'medium', payload: {},
+            });
+            await notificationService.send(notification1);
+            await notificationService.send(notification2);
+            const logs = await logRepo.loadManyByQuery({ tenantId });
+            logs.sort((a, b) => Number(a.metadata.createTimestamp) - Number(b.metadata.createTimestamp));
+            // 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 }],
+                },
+            });
+            const notification = Object.assign(new NotificationLogEntity(), {
+                tenantId, userId: user.id, type: 'readTest', priority: 'medium', payload: {},
+            });
+            await notificationService.send(notification);
+            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);
+            const notification = Object.assign(new NotificationLogEntity(), {
+                tenantId, userId: user.id, type: 'prefTest', priority: 'medium', payload: {},
+            });
+            await notificationService.send(notification);
+            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);
+            const notification = Object.assign(new NotificationLogEntity(), {
+                tenantId, userId: user.id, type: 'unknownTest', priority: 'medium', payload: {},
+            });
+            await notificationService.send(notification);
+            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' } });
+            const notification = Object.assign(new NotificationLogEntity(), {
+                tenantId, userId: user.id, type: 'manageTest', priority: 'medium', payload: {},
+            });
+            await notificationService.send(notification);
+            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 (default excludes archived)
+            list = await notificationService.listInApp(tenantId, user.id);
+            expect(list).toHaveLength(0);
+            // List (include archived)
+            list = await notificationService.listInApp(tenantId, user.id, { includeArchived: true });
+            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');
+        });
+    });
+    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);
+        });
+    });
 });

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

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

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

@@ -0,0 +1,35 @@
+import { describe, expect, test } from 'vitest';
+import { runInInjectionContext } from '../../injector/index.js';
+import { setupIntegrationTest, truncateTables } from '../../unit-test/index.js';
+import { NotificationTypeService } from '../server/services/notification-type.service.js';
+describe('NotificationTypeService', () => {
+    test('should initialize types correctly', async () => {
+        const { injector, database } = await setupIntegrationTest({ modules: { notification: true, authentication: true } });
+        // Cleanup
+        await truncateTables(database, 'notification', ['type']);
+        const service = injector.resolve(NotificationTypeService);
+        const typeData = {
+            TYPE1: { label: 'Type 1' },
+            TYPE2: { label: 'Type 2', throttling: { limit: 1, interval: 1000 } }
+        };
+        await runInInjectionContext(injector, async () => {
+            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.loadAll();
+            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.loadAll();
+            expect(dbTypesUpdated).toHaveLength(2);
+            expect(dbTypesUpdated.find((c) => c.key == 'TYPE1')?.label).toBe('Type 1 Updated');
+        });
+    });
+});

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tstdl/base",
-  "version": "0.93.100",
+  "version": "0.93.102",
   "author": "Patrick Hein",
   "publishConfig": {
     "access": "public"

package/rate-limit/postgres/postgres-rate-limiter.d.ts

@@ -1,9 +1,14 @@
-import { RateLimiter } from '../rate-limiter.js';
+import { RateLimiter, type RateLimiterArgument, type RateLimiterConfig } from '../rate-limiter.js';
+type PostgresRateLimiterContext = {
+    config: RateLimiterArgument;
+};
 export declare class PostgresRateLimiter extends RateLimiter {
     #private;
     readonly burstCapacity: number;
-    readonly refillIntervalMs: number;
+    readonly refillInterval: number;
     readonly refillRate: number;
-    tryAcquire(resource: string, cost?: number): Promise<boolean>;
-    refund(resource: string, amount: number): Promise<void>;
+    tryAcquire(resource: string, cost?: number, options?: Partial<RateLimiterConfig>): Promise<boolean>;
+    refund(resource: string, amount: number, options?: Partial<Pick<RateLimiterConfig, 'burstCapacity'>>): Promise<void>;
+    protected getTransactionalContextData(): PostgresRateLimiterContext;
 }
+export {};

package/rate-limit/postgres/postgres-rate-limiter.js

@@ -15,15 +15,18 @@ import { PostgresRateLimit } from './rate-limit.model.js';
 import { rateLimit } from './schemas.js';
 let PostgresRateLimiter = class PostgresRateLimiter extends RateLimiter {
     #repository = injectRepository(PostgresRateLimit);
-    #config = injectArgument(this);
+    #config = this.transactionalContextData?.config ?? injectArgument(this);
     burstCapacity = isString(this.#config) ? 100 : this.#config.burstCapacity;
-    refillIntervalMs = isString(this.#config) ? 1000 : this.#config.refillIntervalMs;
-    refillRate = this.burstCapacity / this.refillIntervalMs;
-    async tryAcquire(resource, cost = 1) {
+    refillInterval = isString(this.#config) ? 1000 : this.#config.refillInterval;
+    refillRate = this.burstCapacity / this.refillInterval;
+    async tryAcquire(resource, cost = 1, options) {
+        const burstCapacity = options?.burstCapacity ?? this.burstCapacity;
+        const refillInterval = options?.refillInterval ?? this.refillInterval;
+        const refillRate = burstCapacity / refillInterval;
         if (cost <= 0) {
             return true;
         }
-        if (cost > this.burstCapacity) {
+        if (cost > burstCapacity) {
             return false;
         }
         // Atomic Upsert with Conditional Update
@@ -33,16 +36,20 @@ let PostgresRateLimiter = class PostgresRateLimiter extends RateLimiter {
         // RETURNING clause will only return a row if the INSERT or UPDATE actually happened.
         const nowMs = sql `(EXTRACT(EPOCH FROM ${TRANSACTION_TIMESTAMP}) * 1000)`;
         const lastRefillMs = sql `(EXTRACT(EPOCH FROM ${rateLimit.lastRefillTimestamp}) * 1000)`;
-        const tokensToAdd = sql `(${nowMs} - ${lastRefillMs}) * ${this.refillRate}`;
-        const newTokensExpression = least(this.burstCapacity, sql `${rateLimit.tokens} + ${tokensToAdd}`);
-        const result = await this.#repository.tryUpsert('resource', { resource, tokens: this.burstCapacity - cost, lastRefillTimestamp: TRANSACTION_TIMESTAMP }, { tokens: sql `${newTokensExpression} - ${cost}`, lastRefillTimestamp: TRANSACTION_TIMESTAMP }, { set: gte(newTokensExpression, cost) });
+        const tokensToAdd = sql `(${nowMs} - ${lastRefillMs}) * ${refillRate}`;
+        const newTokensExpression = least(burstCapacity, sql `${rateLimit.tokens} + ${tokensToAdd}`);
+        const result = await this.#repository.tryUpsert('resource', { resource, tokens: burstCapacity - cost, lastRefillTimestamp: TRANSACTION_TIMESTAMP }, { tokens: sql `${newTokensExpression} - ${cost}`, lastRefillTimestamp: TRANSACTION_TIMESTAMP }, { set: gte(newTokensExpression, cost) });
         return isDefined(result);
     }
-    async refund(resource, amount) {
+    async refund(resource, amount, options) {
         if (amount <= 0) {
             return;
         }
-        await this.#repository.updateByQuery({ resource }, { tokens: least(this.burstCapacity, sql `${rateLimit.tokens} + ${amount}`) });
+        const burstCapacity = options?.burstCapacity ?? this.burstCapacity;
+        await this.#repository.updateByQuery({ resource }, { tokens: least(burstCapacity, sql `${rateLimit.tokens} + ${amount}`) });
+    }
+    getTransactionalContextData() {
+        return { config: this.#config };
     }
 };
 PostgresRateLimiter = __decorate([

package/rate-limit/rate-limiter.d.ts

@@ -8,7 +8,7 @@ export type RateLimiterConfig = {
     /**
      * Time in milliseconds in which the bucket refills to its full burst capacity.
      */
-    refillIntervalMs: number;
+    refillInterval: number;
 };
 export type RateLimiterArgument = string | (RateLimiterConfig & {
     resource: string;
@@ -16,20 +16,20 @@ export type RateLimiterArgument = string | (RateLimiterConfig & {
 export declare abstract class RateLimiter extends Transactional implements Resolvable<RateLimiterArgument> {
     readonly [resolveArgumentType]: RateLimiterArgument;
     abstract readonly burstCapacity: number;
-    abstract readonly refillIntervalMs: number;
+    abstract readonly refillInterval: number;
     /**
      * Attempts to acquire the specified number of tokens for a resource.
      * @param resource The resource identifier to acquire tokens for.
      * @param cost The number of tokens to acquire. Defaults to 1.
-     * @param transaction Optional transaction to participate in.
+     * @param options Optional configuration overrides for this acquisition.
      * @returns A promise that resolves to true if tokens were successfully acquired, false otherwise.
      */
-    abstract tryAcquire(resource: string, cost?: number): Promise<boolean>;
+    abstract tryAcquire(resource: string, cost?: number, options?: Partial<RateLimiterConfig>): Promise<boolean>;
     /**
      * Refunds tokens back to the bucket for a resource.
      * @param resource The resource identifier to refund tokens to.
      * @param amount The number of tokens to refund.
-     * @param transaction Optional transaction to participate in.
+     * @param options Optional configuration overrides for this refund.
      */
-    abstract refund(resource: string, amount: number): Promise<void>;
+    abstract refund(resource: string, amount: number, options?: Partial<Pick<RateLimiterConfig, 'burstCapacity'>>): Promise<void>;
 }

package/rate-limit/tests/postgres-rate-limiter.test.js

@@ -13,7 +13,7 @@ describe('PostgresRateLimiter Integration Tests', () => {
         const rateLimiterProvider = injector.resolve(RateLimiterProvider);
         return rateLimiterProvider.get(limiterName, {
             burstCapacity: 10,
-            refillIntervalMs: 1000, // 10 tokens per second -> 1 token per 100ms
+            refillInterval: 1000, // 10 tokens per second -> 1 token per 100ms
         });
     }
     afterAll(async () => {