@tstdl/base 0.93.122 → 0.93.125

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

@@ -6,26 +6,30 @@ var __decorate = (this && this.__decorate) || function (decorators, target, key,
 };
 var _a;
 var NotificationService_1;
-import { and, desc, eq, isNull, lt, or } from 'drizzle-orm';
+import { and, desc, eq, gt, isNull, lt, or, sql } from 'drizzle-orm';
+import { match, P } from 'ts-pattern';
 import { BadRequestError } from '../../../errors/bad-request.error.js';
 import { inject, Singleton } from '../../../injector/index.js';
 import { Logger } from '../../../logger/logger.js';
-import { TRANSACTION_TIMESTAMP } from '../../../orm/index.js';
+import { getEntityIds, TRANSACTION_TIMESTAMP } from '../../../orm/index.js';
 import { injectRepository, Transactional } from '../../../orm/server/index.js';
 import { TaskQueue } from '../../../task-queue/task-queue.js';
 import { tryIgnoreLogAsync } from '../../../utils/try-ignore.js';
-import { isDefined } from '../../../utils/type-guards.js';
-import { InAppNotification, NotificationChannel, NotificationLogEntity, NotificationPreference, NotificationPriority, NotificationStatus, toInAppNotificationView, WebPushSubscription } from '../../models/index.js';
-import { inAppNotification, notificationLog } from '../schemas.js';
+import { isDefined, isUndefined } from '../../../utils/type-guards.js';
+import { InAppNotification, InAppNotificationArchive, NotificationChannel, NotificationLogEntity, NotificationPreference, NotificationPriority, NotificationStatus, toInAppNotificationView, WebPushSubscription } from '../../models/index.js';
+import { NotificationConfiguration } from '../module.js';
+import { inAppNotification, inAppNotificationArchive, notificationLog } from '../schemas.js';
 import { NotificationAncillaryService } from './notification-ancillary.service.js';
 import { NotificationSseService } from './notification-sse.service.js';
 let NotificationService = NotificationService_1 = class NotificationService extends Transactional {
     #notificationLogRepository = injectRepository(NotificationLogEntity);
     #inAppNotificationRepository = injectRepository(InAppNotification);
+    #inAppNotificationArchiveRepository = injectRepository(InAppNotificationArchive);
     #preferenceRepository = injectRepository(NotificationPreference);
     #webPushSubscriptionRepository = injectRepository(WebPushSubscription);
     #notificationAncillaryService = inject(NotificationAncillaryService);
     #taskQueue = inject((TaskQueue), 'notification');
+    #configuration = inject(NotificationConfiguration);
     #sseService = inject(NotificationSseService);
     #logger = inject(Logger, NotificationService_1.name);
     async send(tenantId, userId, notification, options) {
@@ -44,61 +48,189 @@ let NotificationService = NotificationService_1 = class NotificationService exte
         });
     }
     async listInApp(tenantId, userId, options = {}) {
-        let afterNotification;
-        if (options.after != null) {
-            const inApp = await this.#inAppNotificationRepository.loadByQuery({ tenantId, userId, id: options.after });
-            afterNotification = await this.#notificationLogRepository.loadByQuery({ tenantId, userId, id: inApp.logId });
-        }
-        const rows = await this.#notificationLogRepository.session
+        return await this.#list(tenantId, userId, inAppNotification, this.#inAppNotificationRepository, options);
+    }
+    async listArchivedInApp(tenantId, userId, options = {}) {
+        return await this.#list(tenantId, userId, inAppNotificationArchive, this.#inAppNotificationArchiveRepository, options);
+    }
+    async #list(tenantId, userId, table, repository, options = {}) {
+        const db = this.#notificationLogRepository.session;
+        const { afterTimestamp, afterNotificationId } = await match(options.after)
+            .with(P.nullish, () => ({ afterTimestamp: undefined, afterNotificationId: undefined }))
+            .with(P.number, (value) => ({ afterTimestamp: value, afterNotificationId: undefined }))
+            .with(P.string, async (value) => {
+            const inApp = await repository.tryLoadByQuery({ tenantId, userId, id: value });
+            return { afterTimestamp: inApp?.timestamp, afterNotificationId: inApp?.logId };
+        })
+            .exhaustive();
+        const rows = await db
             .select({
             notification: notificationLog,
-            inApp: inAppNotification,
+            inApp: table,
         })
