@tstdl/base 0.93.145 → 0.93.146

package/orm/tests/repository-cti-extensive.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 { NumberProperty, StringProperty } from '../../schema/index.js';
 import { sql } from 'drizzle-orm';
 import { beforeAll, describe, expect, test } from 'vitest';
+import { NumberProperty, StringProperty } from '../../schema/index.js';
+import { setupIntegrationTest } from '../../testing/index.js';
 import { ChildEntity, Column, Inheritance, Table } from '../decorators.js';
 import { Entity } from '../entity.js';
-import { configureOrm, Database } from '../server/index.js';
-import { injectRepository } from '../server/repository.js';
+import { getRepository } from '../server/index.js';
 describe('ORM Repository CTI Extensive (Integration)', () => {
     let injector;
     let db;
+    let personRepo;
+    let empRepo;
+    let mgrRepo;
+    let cntRepo;
     const schema = 'test_orm_cti_extensive';
     // --- Entities ---
     let Person = class Person extends Entity {
@@ -78,18 +82,13 @@ describe('ORM Repository CTI Extensive (Integration)', () => {
     ], Contractor);
     // --- Setup ---
     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);
+        ({ injector, database: db } = await setupIntegrationTest({
+            orm: { schema },
+        }));
+        personRepo = injector.resolve(getRepository(Person));
+        empRepo = injector.resolve(getRepository(Employee));
+        mgrRepo = injector.resolve(getRepository(Manager));
+        cntRepo = injector.resolve(getRepository(Contractor));
         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('managers')} CASCADE`);
         await db.execute(sql `DROP TABLE IF EXISTS ${sql.identifier(schema)}.${sql.identifier('employees')} CASCADE`);
@@ -137,102 +136,85 @@ describe('ORM Repository CTI Extensive (Integration)', () => {
     // --- Tests ---
     test('should insert different subtypes via specific repositories', async () => {
         await db.execute(sql `TRUNCATE TABLE ${sql.identifier(schema)}.${sql.identifier('persons')} CASCADE`);
-        await runInInjectionContext(injector, async () => {
-            const empRepo = injectRepository(Employee);
-            const mgrRepo = injectRepository(Manager);
-            const cntRepo = injectRepository(Contractor);
-            const e1 = await empRepo.insert(Object.assign(new Employee(), { name: 'E1', salary: 50000 }));
-            const m1 = await mgrRepo.insert(Object.assign(new Manager(), { name: 'M1', salary: 80000, department: 'IT' }));
-            const c1 = await cntRepo.insert(Object.assign(new Contractor(), { name: 'C1', contractEnd: '2025-12-31' }));
-            expect(e1.type).toBe('employee');
-            expect(m1.type).toBe('manager');
-            expect(c1.type).toBe('contractor');
-        });
+        const e1 = await empRepo.insert(Object.assign(new Employee(), { name: 'E1', salary: 50000 }));
+        const m1 = await mgrRepo.insert(Object.assign(new Manager(), { name: 'M1', salary: 80000, department: 'IT' }));
+        const c1 = await cntRepo.insert(Object.assign(new Contractor(), { name: 'C1', contractEnd: '2025-12-31' }));
+        expect(e1.type).toBe('employee');
+        expect(m1.type).toBe('manager');
+        expect(c1.type).toBe('contractor');
     });
     test('should filter by mixed parent and child properties', async () => {
         await db.execute(sql `TRUNCATE TABLE ${sql.identifier(schema)}.${sql.identifier('persons')} CASCADE`);
-        await runInInjectionContext(injector, async () => {
-            const mgrRepo = injectRepository(Manager);
-            await mgrRepo.insert(Object.assign(new Manager(), { name: 'Alice', salary: 90000, department: 'IT' }));
-            await mgrRepo.insert(Object.assign(new Manager(), { name: 'Bob', salary: 90000, department: 'HR' }));
-            await mgrRepo.insert(Object.assign(new Manager(), { name: 'Charlie', salary: 60000, department: 'IT' }));
-            // Filter by parent (salary) AND child (department)
-            const richITManagers = await mgrRepo.loadManyByQuery({
-                salary: 90000,
-                department: 'IT',
-            });
-            expect(richITManagers).toHaveLength(1);
-            expect(richITManagers[0].name).toBe('Alice');
+        await mgrRepo.insert(Object.assign(new Manager(), { name: 'Alice', salary: 90000, department: 'IT' }));
+        await mgrRepo.insert(Object.assign(new Manager(), { name: 'Bob', salary: 90000, department: 'HR' }));
+        await mgrRepo.insert(Object.assign(new Manager(), { name: 'Charlie', salary: 60000, department: 'IT' }));
+        // Filter by parent (salary) AND child (department)
+        const richITManagers = await mgrRepo.loadManyByQuery({
+            salary: 90000,
+            department: 'IT',
         });
+        expect(richITManagers).toHaveLength(1);
+        expect(richITManagers[0].name).toBe('Alice');
     });
     test('should sort by parent property then child property', async () => {
         await db.execute(sql `TRUNCATE TABLE ${sql.identifier(schema)}.${sql.identifier('persons')} CASCADE`);
-        await runInInjectionContext(injector, async () => {
-            const mgrRepo = injectRepository(Manager);
-            await mgrRepo.insert(Object.assign(new Manager(), { name: 'A', salary: 50000, department: 'Z' }));
-            await mgrRepo.insert(Object.assign(new Manager(), { name: 'B', salary: 50000, department: 'A' }));
-            await mgrRepo.insert(Object.assign(new Manager(), { name: 'C', salary: 90000, department: 'A' }));
-            // Sort by salary (parent) DESC, then department (child) ASC
-            const sorted = await mgrRepo.loadManyByQuery({}, {
-                order: [
-                    ['salary', 'desc'],
-                    ['department', 'asc'],
-                ],
-            });
-            expect(sorted).toHaveLength(3);
-            expect(sorted[0].name).toBe('C'); // 90000
-            expect(sorted[1].name).toBe('B'); // 50000, A
-            expect(sorted[2].name).toBe('A'); // 50000, Z
+        await mgrRepo.insert(Object.assign(new Manager(), { name: 'A', salary: 50000, department: 'Z' }));
+        await mgrRepo.insert(Object.assign(new Manager(), { name: 'B', salary: 50000, department: 'A' }));
+        await mgrRepo.insert(Object.assign(new Manager(), { name: 'C', salary: 90000, department: 'A' }));
+        // Sort by salary (parent) DESC, then department (child) ASC
+        const sorted = await mgrRepo.loadManyByQuery({}, {
+            order: [
+                ['salary', 'desc'],
+                ['department', 'asc'],
+            ],
         });
+        expect(sorted).toHaveLength(3);
+        expect(sorted[0].name).toBe('C'); // 90000
+        expect(sorted[1].name).toBe('B'); // 50000, A
+        expect(sorted[2].name).toBe('A'); // 50000, Z
     });
     test('should paginate polymorphic results correctly', async () => {
         await db.execute(sql `TRUNCATE TABLE ${sql.identifier(schema)}.${sql.identifier('persons')} CASCADE`);
-        await runInInjectionContext(injector, async () => {
-            const personRepo = injectRepository(Person);
-            const empRepo = injectRepository(Employee);
-            const mgrRepo = injectRepository(Manager);
-            const cntRepo = injectRepository(Contractor);
-            // Insert 5 entities: 2 employees, 2 managers, 1 contractor
-            // Names ordered: A, B, C, D, E
-            await empRepo.insert(Object.assign(new Employee(), { name: 'A_Emp', salary: 1000 }));
-            await mgrRepo.insert(Object.assign(new Manager(), { name: 'B_Mgr', salary: 2000, department: 'D1' }));
-            await cntRepo.insert(Object.assign(new Contractor(), { name: 'C_Cnt', contractEnd: '2025' }));
-            await empRepo.insert(Object.assign(new Employee(), { name: 'D_Emp', salary: 1000 }));
-            await mgrRepo.insert(Object.assign(new Manager(), { name: 'E_Mgr', salary: 2000, department: 'D2' }));
-            // Load page 1 (size 2) sorted by name
-            const page1 = await personRepo.loadManyByQuery({}, {
-                order: [['name', 'asc']],
-                limit: 2,
-                offset: 0,
-                includeSubclasses: [Employee, Manager, Contractor],
-            });
-            expect(page1).toHaveLength(2);
-            expect(page1[0].name).toBe('A_Emp');
-            expect(page1[0]).toBeInstanceOf(Employee);
-            expect(page1[1].name).toBe('B_Mgr');
-            expect(page1[1]).toBeInstanceOf(Manager);
-            // Load page 2 (size 2)
-            const page2 = await personRepo.loadManyByQuery({}, {
-                order: [['name', 'asc']],
-                limit: 2,
-                offset: 2,
-                includeSubclasses: [Employee, Manager, Contractor],
-            });
-            expect(page2).toHaveLength(2);
-            expect(page2[0].name).toBe('C_Cnt');
-            expect(page2[0]).toBeInstanceOf(Contractor);
-            expect(page2[1].name).toBe('D_Emp');
-            expect(page2[1]).toBeInstanceOf(Employee);
-            // Load page 3 (size 2) - should have 1
-            const page3 = await personRepo.loadManyByQuery({}, {
-                order: [['name', 'asc']],
-                limit: 2,
-                offset: 4,
-                includeSubclasses: [Employee, Manager, Contractor],
-            });
-            expect(page3).toHaveLength(1);
-            expect(page3[0].name).toBe('E_Mgr');
+        // Insert 5 entities: 2 employees, 2 managers, 1 contractor
+        // Names ordered: A, B, C, D, E
+        await empRepo.insert(Object.assign(new Employee(), { name: 'A_Emp', salary: 1000 }));
+        await mgrRepo.insert(Object.assign(new Manager(), { name: 'B_Mgr', salary: 2000, department: 'D1' }));
+        await cntRepo.insert(Object.assign(new Contractor(), { name: 'C_Cnt', contractEnd: '2025' }));
+        await empRepo.insert(Object.assign(new Employee(), { name: 'D_Emp', salary: 1000 }));
+        await mgrRepo.insert(Object.assign(new Manager(), { name: 'E_Mgr', salary: 2000, department: 'D2' }));
+        // Load page 1 (size 2) sorted by name
+        const page1 = await personRepo.loadManyByQuery({}, {
+            order: [['name', 'asc']],
+            limit: 2,
+            offset: 0,
+            includeSubclasses: [Employee, Manager, Contractor],
+        });
+        expect(page1).toHaveLength(2);
+        expect(page1[0].name).toBe('A_Emp');
+        expect(page1[0]).toBeInstanceOf(Employee);
+        expect(page1[1].name).toBe('B_Mgr');
+        expect(page1[1]).toBeInstanceOf(Manager);
+        // Load page 2 (size 2)
+        const page2 = await personRepo.loadManyByQuery({}, {
+            order: [['name', 'asc']],
+            limit: 2,
+            offset: 2,
+            includeSubclasses: [Employee, Manager, Contractor],
         });
+        expect(page2).toHaveLength(2);
+        expect(page2[0].name).toBe('C_Cnt');
+        expect(page2[0]).toBeInstanceOf(Contractor);
+        expect(page2[1].name).toBe('D_Emp');
+        expect(page2[1]).toBeInstanceOf(Employee);
+        // Load page 3 (size 2) - should have 1
+        const page3 = await personRepo.loadManyByQuery({}, {
+            order: [['name', 'asc']],
+            limit: 2,
+            offset: 4,
+            includeSubclasses: [Employee, Manager, Contractor],
+        });
+        expect(page3).toHaveLength(1);
+        expect(page3[0].name).toBe('E_Mgr');
     });
     test('should rollback whole operation if one child insert fails in bulk insert', async () => {
         // NOTE: Repositories typically don't support heterogeneous bulk insert via `insertMany` directly if they are typed to one Entity.
@@ -240,22 +222,19 @@ describe('ORM Repository CTI Extensive (Integration)', () => {
         // Here we will test doing multiple operations in a transaction and failing one.
         await db.execute(sql `TRUNCATE TABLE ${sql.identifier(schema)}.${sql.identifier('persons')} CASCADE`);
         try {
-            await runInInjectionContext(injector, async () => {
-                const mgrRepo = injectRepository(Manager);
-                await mgrRepo.transaction(async (tx) => {
-                    const txRepo = mgrRepo.withTransaction(tx);
-                    await txRepo.insert(Object.assign(new Manager(), { name: 'TxMgr1', salary: 1000, department: 'D1' }));
-                    // This one should fail due to constraint violation (missing department is not nullable in DB but maybe optional in class?
-                    // In our setup 'department' is NOT NULL.
-                    // Let's force a failure by passing a raw invalid object or similar, or just throwing.
-                    // A better DB constraint failure: Duplicate ID? Or invalid type?
-                    // Let's try inserting a manager with a missing required field using 'any' to bypass TS check.
-                    const invalidMgr = new Manager();
-                    invalidMgr.name = 'TxMgr2';
-                    invalidMgr.salary = 2000;
-                    // Missing department
-                    await txRepo.insert(invalidMgr);
-                });
+            await mgrRepo.transaction(async (tx) => {
+                const txRepo = mgrRepo.withTransaction(tx);
+                await txRepo.insert(Object.assign(new Manager(), { name: 'TxMgr1', salary: 1000, department: 'D1' }));
+                // This one should fail due to constraint violation (missing department is not nullable in DB but maybe optional in class?
+                // In our setup 'department' is NOT NULL.
+                // Let's force a failure by passing a raw invalid object or similar, or just throwing.
+                // A better DB constraint failure: Duplicate ID? Or invalid type?
+                // Let's try inserting a manager with a missing required field using 'any' to bypass TS check.
+                const invalidMgr = new Manager();
+                invalidMgr.name = 'TxMgr2';
+                invalidMgr.salary = 2000;
+                // Missing department
+                await txRepo.insert(invalidMgr);
             });
         }
         catch (e) {
@@ -269,40 +248,32 @@ describe('ORM Repository CTI Extensive (Integration)', () => {
         // In our current schema we avoided it, but let's see if we can query based on aliasing if it were to happen?
         // Actually, let's test querying with 'OR' condition across parent and child fields.
         await db.execute(sql `TRUNCATE TABLE ${sql.identifier(schema)}.${sql.identifier('persons')} CASCADE`);
-        await runInInjectionContext(injector, async () => {
-            const mgrRepo = injectRepository(Manager);
-            await mgrRepo.insert(Object.assign(new Manager(), { name: 'MatchName', salary: 1000, department: 'Other' }));
-            await mgrRepo.insert(Object.assign(new Manager(), { name: 'OtherName', salary: 1000, department: 'MatchDept' }));
-            await mgrRepo.insert(Object.assign(new Manager(), { name: 'NoMatch', salary: 1000, department: 'Other' }));
-            // Logic: name = 'MatchName' OR department = 'MatchDept'
-            // ORM's `loadManyByQuery` usually takes an object for AND.
-            // We might need to use `loadMany` with a custom query builder or check if `loadManyByQuery` supports arrays for OR?
-            // If not supported easily, we skip this specific complex query for now, or use `loadMany` with simple filters.
-            // Let's stick to simple filters that we know are supported: simple object matches (AND).
-            // Let's test a deeply nested query filter if supported.
-            const results = await mgrRepo.loadManyByQuery({
-                department: 'MatchDept',
-            });
-            expect(results).toHaveLength(1);
-            expect(results[0].name).toBe('OtherName');
+        await mgrRepo.insert(Object.assign(new Manager(), { name: 'MatchName', salary: 1000, department: 'Other' }));
+        await mgrRepo.insert(Object.assign(new Manager(), { name: 'OtherName', salary: 1000, department: 'MatchDept' }));
+        await mgrRepo.insert(Object.assign(new Manager(), { name: 'NoMatch', salary: 1000, department: 'Other' }));
+        // Logic: name = 'MatchName' OR department = 'MatchDept'
+        // ORM's `loadManyByQuery` usually takes an object for AND.
+        // We might need to use `loadMany` with a custom query builder or check if `loadManyByQuery` supports arrays for OR?
+        // If not supported easily, we skip this specific complex query for now, or use `loadMany` with simple filters.
+        // Let's stick to simple filters that we know are supported: simple object matches (AND).
+        // Let's test a deeply nested query filter if supported.
+        const results = await mgrRepo.loadManyByQuery({
+            department: 'MatchDept',
         });
+        expect(results).toHaveLength(1);
+        expect(results[0].name).toBe('OtherName');
     });
     test('should correctly count with subclass inclusion', async () => {
         await db.execute(sql `TRUNCATE TABLE ${sql.identifier(schema)}.${sql.identifier('persons')} CASCADE`);
-        await runInInjectionContext(injector, async () => {
-            const personRepo = injectRepository(Person);
-            const empRepo = injectRepository(Employee);
-            const mgrRepo = injectRepository(Manager);
-            await empRepo.insert(Object.assign(new Employee(), { name: 'E1', salary: 100 }));
-            await mgrRepo.insert(Object.assign(new Manager(), { name: 'M1', salary: 200, department: 'D1' }));
-            // Count on Person should see 2
-            expect(await personRepo.count()).toBe(2);
-            // Count on Employee should see 2 (Manager IS-A Employee)
-            // Wait, does 'count()' on Employee include Managers by default?
-            // Standard CTI usually implies querying the 'employees' table which includes Managers' rows.
-            expect(await empRepo.count()).toBe(2);
-            // Count on Manager should see 1
-            expect(await mgrRepo.count()).toBe(1);
-        });
+        await empRepo.insert(Object.assign(new Employee(), { name: 'E1', salary: 100 }));
+        await mgrRepo.insert(Object.assign(new Manager(), { name: 'M1', salary: 200, department: 'D1' }));
+        // Count on Person should see 2
+        expect(await personRepo.count()).toBe(2);
+        // Count on Employee should see 2 (Manager IS-A Employee)
+        // Wait, does 'count()' on Employee include Managers by default?
+        // Standard CTI usually implies querying the 'employees' table which includes Managers' rows.
+        expect(await empRepo.count()).toBe(2);
+        // Count on Manager should see 1
+        expect(await mgrRepo.count()).toBe(1);
     });
 });

package/orm/tests/repository-cti-mapping.test.d.ts

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

package/orm/tests/repository-cti-mapping.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,17 @@ 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 { sql } from 'drizzle-orm';
 import { beforeAll, describe, expect, test } from 'vitest';
+import { StringProperty } from '../../schema/index.js';
+import { setupIntegrationTest } from '../../testing/index.js';
 import { ChildEntity, Column, Inheritance, Table } from '../decorators.js';
 import { Entity } from '../entity.js';
-import { configureOrm, Database } from '../server/index.js';
-import { injectRepository } from '../server/repository.js';
+import { getRepository } from '../server/index.js';
 describe('ORM Repository CTI Mapping (Integration)', () => {
     let injector;
     let db;
+    let repo;
     const schema = 'test_orm_cti_mapping';
     let MappedParent = class MappedParent extends Entity {
         discriminator;
@@ -50,18 +51,10 @@ describe('ORM Repository CTI Mapping (Integration)', () => {
         ChildEntity('child')
     ], MappedChild);
     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);
+        ({ injector, database: db } = await setupIntegrationTest({
+            orm: { schema },
+        }));
+        repo = injector.resolve(getRepository(MappedChild));
         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('mapped_children')} CASCADE`);
         await db.execute(sql `DROP TABLE IF EXISTS ${sql.identifier(schema)}.${sql.identifier('mapped_parents')} CASCADE`);
