@tstdl/base 0.93.125 → 0.93.127

package/injector/type-info.d.ts

@@ -1,12 +1,8 @@
-import type { ForwardRefTypeHint } from '../utils/object/forward-ref.js';
 import type { InjectionToken } from './token.js';
-import type { ArgumentProvider, ForwardRefInjectionToken, Mapper } from './types.js';
+import type { ArgumentProvider, Mapper } from './types.js';
 export type InjectMetadata = {
     /** Token overwrite by inject decorator */
     injectToken?: InjectionToken;
-    /** If defined, resolve the token or ForwardRefToken using ForwardRef strategy instead of resolving the token directly */
-    forwardRef?: boolean | ForwardRefInjectionToken;
-    forwardRefTypeHint?: ForwardRefTypeHint;
     /** Whether injection is optional if token is not registered. Set by optional decorator */
     optional?: boolean;
     /** Whether injection should resolve all providers */

package/injector/types.d.ts

@@ -1,9 +1,7 @@
 import type { CancellationSignal } from '../cancellation/index.js';
 import type { Record } from '../types/index.js';
-import type { ForwardRefTypeHint } from '../utils/object/forward-ref.js';
 import type { DisposeHandler, Injector, ProvidersItem } from './injector.js';
 import type { ResolveArgument } from './interfaces.js';
-import type { InjectionToken } from './token.js';
 /**
  * Transient: new resolution for every resolve
  * resolution: one resolution per resolve tree
@@ -11,26 +9,22 @@ import type { InjectionToken } from './token.js';
  * singleton: one resolution at injector where token is registered
  */
 export type Lifecycle = 'transient' | 'resolution' | 'injector' | 'singleton';
-export type ResolveContext<D extends Record> = Pick<Injector, 'resolve' | 'resolveAll'> & {
+export type ResolveContext<D extends Record = Record<PropertyKey, unknown>> = Pick<Injector, 'resolve' | 'resolveAll'> & {
     readonly data: ResolveContextData<D>;
     readonly cancellationSignal: CancellationSignal;
     addDisposeHandler(handler: DisposeHandler): void;
 };
-export type AfterResolveContext<D extends Record> = {
+export type AfterResolveContext<D extends Record = Record<PropertyKey, unknown>> = {
     readonly data: ResolveContextData<D>;
     readonly cancellationSignal: CancellationSignal;
     addDisposeHandler(handler: DisposeHandler): void;
 };
 export type Mapper<T = any, U = unknown> = (value: T) => U;
-export type ArgumentProvider<T = unknown, D extends Record = Record> = (context: ResolveContext<D>) => T;
-export type ForwardRefInjectionToken<T = any, A = any> = Exclude<InjectionToken<T, A>, Function> | (() => InjectionToken<T, A>);
-export type ResolveOptions<T, A> = {
+export type ArgumentProvider<T = unknown, D extends Record = Record<PropertyKey, unknown>> = (context: ResolveContext<D>) => T;
+export type ResolveOptions = {
     optional?: boolean;
     skipSelf?: boolean | number;
     onlySelf?: boolean;
-    /** If defined, resolve the token using ForwardRef strategy instead of resolving the token directly can be used to circumvent circular dependency problems */
-    forwardRef?: boolean | ForwardRefInjectionToken<T, A>;
-    forwardRefTypeHint?: ForwardRefTypeHint;
 };
 /**
  * Data to store between different stages like resolve and afterResolve

package/logger/tests/pretty-print.test.d.ts

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

package/logger/{formatters → tests}/pretty-print.test.js

@@ -5,7 +5,7 @@ vi.mock('#/supports.js', () => ({
     supportsColoredStderr: true,
 }));
 import { LogLevel } from '../level.js';
-import { PrettyPrintLogFormatter } from './pretty-print.js';
+import { PrettyPrintLogFormatter } from '../formatters/pretty-print.js';
 describe('PrettyPrintLogFormatter', () => {
     const formatter = new PrettyPrintLogFormatter();
     it('should format a log entry with an error and no context', () => {

package/logger/transports/console.d.ts

@@ -1,14 +1,15 @@
 import { type InjectionToken, type Resolvable, type resolveArgumentType } from '../../injector/index.js';
 import type { ProvidersItem } from '../../injector/injector.js';
+import type { TypedOmit } from '../../types/index.js';
 import { LogFormatter, type LogPayload } from '../formatter.js';
-import { LogLevel } from '../level.js';
 import { LogTransport, LogTransportOptions } from '../transport.js';
 export declare class ConsoleLogTransportOptions extends LogTransportOptions {
     formatter: InjectionToken<LogFormatter>;
+    stderrOnly?: boolean;
 }
 export declare class ConsoleLogTransport extends LogTransport implements Resolvable<ConsoleLogTransportOptions> {
     #private;
     readonly [resolveArgumentType]: ConsoleLogTransportOptions;
     log(payload: LogPayload): void;
 }
-export declare function provideConsoleLogTransport(formatter: InjectionToken<LogFormatter>, level?: LogLevel): ProvidersItem;
+export declare function provideConsoleLogTransport(formatter: InjectionToken<LogFormatter>, options?: TypedOmit<ConsoleLogTransportOptions, 'formatter'>): ProvidersItem;

package/logger/transports/console.js

@@ -12,6 +12,7 @@ import { LogLevel } from '../level.js';
 import { LogTransport, LogTransportOptions, provideLogTransport } from '../transport.js';
 export class ConsoleLogTransportOptions extends LogTransportOptions {
     formatter;
+    stderrOnly;
 }
 const consoleLevelFuncMap = {
     [LogLevel.Error]: 'error',
@@ -26,7 +27,7 @@ let ConsoleLogTransport = class ConsoleLogTransport extends LogTransport {
     #formatter = isDefined(this.#argument?.formatter) ? inject(this.#argument.formatter) : inject(LogFormatter);
     log(payload) {
         const message = this.#formatter.format(payload);
-        const consoleFunc = consoleLevelFuncMap[payload.level];
+        const consoleFunc = (this.#argument?.stderrOnly == true) ? 'error' : consoleLevelFuncMap[payload.level];
         console[consoleFunc](message);
     }
 };
@@ -34,6 +35,6 @@ ConsoleLogTransport = __decorate([
     Singleton()
 ], ConsoleLogTransport);
 export { ConsoleLogTransport };
-export function provideConsoleLogTransport(formatter, level) {
-    return provideLogTransport({ useToken: ConsoleLogTransport, defaultArgument: { formatter, level } });
+export function provideConsoleLogTransport(formatter, options) {
+    return provideLogTransport({ useToken: ConsoleLogTransport, defaultArgument: { ...options, formatter } });
 }

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,6 +41,9 @@ describe('Notification API (Integration)', () => {
         });
         userId = user.id;
     });
+    beforeEach(() => {
+        vi.clearAllMocks();
+    });
     const createMockContext = (params = {}) => ({
         parameters: params,
         abortSignal: new AbortController().signal,
@@ -51,7 +54,7 @@ describe('Notification API (Integration)', () => {
                 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();

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', 'in_app_archive', '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 () => {
@@ -296,6 +296,7 @@ describe('Notification Flow (Integration)', () => {
     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: {} });
@@ -306,11 +307,11 @@ describe('Notification Flow (Integration)', () => {
             // 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);
-            vi.useRealTimers();
         });
     });
     test('should archive all notifications for a user', async () => {

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/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();
         });

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

@@ -9,9 +9,9 @@ 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 '../../unit-test/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 { ChildEntity, Column, Inheritance, Table } from '../decorators.js';
 import { Entity } from '../entity.js';
 import { Database, injectRepository } from '../server/index.js';
@@ -137,8 +137,10 @@ describe('ORM Repository CTI (Integration)', () => {
       )
     `);
     });
-    test('should insert into both parent and child tables', async () => {
+    beforeEach(async () => {
         await truncateTables(database, schema, ['users']);
+    });
+    test('should insert into both parent and child tables', async () => {
         await runInInjectionContext(injector, async () => {
             const repository = injectRepository(Admin);
             const newAdmin = new Admin();
@@ -154,17 +156,16 @@ describe('ORM Repository CTI (Integration)', () => {
             // Verify DB state
             const { rows: [userRow] } = await database.execute(sql `SELECT * FROM ${sql.identifier(schema)}.${sql.identifier('users')} WHERE id = ${inserted.id}`);
             expect(userRow).toBeDefined();
-            expect(userRow.type).toBe('admin');
-            expect(userRow.name).toBe('Alice');
-            expect(userRow.revision).toBe(1);
+            expect(userRow['type']).toBe('admin');
+            expect(userRow['name']).toBe('Alice');
+            expect(userRow['revision']).toBe(1);
             const { rows: [adminRow] } = await database.execute(sql `SELECT * FROM ${sql.identifier(schema)}.${sql.identifier('admins')} WHERE id = ${inserted.id}`);
             expect(adminRow).toBeDefined();
-            expect(adminRow.type).toBe('admin');
-            expect(adminRow.role).toBe('SuperAdmin');
+            expect(adminRow['type']).toBe('admin');
+            expect(adminRow['role']).toBe('SuperAdmin');
         });
     });
     test('should insert many into both parent and child tables', async () => {
-        await truncateTables(database, schema, ['users']);
         await runInInjectionContext(injector, async () => {
             const repository = injectRepository(Admin);
             const admins = [
@@ -179,14 +180,13 @@ describe('ORM Repository CTI (Integration)', () => {
             expect(insertedAdmins[1].type).toBe('admin');
             for (const inserted of insertedAdmins) {
                 const { rows: [userRow] } = await database.execute(sql `SELECT * FROM ${sql.identifier(schema)}.${sql.identifier('users')} WHERE id = ${inserted.id}`);
-                expect(userRow.name).toBe(inserted.name);
+                expect(userRow['name']).toBe(inserted.name);
                 const { rows: [adminRow] } = await database.execute(sql `SELECT * FROM ${sql.identifier(schema)}.${sql.identifier('admins')} WHERE id = ${inserted.id}`);
-                expect(adminRow.role).toBe(inserted.role);
+                expect(adminRow['role']).toBe(inserted.role);
             }
         });
     });
     test('should update both parent and child tables', async () => {
-        await truncateTables(database, schema, ['users']);
         await runInInjectionContext(injector, async () => {
             const repository = injectRepository(Admin);
             const newAdmin = Object.assign(new Admin(), { name: 'Alice', role: 'SuperAdmin' });
@@ -198,14 +198,13 @@ describe('ORM Repository CTI (Integration)', () => {
             expect(updated.metadata.revision).toBe(2);
             // Verify DB state
             const { rows: [userRow] } = await database.execute(sql `SELECT * FROM ${sql.identifier(schema)}.${sql.identifier('users')} WHERE id = ${inserted.id}`);
-            expect(userRow.name).toBe('Alice Updated');
-            expect(userRow.revision).toBe(2);
+            expect(userRow['name']).toBe('Alice Updated');
+            expect(userRow['revision']).toBe(2);
             const { rows: [adminRow] } = await database.execute(sql `SELECT * FROM ${sql.identifier(schema)}.${sql.identifier('admins')} WHERE id = ${inserted.id}`);
-            expect(adminRow.role).toBe('MegaAdmin');
+            expect(adminRow['role']).toBe('MegaAdmin');
         });
     });
     test('should soft delete from parent table', async () => {
-        await truncateTables(database, schema, ['users']);
         await runInInjectionContext(injector, async () => {
             const repository = injectRepository(Admin);
             const newAdmin = Object.assign(new Admin(), { name: 'Alice', role: 'SuperAdmin' });
@@ -213,14 +212,13 @@ describe('ORM Repository CTI (Integration)', () => {
             await repository.delete(inserted.id);
             // Verify DB state
             const { rows: [userRow] } = await database.execute(sql `SELECT * FROM ${sql.identifier(schema)}.${sql.identifier('users')} WHERE id = ${inserted.id}`);
-            expect(userRow.delete_timestamp).not.toBeNull();
+            expect(userRow['delete_timestamp']).not.toBeNull();
             // Child table should still have the row (soft delete only affects parent)
             const { rows: [adminRow] } = await database.execute(sql `SELECT * FROM ${sql.identifier(schema)}.${sql.identifier('admins')} WHERE id = ${inserted.id}`);
             expect(adminRow).toBeDefined();
         });
     });
     test('should hard delete from both tables via cascade', async () => {
-        await truncateTables(database, schema, ['users']);
         await runInInjectionContext(injector, async () => {
             const repository = injectRepository(Admin);
             const newAdmin = Object.assign(new Admin(), { name: 'Alice', role: 'SuperAdmin' });
@@ -234,7 +232,6 @@ describe('ORM Repository CTI (Integration)', () => {
         });
     });
     test('should load entities polymorphically from parent repository', async () => {
-        await truncateTables(database, schema, ['users']);
         await runInInjectionContext(injector, async () => {
             const adminRepository = injectRepository(Admin);
             const guestRepository = injectRepository(Guest);
@@ -265,7 +262,6 @@ describe('ORM Repository CTI (Integration)', () => {
         });
     });
     test('should load polymorphic subset from parent repository', async () => {
-        await truncateTables(database, schema, ['users']);
         await runInInjectionContext(injector, async () => {
             const adminRepository = injectRepository(Admin);
             const guestRepository = injectRepository(Guest);
@@ -284,7 +280,6 @@ describe('ORM Repository CTI (Integration)', () => {
         });
     });
     test('should count and check existence for child entities', async () => {
-        await truncateTables(database, schema, ['users']);
         await runInInjectionContext(injector, async () => {
             const adminRepository = injectRepository(Admin);
             const guestRepository = injectRepository(Guest);
@@ -300,7 +295,6 @@ describe('ORM Repository CTI (Integration)', () => {
         });
     });
     test('should query child entities by parent fields', async () => {
-        await truncateTables(database, schema, ['users']);
         await runInInjectionContext(injector, async () => {
             const adminRepository = injectRepository(Admin);
             await adminRepository.insert(Object.assign(new Admin(), { name: 'TargetAdmin', role: 'Super' }));
@@ -312,7 +306,6 @@ describe('ORM Repository CTI (Integration)', () => {
         });
     });
     test('should perform partial updates on parent or child fields', async () => {
-        await truncateTables(database, schema, ['users']);
         await runInInjectionContext(injector, async () => {
             const adminRepository = injectRepository(Admin);
             const inserted = await adminRepository.insert(Object.assign(new Admin(), { name: 'Alice', role: 'Super' }));
@@ -351,7 +344,6 @@ describe('ORM Repository CTI (Integration)', () => {
         await expect(query).rejects.toThrow();
     });
     test('should support nested inheritance', async () => {
-        await truncateTables(database, schema, ['users']);
         await runInInjectionContext(injector, async () => {
             const managerRepository = injectRepository(Manager);
             const manager = new Manager();
@@ -365,15 +357,14 @@ describe('ORM Repository CTI (Integration)', () => {
             expect(inserted.type).toBe('manager');
             // Verify DB state - all 3 tables should have rows
             const { rows: [userRow] } = await database.execute(sql `SELECT * FROM ${sql.identifier(schema)}.${sql.identifier('users')} WHERE id = ${inserted.id}`);
-            expect(userRow.name).toBe('Big Boss');
+            expect(userRow['name']).toBe('Big Boss');
             const { rows: [staffRow] } = await database.execute(sql `SELECT * FROM ${sql.identifier(schema)}.${sql.identifier('staff')} WHERE id = ${inserted.id}`);
-            expect(staffRow.employee_id).toBe('EMP001');
+            expect(staffRow['employee_id']).toBe('EMP001');
             const { rows: [managerRow] } = await database.execute(sql `SELECT * FROM ${sql.identifier(schema)}.${sql.identifier('managers')} WHERE id = ${inserted.id}`);
-            expect(managerRow.department).toBe('Executive');
+            expect(managerRow['department']).toBe('Executive');
         });
     });
     test('should rollback parent insert if child insert fails', async () => {
-        await truncateTables(database, schema, ['users']);
         await runInInjectionContext(injector, async () => {
             const adminRepository = injectRepository(Admin);
             // Attempt to insert an admin with a missing role (should fail because of NOT NULL)
@@ -387,7 +378,6 @@ describe('ORM Repository CTI (Integration)', () => {
         });
     });
     test('should count and check existence polymorphically', async () => {
-        await truncateTables(database, schema, ['users']);
         await runInInjectionContext(injector, async () => {
             const adminRepository = injectRepository(Admin);
             const guestRepository = injectRepository(Guest);
@@ -400,7 +390,6 @@ describe('ORM Repository CTI (Integration)', () => {
         });
     });
     test('should load many by IDs polymorphically', async () => {
-        await truncateTables(database, schema, ['users']);
         await runInInjectionContext(injector, async () => {
             const adminRepository = injectRepository(Admin);
             const guestRepository = injectRepository(Guest);
@@ -414,7 +403,6 @@ describe('ORM Repository CTI (Integration)', () => {
         });
     });
     test('should update many child entities', async () => {
-        await truncateTables(database, schema, ['users']);
         await runInInjectionContext(injector, async () => {
             const adminRepository = injectRepository(Admin);
             const a1 = await adminRepository.insert(Object.assign(new Admin(), { name: 'A1', role: 'Old' }));
@@ -426,7 +414,6 @@ describe('ORM Repository CTI (Integration)', () => {
         });
     });
     test('should update nested inheritance fields', async () => {
-        await truncateTables(database, schema, ['users']);
         await runInInjectionContext(injector, async () => {
             const managerRepository = injectRepository(Manager);
             const manager = Object.assign(new Manager(), { name: 'Boss', employeeId: 'E1', department: 'D1' });
@@ -439,7 +426,6 @@ describe('ORM Repository CTI (Integration)', () => {
         });
     });
     test('should delete from nested inheritance tables', async () => {
-        await truncateTables(database, schema, ['users']);
         await runInInjectionContext(injector, async () => {
             const managerRepository = injectRepository(Manager);
             const manager = Object.assign(new Manager(), { name: 'Boss', employeeId: 'E1', department: 'D1' });

package/orm/tests/repository-extra-coverage.test.js

@@ -10,7 +10,7 @@ var __metadata = (this && this.__metadata) || function (k, v) {
 import { NotFoundError } from '../../errors/not-found.error.js';
 import { Injector, runInInjectionContext } from '../../injector/index.js';
 import { StringProperty } from '../../schema/index.js';
-import { dropTables, setupIntegrationTest, truncateTables } from '../../unit-test/index.js';
+import { dropTables, setupIntegrationTest, truncateTables } from '../../testing/index.js';
 import { toArrayAsync } from '../../utils/async-iterable-helpers/to-array.js';
 import { sql } from 'drizzle-orm';
 import { beforeAll, describe, expect, test } from 'vitest';

package/orm/tests/repository-search.test.js

@@ -8,10 +8,10 @@ var __metadata = (this && this.__metadata) || function (k, v) {
     if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
 };
 import { sql } from 'drizzle-orm';
-import { beforeAll, describe, expect, test } from 'vitest';
+import { beforeAll, beforeEach, describe, expect, test } from 'vitest';
 import { Injector, runInInjectionContext } from '../../injector/index.js';
 import { StringProperty } from '../../schema/index.js';
-import { dropTables, setupIntegrationTest } from '../../unit-test/index.js';
+import { dropTables, setupIntegrationTest, truncateTables } from '../../testing/index.js';
 import { Table } from '../decorators.js';
 import { Entity } from '../entity.js';
 import { Database } from '../server/index.js';
@@ -51,6 +51,9 @@ describe('ORM Repository Search', () => {
       )
     `);
     });
+    beforeEach(async () => {
+        await truncateTables(database, schema, ['search_entities']);
+    });
     test('should support search with score transformer', async () => {
         await runInInjectionContext(injector, async () => {
             const repository = injectRepository(SearchEntity);

package/orm/tests/transaction-safety.test.js

@@ -9,7 +9,7 @@ var __metadata = (this && this.__metadata) || function (k, v) {
 };
 import { Injector, Singleton, runInInjectionContext } from '../../injector/index.js';
 import { StringProperty } from '../../schema/index.js';
-import { dropTables, setupIntegrationTest } from '../../unit-test/index.js';
+import { dropTables, setupIntegrationTest } from '../../testing/index.js';
 import { sql } from 'drizzle-orm';
 import { beforeAll, describe, expect, test } from 'vitest';
 import { Entity, Table } from '../index.js';