-            .from(notificationLog)
-            .innerJoin(inAppNotification, and(eq(inAppNotification.tenantId, notificationLog.tenantId), eq(inAppNotification.userId, notificationLog.userId), eq(inAppNotification.logId, notificationLog.id)))
-            .where(and(eq(notificationLog.tenantId, tenantId), eq(notificationLog.userId, userId), options.includeArchived ? undefined : isNull(inAppNotification.archiveTimestamp), options.unreadOnly ? isNull(inAppNotification.readTimestamp) : undefined, isDefined(afterNotification)
-            ? or(lt(notificationLog.timestamp, afterNotification.timestamp), and(eq(notificationLog.timestamp, afterNotification.timestamp), lt(notificationLog.id, afterNotification.id)))
+            .from(table)
+            .innerJoin(notificationLog, and(eq(notificationLog.tenantId, table.tenantId), eq(notificationLog.userId, table.userId), eq(notificationLog.id, table.logId)))
+            .where(and(eq(table.tenantId, tenantId), eq(table.userId, userId), options.unreadOnly ? isNull(table.readTimestamp) : undefined, isDefined(afterTimestamp)
+            ? isDefined(afterNotificationId)
+                ? or(lt(table.timestamp, afterTimestamp), and(eq(table.timestamp, afterTimestamp), lt(table.logId, afterNotificationId)))
+                : lt(table.timestamp, afterTimestamp)
             : undefined))
             .limit(options.limit ?? 50)
             .offset(options.offset ?? 0)
-            .orderBy(desc(notificationLog.timestamp), desc(notificationLog.id));
+            .orderBy(desc(table.timestamp), desc(table.logId));
         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 inAppEntities = await repository.mapManyToEntity(inAppRows);
         const notificationViewDatas = await this.#notificationAncillaryService.getViewData(tenantId, notificationEntities);
-        const views = notificationEntities.map((notification, index) => {
+        return notificationEntities.map((notification, index) => {
             const inApp = inAppEntities[index];
             const viewData = notificationViewDatas[index];
             const payload = { ...notification.payload, ...viewData };
             return toInAppNotificationView(inApp, { ...notification, payload });
         });
-        return views;
     }
     async markRead(tenantId, userId, id) {
         await this.#inAppNotificationRepository.updateByQuery({ tenantId, id, userId }, { readTimestamp: TRANSACTION_TIMESTAMP });
-        await this.dispatchUnreadCountUpdate(tenantId, userId);
+        await tryIgnoreLogAsync(this.#logger, async () => {
+            const unreadCount = await this.unreadCount(tenantId, userId);
+            await this.#sseService.dispatch(tenantId, userId, { readId: id, unreadCount });
+        });
     }
     async markAllRead(tenantId, userId) {
-        await this.#inAppNotificationRepository.updateByQuery({ tenantId, userId, readTimestamp: null }, { readTimestamp: TRANSACTION_TIMESTAMP });
-        await this.dispatchUnreadCountUpdate(tenantId, userId);
+        await this.#inAppNotificationRepository.updateManyByQuery({ tenantId, userId, readTimestamp: null }, { readTimestamp: TRANSACTION_TIMESTAMP });
+        await tryIgnoreLogAsync(this.#logger, async () => {
+            const unreadCount = await this.unreadCount(tenantId, userId);
+            await this.#sseService.dispatch(tenantId, userId, { readAll: true, unreadCount });
+        });
     }
     async archive(tenantId, userId, id) {
-        await this.#inAppNotificationRepository.updateByQuery({ tenantId, id, userId }, { archiveTimestamp: TRANSACTION_TIMESTAMP });
-        await this.dispatchUnreadCountUpdate(tenantId, userId);
+        const db = this.#inAppNotificationRepository.session;
+        const deletedRows = db.$with('deleted_rows').as(db.delete(inAppNotification)
+            .where(and(eq(inAppNotification.tenantId, tenantId), eq(inAppNotification.id, id), eq(inAppNotification.userId, userId)))
+            .returning());
+        await db.with(deletedRows)
+            .insert(inAppNotificationArchive)
+            .select(db
+            .select({
+            id: deletedRows.id,
+            tenantId: deletedRows.tenantId,
+            userId: deletedRows.userId,
+            logId: deletedRows.logId,
+            timestamp: deletedRows.timestamp,
+            readTimestamp: deletedRows.readTimestamp,
+            archiveTimestamp: TRANSACTION_TIMESTAMP.as('archive_timestamp'),
+        })
+            .from(deletedRows));
+        await tryIgnoreLogAsync(this.#logger, async () => {
+            const unreadCount = await this.unreadCount(tenantId, userId);
+            await this.#sseService.dispatch(tenantId, userId, { archiveId: id, unreadCount });
+        });
+    }
+    async archiveByQuery(tenantId, query) {
+        const db = this.#inAppNotificationRepository.session;
+        const logQueryCondition = this.#notificationLogRepository.convertQuery(query);
+        const rowsToDelete = db.$with('rows_to_delete').as(db.select({ id: inAppNotification.id })
+            .from(inAppNotification)
+            .innerJoin(notificationLog, and(eq(inAppNotification.tenantId, notificationLog.tenantId), eq(inAppNotification.logId, notificationLog.id), eq(inAppNotification.userId, notificationLog.userId)))
+            .where(and(eq(inAppNotification.tenantId, tenantId), logQueryCondition)));
+        const deletedRows = db.$with('deleted_rows').as(db.delete(inAppNotification)
+            .where(sql `${inAppNotification.id} IN (SELECT id FROM ${rowsToDelete})`)
+            .returning());
+        await db.with(rowsToDelete, deletedRows)
+            .insert(inAppNotificationArchive)
+            .select(db
+            .select({
+            id: deletedRows.id,
+            tenantId: deletedRows.tenantId,
+            userId: deletedRows.userId,
+            logId: deletedRows.logId,
+            timestamp: deletedRows.timestamp,
+            readTimestamp: deletedRows.readTimestamp,
+            archiveTimestamp: TRANSACTION_TIMESTAMP.as('archive_timestamp'),
+        })
+            .from(deletedRows));
     }
     async archiveAll(tenantId, userId) {
-        await this.#inAppNotificationRepository.updateByQuery({ tenantId, userId, archiveTimestamp: null }, { archiveTimestamp: TRANSACTION_TIMESTAMP });
-        await this.dispatchUnreadCountUpdate(tenantId, userId);
+        const db = this.#inAppNotificationRepository.session;
+        const deletedRows = db.$with('deleted_rows').as(db.delete(inAppNotification)
+            .where(and(eq(inAppNotification.tenantId, tenantId), eq(inAppNotification.userId, userId)))
+            .returning());
+        await db.with(deletedRows)
+            .insert(inAppNotificationArchive)
+            .select(db
+            .select({
+            id: deletedRows.id,
+            tenantId: deletedRows.tenantId,
+            userId: deletedRows.userId,
+            logId: deletedRows.logId,
+            timestamp: deletedRows.timestamp,
+            readTimestamp: deletedRows.readTimestamp,
+            archiveTimestamp: TRANSACTION_TIMESTAMP.as('archive_timestamp'),
+        })
+            .from(deletedRows));
+        await tryIgnoreLogAsync(this.#logger, async () => {
+            const unreadCount = await this.unreadCount(tenantId, userId);
+            await this.#sseService.dispatch(tenantId, userId, { archiveAll: true, unreadCount });
+        });
+    }
+    async runAutoArchive() {
+        const autoArchiveAfter = this.#configuration.autoArchiveAfter;
+        if (isUndefined(autoArchiveAfter) || (autoArchiveAfter <= 0)) {
+            return;
+        }
+        const threshold = new Date(Date.now() - autoArchiveAfter);
+        const db = this.#inAppNotificationRepository.session;
+        const rowsToDelete = db.$with('rows_to_delete').as(db.select({ id: inAppNotification.id })
+            .from(inAppNotification)
+            .where(lt(inAppNotification.timestamp, threshold.getTime())));
+        const deletedRows = db.$with('deleted_rows').as(db.delete(inAppNotification)
+            .where(sql `${inAppNotification.id} IN (SELECT id FROM ${rowsToDelete})`)
+            .returning());
+        await db.with(rowsToDelete, deletedRows)
+            .insert(inAppNotificationArchive)
+            .select(db
+            .select({
+            id: deletedRows.id,
+            tenantId: deletedRows.tenantId,
+            userId: deletedRows.userId,
+            logId: deletedRows.logId,
+            timestamp: deletedRows.timestamp,
+            readTimestamp: deletedRows.readTimestamp,
+            archiveTimestamp: TRANSACTION_TIMESTAMP.as('archive_timestamp'),
+        })
+            .from(deletedRows));
     }
     async unreadCount(tenantId, userId) {
         return await this.#inAppNotificationRepository.countByQuery({
             tenantId,
             userId,
             readTimestamp: null,
-            archiveTimestamp: null,
         });
     }
