@tstdl/base 0.93.145 → 0.93.146

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

@@ -7,18 +7,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 { 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 { Table } from '../decorators.js';
 import { Entity } from '../entity.js';
-import { Database } from '../server/index.js';
-import { injectRepository } from '../server/repository.js';
+import { getRepository } from '../server/index.js';
 describe('ORM Repository Attributes (Integration)', () => {
     let injector;
     let database;
+    let repository;
     const schema = 'test_orm_attributes';
     let AttributeEntity = class AttributeEntity extends Entity {
         name;
@@ -32,6 +31,7 @@ describe('ORM Repository Attributes (Integration)', () => {
     ], AttributeEntity);
     beforeAll(async () => {
         ({ injector, database } = await setupIntegrationTest({ orm: { schema } }));
+        repository = injector.resolve(getRepository(AttributeEntity));
         await dropTables(database, schema, ['attribute_entities']);
         await database.execute(sql `
       CREATE TABLE ${sql.identifier(schema)}.${sql.identifier('attribute_entities')} (
@@ -49,44 +49,35 @@ describe('ORM Repository Attributes (Integration)', () => {
         await truncateTables(database, schema, ['attribute_entities']);
     });
     test('should support partial attribute updates', async () => {
-        await runInInjectionContext(injector, async () => {
-            const repository = injectRepository(AttributeEntity);
-            const e1 = await repository.insert(Object.assign(new AttributeEntity(), {
-                name: 'E1',
-                metadata: { attributes: { a: 1, b: 2 } },
-            }));
-            expect(e1.metadata.attributes).toEqual({ a: 1, b: 2 });
-            const updated = await repository.update(e1.id, {
-                metadata: { attributes: { b: 3, c: 4 } },
-            });
-            expect(updated.metadata.attributes).toEqual({ a: 1, b: 3, c: 4 });
+        const e1 = await repository.insert(Object.assign(new AttributeEntity(), {
+            name: 'E1',
+            metadata: { attributes: { a: 1, b: 2 } },
+        }));
+        expect(e1.metadata.attributes).toEqual({ a: 1, b: 2 });
+        const updated = await repository.update(e1.id, {
+            metadata: { attributes: { b: 3, c: 4 } },
         });
+        expect(updated.metadata.attributes).toEqual({ a: 1, b: 3, c: 4 });
     });
     test('should update attributes during soft delete', async () => {
-        await runInInjectionContext(injector, async () => {
-            const repository = injectRepository(AttributeEntity);
-            const e1 = await repository.insert(Object.assign(new AttributeEntity(), {
-                name: 'E1',
-                metadata: { attributes: { initial: true } },
-            }));
-            const deleted = await repository.delete(e1.id, undefined, { attributes: { deleted: true } });
-            expect(deleted.metadata.attributes).toEqual({ initial: true, deleted: true });
-        });
+        const e1 = await repository.insert(Object.assign(new AttributeEntity(), {
+            name: 'E1',
+            metadata: { attributes: { initial: true } },
+        }));
+        const deleted = await repository.delete(e1.id, undefined, { attributes: { deleted: true } });
+        expect(deleted.metadata.attributes).toEqual({ initial: true, deleted: true });
     });
     test('should support querying by raw SQL on attributes', async () => {
-        await runInInjectionContext(injector, async () => {
-            const repository = injectRepository(AttributeEntity);
-            await repository.insert(Object.assign(new AttributeEntity(), {
-                name: 'E1',
-                metadata: { attributes: { key: 'value1' } },
-            }));
-            await repository.insert(Object.assign(new AttributeEntity(), {
-                name: 'E2',
-                metadata: { attributes: { key: 'value2' } },
-            }));
-            const results = await repository.loadManyByQuery(sql `attributes->>'key' = 'value1'`);
-            expect(results).toHaveLength(1);
-            expect(results[0].name).toBe('E1');
-        });
+        await repository.insert(Object.assign(new AttributeEntity(), {
+            name: 'E1',
+            metadata: { attributes: { key: 'value1' } },
+        }));
+        await repository.insert(Object.assign(new AttributeEntity(), {
+            name: 'E2',
+            metadata: { attributes: { key: 'value2' } },
+        }));
+        const results = await repository.loadManyByQuery(sql `attributes->>'key' = 'value1'`);
+        expect(results).toHaveLength(1);
+        expect(results[0].name).toBe('E1');
     });
 });

package/orm/tests/repository-compound-primary-key.test.js

@@ -8,19 +8,22 @@ 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 } from '../../testing/index.js';
 import { sql } from 'drizzle-orm';
 import { getTableConfig } from 'drizzle-orm/pg-core';
 import { beforeAll, beforeEach, describe, expect, test } from 'vitest';
+import { StringProperty } from '../../schema/index.js';
+import { dropTables, setupIntegrationTest } from '../../testing/index.js';
 import { ChildEntity, Inheritance, PrimaryKey, Table } from '../decorators.js';
 import { Entity } from '../entity.js';
 import { getDrizzleTableFromType } from '../server/drizzle/index.js';
-import { Database, injectRepository } from '../server/index.js';
+import { getRepository } from '../server/index.js';
 describe('ORM Repository Compound Primary Key (Integration)', () => {
     let injector;
     let database;
+    let compoundRepo;
+    let parentRepo;
+    let childRepo;
+    let grandchildRepo;
     const schema = 'test_orm_compound_pk';
     let CompoundEntity = class CompoundEntity extends Entity {
         namespace;
@@ -79,6 +82,10 @@ describe('ORM Repository Compound Primary Key (Integration)', () => {
     ], GrandchildEntity);
     beforeAll(async () => {
         ({ injector, database } = await setupIntegrationTest({ orm: { schema } }));
+        compoundRepo = injector.resolve(getRepository(CompoundEntity));
+        parentRepo = injector.resolve(getRepository(ParentEntity));
+        childRepo = injector.resolve(getRepository(ChildEntityModel));
+        grandchildRepo = injector.resolve(getRepository(GrandchildEntity));
         await database.execute(sql `CREATE SCHEMA IF NOT EXISTS ${sql.identifier(schema)}`);
         await dropTables(database, schema, ['grandchild_entities', 'child_entities', 'parent_entities', 'compound_entities']);
         await database.execute(sql `
@@ -134,85 +141,70 @@ describe('ORM Repository Compound Primary Key (Integration)', () => {
         await database.execute(sql `TRUNCATE TABLE ${sql.identifier(schema)}.${sql.identifier('grandchild_entities')}, ${sql.identifier(schema)}.${sql.identifier('child_entities')}, ${sql.identifier(schema)}.${sql.identifier('parent_entities')}, ${sql.identifier(schema)}.${sql.identifier('compound_entities')} CASCADE`);
     });
     test('should insert and load compound entity', async () => {
-        await runInInjectionContext(injector, async () => {
-            const repository = injectRepository(CompoundEntity);
-            const entity = new CompoundEntity();
-            entity.id = '00000000-0000-0000-0000-000000000001';
-            entity.namespace = 'ns1';
-            entity.data = 'test data';
-            await repository.insert(entity);
-            const loaded = await repository.loadByQuery({ namespace: 'ns1', id: '00000000-0000-0000-0000-000000000001' });
-            expect(loaded.data).toBe('test data');
-            expect(loaded.namespace).toBe('ns1');
-            expect(loaded.id).toBe('00000000-0000-0000-0000-000000000001');
-        });
+        const entity = new CompoundEntity();
+        entity.id = '00000000-0000-0000-0000-000000000001';
+        entity.namespace = 'ns1';
+        entity.data = 'test data';
+        await compoundRepo.insert(entity);
+        const loaded = await compoundRepo.loadByQuery({ namespace: 'ns1', id: '00000000-0000-0000-0000-000000000001' });
+        expect(loaded.data).toBe('test data');
+        expect(loaded.namespace).toBe('ns1');
+        expect(loaded.id).toBe('00000000-0000-0000-0000-000000000001');
     });
     test('should upsert compound entity', async () => {
-        await runInInjectionContext(injector, async () => {
-            const repository = injectRepository(CompoundEntity);
-            const entity = new CompoundEntity();
-            entity.id = '00000000-0000-0000-0000-000000000010';
-            entity.namespace = 'ns1';
-            entity.data = 'initial data';
-            await repository.insert(entity);
-            const updateEntity = new CompoundEntity();
-            updateEntity.id = '00000000-0000-0000-0000-000000000010';
-            updateEntity.namespace = 'ns1';
-            updateEntity.data = 'updated data';
-            await repository.upsert(['namespace', 'id'], updateEntity);
-            const loaded = await repository.loadByQuery({ namespace: 'ns1', id: '00000000-0000-0000-0000-000000000010' });
-            expect(loaded.data).toBe('updated data');
-        });
+        const entity = new CompoundEntity();
+        entity.id = '00000000-0000-0000-0000-000000000010';
+        entity.namespace = 'ns1';
+        entity.data = 'initial data';
+        await compoundRepo.insert(entity);
+        const updateEntity = new CompoundEntity();
+        updateEntity.id = '00000000-0000-0000-0000-000000000010';
+        updateEntity.namespace = 'ns1';
+        updateEntity.data = 'updated data';
+        await compoundRepo.upsert(['namespace', 'id'], updateEntity);
+        const loaded = await compoundRepo.loadByQuery({ namespace: 'ns1', id: '00000000-0000-0000-0000-000000000010' });
+        expect(loaded.data).toBe('updated data');
     });
     test('should insert and load child entity with compound PK', async () => {
-        await runInInjectionContext(injector, async () => {
-            const repository = injectRepository(ChildEntityModel);
-            const entity = new ChildEntityModel();
-            entity.id = '00000000-0000-0000-0000-000000000020';
-            entity.namespace = 'ns2';
-            entity.type = 'child';
-            entity.childData = 'child specific data';
-            await repository.insert(entity);
-            const loaded = await repository.loadByQuery({ namespace: 'ns2', id: '00000000-0000-0000-0000-000000000020' });
-            expect(loaded.childData).toBe('child specific data');
-            expect(loaded.namespace).toBe('ns2');
-            expect(loaded.id).toBe('00000000-0000-0000-0000-000000000020');
-        });
+        const entity = new ChildEntityModel();
+        entity.id = '00000000-0000-0000-0000-000000000020';
+        entity.namespace = 'ns2';
+        entity.type = 'child';
+        entity.childData = 'child specific data';
+        await childRepo.insert(entity);
+        const loaded = await childRepo.loadByQuery({ namespace: 'ns2', id: '00000000-0000-0000-0000-000000000020' });
+        expect(loaded.childData).toBe('child specific data');
+        expect(loaded.namespace).toBe('ns2');
+        expect(loaded.id).toBe('00000000-0000-0000-0000-000000000020');
     });
     test('should insert and load grandchild entity with compound PK', async () => {
-        await runInInjectionContext(injector, async () => {
-            const repository = injectRepository(GrandchildEntity);
-            const entity = new GrandchildEntity();
-            entity.id = '00000000-0000-0000-0000-000000000050';
-            entity.namespace = 'ns5';
-            entity.type = 'grandchild';
-            entity.childData = 'child part';
-            entity.grandchildData = 'grandchild part';
-            await repository.insert(entity);
-            const loaded = await repository.loadByQuery({ namespace: 'ns5', id: '00000000-0000-0000-0000-000000000050' });
-            expect(loaded.grandchildData).toBe('grandchild part');
-            expect(loaded.childData).toBe('child part');
-            expect(loaded.namespace).toBe('ns5');
-            expect(loaded.id).toBe('00000000-0000-0000-0000-000000000050');
-        });
+        const entity = new GrandchildEntity();
+        entity.id = '00000000-0000-0000-0000-000000000050';
+        entity.namespace = 'ns5';
+        entity.type = 'grandchild';
+        entity.childData = 'child part';
+        entity.grandchildData = 'grandchild part';
+        await grandchildRepo.insert(entity);
+        const loaded = await grandchildRepo.loadByQuery({ namespace: 'ns5', id: '00000000-0000-0000-0000-000000000050' });
+        expect(loaded.grandchildData).toBe('grandchild part');
+        expect(loaded.childData).toBe('child part');
+        expect(loaded.namespace).toBe('ns5');
+        expect(loaded.id).toBe('00000000-0000-0000-0000-000000000050');
     });
     test('should updateManyByQuery with compound PK', async () => {
-        await runInInjectionContext(injector, async () => {
-            const repository = injectRepository(CompoundEntity);
-            const entity1 = new CompoundEntity();
-            entity1.id = '00000000-0000-0000-0000-000000000030';
-            entity1.namespace = 'ns3';
-            entity1.data = 'data 1';
-            const entity2 = new CompoundEntity();
-            entity2.id = '00000000-0000-0000-0000-000000000040';
-            entity2.namespace = 'ns3';
-            entity2.data = 'data 2';
-            await repository.insertMany([entity1, entity2]);
-            await repository.updateManyByQuery({ namespace: 'ns3' }, { data: 'batch updated' });
-            const entities = await repository.loadManyByQuery({ namespace: 'ns3' });
-            expect(entities).toHaveLength(2);
-            expect(entities.every(e => e.data === 'batch updated')).toBe(true);
-        });
+        const entity1 = new CompoundEntity();
+        entity1.id = '00000000-0000-0000-0000-000000000030';
+        entity1.namespace = 'ns3';
+        entity1.data = 'data 1';
+        const entity2 = new CompoundEntity();
+        entity2.id = '00000000-0000-0000-0000-000000000040';
+        entity2.namespace = 'ns3';
+        entity2.data = 'data 2';
+        await compoundRepo.insertMany([entity1, entity2]);
+        await compoundRepo.updateManyByQuery({ namespace: 'ns3' }, { data: 'batch updated' });
+        const entities = await compoundRepo.loadManyByQuery({ namespace: 'ns3' });
+        expect(entities).toHaveLength(2);
+        expect(entities.every(e => e.data === 'batch updated')).toBe(true);
     });
     test('should respect custom primary key name', () => {
         let CustomPkEntity = class CustomPkEntity extends Entity {

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

@@ -9,15 +9,15 @@ var __metadata = (this && this.__metadata) || function (k, v) {
 };
 import { sql } from 'drizzle-orm';
 import { beforeAll, describe, expect, test } from 'vitest';
-import { Injector, runInInjectionContext } from '../../injector/index.js';
 import { Integer, StringProperty } from '../../schema/index.js';
+import { setupIntegrationTest } from '../../testing/index.js';
 import { GeneratedTsVector, Table } from '../decorators.js';
 import { Entity } from '../entity.js';
-import { configureOrm, Database } from '../server/index.js';
-import { injectRepository } from '../server/repository.js';
+import { getRepository, injectRepository } from '../server/index.js';
 describe('ORM Repository Comprehensive Options & Edge Cases', () => {
     let injector;
     let db;
+    let repository;
     const schema = 'test_orm_comprehensive';
     let ComprehensiveEntity = class ComprehensiveEntity extends Entity {
         name;
@@ -46,14 +46,10 @@ describe('ORM Repository Comprehensive Options & Edge Cases', () => {
         Table('comprehensive_entities', { schema })
     ], ComprehensiveEntity);
     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 },
+        }));
+        repository = injector.resolve(getRepository(ComprehensiveEntity));
         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('comprehensive_entities')} CASCADE`);
         await db.execute(sql `
@@ -74,114 +70,93 @@ describe('ORM Repository Comprehensive Options & Edge Cases', () => {
     });
     test('should support DISTINCT ON loading', async () => {
         await db.execute(sql `TRUNCATE TABLE ${sql.identifier(schema)}.${sql.identifier('comprehensive_entities')} CASCADE`);
-        await runInInjectionContext(injector, async () => {
-            const repository = injectRepository(ComprehensiveEntity);
-            await repository.insertMany([
-                Object.assign(new ComprehensiveEntity(), { name: 'A1', category: 'Cat1', value: 10 }),
-                Object.assign(new ComprehensiveEntity(), { name: 'A2', category: 'Cat1', value: 20 }),
-                Object.assign(new ComprehensiveEntity(), { name: 'B1', category: 'Cat2', value: 30 }),
-            ]);
-            // Load distinct by category, order by category and value desc to get the one with highest value per category
-            const results = await repository.loadManyByQuery({}, {
-                distinct: ['category'],
-                order: [['category', 'asc'], ['value', 'desc']],
-            });
-            expect(results).toHaveLength(2);
-            expect(results.find((r) => r.category === 'Cat1').name).toBe('A2'); // Value 20 > 10
-            expect(results.find((r) => r.category === 'Cat2').name).toBe('B1');
+        await repository.insertMany([
+            Object.assign(new ComprehensiveEntity(), { name: 'A1', category: 'Cat1', value: 10 }),
+            Object.assign(new ComprehensiveEntity(), { name: 'A2', category: 'Cat1', value: 20 }),
+            Object.assign(new ComprehensiveEntity(), { name: 'B1', category: 'Cat2', value: 30 }),
+        ]);
+        // Load distinct by category, order by category and value desc to get the one with highest value per category
+        const results = await repository.loadManyByQuery({}, {
+            distinct: ['category'],
+            order: [['category', 'asc'], ['value', 'desc']],
         });
+        expect(results).toHaveLength(2);
+        expect(results.find((r) => r.category === 'Cat1').name).toBe('A2'); // Value 20 > 10
+        expect(results.find((r) => r.category === 'Cat2').name).toBe('B1');
     });
     test('should support search with filter and distinct', async () => {
         await db.execute(sql `TRUNCATE TABLE ${sql.identifier(schema)}.${sql.identifier('comprehensive_entities')} CASCADE`);
-        await runInInjectionContext(injector, async () => {
-            const repository = injectRepository(ComprehensiveEntity);
-            await repository.insertMany([
-                Object.assign(new ComprehensiveEntity(), { name: 'Apple One', category: 'Fruit', value: 5 }),
-                Object.assign(new ComprehensiveEntity(), { name: 'Apple Two', category: 'Fruit', value: 15 }),
-                Object.assign(new ComprehensiveEntity(), { name: 'Apple Three', category: 'Tech', value: 25 }),
-            ]);
-            // Search "Apple", filter value > 10, distinct category
-            const results = await repository.search({
-                query: { $tsvector: { fields: ['searchVector'], query: 'Apple' } },
-                filter: { value: { $gt: 10 } },
-                distinct: ['category'],
-                order: [['category', 'asc'], ['value', 'desc']], // Distinct on requires matching order prefix
-            });
-            expect(results).toHaveLength(2);
-            const categories = results.map((r) => r.entity.category).sort();
-            expect(categories).toEqual(['Fruit', 'Tech']);
-            const fruit = results.find((r) => r.entity.category === 'Fruit');
-            expect(fruit.entity.name).toBe('Apple Two'); // Value 15 > 10, Apple One filtered out or lower
+        await repository.insertMany([
+            Object.assign(new ComprehensiveEntity(), { name: 'Apple One', category: 'Fruit', value: 5 }),
+            Object.assign(new ComprehensiveEntity(), { name: 'Apple Two', category: 'Fruit', value: 15 }),
+            Object.assign(new ComprehensiveEntity(), { name: 'Apple Three', category: 'Tech', value: 25 }),
+        ]);
+        // Search "Apple", filter value > 10, distinct category
+        const results = await repository.search({
+            query: { $tsvector: { fields: ['searchVector'], query: 'Apple' } },
+            filter: { value: { $gt: 10 } },
+            distinct: ['category'],
+            order: [['category', 'asc'], ['value', 'desc']], // Distinct on requires matching order prefix
         });
+        expect(results).toHaveLength(2);
+        const categories = results.map((r) => r.entity.category).sort();
+        expect(categories).toEqual(['Fruit', 'Tech']);
+        const fruit = results.find((r) => r.entity.category === 'Fruit');
+        expect(fruit.entity.name).toBe('Apple Two'); // Value 15 > 10, Apple One filtered out or lower
     });
     test('should handle soft deletes correctly in updates', async () => {
         await db.execute(sql `TRUNCATE TABLE ${sql.identifier(schema)}.${sql.identifier('comprehensive_entities')} CASCADE`);
-        await runInInjectionContext(injector, async () => {
-            const repository = injectRepository(ComprehensiveEntity);
-            const entity = await repository.insert(Object.assign(new ComprehensiveEntity(), { name: 'To Delete', category: 'Test', value: 1 }));
-            await repository.delete(entity.id);
-            // Try update without withDeleted (should fail/return undefined)
-            const tryUpdateResult = await repository.tryUpdate(entity.id, { name: 'Resurrected?' });
-            expect(tryUpdateResult).toBeUndefined();
-            // Ensure DB is unchanged
-            const row = await repository.tryLoad(entity.id, { withDeleted: true });
-            expect(row.name).toBe('To Delete');
-            // Update WITH withDeleted (should work)
-            const updateResult = await repository.update(entity.id, { name: 'Zombie' }, { withDeleted: true });
-            expect(updateResult.name).toBe('Zombie');
-            expect(updateResult.metadata.deleteTimestamp).not.toBeNull(); // Still deleted
-        });
+        const entity = await repository.insert(Object.assign(new ComprehensiveEntity(), { name: 'To Delete', category: 'Test', value: 1 }));
+        await repository.delete(entity.id);
+        // Try update without withDeleted (should fail/return undefined)
+        const tryUpdateResult = await repository.tryUpdate(entity.id, { name: 'Resurrected?' });
+        expect(tryUpdateResult).toBeUndefined();
+        // Ensure DB is unchanged
+        const row = await repository.tryLoad(entity.id, { withDeleted: true });
+        expect(row.name).toBe('To Delete');
+        // Update WITH withDeleted (should work)
+        const updateResult = await repository.update(entity.id, { name: 'Zombie' }, { withDeleted: true });
+        expect(updateResult.name).toBe('Zombie');
+        expect(updateResult.metadata.deleteTimestamp).not.toBeNull(); // Still deleted
     });
     test('should handle count with and without deleted', async () => {
         await db.execute(sql `TRUNCATE TABLE ${sql.identifier(schema)}.${sql.identifier('comprehensive_entities')} CASCADE`);
-        await runInInjectionContext(injector, async () => {
-            const repository = injectRepository(ComprehensiveEntity);
-            await repository.insert(Object.assign(new ComprehensiveEntity(), { name: 'Alive', category: 'A', value: 1 }));
-            const dead = await repository.insert(Object.assign(new ComprehensiveEntity(), { name: 'Dead', category: 'A', value: 2 }));
-            await repository.delete(dead.id);
-            expect(await repository.count()).toBe(1);
-            expect(await repository.count({ withDeleted: true })).toBe(2);
-            expect(await repository.countByQuery({ category: 'A' })).toBe(1);
-            expect(await repository.countByQuery({ category: 'A' }, { withDeleted: true })).toBe(2);
-        });
+        await repository.insert(Object.assign(new ComprehensiveEntity(), { name: 'Alive', category: 'A', value: 1 }));
+        const dead = await repository.insert(Object.assign(new ComprehensiveEntity(), { name: 'Dead', category: 'A', value: 2 }));
+        await repository.delete(dead.id);
+        expect(await repository.count()).toBe(1);
+        expect(await repository.count({ withDeleted: true })).toBe(2);
+        expect(await repository.countByQuery({ category: 'A' })).toBe(1);
+        expect(await repository.countByQuery({ category: 'A' }, { withDeleted: true })).toBe(2);
     });
     test('should fail gracefully (return undefined) for missing entities in tryLoad operations', async () => {
-        await runInInjectionContext(injector, async () => {
-            const repository = injectRepository(ComprehensiveEntity);
-            expect(await repository.tryLoad('00000000-0000-0000-0000-000000000000')).toBeUndefined();
-            expect(await repository.tryLoadByQuery({ name: 'NonExistent' })).toBeUndefined();
-        });
+        expect(await repository.tryLoad('00000000-0000-0000-0000-000000000000')).toBeUndefined();
+        expect(await repository.tryLoadByQuery({ name: 'NonExistent' })).toBeUndefined();
     });
     test('should return empty array for empty search results', async () => {
-        await runInInjectionContext(injector, async () => {
-            const repository = injectRepository(ComprehensiveEntity);
-            const results = await repository.search({ query: { $tsvector: { fields: ['name'], query: 'NonExistentTerm' } } });
-            expect(results).toEqual([]);
-        });
+        const results = await repository.search({ query: { $tsvector: { fields: ['name'], query: 'NonExistentTerm' } } });
+        expect(results).toEqual([]);
     });
     test('should support complex ordering with multiple fields', async () => {
         await db.execute(sql `TRUNCATE TABLE ${sql.identifier(schema)}.${sql.identifier('comprehensive_entities')} CASCADE`);
-        await runInInjectionContext(injector, async () => {
-            const repository = injectRepository(ComprehensiveEntity);
-            await repository.insertMany([
-                Object.assign(new ComprehensiveEntity(), { name: 'A', category: 'X', value: 1 }),
-                Object.assign(new ComprehensiveEntity(), { name: 'B', category: 'X', value: 2 }),
-                Object.assign(new ComprehensiveEntity(), { name: 'A', category: 'Y', value: 3 }),
-            ]);
-            // Order by Name ASC, then Value DESC
-            const results = await repository.loadAll({
-                order: [['name', 'asc'], ['value', 'desc']],
-            });
-            expect(results).toHaveLength(3);
-            expect(results[0].name).toBe('A');
-            expect(results[0].value).toBe(3); // Y (3) comes before X (1) because both are A? No, wait.
-            // Name A (Y, 3) and Name A (X, 1).
-            // Order: Name ASC. A, A, B.
-            // Tie-break Name: Value DESC. 3, 1.
-            // So A(3) then A(1).
-            expect(results[1].name).toBe('A');
-            expect(results[1].value).toBe(1);
-            expect(results[2].name).toBe('B');
+        await repository.insertMany([
+            Object.assign(new ComprehensiveEntity(), { name: 'A', category: 'X', value: 1 }),
+            Object.assign(new ComprehensiveEntity(), { name: 'B', category: 'X', value: 2 }),
+            Object.assign(new ComprehensiveEntity(), { name: 'A', category: 'Y', value: 3 }),
+        ]);
+        // Order by Name ASC, then Value DESC
+        const results = await repository.loadAll({
+            order: [['name', 'asc'], ['value', 'desc']],
         });
+        expect(results).toHaveLength(3);
+        expect(results[0].name).toBe('A');
+        expect(results[0].value).toBe(3); // Y (3) comes before X (1) because both are A? No, wait.
+        // Name A (Y, 3) and Name A (X, 1).
+        // Order: Name ASC. A, A, B.
+        // Tie-break Name: Value DESC. 3, 1.
+        // So A(3) then A(1).
+        expect(results[1].name).toBe('A');
+        expect(results[1].value).toBe(1);
+        expect(results[2].name).toBe('B');
     });
 });

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

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