@tstdl/base 0.93.145 → 0.93.146

package/notification/tests/notification-type.service.test.js

@@ -1,5 +1,4 @@
 import { afterEach, beforeEach, describe, expect, test } from 'vitest';
-import { runInInjectionContext } from '../../injector/index.js';
 import { setupIntegrationTest, truncateTables } from '../../testing/index.js';
 import { NotificationTypeService } from '../server/services/notification-type.service.js';
 describe('NotificationTypeService', () => {
@@ -21,24 +20,22 @@ describe('NotificationTypeService', () => {
             [type1]: { label: 'Type 1' },
             [type2]: { label: 'Type 2', throttling: { limit: 1, interval: 1000 } }
         };
-        await runInInjectionContext(injector, async () => {
-            const result = await service.initializeTypes(typeData);
-            expect(result[type1]?.label).toBe('Type 1');
-            expect(result[type2]?.key).toBe(type2);
-            expect(result[type2]?.throttling?.limit).toBe(1);
-            // Verify persistence
-            const dbTypes = await service.repository.loadManyByQuery({ key: { $in: [type1, type2] } });
-            expect(dbTypes).toHaveLength(2);
-            // Update
-            const updatedData = {
-                [type1]: { label: 'Type 1 Updated' },
-                [type2]: { label: 'Type 2', throttling: { limit: 1, interval: 1000 } }
-            };
-            const resultUpdated = await service.initializeTypes(updatedData);
-            expect(resultUpdated[type1]?.label).toBe('Type 1 Updated');
-            const dbTypesUpdated = await service.repository.loadManyByQuery({ key: { $in: [type1, type2] } });
-            expect(dbTypesUpdated).toHaveLength(2);
-            expect(dbTypesUpdated.find((c) => c.key == type1)?.label).toBe('Type 1 Updated');
-        });
+        const result = await service.initializeTypes(typeData);
+        expect(result[type1]?.label).toBe('Type 1');
+        expect(result[type2]?.key).toBe(type2);
+        expect(result[type2]?.throttling?.limit).toBe(1);
+        // Verify persistence
+        const dbTypes = await service.repository.loadManyByQuery({ key: { $in: [type1, type2] } });
+        expect(dbTypes).toHaveLength(2);
+        // Update
+        const updatedData = {
+            [type1]: { label: 'Type 1 Updated' },
+            [type2]: { label: 'Type 2', throttling: { limit: 1, interval: 1000 } }
+        };
+        const resultUpdated = await service.initializeTypes(updatedData);
+        expect(resultUpdated[type1]?.label).toBe('Type 1 Updated');
+        const dbTypesUpdated = await service.repository.loadManyByQuery({ key: { $in: [type1, type2] } });
+        expect(dbTypesUpdated).toHaveLength(2);
+        expect(dbTypesUpdated.find((c) => c.key == type1)?.label).toBe('Type 1 Updated');
     });
 });

package/orm/tests/query-complex.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 { 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 Query Complex (Integration)', () => {
     let injector;
     let db;
+    let repo;
     const schema = 'test_orm_query_complex';
     let QueryEntity = class QueryEntity extends Entity {
         tag;
@@ -40,14 +40,10 @@ describe('ORM Query Complex (Integration)', () => {
         Table('query_entities', { schema })
     ], QueryEntity);
     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(QueryEntity));
         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('query_entities')} CASCADE`);
         await db.execute(sql `