+    async getCatchupData(tenantId, userId, stateTimestamp) {
+        const db = this.#notificationLogRepository.session;
+        const [unreadCount, missedNotifications, readRows, archiveRows] = await Promise.all([
+            this.unreadCount(tenantId, userId),
+            this.listInApp(tenantId, userId, { after: stateTimestamp, limit: 50 }),
+            db.select({ id: inAppNotification.id })
+                .from(inAppNotification)
+                .where(and(eq(inAppNotification.tenantId, tenantId), eq(inAppNotification.userId, userId), gt(inAppNotification.readTimestamp, stateTimestamp)))
+                .orderBy(desc(inAppNotification.readTimestamp))
+                .limit(50),
+            db.select({ id: inAppNotificationArchive.id })
+                .from(inAppNotificationArchive)
+                .where(and(eq(inAppNotificationArchive.tenantId, tenantId), eq(inAppNotificationArchive.userId, userId), gt(inAppNotificationArchive.archiveTimestamp, stateTimestamp)))
+                .orderBy(desc(inAppNotificationArchive.archiveTimestamp))
+                .limit(50),
+        ]);
+        return {
+            unreadCount,
+            missedNotifications,
+            readIds: getEntityIds(readRows),
+            archiveIds: getEntityIds(archiveRows),
+        };
+    }
     async getPreferences(tenantId, userId) {
         return await this.#preferenceRepository.loadManyByQuery({ tenantId, userId });
     }
