@tstdl/base 0.93.144 → 0.93.146

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

@@ -1,3 +1,4 @@
+/** biome-ignore-all lint/nursery/noExcessiveClassesPerFile: <explanation> */
 var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
     var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
     if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
@@ -7,17 +8,20 @@ var __decorate = (this && this.__decorate) || function (decorators, target, key,
 var __metadata = (this && this.__metadata) || function (k, v) {
     if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(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, beforeEach, describe, expect, test } from 'vitest';
+import { StringProperty } from '../../schema/index.js';
+import { dropTables, setupIntegrationTest, truncateTables } from '../../testing/index.js';
 import { ChildEntity, Column, Inheritance, Table } from '../decorators.js';
 import { Entity } from '../entity.js';
-import { Database, injectRepository } from '../server/index.js';
+import { getRepository } from '../server/index.js';
 describe('ORM Repository CTI (Integration)', () => {
     let injector;
     let database;
+    let adminRepository;
+    let guestRepository;
+    let userRepository;
+    let managerRepository;
     const schema = 'test_orm_cti';
     let BaseUser = class BaseUser extends Entity {
         type;
@@ -88,6 +92,10 @@ describe('ORM Repository CTI (Integration)', () => {
     ], Manager);
     beforeAll(async () => {
         ({ injector, database } = await setupIntegrationTest({ orm: { schema } }));
+        adminRepository = injector.resolve(getRepository(Admin));
+        guestRepository = injector.resolve(getRepository(Guest));
+        userRepository = injector.resolve(getRepository(BaseUser));
+        managerRepository = injector.resolve(getRepository(Manager));
         await database.execute(sql `CREATE SCHEMA IF NOT EXISTS ${sql.identifier(schema)}`);
         await dropTables(database, schema, ['managers', 'staff', 'guests', 'admins', 'users']);
         await database.execute(sql `
@@ -141,185 +149,150 @@ describe('ORM Repository CTI (Integration)', () => {
         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();
-            newAdmin.name = 'Alice';
-            newAdmin.role = 'SuperAdmin';
-            const inserted = await repository.insert(newAdmin);
-            expect(inserted).toBeInstanceOf(Admin);
-            expect(inserted.id).toBeDefined();
-            expect(inserted.name).toBe('Alice');
-            expect(inserted.role).toBe('SuperAdmin');
-            expect(inserted.type).toBe('admin');
-            expect(inserted.metadata.revision).toBe(1);
-            // 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);
-            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');
-        });
+        const newAdmin = new Admin();
+        newAdmin.name = 'Alice';
+        newAdmin.role = 'SuperAdmin';
+        const inserted = await adminRepository.insert(newAdmin);
+        expect(inserted).toBeInstanceOf(Admin);
+        expect(inserted.id).toBeDefined();
+        expect(inserted.name).toBe('Alice');
+        expect(inserted.role).toBe('SuperAdmin');
+        expect(inserted.type).toBe('admin');
+        expect(inserted.metadata.revision).toBe(1);
+        // 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);
+        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');
     });
     test('should insert many into both parent and child tables', async () => {
-        await runInInjectionContext(injector, async () => {
-            const repository = injectRepository(Admin);
-            const admins = [
-                Object.assign(new Admin(), { name: 'Bob', role: 'Admin' }),
-                Object.assign(new Admin(), { name: 'Charlie', role: 'Moderator' }),
-            ];
-            const insertedAdmins = await repository.insertMany(admins);
-            expect(insertedAdmins).toHaveLength(2);
-            expect(insertedAdmins[0].name).toBe('Bob');
-            expect(insertedAdmins[1].name).toBe('Charlie');
-            expect(insertedAdmins[0].type).toBe('admin');
-            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);
-                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);
-            }
-        });
-    });
-    test('should update both parent and child tables', async () => {
-        await runInInjectionContext(injector, async () => {
-            const repository = injectRepository(Admin);
-            const newAdmin = Object.assign(new Admin(), { name: 'Alice', role: 'SuperAdmin' });
-            const inserted = await repository.insert(newAdmin);
-            const update = { name: 'Alice Updated', role: 'MegaAdmin' };
-            const updated = await repository.update(inserted.id, update);
-            expect(updated.name).toBe('Alice Updated');
-            expect(updated.role).toBe('MegaAdmin');
-            expect(updated.metadata.revision).toBe(2);
-            // Verify DB state
+        const admins = [
+            Object.assign(new Admin(), { name: 'Bob', role: 'Admin' }),
+            Object.assign(new Admin(), { name: 'Charlie', role: 'Moderator' }),
+        ];
+        const insertedAdmins = await adminRepository.insertMany(admins);
+        expect(insertedAdmins).toHaveLength(2);
+        expect(insertedAdmins[0].name).toBe('Bob');
+        expect(insertedAdmins[1].name).toBe('Charlie');
+        expect(insertedAdmins[0].type).toBe('admin');
+        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('Alice Updated');
-            expect(userRow['revision']).toBe(2);
+            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('MegaAdmin');
-        });
+            expect(adminRow['role']).toBe(inserted.role);
+        }
+    });
+    test('should update both parent and child tables', async () => {
+        const newAdmin = Object.assign(new Admin(), { name: 'Alice', role: 'SuperAdmin' });
+        const inserted = await adminRepository.insert(newAdmin);
+        const update = { name: 'Alice Updated', role: 'MegaAdmin' };
+        const updated = await adminRepository.update(inserted.id, update);
+        expect(updated.name).toBe('Alice Updated');
+        expect(updated.role).toBe('MegaAdmin');
+        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);
+        const { rows: [adminRow] } = await database.execute(sql `SELECT * FROM ${sql.identifier(schema)}.${sql.identifier('admins')} WHERE id = ${inserted.id}`);
+        expect(adminRow['role']).toBe('MegaAdmin');
     });
     test('should soft delete from parent table', async () => {
-        await runInInjectionContext(injector, async () => {
-            const repository = injectRepository(Admin);
-            const newAdmin = Object.assign(new Admin(), { name: 'Alice', role: 'SuperAdmin' });
-            const inserted = await repository.insert(newAdmin);
-            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();
-            // 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();
-        });
+        const newAdmin = Object.assign(new Admin(), { name: 'Alice', role: 'SuperAdmin' });
+        const inserted = await adminRepository.insert(newAdmin);
+        await adminRepository.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();
+        // 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 runInInjectionContext(injector, async () => {
-            const repository = injectRepository(Admin);
-            const newAdmin = Object.assign(new Admin(), { name: 'Alice', role: 'SuperAdmin' });
-            const inserted = await repository.insert(newAdmin);
-            await repository.hardDelete(inserted.id);
-            // Verify DB state
-            const { rows: userRows } = await database.execute(sql `SELECT * FROM ${sql.identifier(schema)}.${sql.identifier('users')} WHERE id = ${inserted.id}`);
-            expect(userRows).toHaveLength(0);
-            const { rows: adminRows } = await database.execute(sql `SELECT * FROM ${sql.identifier(schema)}.${sql.identifier('admins')} WHERE id = ${inserted.id}`);
-            expect(adminRows).toHaveLength(0);
-        });
+        const newAdmin = Object.assign(new Admin(), { name: 'Alice', role: 'SuperAdmin' });
+        const inserted = await adminRepository.insert(newAdmin);
+        await adminRepository.hardDelete(inserted.id);
+        // Verify DB state
+        const { rows: userRows } = await database.execute(sql `SELECT * FROM ${sql.identifier(schema)}.${sql.identifier('users')} WHERE id = ${inserted.id}`);
+        expect(userRows).toHaveLength(0);
+        const { rows: adminRows } = await database.execute(sql `SELECT * FROM ${sql.identifier(schema)}.${sql.identifier('admins')} WHERE id = ${inserted.id}`);
+        expect(adminRows).toHaveLength(0);
     });
     test('should load entities polymorphically from parent repository', async () => {
-        await runInInjectionContext(injector, async () => {
-            const adminRepository = injectRepository(Admin);
-            const guestRepository = injectRepository(Guest);
-            const userRepository = injectRepository(BaseUser);
-            await adminRepository.insert(Object.assign(new Admin(), { name: 'Admin1', role: 'Super' }));
-            await guestRepository.insert(Object.assign(new Guest(), { name: 'Guest1', permissions: 'Read' }));
-            // Load without subclasses (default)
-            const users = await userRepository.loadAll();
-            expect(users).toHaveLength(2);
-            expect(users[0]).toBeInstanceOf(BaseUser);
-            expect(users[1]).toBeInstanceOf(BaseUser);
-            expect(users[0].role).toBeUndefined();
-            // Load with subclasses
-            const polymorphicUsers = await userRepository.loadAll({ includeSubclasses: true });
-            expect(polymorphicUsers).toHaveLength(2);
-            const admin = polymorphicUsers.find((u) => u instanceof Admin);
-            const guest = polymorphicUsers.find((u) => u instanceof Guest);
-            expect(admin).toBeDefined();
-            expect(admin).toBeInstanceOf(Admin);
-            expect(admin.name).toBe('Admin1');
-            expect(admin.role).toBe('Super');
-            expect(guest).toBeDefined();
-            expect(guest).toBeInstanceOf(Guest);
-            expect(guest.name).toBe('Guest1');
-            expect(guest).toBeInstanceOf(Guest);
-            expect(guest.name).toBe('Guest1');
-            expect(guest.permissions).toBe('Read');
-        });
+        await adminRepository.insert(Object.assign(new Admin(), { name: 'Admin1', role: 'Super' }));
+        await guestRepository.insert(Object.assign(new Guest(), { name: 'Guest1', permissions: 'Read' }));
+        // Load without subclasses (default)
+        const users = await userRepository.loadAll();
+        expect(users).toHaveLength(2);
+        expect(users[0]).toBeInstanceOf(BaseUser);
+        expect(users[1]).toBeInstanceOf(BaseUser);
+        expect(users[0].role).toBeUndefined();
+        // Load with subclasses
+        const polymorphicUsers = await userRepository.loadAll({ includeSubclasses: true });
+        expect(polymorphicUsers).toHaveLength(2);
+        const admin = polymorphicUsers.find((u) => u instanceof Admin);
+        const guest = polymorphicUsers.find((u) => u instanceof Guest);
+        expect(admin).toBeDefined();
+        expect(admin).toBeInstanceOf(Admin);
+        expect(admin.name).toBe('Admin1');
+        expect(admin.role).toBe('Super');
+        expect(guest).toBeDefined();
+        expect(guest).toBeInstanceOf(Guest);
+        expect(guest.name).toBe('Guest1');
+        expect(guest).toBeInstanceOf(Guest);
+        expect(guest.name).toBe('Guest1');
+        expect(guest.permissions).toBe('Read');
     });
     test('should load polymorphic subset from parent repository', async () => {
-        await runInInjectionContext(injector, async () => {
-            const adminRepository = injectRepository(Admin);
-            const guestRepository = injectRepository(Guest);
-            const userRepository = injectRepository(BaseUser);
-            await adminRepository.insert(Object.assign(new Admin(), { name: 'Admin1', role: 'Super' }));
-            await guestRepository.insert(Object.assign(new Guest(), { name: 'Guest1', permissions: 'Read' }));
-            // Load ONLY Admins polymorphically
-            const onlyAdmins = await userRepository.loadManyByQuery({}, { includeSubclasses: [Admin] });
-            expect(onlyAdmins).toHaveLength(2); // Still returns all users from base table
-            const admin = onlyAdmins.find((u) => u instanceof Admin);
-            const guestAsBase = onlyAdmins.find((u) => u.name === 'Guest1');
-            expect(admin).toBeInstanceOf(Admin);
-            expect(admin.role).toBe('Super');
-            expect(guestAsBase).not.toBeInstanceOf(Guest);
-            expect(guestAsBase).toBeInstanceOf(BaseUser);
-        });
+        await adminRepository.insert(Object.assign(new Admin(), { name: 'Admin1', role: 'Super' }));
+        await guestRepository.insert(Object.assign(new Guest(), { name: 'Guest1', permissions: 'Read' }));
+        // Load ONLY Admins polymorphically
+        const onlyAdmins = await userRepository.loadManyByQuery({}, { includeSubclasses: [Admin] });
+        expect(onlyAdmins).toHaveLength(2); // Still returns all users from base table
+        const admin = onlyAdmins.find((u) => u instanceof Admin);
+        const guestAsBase = onlyAdmins.find((u) => u.name === 'Guest1');
+        expect(admin).toBeInstanceOf(Admin);
+        expect(admin.role).toBe('Super');
+        expect(guestAsBase).not.toBeInstanceOf(Guest);
+        expect(guestAsBase).toBeInstanceOf(BaseUser);
     });
     test('should count and check existence for child entities', async () => {
-        await runInInjectionContext(injector, async () => {
-            const adminRepository = injectRepository(Admin);
-            const guestRepository = injectRepository(Guest);
-            await adminRepository.insert(Object.assign(new Admin(), { name: 'Admin1', role: 'Super' }));
-            await adminRepository.insert(Object.assign(new Admin(), { name: 'Admin2', role: 'Normal' }));
-            await guestRepository.insert(Object.assign(new Guest(), { name: 'Guest1', permissions: 'Read' }));
-            expect(await adminRepository.count()).toBe(2);
-            expect(await guestRepository.count()).toBe(1);
-            const admins = await adminRepository.loadAll();
-            expect(await adminRepository.has(admins[0].id)).toBe(true);
-            expect(await adminRepository.hasByQuery({ name: 'Admin2' })).toBe(true);
-            expect(await adminRepository.hasByQuery({ name: 'Guest1' })).toBe(false); // Different table
-        });
+        await adminRepository.insert(Object.assign(new Admin(), { name: 'Admin1', role: 'Super' }));
+        await adminRepository.insert(Object.assign(new Admin(), { name: 'Admin2', role: 'Normal' }));
+        await guestRepository.insert(Object.assign(new Guest(), { name: 'Guest1', permissions: 'Read' }));
+        expect(await adminRepository.count()).toBe(2);
+        expect(await guestRepository.count()).toBe(1);
+        const admins = await adminRepository.loadAll();
+        expect(await adminRepository.has(admins[0].id)).toBe(true);
+        expect(await adminRepository.hasByQuery({ name: 'Admin2' })).toBe(true);
+        expect(await adminRepository.hasByQuery({ name: 'Guest1' })).toBe(false); // Different table
     });
     test('should query child entities by parent fields', async () => {
-        await runInInjectionContext(injector, async () => {
-            const adminRepository = injectRepository(Admin);
-            await adminRepository.insert(Object.assign(new Admin(), { name: 'TargetAdmin', role: 'Super' }));
-            await adminRepository.insert(Object.assign(new Admin(), { name: 'OtherAdmin', role: 'Normal' }));
-            const results = await adminRepository.loadManyByQuery({ name: 'TargetAdmin' });
-            expect(results).toHaveLength(1);
-            expect(results[0].name).toBe('TargetAdmin');
-            expect(results[0].role).toBe('Super');
-        });
+        await adminRepository.insert(Object.assign(new Admin(), { name: 'TargetAdmin', role: 'Super' }));
+        await adminRepository.insert(Object.assign(new Admin(), { name: 'OtherAdmin', role: 'Normal' }));
+        const results = await adminRepository.loadManyByQuery({ name: 'TargetAdmin' });
+        expect(results).toHaveLength(1);
+        expect(results[0].name).toBe('TargetAdmin');
+        expect(results[0].role).toBe('Super');
     });
     test('should perform partial updates on parent or child fields', async () => {
-        await runInInjectionContext(injector, async () => {
-            const adminRepository = injectRepository(Admin);
-            const inserted = await adminRepository.insert(Object.assign(new Admin(), { name: 'Alice', role: 'Super' }));
-            // Update only parent field
-            await adminRepository.update(inserted.id, { name: 'Alice Renamed' });
-            let updated = await adminRepository.load(inserted.id);
-            expect(updated.name).toBe('Alice Renamed');
-            expect(updated.role).toBe('Super');
-            // Update only child field
-            await adminRepository.update(inserted.id, { role: 'Demoted' });
-            updated = await adminRepository.load(inserted.id);
-            expect(updated.name).toBe('Alice Renamed');
-            expect(updated.role).toBe('Demoted');
-        });
+        const inserted = await adminRepository.insert(Object.assign(new Admin(), { name: 'Alice', role: 'Super' }));
+        // Update only parent field
+        await adminRepository.update(inserted.id, { name: 'Alice Renamed' });
+        let updated = await adminRepository.load(inserted.id);
+        expect(updated.name).toBe('Alice Renamed');
+        expect(updated.role).toBe('Super');
+        // Update only child field
+        await adminRepository.update(inserted.id, { role: 'Demoted' });
+        updated = await adminRepository.load(inserted.id);
+        expect(updated.name).toBe('Alice Renamed');
+        expect(updated.role).toBe('Demoted');
     });
     test('should fail when violating discriminator check constraint', async () => {
         // Attempt manual insert with mismatched type
@@ -344,99 +317,74 @@ describe('ORM Repository CTI (Integration)', () => {
         await expect(query).rejects.toThrow();
     });
     test('should support nested inheritance', async () => {
-        await runInInjectionContext(injector, async () => {
-            const managerRepository = injectRepository(Manager);
-            const manager = new Manager();
-            manager.name = 'Big Boss';
-            manager.employeeId = 'EMP001';
-            manager.department = 'Executive';
-            const inserted = await managerRepository.insert(manager);
-            expect(inserted.name).toBe('Big Boss');
-            expect(inserted.employeeId).toBe('EMP001');
-            expect(inserted.department).toBe('Executive');
-            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');
-            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');
-            const { rows: [managerRow] } = await database.execute(sql `SELECT * FROM ${sql.identifier(schema)}.${sql.identifier('managers')} WHERE id = ${inserted.id}`);
-            expect(managerRow['department']).toBe('Executive');
-        });
+        const manager = new Manager();
+        manager.name = 'Big Boss';
+        manager.employeeId = 'EMP001';
+        manager.department = 'Executive';
+        const inserted = await managerRepository.insert(manager);
+        expect(inserted.name).toBe('Big Boss');
+        expect(inserted.employeeId).toBe('EMP001');
+        expect(inserted.department).toBe('Executive');
+        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');
+        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');
+        const { rows: [managerRow] } = await database.execute(sql `SELECT * FROM ${sql.identifier(schema)}.${sql.identifier('managers')} WHERE id = ${inserted.id}`);
+        expect(managerRow['department']).toBe('Executive');
     });
     test('should rollback parent insert if child insert fails', async () => {
-        await runInInjectionContext(injector, async () => {
-            const adminRepository = injectRepository(Admin);
-            // Attempt to insert an admin with a missing role (should fail because of NOT NULL)
-            const invalidAdmin = new Admin();
-            invalidAdmin.name = 'Broken Admin';
-            // role is missing
-            await expect(adminRepository.insert(invalidAdmin)).rejects.toThrow();
-            // Verify that NO row was created in the users table
-            const { rows } = await database.execute(sql `SELECT * FROM ${sql.identifier(schema)}.${sql.identifier('users')}`);
-            expect(rows).toHaveLength(0);
-        });
+        // Attempt to insert an admin with a missing role (should fail because of NOT NULL)
+        const invalidAdmin = new Admin();
+        invalidAdmin.name = 'Broken Admin';
+        // role is missing
+        await expect(adminRepository.insert(invalidAdmin)).rejects.toThrow();
+        // Verify that NO row was created in the users table
+        const { rows } = await database.execute(sql `SELECT * FROM ${sql.identifier(schema)}.${sql.identifier('users')}`);
+        expect(rows).toHaveLength(0);
     });
     test('should count and check existence polymorphically', async () => {
-        await runInInjectionContext(injector, async () => {
-            const adminRepository = injectRepository(Admin);
-            const guestRepository = injectRepository(Guest);
-            const userRepository = injectRepository(BaseUser);
-            await adminRepository.insert(Object.assign(new Admin(), { name: 'A1', role: 'R1' }));
-            await guestRepository.insert(Object.assign(new Guest(), { name: 'G1', permissions: 'P1' }));
-            expect(await userRepository.count()).toBe(2);
-            expect(await userRepository.hasByQuery({ name: 'A1' })).toBe(true);
-            expect(await userRepository.hasByQuery({ name: 'G1' })).toBe(true);
-        });
+        await adminRepository.insert(Object.assign(new Admin(), { name: 'A1', role: 'R1' }));
+        await guestRepository.insert(Object.assign(new Guest(), { name: 'G1', permissions: 'P1' }));
+        expect(await userRepository.count()).toBe(2);
+        expect(await userRepository.hasByQuery({ name: 'A1' })).toBe(true);
+        expect(await userRepository.hasByQuery({ name: 'G1' })).toBe(true);
     });
     test('should load many by IDs polymorphically', async () => {
-        await runInInjectionContext(injector, async () => {
-            const adminRepository = injectRepository(Admin);
-            const guestRepository = injectRepository(Guest);
-            const userRepository = injectRepository(BaseUser);
-            const a1 = await adminRepository.insert(Object.assign(new Admin(), { name: 'A1', role: 'R1' }));
-            const g1 = await guestRepository.insert(Object.assign(new Guest(), { name: 'G1', permissions: 'P1' }));
-            const results = await userRepository.loadMany([a1.id, g1.id], { includeSubclasses: true });
-            expect(results).toHaveLength(2);
-            expect(results.find((u) => u.id === a1.id)).toBeInstanceOf(Admin);
-            expect(results.find((u) => u.id === g1.id)).toBeInstanceOf(Guest);
-        });
+        const a1 = await adminRepository.insert(Object.assign(new Admin(), { name: 'A1', role: 'R1' }));
+        const g1 = await guestRepository.insert(Object.assign(new Guest(), { name: 'G1', permissions: 'P1' }));
+        const results = await userRepository.loadMany([a1.id, g1.id], { includeSubclasses: true });
+        expect(results).toHaveLength(2);
+        expect(results.find((u) => u.id === a1.id)).toBeInstanceOf(Admin);
+        expect(results.find((u) => u.id === g1.id)).toBeInstanceOf(Guest);
     });
     test('should update many child entities', async () => {
-        await runInInjectionContext(injector, async () => {
-            const adminRepository = injectRepository(Admin);
-            const a1 = await adminRepository.insert(Object.assign(new Admin(), { name: 'A1', role: 'Old' }));
-            const a2 = await adminRepository.insert(Object.assign(new Admin(), { name: 'A2', role: 'Old' }));
-            await adminRepository.updateMany([a1.id, a2.id], { role: 'New' });
-            const results = await adminRepository.loadMany([a1.id, a2.id]);
-            expect(results[0].role).toBe('New');
-            expect(results[1].role).toBe('New');
-        });
+        const a1 = await adminRepository.insert(Object.assign(new Admin(), { name: 'A1', role: 'Old' }));
+        const a2 = await adminRepository.insert(Object.assign(new Admin(), { name: 'A2', role: 'Old' }));
+        await adminRepository.updateMany([a1.id, a2.id], { role: 'New' });
+        const results = await adminRepository.loadMany([a1.id, a2.id]);
+        expect(results[0].role).toBe('New');
+        expect(results[1].role).toBe('New');
     });
     test('should update nested inheritance fields', async () => {
-        await runInInjectionContext(injector, async () => {
-            const managerRepository = injectRepository(Manager);
-            const manager = Object.assign(new Manager(), { name: 'Boss', employeeId: 'E1', department: 'D1' });
-            const inserted = await managerRepository.insert(manager);
-            await managerRepository.update(inserted.id, { name: 'New Boss', employeeId: 'E2', department: 'D2' });
-            const updated = await managerRepository.load(inserted.id);
-            expect(updated.name).toBe('New Boss');
-            expect(updated.employeeId).toBe('E2');
-            expect(updated.department).toBe('D2');
-        });
+        const manager = Object.assign(new Manager(), { name: 'Boss', employeeId: 'E1', department: 'D1' });
+        const inserted = await managerRepository.insert(manager);
+        await managerRepository.update(inserted.id, { name: 'New Boss', employeeId: 'E2', department: 'D2' });
+        const updated = await managerRepository.load(inserted.id);
+        expect(updated.name).toBe('New Boss');
+        expect(updated.employeeId).toBe('E2');
+        expect(updated.department).toBe('D2');
     });
     test('should delete from nested inheritance tables', async () => {
-        await runInInjectionContext(injector, async () => {
-            const managerRepository = injectRepository(Manager);
-            const manager = Object.assign(new Manager(), { name: 'Boss', employeeId: 'E1', department: 'D1' });
-            const inserted = await managerRepository.insert(manager);
-            await managerRepository.hardDelete(inserted.id);
-            const { rows: userRows } = await database.execute(sql `SELECT * FROM ${sql.identifier(schema)}.${sql.identifier('users')} WHERE id = ${inserted.id}`);
-            const { rows: staffRows } = await database.execute(sql `SELECT * FROM ${sql.identifier(schema)}.${sql.identifier('staff')} WHERE id = ${inserted.id}`);
-            const { rows: managerRows } = await database.execute(sql `SELECT * FROM ${sql.identifier(schema)}.${sql.identifier('managers')} WHERE id = ${inserted.id}`);
-            expect(userRows).toHaveLength(0);
-            expect(staffRows).toHaveLength(0);
-            expect(managerRows).toHaveLength(0);
-        });
+        const manager = Object.assign(new Manager(), { name: 'Boss', employeeId: 'E1', department: 'D1' });
+        const inserted = await managerRepository.insert(manager);
+        await managerRepository.hardDelete(inserted.id);
+        const { rows: userRows } = await database.execute(sql `SELECT * FROM ${sql.identifier(schema)}.${sql.identifier('users')} WHERE id = ${inserted.id}`);
+        const { rows: staffRows } = await database.execute(sql `SELECT * FROM ${sql.identifier(schema)}.${sql.identifier('staff')} WHERE id = ${inserted.id}`);
+        const { rows: managerRows } = await database.execute(sql `SELECT * FROM ${sql.identifier(schema)}.${sql.identifier('managers')} WHERE id = ${inserted.id}`);
+        expect(userRows).toHaveLength(0);
+        expect(staffRows).toHaveLength(0);
+        expect(managerRows).toHaveLength(0);
     });
 });

package/orm/tests/repository-expiration.test.d.ts

@@ -1 +1,2 @@
+/** biome-ignore-all lint/nursery/noExcessiveClassesPerFile: <explanation> */
 export {};