@@ -88,34 +81,28 @@ describe('ORM Repository CTI Mapping (Integration)', () => {
     `);
     });
     test('should respect @Column renaming in CTI', async () => {
-        await runInInjectionContext(injector, async () => {
-            const repo = injectRepository(MappedChild);
-            const child = await repo.insert(Object.assign(new MappedChild(), { displayName: 'Visible', secret: 'Hidden' }));
-            expect(child.discriminator).toBe('child');
-            expect(child.displayName).toBe('Visible');
-            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');
-            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');
-            // Load back
-            const loaded = await repo.load(child.id);
-            expect(loaded.displayName).toBe('Visible');
-            expect(loaded.secret).toBe('Hidden');
-        });
+        const child = await repo.insert(Object.assign(new MappedChild(), { displayName: 'Visible', secret: 'Hidden' }));
+        expect(child.discriminator).toBe('child');
+        expect(child.displayName).toBe('Visible');
+        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');
+        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');
+        // Load back
+        const loaded = await repo.load(child.id);
+        expect(loaded.displayName).toBe('Visible');
+        expect(loaded.secret).toBe('Hidden');
     });
     test('should filter by renamed columns in both tables', async () => {
-        await runInInjectionContext(injector, async () => {
-            const repo = injectRepository(MappedChild);
-            await repo.insert(Object.assign(new MappedChild(), { displayName: 'A', secret: 'S1' }));
-            await repo.insert(Object.assign(new MappedChild(), { displayName: 'B', secret: 'S2' }));
-            const results = await repo.loadManyByQuery({
-                displayName: 'B',
-                secret: 'S2'
-            });
-            expect(results).toHaveLength(1);
-            expect(results[0].displayName).toBe('B');
+        await repo.insert(Object.assign(new MappedChild(), { displayName: 'A', secret: 'S1' }));
+        await repo.insert(Object.assign(new MappedChild(), { displayName: 'B', secret: 'S2' }));
+        const results = await repo.loadManyByQuery({
+            displayName: 'B',
+            secret: 'S2'
         });
+        expect(results).toHaveLength(1);
+        expect(results[0].displayName).toBe('B');
     });
 });

package/orm/tests/repository-cti-soft-delete.test.d.ts

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

package/orm/tests/repository-cti-soft-delete.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,18 @@ 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 { sql } from 'drizzle-orm';
 import { beforeAll, describe, expect, test } from 'vitest';
+import { StringProperty } from '../../schema/index.js';
+import { setupIntegrationTest } from '../../testing/index.js';
 import { ChildEntity, Column, Inheritance, Table } from '../decorators.js';
 import { Entity } from '../entity.js';
-import { configureOrm, Database } from '../server/index.js';
-import { injectRepository } from '../server/repository.js';
+import { getRepository } from '../server/index.js';
 describe('ORM Repository CTI Soft Delete (Integration)', () => {
     let injector;
     let db;
+    let baseRepo;
+    let subRepo;
     const schema = 'test_orm_cti_soft_delete';
     let Base = class Base extends Entity {
         type;
@@ -48,18 +50,11 @@ describe('ORM Repository CTI Soft Delete (Integration)', () => {
         ChildEntity('subtype')
     ], Subtype);
     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);
+        ({ injector, database: db } = await setupIntegrationTest({
+            orm: { schema },
+        }));
+        baseRepo = injector.resolve(getRepository(Base));
+        subRepo = injector.resolve(getRepository(Subtype));
         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('subtypes')} CASCADE`);
         await db.execute(sql `DROP TABLE IF EXISTS ${sql.identifier(schema)}.${sql.identifier('bases')} CASCADE`);
@@ -87,29 +82,22 @@ describe('ORM Repository CTI Soft Delete (Integration)', () => {
     });
     test('should soft delete from subtype repository', async () => {
         await db.execute(sql `TRUNCATE TABLE ${sql.identifier(schema)}.${sql.identifier('bases')} CASCADE`);
-        await runInInjectionContext(injector, async () => {
-            const repo = injectRepository(Subtype);
-            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(await repo.has(entity.id)).toBe(false);
-            expect(await repo.loadManyByQuery({ id: entity.id }).then((r) => r[0])).toBeUndefined();
-        });
+        const entity = await subRepo.insert(Object.assign(new Subtype(), { baseName: 'B1', subData: 'S1' }));
+        await subRepo.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(await subRepo.has(entity.id)).toBe(false);
+        expect(await subRepo.loadManyByQuery({ id: entity.id }).then((r) => r[0])).toBeUndefined();
     });
     test('should polymorphically filter soft deleted entities', async () => {
         await db.execute(sql `TRUNCATE TABLE ${sql.identifier(schema)}.${sql.identifier('bases')} CASCADE`);
-        await runInInjectionContext(injector, async () => {
-            const baseRepo = injectRepository(Base);
-            const subRepo = injectRepository(Subtype);
-            const s1 = await subRepo.insert(Object.assign(new Subtype(), { baseName: 'Active', subData: 'S1' }));
-            const s2 = await subRepo.insert(Object.assign(new Subtype(), { baseName: 'Deleted', subData: 'S2' }));
-            await subRepo.delete(s2.id);
-            const allActive = await baseRepo.loadAll({ includeSubclasses: true });
-            expect(allActive).toHaveLength(1);
-            expect(allActive[0].id).toBe(s1.id);
-            const allIncludingDeleted = await baseRepo.loadAll({ includeSubclasses: true, withDeleted: true });
-            expect(allIncludingDeleted).toHaveLength(2);
-        });
+        const s1 = await subRepo.insert(Object.assign(new Subtype(), { baseName: 'Active', subData: 'S1' }));
+        const s2 = await subRepo.insert(Object.assign(new Subtype(), { baseName: 'Deleted', subData: 'S2' }));
+        await subRepo.delete(s2.id);
+        const allActive = await baseRepo.loadAll({ includeSubclasses: true });
+        expect(allActive).toHaveLength(1);
+        expect(allActive[0].id).toBe(s1.id);
+        const allIncludingDeleted = await baseRepo.loadAll({ includeSubclasses: true, withDeleted: true });
+        expect(allIncludingDeleted).toHaveLength(2);
     });
 });