@tstdl/base 0.93.145 → 0.93.146

package/orm/tests/repository-extra-coverage.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,21 +8,23 @@ 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 { sql } from 'drizzle-orm';
+import { beforeAll, beforeEach, describe, expect, test } from 'vitest';
 import { NotFoundError } from '../../errors/not-found.error.js';
-import { Injector, runInInjectionContext } from '../../injector/index.js';
 import { StringProperty } from '../../schema/index.js';
 import { dropTables, setupIntegrationTest, truncateTables } from '../../testing/index.js';
 import { toArrayAsync } from '../../utils/async-iterable-helpers/to-array.js';
-import { sql } from 'drizzle-orm';
-import { beforeAll, describe, expect, test } from 'vitest';
 import { ChildEntity, Column, Inheritance, Table } from '../decorators.js';
 import { BaseEntity, Entity } from '../entity.js';
-import { Database } from '../server/index.js';
-import { injectRepository } from '../server/repository.js';
+import { getRepository } from '../server/repository.js';
 import { ENCRYPTION_SECRET } from '../server/tokens.js';
 describe('ORM Repository Extra Coverage', () => {
     let injector;
     let database;
+    let baseItemRepo;
+    let premiumItemRepo;
+    let simpleItemRepo;
+    let plainItemRepo;
     const schema = 'test_orm_extra_coverage';
     let BaseItem = class BaseItem extends Entity {
         type;
@@ -78,6 +81,10 @@ describe('ORM Repository Extra Coverage', () => {
     beforeAll(async () => {
         ({ injector, database } = await setupIntegrationTest({ orm: { schema } }));
         injector.register(ENCRYPTION_SECRET, { useValue: new Uint8Array(32).fill(1) });
+        baseItemRepo = injector.resolve(getRepository(BaseItem));
+        premiumItemRepo = injector.resolve(getRepository(PremiumItem));
+        simpleItemRepo = injector.resolve(getRepository(SimpleItem));
+        plainItemRepo = injector.resolve(getRepository(PlainItem));
         await dropTables(database, schema, ['premium_items', 'items', 'simple_items', 'plain_items']);
         await database.execute(sql `
       CREATE TABLE ${sql.identifier(schema)}.${sql.identifier('items')} (
@@ -118,429 +125,280 @@ describe('ORM Repository Extra Coverage', () => {
       )
     `);
     });
-    test.beforeEach(async () => {
+    beforeEach(async () => {
         await truncateTables(database, schema, ['premium_items', 'items', 'simple_items', 'plain_items']);
     });
     test('loadManyCursor should work', async () => {
-        await runInInjectionContext(injector, async () => {
-            const repository = injectRepository(SimpleItem);
-            const item = await repository.insert(Object.assign(new SimpleItem(), { label: 'Cursor Test' }));
-            const cursor = repository.loadManyCursor([item.id]);
-            const results = await toArrayAsync(cursor);
-            expect(results).toHaveLength(1);
-            expect(results[0].id).toBe(item.id);
-        });
+        const item = await simpleItemRepo.insert(Object.assign(new SimpleItem(), { label: 'Cursor Test' }));
+        const cursor = simpleItemRepo.loadManyCursor([item.id]);
+        const results = await toArrayAsync(cursor);
+        expect(results).toHaveLength(1);
+        expect(results[0].id).toBe(item.id);
     });
     test('loadAllCursor should work', async () => {
-        await runInInjectionContext(injector, async () => {
-            const repository = injectRepository(SimpleItem);
-            await repository.insert(Object.assign(new SimpleItem(), { label: 'All Cursor Test' }));
-            const cursor = repository.loadAllCursor();
-            const results = await toArrayAsync(cursor);
-            expect(results.length).toBeGreaterThan(0);
-        });
+        await simpleItemRepo.insert(Object.assign(new SimpleItem(), { label: 'All Cursor Test' }));
+        const cursor = simpleItemRepo.loadAllCursor();
+        const results = await toArrayAsync(cursor);
+        expect(results.length).toBeGreaterThan(0);
     });
     test('tryLoadByQuery with order option', async () => {
-        await runInInjectionContext(injector, async () => {
-            const repository = injectRepository(SimpleItem);
-            await repository.insert(Object.assign(new SimpleItem(), { label: 'A' }));
-            await repository.insert(Object.assign(new SimpleItem(), { label: 'B' }));
-            const item = await repository.tryLoadByQuery({}, { order: { label: 'desc' } });
-            expect(item.label).toBe('B');
-        });
+        await simpleItemRepo.insert(Object.assign(new SimpleItem(), { label: 'A' }));
+        await simpleItemRepo.insert(Object.assign(new SimpleItem(), { label: 'B' }));
+        const item = await simpleItemRepo.tryLoadByQuery({}, { order: { label: 'desc' } });
+        expect(item.label).toBe('B');
     });
     test('insertManyIfNotExists with empty array', async () => {
-        await runInInjectionContext(injector, async () => {
-            const repository = injectRepository(SimpleItem);
-            const results = await repository.insertManyIfNotExists(['label'], []);
-            expect(results).toHaveLength(0);
-        });
+        const results = await simpleItemRepo.insertManyIfNotExists(['label'], []);
+        expect(results).toHaveLength(0);
     });
     test('insertManyIfNotExists with items', async () => {
-        await runInInjectionContext(injector, async () => {
-            const repository = injectRepository(SimpleItem);
-            const item = Object.assign(new SimpleItem(), { label: 'Unique' });
-            const results = await repository.insertManyIfNotExists(['label'], [item]);
-            expect(results).toHaveLength(1);
-            const results2 = await repository.insertManyIfNotExists(['label'], [item]);
-            expect(results2).toHaveLength(0);
-        });
+        const item = Object.assign(new SimpleItem(), { label: 'Unique' });
+        const results = await simpleItemRepo.insertManyIfNotExists(['label'], [item]);
+        expect(results).toHaveLength(1);
+        const results2 = await simpleItemRepo.insertManyIfNotExists(['label'], [item]);
+        expect(results2).toHaveLength(0);
     });
     test('tryInsert returning entity', async () => {
-        await runInInjectionContext(injector, async () => {
-            const repository = injectRepository(SimpleItem);
-            const item = Object.assign(new SimpleItem(), { label: 'TryInsert' });
-            const inserted = await repository.tryInsert(item);
-            expect(inserted).toBeDefined();
-            expect(inserted.label).toBe('TryInsert');
-            const conflict = await repository.tryInsert(inserted); // Should conflict on ID
-            expect(conflict).toBeUndefined();
-        });
+        const item = Object.assign(new SimpleItem(), { label: 'TryInsert' });
+        const inserted = await simpleItemRepo.tryInsert(item);
+        expect(inserted).toBeDefined();
+        expect(inserted.label).toBe('TryInsert');
+        const conflict = await simpleItemRepo.tryInsert(inserted); // Should conflict on ID
+        expect(conflict).toBeUndefined();
     });
     test('loadMany with empty array', async () => {
-        await runInInjectionContext(injector, async () => {
-            const repository = injectRepository(SimpleItem);
-            const results = await repository.loadMany([]);
-            expect(results).toHaveLength(0);
-        });
+        const results = await simpleItemRepo.loadMany([]);
+        expect(results).toHaveLength(0);
     });
     test('insertMany for non-CTI with empty array', async () => {
-        await runInInjectionContext(injector, async () => {
-            const repository = injectRepository(SimpleItem);
-            const results = await repository.insertMany([]);
-            expect(results).toHaveLength(0);
-        });
+        const results = await simpleItemRepo.insertMany([]);
+        expect(results).toHaveLength(0);
     });
     test('countByQuery returning count', async () => {
-        await runInInjectionContext(injector, async () => {
-            const repository = injectRepository(SimpleItem);
-            const initialCount = await repository.count();
-            await repository.insert(Object.assign(new SimpleItem(), { label: 'Count Test' }));
-            const newCount = await repository.count();
-            expect(newCount).toBe(initialCount + 1);
-        });
+        const initialCount = await simpleItemRepo.count();
+        await simpleItemRepo.insert(Object.assign(new SimpleItem(), { label: 'Count Test' }));
+        const newCount = await simpleItemRepo.count();
+        expect(newCount).toBe(initialCount + 1);
     });
     test('mapManyToColumns and mapManyToInsertColumns', async () => {
-        await runInInjectionContext(injector, async () => {
-            const repository = injectRepository(SimpleItem);
-            const item = Object.assign(new SimpleItem(), { label: 'Map Test' });
-            const cols = await repository.mapManyToColumns([item]);
-            expect(cols).toHaveLength(1);
-            expect(cols[0].label).toBe('Map Test');
-            const insertCols = await repository.mapManyToInsertColumns([item]);
-            expect(insertCols).toHaveLength(1);
-            expect(insertCols[0].label).toBe('Map Test');
-        });
+        const item = Object.assign(new SimpleItem(), { label: 'Map Test' });
+        const cols = await simpleItemRepo.mapManyToColumns([item]);
+        expect(cols).toHaveLength(1);
+        expect(cols[0].label).toBe('Map Test');
+        const insertCols = await simpleItemRepo.mapManyToInsertColumns([item]);
+        expect(insertCols).toHaveLength(1);
+        expect(insertCols[0].label).toBe('Map Test');
     });
     test('tryUpsert on non-CTI returning undefined when condition fails', async () => {
-        await runInInjectionContext(injector, async () => {
-            const repository = injectRepository(SimpleItem);
-            const item = await repository.insert(Object.assign(new SimpleItem(), { label: 'Upsert Condition' }));
-            const conflictItem = Object.assign(new SimpleItem(), { id: item.id, label: 'Should Fail' });
-            const result = await repository.tryUpsert(['id'], conflictItem, undefined, { set: { label: 'Impossible' } });
-            expect(result).toBeUndefined();
-        });
+        const item = await simpleItemRepo.insert(Object.assign(new SimpleItem(), { label: 'Upsert Condition' }));
+        const conflictItem = Object.assign(new SimpleItem(), { id: item.id, label: 'Should Fail' });
+        const result = await simpleItemRepo.tryUpsert(['id'], conflictItem, undefined, { set: { label: 'Impossible' } });
+        expect(result).toBeUndefined();
     });
     test('tryUpdateByQuery on non-CTI', async () => {
-        await runInInjectionContext(injector, async () => {
-            const repository = injectRepository(SimpleItem);
-            const item = await repository.insert(Object.assign(new SimpleItem(), { label: 'UpdateByQuery' }));
-            const result = await repository.tryUpdateByQuery({ label: 'UpdateByQuery' }, { label: 'UpdatedByQuery' });
-            expect(result).toBeDefined();
-            expect(result.label).toBe('UpdatedByQuery');
-            const result2 = await repository.tryUpdateByQuery({ label: 'Ghost' }, { label: 'Buster' });
-            expect(result2).toBeUndefined();
-        });
+        await simpleItemRepo.insert(Object.assign(new SimpleItem(), { label: 'UpdateByQuery' }));
+        const result = await simpleItemRepo.tryUpdateByQuery({ label: 'UpdateByQuery' }, { label: 'UpdatedByQuery' });
+        expect(result).toBeDefined();
+        expect(result.label).toBe('UpdatedByQuery');
+        const result2 = await simpleItemRepo.tryUpdateByQuery({ label: 'Ghost' }, { label: 'Buster' });
+        expect(result2).toBeUndefined();
     });
     test('tryDeleteByQuery on CTI', async () => {
-        await runInInjectionContext(injector, async () => {
-            const repository = injectRepository(PremiumItem);
-            const item = await repository.insert(Object.assign(new PremiumItem(), { name: 'DeleteMe', code: 'D1' }));
-            const result = await repository.tryDeleteByQuery({ name: 'DeleteMe' });
-            expect(result).toBeDefined();
-            expect(result.metadata.deleteTimestamp).not.toBeNull();
-            const result2 = await repository.tryDeleteByQuery({ name: 'Ghost' });
-            expect(result2).toBeUndefined();
-        });
+        const item = await premiumItemRepo.insert(Object.assign(new PremiumItem(), { name: 'DeleteMe', code: 'D1' }));
+        const result = await premiumItemRepo.tryDeleteByQuery({ name: 'DeleteMe' });
+        expect(result).toBeDefined();
+        expect(result.metadata.deleteTimestamp).not.toBeNull();
+        const result2 = await premiumItemRepo.tryDeleteByQuery({ name: 'Ghost' });
+        expect(result2).toBeUndefined();
     });
     test('getIdLimitQuery for update', async () => {
-        await runInInjectionContext(injector, async () => {
-            const repository = injectRepository(SimpleItem);
-            const query = repository.getIdLimitQuery({ label: 'Any' }).for('update');
-            expect(query).toBeDefined();
-        });
+        const query = simpleItemRepo.getIdLimitQuery({ label: 'Any' }).for('update');
+        expect(query).toBeDefined();
     });
     test('applySelect with distinct and distinctOn', async () => {
-        await runInInjectionContext(injector, async () => {
-            const repository = injectRepository(SimpleItem);
-            const q1 = repository.applySelect(database, true);
-            expect(q1).toBeDefined();
-            const q2 = repository.applySelect(database, ['label']);
-            expect(q2).toBeDefined();
-        });
+        const q1 = simpleItemRepo.applySelect(database, true);
+        expect(q1).toBeDefined();
+        const q2 = simpleItemRepo.applySelect(database, ['label']);
+        expect(q2).toBeDefined();
     });
     test('mapToColumns and mapToInsertColumns', async () => {
-        await runInInjectionContext(injector, async () => {
-            const repository = injectRepository(SimpleItem);
-            const item = Object.assign(new SimpleItem(), { label: 'Map Single' });
-            const col = await repository.mapToColumns(item);
-            expect(col.label).toBe('Map Single');
-            const insertCol = await repository.mapToInsertColumns(item);
-            expect(insertCol.label).toBe('Map Single');
-        });
+        const item = Object.assign(new SimpleItem(), { label: 'Map Single' });
+        const col = await simpleItemRepo.mapToColumns(item);
+        expect(col.label).toBe('Map Single');
+        const insertCol = await simpleItemRepo.mapToInsertColumns(item);
+        expect(insertCol.label).toBe('Map Single');
     });
     test('hasAll with duplicates and missing IDs', async () => {
-        await runInInjectionContext(injector, async () => {
-            const repository = injectRepository(SimpleItem);
-            const item = await repository.insert(Object.assign(new SimpleItem(), { label: 'HasAll' }));
-            expect(await repository.hasAll([item.id, item.id])).toBe(true);
-            expect(await repository.hasAll([item.id, '00000000-0000-0000-0000-000000000000'])).toBe(false);
-            expect(await repository.hasAll([])).toBe(false);
-        });
+        const item = await simpleItemRepo.insert(Object.assign(new SimpleItem(), { label: 'HasAll' }));
+        expect(await simpleItemRepo.hasAll([item.id, item.id])).toBe(true);
+        expect(await simpleItemRepo.hasAll([item.id, '00000000-0000-0000-0000-000000000000'])).toBe(false);
+        expect(await simpleItemRepo.hasAll([])).toBe(false);
     });
     test('loadManyByQueryCursor should work', async () => {
-        await runInInjectionContext(injector, async () => {
-            const repository = injectRepository(SimpleItem);
-            await repository.insert(Object.assign(new SimpleItem(), { label: 'Many Cursor' }));
-            const cursor = repository.loadManyByQueryCursor({ label: 'Many Cursor' });
-            const results = await toArrayAsync(cursor);
-            expect(results).toHaveLength(1);
-        });
+        await simpleItemRepo.insert(Object.assign(new SimpleItem(), { label: 'Many Cursor' }));
+        const cursor = simpleItemRepo.loadManyByQueryCursor({ label: 'Many Cursor' });
+        const results = await toArrayAsync(cursor);
+        expect(results).toHaveLength(1);
     });
     test('upsert (non-CTI) with wheres', async () => {
-        await runInInjectionContext(injector, async () => {
-            const repository = injectRepository(SimpleItem);
-            const item = await repository.insert(Object.assign(new SimpleItem(), { label: 'Upsert' }));
-            // This should succeed
-            const upserted = await repository.upsert(['label'], Object.assign(new SimpleItem(), { label: 'Upsert' }), { label: 'Upsert Updated' }, { set: { label: 'Upsert' } });
-            expect(upserted.label).toBe('Upsert Updated');
-            // This should fail to return a row due to condition
-            await expect(repository.upsert(['label'], Object.assign(new SimpleItem(), { label: 'Upsert Updated' }), { label: 'Should Not Happen' }, { set: { label: 'Wrong' } }))
-                .rejects.toThrow('upsert failed to return a row');
-        });
+        const item = await simpleItemRepo.insert(Object.assign(new SimpleItem(), { label: 'Upsert' }));
+        // This should succeed
+        const upserted = await simpleItemRepo.upsert(['label'], Object.assign(new SimpleItem(), { label: 'Upsert' }), { label: 'Upsert Updated' }, { set: { label: 'Upsert' } });
+        expect(upserted.label).toBe('Upsert Updated');
+        // This should fail to return a row due to condition
+        await expect(simpleItemRepo.upsert(['label'], Object.assign(new SimpleItem(), { label: 'Upsert Updated' }), { label: 'Should Not Happen' }, { set: { label: 'Wrong' } }))
+            .rejects.toThrow('upsert failed to return a row');
     });
     test('updateMany (non-CTI) with empty array', async () => {
-        await runInInjectionContext(injector, async () => {
-            const repository = injectRepository(SimpleItem);
-            expect(await repository.updateMany([], { label: 'None' })).toEqual([]);
-        });
+        expect(await simpleItemRepo.updateMany([], { label: 'None' })).toEqual([]);
     });
     test('hardDeleteByQuery throws NotFoundError', async () => {
-        await runInInjectionContext(injector, async () => {
-            const repository = injectRepository(SimpleItem);
-            await expect(repository.hardDeleteByQuery({ label: 'Ghost' })).rejects.toThrow('SimpleItem not found');
-        });
+        await expect(simpleItemRepo.hardDeleteByQuery({ label: 'Ghost' })).rejects.toThrow('SimpleItem not found');
     });
     test('hardDeleteMany with empty array', async () => {
-        await runInInjectionContext(injector, async () => {
-            const repository = injectRepository(SimpleItem);
-            expect(await repository.hardDeleteMany([])).toEqual([]);
-        });
+        expect(await simpleItemRepo.hardDeleteMany([])).toEqual([]);
     });
     test('convertOrderBy with various inputs', async () => {
-        await runInInjectionContext(injector, async () => {
-            const repository = injectRepository(SimpleItem);
-            expect(repository.convertOrderBy('label')).toBeDefined();
-            expect(repository.convertOrderBy(['label', ['id', 'desc']])).toHaveLength(2);
-            expect(repository.convertOrderBy(sql `label`)).toHaveLength(1);
-        });
+        expect(simpleItemRepo.convertOrderBy('label')).toBeDefined();
+        expect(simpleItemRepo.convertOrderBy(['label', ['id', 'desc']])).toHaveLength(2);
+        expect(simpleItemRepo.convertOrderBy(sql `label`)).toHaveLength(1);
     });
     test('mapManyToEntity and mapToEntity with subclasses', async () => {
-        await runInInjectionContext(injector, async () => {
-            const repository = injectRepository(BaseItem);
-            const item = await injectRepository(PremiumItem).insert(Object.assign(new PremiumItem(), { name: 'P1', code: 'C1' }));
-            const polymorphic = await repository.load(item.id, { includeSubclasses: true });
-            expect(polymorphic).toBeInstanceOf(PremiumItem);
-            const rows = await database.execute(sql `SELECT * FROM ${sql.identifier(schema)}.${sql.identifier('items')} i LEFT JOIN ${sql.identifier(schema)}.${sql.identifier('premium_items')} p ON i.id = p.id`);
-            // We need to manually construct the polymorphic row structure if we want to test mapManyToEntity directly with subclasses
-            // But loadAll({ includeSubclasses: true }) already does this.
-        });
+        const item = await premiumItemRepo.insert(Object.assign(new PremiumItem(), { name: 'P1', code: 'C1' }));
+        const polymorphic = await baseItemRepo.load(item.id, { includeSubclasses: true });
+        expect(polymorphic).toBeInstanceOf(PremiumItem);
+        // We need to manually construct the polymorphic row structure if we want to test mapManyToEntity directly with subclasses
+        // But loadAll({ includeSubclasses: true }) already does this.
     });
     test('tryUpdateCTI with no changes', async () => {
-        await runInInjectionContext(injector, async () => {
-            const repository = injectRepository(PremiumItem);
-            const item = await repository.insert(Object.assign(new PremiumItem(), { name: 'NoChange', code: 'NC' }));
-            const updated = await repository.tryUpdate(item.id, {});
-            expect(updated.id).toBe(item.id);
-        });
+        const item = await premiumItemRepo.insert(Object.assign(new PremiumItem(), { name: 'NoChange', code: 'NC' }));
+        const updated = await premiumItemRepo.tryUpdate(item.id, {});
+        expect(updated.id).toBe(item.id);
     });
     test('tsvector search with various options', async () => {
-        await runInInjectionContext(injector, async () => {
-            const repository = injectRepository(SimpleItem);
-            await repository.insert(Object.assign(new SimpleItem(), { label: 'Search Item' }));
-            // score: false
-            const r1 = await repository.search({
-                query: { $tsvector: { fields: ['label'], query: 'Search' } },
-                score: false,
-            });
-            expect(r1[0].score).toBeUndefined();
-            // highlight variants
-            const r2 = await repository.search({
-                query: { $tsvector: { fields: ['label'], query: 'Search' } },
-                highlight: 'label',
-            });
-            expect(r2[0].highlight).toBeDefined();
-            const r3 = await repository.search({
-                query: { $tsvector: { fields: ['label'], query: 'Search' } },
-                highlight: { source: sql `label`, minWords: 5, maxWords: 10 },
-            });
-            expect(r3[0].highlight).toBeDefined();
-            // offset and limit
-            const r4 = await repository.search({
-                query: { $tsvector: { fields: ['label'], query: 'Search' } },
-                offset: 0,
-                limit: 1,
-            });
-            expect(r4).toHaveLength(1);
-        });
+        await simpleItemRepo.insert(Object.assign(new SimpleItem(), { label: 'Search Item' }));
+        // score: false
+        const r1 = await simpleItemRepo.search({
+            query: { $tsvector: { fields: ['label'], query: 'Search' } },
+            score: false,
+        });
+        expect(r1[0].score).toBeUndefined();
+        // highlight variants
+        const r2 = await simpleItemRepo.search({
+            query: { $tsvector: { fields: ['label'], query: 'Search' } },
+            highlight: 'label',
+        });
+        expect(r2[0].highlight).toBeDefined();
+        const r3 = await simpleItemRepo.search({
+            query: { $tsvector: { fields: ['label'], query: 'Search' } },
+            highlight: { source: sql `label`, minWords: 5, maxWords: 10 },
+        });
+        expect(r3[0].highlight).toBeDefined();
+        // offset and limit
+        const r4 = await simpleItemRepo.search({
+            query: { $tsvector: { fields: ['label'], query: 'Search' } },
+            offset: 0,
+            limit: 1,
+        });
+        expect(r4).toHaveLength(1);
     });
     test('trigram search with rank: false', async () => {
-        await runInInjectionContext(injector, async () => {
-            const repository = injectRepository(SimpleItem);
-            await repository.insert(Object.assign(new SimpleItem(), { label: 'Trigram' }));
-            const results = await repository.search({
-                query: { $trigram: { fields: ['label'], query: 'Trigram' } },
-                rank: false,
-            });
-            expect(results).toHaveLength(1);
+        await simpleItemRepo.insert(Object.assign(new SimpleItem(), { label: 'Trigram' }));
+        const results = await simpleItemRepo.search({
+            query: { $trigram: { fields: ['label'], query: 'Trigram' } },
+            rank: false,
         });
+        expect(results).toHaveLength(1);
     });
     test('PlainItem (no metadata) operations', async () => {
-        await runInInjectionContext(injector, async () => {
-            const repository = injectRepository(PlainItem);
-            const item = await repository.insert(Object.assign(new PlainItem(), { description: 'Plain' }));
-            expect(repository.hasMetadata).toBe(false);
-            const deleted = await repository.delete(item.id);
-            expect(deleted.description).toBe('Plain');
-            const exists = await repository.has(item.id);
-            expect(exists).toBe(false);
-        });
+        const item = await plainItemRepo.insert(Object.assign(new PlainItem(), { description: 'Plain' }));
+        expect(plainItemRepo.hasMetadata).toBe(false);
+        const deleted = await plainItemRepo.delete(item.id);
+        expect(deleted.description).toBe('Plain');
+        const exists = await plainItemRepo.has(item.id);
+        expect(exists).toBe(false);
     });
     test('convertOrderBy with object', async () => {
-        await runInInjectionContext(injector, async () => {
-            const repository = injectRepository(SimpleItem);
-            const order = repository.convertOrderBy({ label: 'desc' });
-            expect(order).toHaveLength(1);
-        });
+        const order = simpleItemRepo.convertOrderBy({ label: 'desc' });
+        expect(order).toHaveLength(1);
     });
     test('tryHardDelete returning undefined', async () => {
-        await runInInjectionContext(injector, async () => {
-            const repository = injectRepository(SimpleItem);
-            const result = await repository.tryHardDelete('00000000-0000-0000-0000-000000000000');
-            expect(result).toBeUndefined();
-        });
+        const result = await simpleItemRepo.tryHardDelete('00000000-0000-0000-0000-000000000000');
+        expect(result).toBeUndefined();
     });
     test('tryHardDeleteByQuery returning undefined', async () => {
-        await runInInjectionContext(injector, async () => {
-            const repository = injectRepository(SimpleItem);
-            const result = await repository.tryHardDeleteByQuery({ label: 'Ghost' });
-            expect(result).toBeUndefined();
-        });
+        const result = await simpleItemRepo.tryHardDeleteByQuery({ label: 'Ghost' });
+        expect(result).toBeUndefined();
     });
     test('hardDeleteMany with empty array branch', async () => {
-        await runInInjectionContext(injector, async () => {
-            const repository = injectRepository(SimpleItem);
-            const results = await repository.hardDeleteMany([]);
-            expect(results).toEqual([]);
-        });
+        const results = await simpleItemRepo.hardDeleteMany([]);
+        expect(results).toEqual([]);
     });
     test('hardDeleteManyByQuery works', async () => {
-        await runInInjectionContext(injector, async () => {
-            const repository = injectRepository(SimpleItem);
-            await repository.insert(Object.assign(new SimpleItem(), { label: 'To Hard Delete' }));
-            const results = await repository.hardDeleteManyByQuery({ label: 'To Hard Delete' });
-            expect(results).toHaveLength(1);
-        });
+        await simpleItemRepo.insert(Object.assign(new SimpleItem(), { label: 'To Hard Delete' }));
+        const results = await simpleItemRepo.hardDeleteManyByQuery({ label: 'To Hard Delete' });
+        expect(results).toHaveLength(1);
     });
     test('applySelect with false (default)', async () => {
-        await runInInjectionContext(injector, async () => {
-            const repository = injectRepository(SimpleItem);
-            const q = repository.applySelect(database, undefined, false);
-            expect(q).toBeDefined();
-        });
+        const q = simpleItemRepo.applySelect(database, undefined, false);
+        expect(q).toBeDefined();
     });
     test('load should throw NotFoundError', async () => {
-        await runInInjectionContext(injector, async () => {
-            const repository = injectRepository(SimpleItem);
-            await expect(repository.load('00000000-0000-0000-0000-000000000000')).rejects.toThrow(NotFoundError);
-        });
+        await expect(simpleItemRepo.load('00000000-0000-0000-0000-000000000000')).rejects.toThrow(NotFoundError);
     });
     test('tsvector search with rank number', async () => {
-        await runInInjectionContext(injector, async () => {
-            const repository = injectRepository(SimpleItem);
-            await repository.insert(Object.assign(new SimpleItem(), { label: 'Rank' }));
-            const results = await repository.search({
-                query: { $tsvector: { fields: ['label'], query: 'Rank' } },
-                rank: { normalization: 1 }, // normalization
-            });
-            expect(results).toHaveLength(1);
+        await simpleItemRepo.insert(Object.assign(new SimpleItem(), { label: 'Rank' }));
+        const results = await simpleItemRepo.search({
+            query: { $tsvector: { fields: ['label'], query: 'Rank' } },
+            rank: { normalization: 1 }, // normalization
         });
+        expect(results).toHaveLength(1);
     });
     test('encryptionSecret usage in getTransformContext', async () => {
-        await runInInjectionContext(injector, async () => {
-            await runInInjectionContext(injector, async () => {
-                const repository = injectRepository(SimpleItem);
-                const context = await repository.getTransformContext();
-                expect(context.encryptionKey).toBeDefined();
-                // Call it again to hit the cached branch
-                const context2 = await repository.getTransformContext();
-                expect(context2).toBe(context);
-            });
-        });
+        const context = await simpleItemRepo.getTransformContext();
+        expect(context.encryptionKey).toBeDefined();
+        // Call it again to hit the cached branch
+        const context2 = await simpleItemRepo.getTransformContext();
+        expect(context2).toBe(context);
     });
     test('tsvector search with rank true/false', async () => {
-        await runInInjectionContext(injector, async () => {
-            const repository = injectRepository(SimpleItem);
-            await repository.insert(Object.assign(new SimpleItem(), { label: 'Rank' }));
-            await repository.search({
-                query: { $tsvector: { fields: ['label'], query: 'Rank' } },
-                rank: true,
-            });
-            await repository.search({
-                query: { $tsvector: { fields: ['label'], query: 'Rank' } },
-                rank: false,
-            });
+        await simpleItemRepo.insert(Object.assign(new SimpleItem(), { label: 'Rank' }));
+        await simpleItemRepo.search({
+            query: { $tsvector: { fields: ['label'], query: 'Rank' } },
+            rank: true,
+        });
+        await simpleItemRepo.search({
+            query: { $tsvector: { fields: ['label'], query: 'Rank' } },
+            rank: false,
         });
     });
     test('trigram search with threshold', async () => {
-        await runInInjectionContext(injector, async () => {
-            const repository = injectRepository(SimpleItem);
-            await repository.insert(Object.assign(new SimpleItem(), { label: 'Trigram Threshold' }));
-            await database.execute(sql `SET pg_trgm.similarity_threshold = 0.1`);
-            const results = await repository.search({
-                query: { $trigram: { fields: ['label'], query: 'Trigram', threshold: 0.1 } },
-            });
-            expect(results).toHaveLength(1);
+        await simpleItemRepo.insert(Object.assign(new SimpleItem(), { label: 'Trigram Threshold' }));
+        await database.execute(sql `SET pg_trgm.similarity_threshold = 0.1`);
+        const results = await simpleItemRepo.search({
+            query: { $trigram: { fields: ['label'], query: 'Trigram', threshold: 0.1 } },
         });
+        expect(results).toHaveLength(1);
     });
     test('repository resolution inside transaction', async () => {
-        await database.transaction(async (transaction) => {
-            await runInInjectionContext(injector, async () => {
-                const repository = injectRepository(SimpleItem, transaction);
-                expect(repository).toBeDefined();
-            });
+        await simpleItemRepo.transaction(async (transaction) => {
+            const repository = injector.resolve(getRepository(SimpleItem)).withTransaction(transaction);
+            expect(repository).toBeDefined();
         });
     });
     test('updateManyCTI with no matches', async () => {
-        await runInInjectionContext(injector, async () => {
-            const repository = injectRepository(PremiumItem);
-            const results = await repository.updateMany(['00000000-0000-0000-0000-000000000000'], { name: 'Ghost' });
-            expect(results).toEqual([]);
-        });
+        const results = await premiumItemRepo.updateMany(['00000000-0000-0000-0000-000000000000'], { name: 'Ghost' });
+        expect(results).toEqual([]);
     });
     test('upsertMany on CTI with wheres and update object', async () => {
-        await runInInjectionContext(injector, async () => {
-            const repository = injectRepository(PremiumItem);
-            const item = await repository.insert(Object.assign(new PremiumItem(), { name: 'UpsertManyCTI', code: 'U1' }));
-            const conflictItem = Object.assign(new PremiumItem(), { id: item.id, name: 'UpsertManyCTI', code: 'U1' });
-            const results = await repository.upsertMany(['id'], [conflictItem], { name: 'UpsertManyCTI Updated', code: 'U2' }, { target: { name: 'UpsertManyCTI' } });
-            expect(results).toHaveLength(1);
-            expect(results[0].name).toBe('UpsertManyCTI Updated');
-            expect(results[0].code).toBe('U2');
-        });
-    });
-    test('updateManyCTI with no matches', async () => {
-        await runInInjectionContext(injector, async () => {
-            const repository = injectRepository(PremiumItem);
-            const results = await repository.updateMany(['00000000-0000-0000-0000-000000000000'], { name: 'Ghost' });
-            expect(results).toEqual([]);
-        });
-    });
-    test('upsertMany on CTI with wheres and update object', async () => {
-        await runInInjectionContext(injector, async () => {
-            const repository = injectRepository(PremiumItem);
-            const item = await repository.insert(Object.assign(new PremiumItem(), { name: 'UpsertManyCTI', code: 'U1' }));
-            const conflictItem = Object.assign(new PremiumItem(), { id: item.id, name: 'UpsertManyCTI', code: 'U1' });
-            const results = await repository.upsertMany(['id'], [conflictItem], { name: 'UpsertManyCTI Updated', code: 'U2' }, { target: { name: 'UpsertManyCTI' } });
-            expect(results).toHaveLength(1);
-            expect(results[0].name).toBe('UpsertManyCTI Updated');
-            expect(results[0].code).toBe('U2');
-        });
+        const item = await premiumItemRepo.insert(Object.assign(new PremiumItem(), { name: 'UpsertManyCTI', code: 'U1' }));
+        const conflictItem = Object.assign(new PremiumItem(), { id: item.id, name: 'UpsertManyCTI', code: 'U1' });
+        const results = await premiumItemRepo.upsertMany(['id'], [conflictItem], { name: 'UpsertManyCTI Updated', code: 'U2' }, { target: { name: 'UpsertManyCTI' } });
+        expect(results).toHaveLength(1);
+        expect(results[0].name).toBe('UpsertManyCTI Updated');
+        expect(results[0].code).toBe('U2');
     });
     test('processExpirations with no expiration columns', async () => {
-        await runInInjectionContext(injector, async () => {
-            const repository = injectRepository(SimpleItem);
-            await repository.processExpirations(); // Should just return
-        });
+        await simpleItemRepo.processExpirations(); // Should just return
     });
 });