@@ -132,12 +264,6 @@ let NotificationService = NotificationService_1 = class NotificationService exte
             auth,
         });
     }
-    async dispatchUnreadCountUpdate(tenantId, userId) {
-        await tryIgnoreLogAsync(this.#logger, async () => {
-            const unreadCount = await this.unreadCount(tenantId, userId);
-            await this.#sseService.dispatchUnreadCountUpdate(tenantId, userId, unreadCount);
-        });
-    }
 };
 NotificationService = NotificationService_1 = __decorate([
     Singleton()

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

@@ -44,6 +44,7 @@ describe('Notification API (Integration)', () => {
     const createMockContext = (params = {}) => ({
         parameters: params,
         abortSignal: new AbortController().signal,
+        serverSentEvents: {},
         getToken: async () => ({
             payload: {
                 tenant: tenantId,
@@ -74,10 +75,16 @@ describe('Notification API (Integration)', () => {
     });
     test('listInApp should call service', async () => {
         const listInAppSpy = vi.spyOn(notificationService, 'listInApp').mockResolvedValue([]);
-        const params = { limit: 10, offset: 0, includeArchived: false };
+        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' };

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

@@ -64,7 +64,7 @@ describe('Notification Flow (Integration)', () => {
     });
     beforeEach(async () => {
         await truncateTables(database, 'authentication', ['user', 'subject']);
-        await truncateTables(database, 'notification', ['log', 'in_app', 'type', 'preference', 'web_push_subscription']);
+        await truncateTables(database, 'notification', ['log', 'in_app', 'in_app_archive', 'type', 'preference', 'web_push_subscription']);
         vi.clearAllMocks();
     });
     test('should execute full notification flow with escalation', async () => {
@@ -234,11 +234,11 @@ describe('Notification Flow (Integration)', () => {
             expect(list[0].readTimestamp).not.toBeNull();
             // Archive
             await notificationService.archive(tenantId, user.id, list[0].id);
-            // List (default excludes archived)
+            // List (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 });
+            // List archived
+            list = await notificationService.listArchivedInApp(tenantId, user.id);
             expect(list).toHaveLength(1);
             expect(list[0].archiveTimestamp).not.toBeNull();
         });
@@ -293,4 +293,41 @@ describe('Notification Flow (Integration)', () => {
             expect(afterSecond[0].id).toBe(list[2].id);
         });
     });
+    test('should auto-archive old notifications', async () => {
+        await runInInjectionContext(injector, async () => {
+            const logRepo = injectRepository(NotificationLogEntity);
+            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 notificationService.runAutoArchive();
+            // Verify archived
+            expect(await notificationService.listInApp(tenantId, user.id)).toHaveLength(0);
+            expect(await notificationService.listArchivedInApp(tenantId, user.id)).toHaveLength(1);
+            vi.useRealTimers();
+        });
+    });
+    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);
+        });
+    });
 });

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

@@ -13,8 +13,8 @@ describe('NotificationSseService', () => {
             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 = { tenantId, userId, logId: 'l1' };
-            await expect(service.send(msg, 1)).resolves.not.toThrow();
+            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 () => {
@@ -23,7 +23,28 @@ describe('NotificationSseService', () => {
         const tenantId = 't1';
         const userId = 'u1';
         await runInInjectionContext(injector, async () => {
-            await expect(service.dispatchUnreadCountUpdate(tenantId, userId, 5)).resolves.not.toThrow();
+            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 });
         });
     });
 });

package/notification/types.d.ts

@@ -1,9 +1,17 @@
 import { InAppNotificationView, type NotificationDefinitionMap } from './models/index.js';
 export declare const notificationStreamItemSchema: import("../schema/index.js").ObjectSchema<{
-    unreadCount: number;
     notification?: InAppNotificationView<Record<string, import("./models/notification-log.model.js").NotificationDefinition<import("../types/types.js").ObjectLiteral, import("../types/types.js").ObjectLiteral>>> | undefined;
+    readId?: string | undefined;
+    readAll?: boolean | undefined;
+    archiveId?: string | undefined;
+    archiveAll?: boolean | undefined;
+    unreadCount?: number | undefined;
 }>;
 export type NotificationStreamItem<Definitions extends NotificationDefinitionMap = NotificationDefinitionMap> = {
     notification?: InAppNotificationView<Definitions>;
-    unreadCount: number;
+    readId?: string;
+    readAll?: boolean;
+    archiveId?: string;
+    archiveAll?: boolean;
+    unreadCount?: number;
 };

package/notification/types.js

@@ -1,6 +1,10 @@
-import { number, object, optional } from '../schema/index.js';
+import { boolean, number, object, optional, string } from '../schema/index.js';
 import { InAppNotificationView } from './models/index.js';
 export const notificationStreamItemSchema = object({
     notification: optional(InAppNotificationView),
-    unreadCount: number(),
+    readId: optional(string()),
+    readAll: optional(boolean()),
+    archiveId: optional(string()),
+    archiveAll: optional(boolean()),
+    unreadCount: optional(number()),
 });

package/orm/server/drizzle/schema-converter.js

@@ -86,7 +86,8 @@ export function _getDrizzleTableFromType(type, fallbackSchemaName) {
             return column;
         });
         const indexFn = (data.options?.unique == true) ? uniqueIndex : index;
-        let builder = indexFn(data.options?.name ?? getIndexName(tableName, columns, { naming: data.options?.naming })).using(data.options?.using ?? 'btree', ...columns);
+        let builder = indexFn(data.options?.name ?? getIndexName(tableName, columns, { naming: data.options?.naming, partial: isDefined(data.options?.where) }))
+            .using(data.options?.using ?? 'btree', ...columns);
         if (isDefined(data.options?.where)) {
             const query = convertQuery(data.options.where(table), table, columnDefinitionsMap);
             builder = builder.where(query.inlineParams());
@@ -198,7 +199,7 @@ export function _getDrizzleTableFromType(type, fallbackSchemaName) {
             const paradeOptions = columnDef.reflectionData.paradeField;
             return buildParadeCast(columnSql, paradeOptions);
         });
-        const indexName = getIndexName(tableName, 'parade', { naming });
+        const indexName = getIndexName(tableName, 'parade', { naming, partial: isDefined(where) });
         const indexColumns = [
             table.id, // this orm always uses 'id' as key field as every entity has it
             ...classLevelColumnSqls,
@@ -468,7 +469,8 @@ function getPrimaryKeyName(tableName, columnsOrBaseName, options) {
     return getIdentifier(tableName, columnsOrBaseName, 'pk', options);
 }
 function getIndexName(tableName, columnsOrBaseName, options) {
-    return getIdentifier(tableName, columnsOrBaseName, 'idx', options);
+    const suffix = (options?.partial == true) ? 'partial_idx' : 'idx';
+    return getIdentifier(tableName, columnsOrBaseName, suffix, options);
 }
 function getUniqueName(tableName, columnsOrBaseName, options) {
     return getIdentifier(tableName, columnsOrBaseName, 'unique', options);

package/orm/tests/schema-converter.test.js

@@ -42,6 +42,7 @@ describe('ORM Schema Generation - Detailed Configurations', () => {
         expect(config.indexes.length).toBeGreaterThan(0);
         const idx = config.indexes[0];
         expect(idx).toBeDefined();
+        expect(idx.config.name).toContain('partial_idx');
         expect(idx.config.where).toBeDefined();
     });
     test('should handle index with nulls ordering', () => {

package/package.json

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

package/sse/data-stream-source.d.ts

@@ -2,20 +2,23 @@ import type { UndefinableJson } from '../types/types.js';
 import type { AnyIterable } from '../utils/any-iterable-iterator.js';
 import { ServerSentEventsSource } from './server-sent-events-source.js';
 export type DataStreamErrorFormatter = (error: unknown) => UndefinableJson;
-export type DataStreamSourceOptions = {
+export type DataStreamSourceOptions<T> = {
     /**
      * Whether to send deltas (the changes) between the last and current data or always the full data.
+     * Useful when the target data is a full "state object".
+     * For notification-like streams, where only new items are sent, delta should usually be disabled.
      */
     delta?: boolean;
     errorFormatter?: DataStreamErrorFormatter;
+    idProvider?: (data: T) => string | undefined;
 };
 export declare class DataStreamSource<T> {
     #private;
     readonly eventSource: ServerSentEventsSource;
     readonly closed: import("../signals/api.js").Signal<boolean>;
-    constructor({ delta, errorFormatter }?: DataStreamSourceOptions);
-    static fromIterable<T>(iterable: AnyIterable<T>, options?: DataStreamSourceOptions): DataStreamSource<T>;
-    send(data: T): Promise<void>;
+    constructor({ delta, errorFormatter, idProvider }?: DataStreamSourceOptions<T>);
+    static fromIterable<T>(iterable: AnyIterable<T>, options?: DataStreamSourceOptions<T>): DataStreamSource<T>;
+    send(data: T, id?: string): Promise<void>;
     close(): Promise<void>;
     error(error: unknown): Promise<void>;
 }

package/sse/data-stream-source.js

@@ -16,12 +16,14 @@ const jsonDiffPatch = createDiffPatch({
 export class DataStreamSource {
     #useDelta;
     #errorFormatter;
+    #idProvider;
     eventSource = new ServerSentEventsSource();
     closed = this.eventSource.closed;
     #lastData;
-    constructor({ delta = true, errorFormatter } = {}) {
+    constructor({ delta = true, errorFormatter, idProvider } = {}) {
         this.#useDelta = delta;
         this.#errorFormatter = errorFormatter ?? defaultErrorFormatter;
+        this.#idProvider = idProvider;
     }
     static fromIterable(iterable, options) {
         const source = new DataStreamSource(options);
@@ -43,16 +45,17 @@ export class DataStreamSource {
         })();
         return source;
     }
-    async send(data) {
+    async send(data, id) {
         if (this.eventSource.closed()) {
             throw new Error('Cannot send data to a closed DataStreamSource connection.');
         }
+        const eventId = id ?? this.#idProvider?.(data);
         if (this.#useDelta && isDefined(this.#lastData)) {
             const delta = jsonDiffPatch.diff(this.#lastData, data);
-            await this.eventSource.sendJson({ name: 'delta', data: delta });
+            await this.eventSource.sendJson({ name: 'delta', data: delta, id: eventId });
         }
         else {
-            await this.eventSource.sendJson({ name: 'data', data });
+            await this.eventSource.sendJson({ name: 'data', data, id: eventId });
         }
         if (this.#useDelta) {
             this.#lastData = data;