@tstdl/base 0.93.123 → 0.93.126

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, gt, 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, isNotNull } 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,36 +48,47 @@ 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 });
@@ -90,50 +105,131 @@ let NotificationService = NotificationService_1 = class NotificationService exte
         });
     }
     async archive(tenantId, userId, id) {
-        await this.#inAppNotificationRepository.updateByQuery({ tenantId, id, userId }, { archiveTimestamp: TRANSACTION_TIMESTAMP });
+        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.updateManyByQuery({ tenantId, userId, archiveTimestamp: null }, { archiveTimestamp: TRANSACTION_TIMESTAMP });
+        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, lastNotificationId) {
-        const lastTimestamp = await this.getTimestamp(tenantId, userId, lastNotificationId);
-        const [unreadCount, missedNotifications, readAndArchived] = await Promise.all([
+    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: lastNotificationId, limit: 50 }),
-            this.#inAppNotificationRepository.session
-                .select({
-                id: inAppNotification.id,
-                readTimestamp: inAppNotification.readTimestamp,
-                archiveTimestamp: inAppNotification.archiveTimestamp,
-            })
+            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), or(gt(inAppNotification.readTimestamp, lastTimestamp), gt(inAppNotification.archiveTimestamp, lastTimestamp))))
+                .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),
         ]);