@@ -66,138 +62,111 @@ describe('ORM Query Complex (Integration)', () => {
     });
     test('should support nested AND/OR logic', async () => {
         await db.execute(sql `TRUNCATE TABLE ${sql.identifier(schema)}.${sql.identifier('query_entities')} CASCADE`);
-        await runInInjectionContext(injector, async () => {
-            const repo = injectRepository(QueryEntity);
-            await repo.insertMany([
-                Object.assign(new QueryEntity(), { tag: 'A', score: 10, status: 'active' }),
-                Object.assign(new QueryEntity(), { tag: 'A', score: 20, status: 'inactive' }),
-                Object.assign(new QueryEntity(), { tag: 'B', score: 10, status: 'active' }),
-                Object.assign(new QueryEntity(), { tag: 'B', score: 20, status: 'inactive' }),
-            ]);
-            // (Tag A AND Active) OR (Tag B AND Inactive)
-            const results = await repo.loadManyByQuery({
-                $or: [
-                    { $and: [{ tag: 'A' }, { status: 'active' }] },
-                    { $and: [{ tag: 'B' }, { status: 'inactive' }] },
-                ],
-            });
-            expect(results).toHaveLength(2);
-            expect(results.some((r) => r.tag === 'A' && r.status === 'active')).toBe(true);
-            expect(results.some((r) => r.tag === 'B' && r.status === 'inactive')).toBe(true);
+        await repo.insertMany([
+            Object.assign(new QueryEntity(), { tag: 'A', score: 10, status: 'active' }),
+            Object.assign(new QueryEntity(), { tag: 'A', score: 20, status: 'inactive' }),
+            Object.assign(new QueryEntity(), { tag: 'B', score: 10, status: 'active' }),
+            Object.assign(new QueryEntity(), { tag: 'B', score: 20, status: 'inactive' }),
+        ]);
+        // (Tag A AND Active) OR (Tag B AND Inactive)
+        const results = await repo.loadManyByQuery({
+            $or: [
+                { $and: [{ tag: 'A' }, { status: 'active' }] },
+                { $and: [{ tag: 'B' }, { status: 'inactive' }] },
+            ],
         });
+        expect(results).toHaveLength(2);
+        expect(results.some((r) => r.tag === 'A' && r.status === 'active')).toBe(true);
+        expect(results.some((r) => r.tag === 'B' && r.status === 'inactive')).toBe(true);
     });
     test('should support implicit AND', async () => {
         await db.execute(sql `TRUNCATE TABLE ${sql.identifier(schema)}.${sql.identifier('query_entities')} CASCADE`);
-        await runInInjectionContext(injector, async () => {
-            const repo = injectRepository(QueryEntity);
-            await repo.insert(Object.assign(new QueryEntity(), { tag: 'A', score: 10, status: 'active' }));
-            const results = await repo.loadManyByQuery({
-                tag: 'A',
-                score: 10,
-                status: 'active',
-            });
-            expect(results).toHaveLength(1);
+        await repo.insert(Object.assign(new QueryEntity(), { tag: 'A', score: 10, status: 'active' }));
+        const results = await repo.loadManyByQuery({
+            tag: 'A',
+            score: 10,
+            status: 'active',
         });
+        expect(results).toHaveLength(1);
     });
     test('should support NOT operator', async () => {
         await db.execute(sql `TRUNCATE TABLE ${sql.identifier(schema)}.${sql.identifier('query_entities')} CASCADE`);
-        await runInInjectionContext(injector, async () => {
-            const repo = injectRepository(QueryEntity);
-            await repo.insertMany([
-                Object.assign(new QueryEntity(), { tag: 'A', score: 10, status: 'active' }),
-                Object.assign(new QueryEntity(), { tag: 'B', score: 20, status: 'inactive' }),
-            ]);
-            const results = await repo.loadManyByQuery({
-                tag: { $not: { $eq: 'A' } },
-            });
-            expect(results).toHaveLength(1);
-            expect(results[0].tag).toBe('B');
+        await repo.insertMany([
+            Object.assign(new QueryEntity(), { tag: 'A', score: 10, status: 'active' }),
+            Object.assign(new QueryEntity(), { tag: 'B', score: 20, status: 'inactive' }),
+        ]);
+        const results = await repo.loadManyByQuery({
+            tag: { $not: { $eq: 'A' } },
         });
+        expect(results).toHaveLength(1);
+        expect(results[0].tag).toBe('B');
     });
     test('should support IN operator with empty array (should match nothing)', async () => {
         await db.execute(sql `TRUNCATE TABLE ${sql.identifier(schema)}.${sql.identifier('query_entities')} CASCADE`);
-        await runInInjectionContext(injector, async () => {
-            const repo = injectRepository(QueryEntity);
-            await repo.insert(Object.assign(new QueryEntity(), { tag: 'A', score: 10, status: 'active' }));
-            const results = await repo.loadManyByQuery({
-                tag: { $in: [] },
-            });
-            expect(results).toHaveLength(0);
+        await repo.insert(Object.assign(new QueryEntity(), { tag: 'A', score: 10, status: 'active' }));
+        const results = await repo.loadManyByQuery({
+            tag: { $in: [] },
         });
+        expect(results).toHaveLength(0);
     });
     test('should support NOT IN operator with empty array (should match everything)', async () => {
         await db.execute(sql `TRUNCATE TABLE ${sql.identifier(schema)}.${sql.identifier('query_entities')} CASCADE`);
-        await runInInjectionContext(injector, async () => {
-            const repo = injectRepository(QueryEntity);
-            await repo.insert(Object.assign(new QueryEntity(), { tag: 'A', score: 10, status: 'active' }));
-            const results = await repo.loadManyByQuery({
-                tag: { $nin: [] },
-            });
-            expect(results).toHaveLength(1);
+        await repo.insert(Object.assign(new QueryEntity(), { tag: 'A', score: 10, status: 'active' }));
+        const results = await repo.loadManyByQuery({
+            tag: { $nin: [] },
         });
+        expect(results).toHaveLength(1);
     });
     test('should support REGEX operator', async () => {
         await db.execute(sql `TRUNCATE TABLE ${sql.identifier(schema)}.${sql.identifier('query_entities')} CASCADE`);
-        await runInInjectionContext(injector, async () => {
-            const repo = injectRepository(QueryEntity);
-            await repo.insertMany([
-                Object.assign(new QueryEntity(), { tag: 'apple', score: 10, status: '' }),
-                Object.assign(new QueryEntity(), { tag: 'banana', score: 10, status: '' }),
-                Object.assign(new QueryEntity(), { tag: 'apricot', score: 10, status: '' }),
-            ]);
-            const results = await repo.loadManyByQuery({
-                tag: { $regex: '^ap' },
-            });
-            expect(results).toHaveLength(2); // apple, apricot
+        await repo.insertMany([
+            Object.assign(new QueryEntity(), { tag: 'apple', score: 10, status: '' }),
+            Object.assign(new QueryEntity(), { tag: 'banana', score: 10, status: '' }),
+            Object.assign(new QueryEntity(), { tag: 'apricot', score: 10, status: '' }),
+        ]);
+        const results = await repo.loadManyByQuery({
+            tag: { $regex: '^ap' },
         });
+        expect(results).toHaveLength(2); // apple, apricot
     });
     test('should support complex combination of logic and comparison', async () => {
         await db.execute(sql `TRUNCATE TABLE ${sql.identifier(schema)}.${sql.identifier('query_entities')} CASCADE`);
-        await runInInjectionContext(injector, async () => {
-            const repo = injectRepository(QueryEntity);
-            await repo.insertMany([
-                Object.assign(new QueryEntity(), { tag: 'A', score: 5, status: 'ok' }),
-                Object.assign(new QueryEntity(), { tag: 'A', score: 15, status: 'ok' }),
-                Object.assign(new QueryEntity(), { tag: 'A', score: 25, status: 'fail' }),
-                Object.assign(new QueryEntity(), { tag: 'B', score: 5, status: 'ok' }),
-            ]);
-            // Tag A AND (Score > 10 AND Score < 20) AND Status != fail
-            const results = await repo.loadManyByQuery({
-                tag: 'A',
-                $and: [{ score: { $gt: 10 } }, { score: { $lt: 20 } }],
-                status: { $neq: 'fail' },
-            });
-            expect(results).toHaveLength(1);
-            expect(results[0].score).toBe(15);
+        await repo.insertMany([
+            Object.assign(new QueryEntity(), { tag: 'A', score: 5, status: 'ok' }),
+            Object.assign(new QueryEntity(), { tag: 'A', score: 15, status: 'ok' }),
+            Object.assign(new QueryEntity(), { tag: 'A', score: 25, status: 'fail' }),
+            Object.assign(new QueryEntity(), { tag: 'B', score: 5, status: 'ok' }),
+        ]);
+        // Tag A AND (Score > 10 AND Score < 20) AND Status != fail
+        const results = await repo.loadManyByQuery({
+            tag: 'A',
+            $and: [{ score: { $gt: 10 } }, { score: { $lt: 20 } }],
+            status: { $neq: 'fail' },
         });
+        expect(results).toHaveLength(1);
+        expect(results[0].score).toBe(15);
     });
     test('should support NULL check', async () => {
         await db.execute(sql `TRUNCATE TABLE ${sql.identifier(schema)}.${sql.identifier('query_entities')} CASCADE`);
-        await runInInjectionContext(injector, async () => {
-            const repo = injectRepository(QueryEntity);
-            // Manually insert null status (violates NOT NULL usually, but let's assume nullable if we could change schema,
-            // but Entity defines it as string. We can query for null even if no rows can be null (result 0) OR if we use a nullable column).
-            // 'attributes' is JSONB and can be queried.
-            // But query-converter maps properties.
-            // Let's use a non-existent value for $eq which is different from null.
-            // But checking $eq: null generates IS NULL.
-            // Since our columns are NOT NULL, it should return empty.
-            await repo.insert(Object.assign(new QueryEntity(), { tag: 'A', score: 10, status: 'active' }));
-            const results = await repo.loadManyByQuery({
-                status: { $eq: null },
-            });
-            expect(results).toHaveLength(0);
+        // Manually insert null status (violates NOT NULL usually, but let's assume nullable if we could change schema,
+        // but Entity defines it as string. We can query for null even if no rows can be null (result 0) OR if we use a nullable column).
+        // 'attributes' is JSONB and can be queried.
+        // But query-converter maps properties.
+        // Let's use a non-existent value for $eq which is different from null.
+        // But checking $eq: null generates IS NULL.
+        // Since our columns are NOT NULL, it should return empty.
+        await repo.insert(Object.assign(new QueryEntity(), { tag: 'A', score: 10, status: 'active' }));
+        const results = await repo.loadManyByQuery({
+            status: { $eq: null },
         });
+        expect(results).toHaveLength(0);
     });
     test('should support NOT NULL check', async () => {
         await db.execute(sql `TRUNCATE TABLE ${sql.identifier(schema)}.${sql.identifier('query_entities')} CASCADE`);
-        await runInInjectionContext(injector, async () => {
-            const repo = injectRepository(QueryEntity);
-            await repo.insert(Object.assign(new QueryEntity(), { tag: 'A', score: 10, status: 'active' }));
-            const results = await repo.loadManyByQuery({
-                status: { $neq: null },
-            });
-            expect(results).toHaveLength(1);
+        await repo.insert(Object.assign(new QueryEntity(), { tag: 'A', score: 10, status: 'active' }));
+        const results = await repo.loadManyByQuery({
+            status: { $neq: null },
         });
+        expect(results).toHaveLength(1);
     });
 });

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

@@ -7,18 +7,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 { Integer, StringProperty } from '../../schema/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 { Integer, StringProperty } from '../../schema/index.js';
+import { setupIntegrationTest } from '../../testing/index.js';
+import { toArrayAsync } from '../../utils/async-iterable-helpers/to-array.js';
 import { 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 Advanced (Integration)', () => {
     let injector;
     let db;
+    let repository;
     const schema = 'test_orm_advanced';
     let AdvancedEntity = class AdvancedEntity extends Entity {
         name;
@@ -36,14 +36,10 @@ describe('ORM Repository Advanced (Integration)', () => {
         Table('advanced_entities', { schema })
     ], AdvancedEntity);
     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(AdvancedEntity));
         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('advanced_entities')} CASCADE`);
         await db.execute(sql `
@@ -61,172 +57,133 @@ describe('ORM Repository Advanced (Integration)', () => {
     });
     test('should support loadManyCursor', async () => {
         await db.execute(sql `TRUNCATE TABLE ${sql.identifier(schema)}.${sql.identifier('advanced_entities')} CASCADE`);
-        await runInInjectionContext(injector, async () => {
-            const repository = injectRepository(AdvancedEntity);
-            const e1 = await repository.insert(Object.assign(new AdvancedEntity(), { name: 'E1', value: 1 }));
-            const e2 = await repository.insert(Object.assign(new AdvancedEntity(), { name: 'E2', value: 2 }));
-            const cursor = repository.loadManyCursor([e1.id, e2.id]);
-            const results = await toArrayAsync(cursor);
-            expect(results).toHaveLength(2);
-            expect(results.map((r) => r.name).sort()).toEqual(['E1', 'E2']);
-        });
+        const e1 = await repository.insert(Object.assign(new AdvancedEntity(), { name: 'E1', value: 1 }));
+        const e2 = await repository.insert(Object.assign(new AdvancedEntity(), { name: 'E2', value: 2 }));
+        const cursor = repository.loadManyCursor([e1.id, e2.id]);
+        const results = await toArrayAsync(cursor);
+        expect(results).toHaveLength(2);
+        expect(results.map((r) => r.name).sort()).toEqual(['E1', 'E2']);
     });
     test('should support loadAllCursor', async () => {
         await db.execute(sql `TRUNCATE TABLE ${sql.identifier(schema)}.${sql.identifier('advanced_entities')} CASCADE`);
-        await runInInjectionContext(injector, async () => {
-            const repository = injectRepository(AdvancedEntity);
-            await repository.insertMany([
-                Object.assign(new AdvancedEntity(), { name: 'E1', value: 1 }),
-                Object.assign(new AdvancedEntity(), { name: 'E2', value: 2 }),
-            ]);
-            const cursor = repository.loadAllCursor();
-            const results = await toArrayAsync(cursor);
-            expect(results).toHaveLength(2);
-        });
+        await repository.insertMany([
+            Object.assign(new AdvancedEntity(), { name: 'E1', value: 1 }),
+            Object.assign(new AdvancedEntity(), { name: 'E2', value: 2 }),
+        ]);
+        const cursor = repository.loadAllCursor();
+        const results = await toArrayAsync(cursor);
+        expect(results).toHaveLength(2);
     });
     test('should support countByQuery with various filters', async () => {
         await db.execute(sql `TRUNCATE TABLE ${sql.identifier(schema)}.${sql.identifier('advanced_entities')} CASCADE`);
-        await runInInjectionContext(injector, async () => {
-            const repository = injectRepository(AdvancedEntity);
-            await repository.insertMany([
-                Object.assign(new AdvancedEntity(), { name: 'A', value: 10 }),
-                Object.assign(new AdvancedEntity(), { name: 'B', value: 20 }),
-                Object.assign(new AdvancedEntity(), { name: 'C', value: 30 }),
-            ]);
-            expect(await repository.countByQuery({ value: { $gt: 15 } })).toBe(2);
-            expect(await repository.countByQuery({ value: { $lt: 25 } })).toBe(2);
-            expect(await repository.countByQuery({ name: 'A' })).toBe(1);
-        });
+        await repository.insertMany([
+            Object.assign(new AdvancedEntity(), { name: 'A', value: 10 }),
+            Object.assign(new AdvancedEntity(), { name: 'B', value: 20 }),
+            Object.assign(new AdvancedEntity(), { name: 'C', value: 30 }),
+        ]);
+        expect(await repository.countByQuery({ value: { $gt: 15 } })).toBe(2);
+        expect(await repository.countByQuery({ value: { $lt: 25 } })).toBe(2);
+        expect(await repository.countByQuery({ name: 'A' })).toBe(1);
     });
     test('should support has and hasByQuery', async () => {
         await db.execute(sql `TRUNCATE TABLE ${sql.identifier(schema)}.${sql.identifier('advanced_entities')} CASCADE`);
-        await runInInjectionContext(injector, async () => {
-            const repository = injectRepository(AdvancedEntity);
-            const e1 = await repository.insert(Object.assign(new AdvancedEntity(), { name: 'E1', value: 1 }));
-            expect(await repository.has(e1.id)).toBe(true);
-            expect(await repository.has('00000000-0000-0000-0000-000000000000')).toBe(false);
-            expect(await repository.hasByQuery({ name: 'E1' })).toBe(true);
-            expect(await repository.hasByQuery({ name: 'E2' })).toBe(false);
-        });
+        const e1 = await repository.insert(Object.assign(new AdvancedEntity(), { name: 'E1', value: 1 }));
+        expect(await repository.has(e1.id)).toBe(true);
+        expect(await repository.has('00000000-0000-0000-0000-000000000000')).toBe(false);
+        expect(await repository.hasByQuery({ name: 'E1' })).toBe(true);
+        expect(await repository.hasByQuery({ name: 'E2' })).toBe(false);
     });
     test('should support tryUpdate', async () => {
         await db.execute(sql `TRUNCATE TABLE ${sql.identifier(schema)}.${sql.identifier('advanced_entities')} CASCADE`);
-        await runInInjectionContext(injector, async () => {
-            const repository = injectRepository(AdvancedEntity);
-            const e1 = await repository.insert(Object.assign(new AdvancedEntity(), { name: 'E1', value: 1 }));
-            const updated = await repository.tryUpdate(e1.id, { name: 'E1-Updated' });
-            expect(updated.name).toBe('E1-Updated');
-            const missing = await repository.tryUpdate('00000000-0000-0000-0000-000000000000', { name: 'X' });
-            expect(missing).toBeUndefined();
-        });
+        const e1 = await repository.insert(Object.assign(new AdvancedEntity(), { name: 'E1', value: 1 }));
+        const updated = await repository.tryUpdate(e1.id, { name: 'E1-Updated' });
+        expect(updated.name).toBe('E1-Updated');
+        const missing = await repository.tryUpdate('00000000-0000-0000-0000-000000000000', { name: 'X' });
+        expect(missing).toBeUndefined();
     });
     test('should support tryUpdateByQuery', async () => {
         await db.execute(sql `TRUNCATE TABLE ${sql.identifier(schema)}.${sql.identifier('advanced_entities')} CASCADE`);
-        await runInInjectionContext(injector, async () => {
-            const repository = injectRepository(AdvancedEntity);
-            await repository.insert(Object.assign(new AdvancedEntity(), { name: 'E1', value: 1 }));
-            const updated = await repository.tryUpdateByQuery({ name: 'E1' }, { value: 100 });
-            expect(updated.value).toBe(100);
-            const missing = await repository.tryUpdateByQuery({ name: 'Missing' }, { value: 0 });
-            expect(missing).toBeUndefined();
-        });
+        await repository.insert(Object.assign(new AdvancedEntity(), { name: 'E1', value: 1 }));
+        const updated = await repository.tryUpdateByQuery({ name: 'E1' }, { value: 100 });
+        expect(updated.value).toBe(100);
+        const missing = await repository.tryUpdateByQuery({ name: 'Missing' }, { value: 0 });
+        expect(missing).toBeUndefined();
     });
     test('should support insertIfNotExists', async () => {
         await db.execute(sql `TRUNCATE TABLE ${sql.identifier(schema)}.${sql.identifier('advanced_entities')} CASCADE`);
-        await runInInjectionContext(injector, async () => {
-            const repository = injectRepository(AdvancedEntity);
-            const e1 = await repository.insert(Object.assign(new AdvancedEntity(), { name: 'E1', value: 1 }));
-            // Conflict on ID
-            const conflict = await repository.insertIfNotExists('id', Object.assign(new AdvancedEntity(), { id: e1.id, name: 'Conflict', value: 2 }));
-            expect(conflict).toBeUndefined();
-            // No conflict
-            const success = await repository.insertIfNotExists('id', Object.assign(new AdvancedEntity(), { name: 'E2', value: 2 }));
-            expect(success).toBeDefined();
-            expect(success.name).toBe('E2');
-        });
+        const e1 = await repository.insert(Object.assign(new AdvancedEntity(), { name: 'E1', value: 1 }));
+        // Conflict on ID
+        const conflict = await repository.insertIfNotExists('id', Object.assign(new AdvancedEntity(), { id: e1.id, name: 'Conflict', value: 2 }));
+        expect(conflict).toBeUndefined();
+        // No conflict
+        const success = await repository.insertIfNotExists('id', Object.assign(new AdvancedEntity(), { name: 'E2', value: 2 }));
+        expect(success).toBeDefined();
+        expect(success.name).toBe('E2');
     });
     test('should support pagination (limit/offset)', async () => {
         await db.execute(sql `TRUNCATE TABLE ${sql.identifier(schema)}.${sql.identifier('advanced_entities')} CASCADE`);
-        await runInInjectionContext(injector, async () => {
-            const repository = injectRepository(AdvancedEntity);
-            await repository.insertMany([
-                Object.assign(new AdvancedEntity(), { name: 'E1', value: 1 }),
-                Object.assign(new AdvancedEntity(), { name: 'E2', value: 2 }),
-                Object.assign(new AdvancedEntity(), { name: 'E3', value: 3 }),
-            ]);
-            const p1 = await repository.loadAll({ limit: 2, order: { value: 'asc' } });
-            expect(p1).toHaveLength(2);
-            expect(p1[0].name).toBe('E1');
-            expect(p1[1].name).toBe('E2');
-            const p2 = await repository.loadAll({ limit: 2, offset: 2, order: { value: 'asc' } });
-            expect(p2).toHaveLength(1);
-            expect(p2[0].name).toBe('E3');
-        });
+        await repository.insertMany([
+            Object.assign(new AdvancedEntity(), { name: 'E1', value: 1 }),
+            Object.assign(new AdvancedEntity(), { name: 'E2', value: 2 }),
+            Object.assign(new AdvancedEntity(), { name: 'E3', value: 3 }),
+        ]);
+        const p1 = await repository.loadAll({ limit: 2, order: { value: 'asc' } });
+        expect(p1).toHaveLength(2);
+        expect(p1[0].name).toBe('E1');
+        expect(p1[1].name).toBe('E2');
+        const p2 = await repository.loadAll({ limit: 2, offset: 2, order: { value: 'asc' } });
+        expect(p2).toHaveLength(1);
+        expect(p2[0].name).toBe('E3');
     });
     test('should support complex ordering', async () => {
         await db.execute(sql `TRUNCATE TABLE ${sql.identifier(schema)}.${sql.identifier('advanced_entities')} CASCADE`);
-        await runInInjectionContext(injector, async () => {
-            const repository = injectRepository(AdvancedEntity);
-            await repository.insertMany([
-                Object.assign(new AdvancedEntity(), { name: 'B', value: 10 }),
-                Object.assign(new AdvancedEntity(), { name: 'A', value: 20 }),
-                Object.assign(new AdvancedEntity(), { name: 'A', value: 10 }),
-            ]);
-            const results = await repository.loadAll({
-                order: [
-                    ['name', 'asc'],
-                    ['value', 'desc'],
-                ],
-            });
-            expect(results[0].name).toBe('A');
-            expect(results[0].value).toBe(20);
-            expect(results[1].name).toBe('A');
-            expect(results[1].value).toBe(10);
-            expect(results[2].name).toBe('B');
+        await repository.insertMany([
+            Object.assign(new AdvancedEntity(), { name: 'B', value: 10 }),
+            Object.assign(new AdvancedEntity(), { name: 'A', value: 20 }),
+            Object.assign(new AdvancedEntity(), { name: 'A', value: 10 }),
+        ]);
+        const results = await repository.loadAll({
+            order: [
+                ['name', 'asc'],
+                ['value', 'desc'],
+            ],
         });
+        expect(results[0].name).toBe('A');
+        expect(results[0].value).toBe(20);
+        expect(results[1].name).toBe('A');
+        expect(results[1].value).toBe(10);
+        expect(results[2].name).toBe('B');
     });
     test('should return empty array for empty loadMany', async () => {
-        await runInInjectionContext(injector, async () => {
-            const repository = injectRepository(AdvancedEntity);
-            const results = await repository.loadMany([]);
-            expect(results).toEqual([]);
-        });
+        const results = await repository.loadMany([]);
+        expect(results).toEqual([]);
     });
     test('should fail on duplicate ID insert', async () => {
         await db.execute(sql `TRUNCATE TABLE ${sql.identifier(schema)}.${sql.identifier('advanced_entities')} CASCADE`);
-        await runInInjectionContext(injector, async () => {
-            const repository = injectRepository(AdvancedEntity);
-            const id = '00000000-0000-0000-0000-000000000001';
-            await repository.insert(Object.assign(new AdvancedEntity(), { id, name: 'E1', value: 1 }));
-            await expect(repository.insert(Object.assign(new AdvancedEntity(), { id, name: 'E2', value: 2 }))).rejects.toThrow();
-        });
+        const id = '00000000-0000-0000-0000-000000000001';
+        await repository.insert(Object.assign(new AdvancedEntity(), { id, name: 'E1', value: 1 }));
+        await expect(repository.insert(Object.assign(new AdvancedEntity(), { id, name: 'E2', value: 2 }))).rejects.toThrow();
     });
     test('should support explicit transaction usage', async () => {
         await db.execute(sql `TRUNCATE TABLE ${sql.identifier(schema)}.${sql.identifier('advanced_entities')} CASCADE`);
-        await runInInjectionContext(injector, async () => {
-            const repository = injectRepository(AdvancedEntity);
-            await repository.transaction(async (tx) => {
-                const txRepo = repository.withTransaction(tx);
-                await txRepo.insert(Object.assign(new AdvancedEntity(), { name: 'TxEntity', value: 100 }));
-                // Should be visible in tx
-                expect(await txRepo.count()).toBe(1);
-            });
-            // Should be committed
-            expect(await repository.count()).toBe(1);
+        await repository.transaction(async (tx) => {
+            const txRepo = repository.withTransaction(tx);
+            await txRepo.insert(Object.assign(new AdvancedEntity(), { name: 'TxEntity', value: 100 }));
+            // Should be visible in tx
+            expect(await txRepo.count()).toBe(1);
         });
+        // Should be committed
+        expect(await repository.count()).toBe(1);
     });
     test('should exclude soft-deleted entities by default', async () => {
         await db.execute(sql `TRUNCATE TABLE ${sql.identifier(schema)}.${sql.identifier('advanced_entities')} CASCADE`);
-        await runInInjectionContext(injector, async () => {
-            const repository = injectRepository(AdvancedEntity);
-            const e1 = await repository.insert(Object.assign(new AdvancedEntity(), { name: 'E1', value: 1 }));
-            await repository.insert(Object.assign(new AdvancedEntity(), { name: 'E2', value: 2 }));
-            await repository.delete(e1.id);
-            const all = await repository.loadAll();
-            expect(all).toHaveLength(1);
-            expect(all[0].name).toBe('E2');
-            const withDeleted = await repository.loadManyByQuery({}, { withDeleted: true });
-            expect(withDeleted).toHaveLength(2);
-        });
+        const e1 = await repository.insert(Object.assign(new AdvancedEntity(), { name: 'E1', value: 1 }));
+        await repository.insert(Object.assign(new AdvancedEntity(), { name: 'E2', value: 2 }));
+        await repository.delete(e1.id);
+        const all = await repository.loadAll();
+        expect(all).toHaveLength(1);
+        expect(all[0].name).toBe('E2');
+        const withDeleted = await repository.loadManyByQuery({}, { withDeleted: true });
+        expect(withDeleted).toHaveLength(2);
     });
 });