-        const readIds = readAndArchived.filter((row) => isNotNull(row.readTimestamp) && (row.readTimestamp > lastTimestamp)).map((row) => row.id);
-        const archiveIds = readAndArchived.filter((row) => isNotNull(row.archiveTimestamp) && (row.archiveTimestamp > lastTimestamp)).map((row) => row.id);
-        return { unreadCount, missedNotifications, readIds, archiveIds };
-    }
-    async getTimestamp(tenantId, userId, inAppId) {
-        const inApp = await this.#inAppNotificationRepository.loadByQuery({ tenantId, userId, id: inAppId });
-        const log = await this.#notificationLogRepository.loadByQuery({ tenantId, userId, id: inApp.logId });
-        return log.timestamp;
+        return {
+            unreadCount,
+            missedNotifications,
+            readIds: getEntityIds(readRows),
+            archiveIds: getEntityIds(archiveRows),
+        };
     }
     async getPreferences(tenantId, userId) {
         return await this.#preferenceRepository.loadManyByQuery({ tenantId, userId });

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

@@ -1,7 +1,7 @@
 import { Subject } from 'rxjs';
-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 { setupIntegrationTest, truncateTables } from '../../unit-test/index.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';
@@ -15,7 +15,7 @@ describe('Notification API (Integration)', () => {
     let sseService;
     let subjectService;
     const schema = 'notification';
-    const tenantId = '00000000-0000-0000-0000-000000000000';
+    const tenantId = crypto.randomUUID();
     let userId;
     beforeAll(async () => {
         ({ injector, database } = await setupIntegrationTest({
@@ -27,7 +27,7 @@ describe('Notification API (Integration)', () => {
                 rateLimiter: true,
             },
         }));
-        await truncateTables(database, 'authentication', ['user', 'subject']);
+        await clearTenantData(database, 'authentication', ['user', 'subject'], tenantId);
         controller = injector.resolve(NotificationApiController);
         notificationService = injector.resolve(NotificationService);
         sseService = injector.resolve(NotificationSseService);
@@ -41,16 +41,20 @@ describe('Notification API (Integration)', () => {
         });
         userId = user.id;
     });
+    beforeEach(() => {
+        vi.clearAllMocks();
+    });
     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();
@@ -74,10 +78,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-client.test.d.ts

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

package/notification/tests/{unit/notification-client.test.js → notification-client.test.js}

@@ -1,9 +1,9 @@
 import { afterEach, beforeEach, describe, expect, test, vi } from 'vitest';
-import { AuthenticationClientService } from '../../../authentication/client/authentication.service.js';
-import { Injector, runInInjectionContext } 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 { AuthenticationClientService } from '../../authentication/client/authentication.service.js';
+import { Injector, runInInjectionContext } 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 { BehaviorSubject, of, Subject } from 'rxjs';
 describe('NotificationClient', () => {
     let injector;

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

@@ -9,7 +9,7 @@ import { SubjectService } from '../../authentication/server/subject.service.js';
 import { runInInjectionContext, Singleton } 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 { clearTenantData, setupIntegrationTest, truncateTables } from '../../testing/index.js';
 import { InAppNotification, NotificationChannel, NotificationLogEntity, NotificationStatus, WebPushSubscription } from '../models/index.js';
 import { configureNotification } from '../server/module.js';
 import { EmailChannelProvider } from '../server/providers/email-channel-provider.js';
@@ -34,7 +34,7 @@ describe('Notification Flow (Integration)', () => {
     let subjectService;
     let mailServiceMock;
     const schema = 'notification';
-    const tenantId = '00000000-0000-0000-0000-000000000000';
+    const tenantId = crypto.randomUUID();
     beforeAll(async () => {
         ({ injector, database } = await setupIntegrationTest({
             orm: { schema },
@@ -63,8 +63,8 @@ describe('Notification Flow (Integration)', () => {
         worker.registerProvider(NotificationChannel.InApp, injector.resolve(InAppChannelProvider));
     });
     beforeEach(async () => {
-        await truncateTables(database, 'authentication', ['user', 'subject']);
-        await truncateTables(database, 'notification', ['log', 'in_app', 'type', 'preference', 'web_push_subscription']);
+        await truncateTables(database, schema, ['log', 'in_app', 'in_app_archive', 'type', 'preference', 'web_push_subscription']);
+        await clearTenantData(database, 'authentication', ['user', 'subject'], tenantId);
         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,42 @@ 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 inAppRepo = injectRepository(InAppNotification);
+            const user = await subjectService.createUser({ tenantId, email: 'auto@example.com', firstName: 'Auto', lastName: 'User' });
+            await typeService.initializeTypes({ test: { label: 'Auto Test' } });
+            await notificationService.send(tenantId, user.id, { type: 'test', triggerSubjectId: user.id, payload: {} });
+            const logs = await logRepo.loadManyByQuery({ tenantId });
+            await worker.deliver(logs[0].id);
+            // Verify active
+            expect(await notificationService.listInApp(tenantId, user.id)).toHaveLength(1);
+            // Manually update timestamp to be old (31 days ago)
+            const oldTimestamp = Date.now() - 31 * 24 * 60 * 60 * 1000;
+            await logRepo.updateByQuery({ id: logs[0].id }, { timestamp: oldTimestamp });
+            await inAppRepo.updateByQuery({ tenantId, logId: logs[0].id }, { timestamp: oldTimestamp });
+            await notificationService.runAutoArchive();
+            // Verify archived
+            expect(await notificationService.listInApp(tenantId, user.id)).toHaveLength(0);
+            expect(await notificationService.listArchivedInApp(tenantId, user.id)).toHaveLength(1);
+        });
+    });
+    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

@@ -1,6 +1,6 @@
 import { describe, expect, test } from 'vitest';
 import { runInInjectionContext } from '../../injector/index.js';
-import { setupIntegrationTest } from '../../unit-test/index.js';
+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 () => {

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

@@ -1,6 +1,6 @@
 import { describe, expect, test } from 'vitest';
 import { runInInjectionContext } from '../../injector/index.js';
-import { setupIntegrationTest, truncateTables } from '../../unit-test/index.js';
+import { setupIntegrationTest, truncateTables } from '../../testing/index.js';
 import { NotificationTypeService } from '../server/services/notification-type.service.js';
 describe('NotificationTypeService', () => {
     test('should initialize types correctly', async () => {

package/object-storage/s3/s3.object-storage.js

@@ -56,6 +56,9 @@ let S3ObjectStorage = S3ObjectStorage_1 = class S3ObjectStorage extends ObjectSt
                 }));
                 return;
             }
+            if (this.isError(error, 'BucketAlreadyOwnedByYou', 'BucketAlreadyExists')) {
+                return;
+            }
             if (this.isBadRequestError(error)) {
                 throw new BadRequestError(`S3 request failed with 400 Bad Request. This often indicates an invalid bucket name ("${this.bucket}") or missing "forcePathStyle: true" for local S3 providers.`);
             }

package/object-storage/s3/tests/s3.object-storage.integration.test.js

@@ -1,5 +1,5 @@
 import { afterAll, beforeAll, describe, expect, it } from 'vitest';
-import { setupIntegrationTest } from '../../../unit-test/index.js';
+import { setupIntegrationTest } from '../../../testing/index.js';
 import { readBinaryStream } from '../../../utils/stream/stream-reader.js';
 import { configureS3ObjectStorage } from '../s3.object-storage-provider.js';
 import { S3ObjectStorage } from '../s3.object-storage.js';

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/repository-attributes.test.js

@@ -9,15 +9,16 @@ var __metadata = (this && this.__metadata) || function (k, v) {
 };
 import { Injector, runInInjectionContext } from '../../injector/index.js';
 import { StringProperty } from '../../schema/index.js';
+import { dropTables, setupIntegrationTest, truncateTables } from '../../testing/index.js';
 import { sql } from 'drizzle-orm';
-import { beforeAll, describe, expect, test } from 'vitest';
+import { beforeAll, beforeEach, describe, expect, test } from 'vitest';
 import { Table } from '../decorators.js';
 import { Entity } from '../entity.js';
-import { configureOrm, Database } from '../server/index.js';
+import { Database } from '../server/index.js';
 import { injectRepository } from '../server/repository.js';
 describe('ORM Repository Attributes (Integration)', () => {
     let injector;
-    let db;
+    let database;
     const schema = 'test_orm_attributes';
     let AttributeEntity = class AttributeEntity extends Entity {
         name;
@@ -30,17 +31,9 @@ describe('ORM Repository Attributes (Integration)', () => {
         Table('attribute_entities', { schema })
     ], AttributeEntity);
     beforeAll(async () => {
-        injector = new Injector('Test');
-        configureOrm({
-            repositoryConfig: { schema },
-            connection: {
-                host: '127.0.0.1', port: 5432, user: 'tstdl', password: 'wf7rq6glrk5jykne', database: 'tstdl',
-            },
-        });
-        db = injector.resolve(Database);
-        await db.execute(sql `CREATE SCHEMA IF NOT EXISTS ${sql.identifier(schema)}`);
-        await db.execute(sql `DROP TABLE IF EXISTS ${sql.identifier(schema)}.${sql.identifier('attribute_entities')} CASCADE`);
-        await db.execute(sql `
+        ({ injector, database } = await setupIntegrationTest({ orm: { schema } }));
+        await dropTables(database, schema, ['attribute_entities']);
+        await database.execute(sql `
       CREATE TABLE ${sql.identifier(schema)}.${sql.identifier('attribute_entities')} (
         id UUID PRIMARY KEY DEFAULT gen_random_uuid(),
         name TEXT NOT NULL,
@@ -52,8 +45,10 @@ describe('ORM Repository Attributes (Integration)', () => {
       )
     `);
     });
+    beforeEach(async () => {
+        await truncateTables(database, schema, ['attribute_entities']);
+    });
     test('should support partial attribute updates', async () => {
-        await db.execute(sql `TRUNCATE TABLE ${sql.identifier(schema)}.${sql.identifier('attribute_entities')} CASCADE`);
         await runInInjectionContext(injector, async () => {
             const repository = injectRepository(AttributeEntity);
             const e1 = await repository.insert(Object.assign(new AttributeEntity(), {
@@ -68,7 +63,6 @@ describe('ORM Repository Attributes (Integration)', () => {
         });
     });
     test('should update attributes during soft delete', async () => {
-        await db.execute(sql `TRUNCATE TABLE ${sql.identifier(schema)}.${sql.identifier('attribute_entities')} CASCADE`);
         await runInInjectionContext(injector, async () => {
             const repository = injectRepository(AttributeEntity);
             const e1 = await repository.insert(Object.assign(new AttributeEntity(), {
@@ -80,7 +74,6 @@ describe('ORM Repository Attributes (Integration)', () => {
         });
     });
     test('should support querying by raw SQL on attributes', async () => {
-        await db.execute(sql `TRUNCATE TABLE ${sql.identifier(schema)}.${sql.identifier('attribute_entities')} CASCADE`);
         await runInInjectionContext(injector, async () => {
             const repository = injectRepository(AttributeEntity);
             await repository.insert(Object.assign(new AttributeEntity(), {

package/orm/tests/repository-cti-mapping.test.js

@@ -96,9 +96,9 @@ describe('ORM Repository CTI Mapping (Integration)', () => {
             expect(child.secret).toBe('Hidden');
             // Verify DB column names
             const { rows: parentRows } = await db.execute(sql `SELECT display_name FROM ${sql.identifier(schema)}.${sql.identifier('mapped_parents')} WHERE id = ${child.id}`);
-            expect(parentRows[0].display_name).toBe('Visible');
+            expect(parentRows[0]['display_name']).toBe('Visible');
             const { rows: childRows } = await db.execute(sql `SELECT internal_secret FROM ${sql.identifier(schema)}.${sql.identifier('mapped_children')} WHERE id = ${child.id}`);
-            expect(childRows[0].internal_secret).toBe('Hidden');
+            expect(childRows[0]['internal_secret']).toBe('Hidden');
             // Load back
             const loaded = await repo.load(child.id);
             expect(loaded.displayName).toBe('Visible');

package/orm/tests/repository-cti-soft-delete.test.js

@@ -92,7 +92,7 @@ describe('ORM Repository CTI Soft Delete (Integration)', () => {
             const entity = await repo.insert(Object.assign(new Subtype(), { baseName: 'B1', subData: 'S1' }));
             await repo.delete(entity.id);
             const { rows } = await db.execute(sql `SELECT delete_timestamp FROM ${sql.identifier(schema)}.${sql.identifier('bases')} WHERE id = ${entity.id}`);
-            expect(rows[0].delete_timestamp).not.toBeNull();
+            expect(rows[0]['delete_timestamp']).not.toBeNull();
             expect(await repo.has(entity.id)).toBe(false);
             expect(await repo.loadManyByQuery({ id: entity.id }).then((r) => r[0])).toBeUndefined();
         });