@tstdl/base 0.93.144 → 0.93.146

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

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

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

@@ -1,3 +1,4 @@
+/** biome-ignore-all lint/nursery/noExcessiveClassesPerFile: <explanation> */
 var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
     var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
     if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
@@ -8,12 +9,12 @@ var __metadata = (this && this.__metadata) || function (k, v) {
     if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
 };
 import { describe, expect, test } from 'vitest';
+import { Injector } from '../../injector/index.js';
 import { StringProperty } from '../../schema/index.js';
+import { ChildEntity, Column, Inheritance, Table } from '../decorators.js';
 import { Entity } from '../entity.js';
-import { Column, Inheritance, ChildEntity, Table } from '../decorators.js';
-import { getRepository } from '../server/repository.js';
 import { configureOrm } from '../server/index.js';
-import { Injector, runInInjectionContext } from '../../injector/index.js';
+import { getRepository } from '../server/repository.js';
 describe('ORM Repository Mapping (CTI)', () => {
     test('should flatten joined result when mapping child entity', async () => {
         let BaseUser = class BaseUser extends Entity {
@@ -49,23 +50,22 @@ describe('ORM Repository Mapping (CTI)', () => {
         const injector = new Injector('Test');
         configureOrm({
             repositoryConfig: { schema: 'test' },
-            connection: { database: 'test' } // Mock config, we won't query DB
-        });
-        await runInInjectionContext(injector, async () => {
-            const repository = new (getRepository(Admin))();
-            // Simulate Drizzle joined result structure
-            const mockResult = {
-                users: { id: '123', type: 'admin', name: 'John Doe', revision: 1 },
-                admins: { id: '123', type: 'admin', role: 'super-admin' }
-            };
-            // Access private method for testing (using any cast)
-            const mappedEntity = await repository._mapToEntity(mockResult, {});
-            expect(mappedEntity).toBeInstanceOf(Admin);
-            expect(mappedEntity.id).toBe('123');
-            expect(mappedEntity.type).toBe('admin');
-            expect(mappedEntity.name).toBe('John Doe');
-            expect(mappedEntity.role).toBe('super-admin');
-            expect(mappedEntity.metadata.revision).toBe(1);
+            connection: { database: 'test' }, // Mock config, we won't query DB
+            injector,
         });
+        const repository = injector.resolve(getRepository(Admin));
+        // Simulate Drizzle joined result structure
+        const mockResult = {
+            users: { id: '123', type: 'admin', name: 'John Doe', revision: 1 },
+            admins: { id: '123', type: 'admin', role: 'super-admin' }
+        };
+        // Access private method for testing (using any cast)
+        const mappedEntity = await repository._mapToEntity(mockResult, {});
+        expect(mappedEntity).toBeInstanceOf(Admin);
+        expect(mappedEntity.id).toBe('123');
+        expect(mappedEntity.type).toBe('admin');
+        expect(mappedEntity.name).toBe('John Doe');
+        expect(mappedEntity.role).toBe('super-admin');
+        expect(mappedEntity.metadata.revision).toBe(1);
     });
 });

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

@@ -7,20 +7,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 { sql } from 'drizzle-orm';
+import { beforeAll, describe, expect, test } from 'vitest';
 import { defineEnum } from '../../enumeration/index.js';
 import { NotFoundError } from '../../errors/not-found.error.js';
-import { Injector, runInInjectionContext } from '../../injector/index.js';
 import { Array, Enumeration, Integer, string, StringProperty } from '../../schema/index.js';
-import { sql } from 'drizzle-orm';
-import { beforeAll, describe, expect, test } from 'vitest';
+import { setupIntegrationTest } from '../../testing/index.js';
 import { Column, EmbeddedProperty, EncryptedProperty, Reference, Table } from '../decorators.js';
 import { Entity } from '../entity.js';
 import { JsonProperty, NumericDateProperty } from '../schemas/index.js';
-import { configureOrm, Database } from '../server/index.js';
-import { injectRepository } from '../server/repository.js';
+import { getRepository } from '../server/index.js';
+import { ENCRYPTION_SECRET } from '../server/tokens.js';
 describe('ORM Repository Regression (Integration)', () => {
     let injector;
     let db;
+    let standardRepository;
+    let postRepository;
     const schema = 'test_orm_regression';
     const UserRole = defineEnum('UserRole', {
         Admin: 'admin',
@@ -99,20 +101,13 @@ describe('ORM Repository Regression (Integration)', () => {
         Table('posts', { schema })
     ], Post);
     beforeAll(async () => {
-        injector = new Injector('Test');
         const encryptionSecret = new Uint8Array(32).fill(1);
-        configureOrm({
-            repositoryConfig: { schema },
-            connection: {
-                host: '127.0.0.1',
-                port: 5432,
-                user: 'tstdl',
-                password: 'wf7rq6glrk5jykne',
-                database: 'tstdl',
-            },
-            encryptionSecret
-        });
-        db = injector.resolve(Database);
+        ({ injector, database: db } = await setupIntegrationTest({
+            orm: { schema },
+        }));
+        injector.register(ENCRYPTION_SECRET, { useValue: encryptionSecret });
+        standardRepository = injector.resolve(getRepository(StandardEntity));
+        postRepository = injector.resolve(getRepository(Post));
         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('posts')} CASCADE`);
         await db.execute(sql `DROP TABLE IF EXISTS ${sql.identifier(schema)}.${sql.identifier('standard_entities')} CASCADE`);
@@ -151,180 +146,146 @@ describe('ORM Repository Regression (Integration)', () => {
     });
     test('should perform basic CRUD on standard entity', async () => {
         await db.execute(sql `TRUNCATE TABLE ${sql.identifier(schema)}.${sql.identifier('standard_entities')} CASCADE`);
-        await runInInjectionContext(injector, async () => {
-            const repository = injectRepository(StandardEntity);
-            const entity = new StandardEntity();
-            entity.name = 'Test';
-            entity.address = { street: 'Main St', number: 123 };
-            entity.secret = 'my-secret-password';
-            entity.role = UserRole.User;
-            entity.data = { foo: 'bar' };
-            entity.tags = ['a', 'b'];
-            entity.birthday = 19716; // 2023-12-25
-            const inserted = await repository.insert(entity);
-            expect(inserted.id).toBeDefined();
-            expect(inserted.name).toBe('Test');
-            expect(inserted.address.street).toBe('Main St');
-            expect(inserted.secret).toBe('my-secret-password');
-            expect(inserted.role).toBe(UserRole.User);
-            expect(inserted.data).toEqual({ foo: 'bar' });
-            expect(inserted.tags).toEqual(['a', 'b']);
-            expect(inserted.birthday).toBe(19716);
-            // Verify DB encrypted state
-            const { rows: [row] } = await db.execute(sql `SELECT secret, dob FROM ${sql.identifier(schema)}.${sql.identifier('standard_entities')} WHERE id = ${inserted.id}`);
-            expect(row['secret']).toBeInstanceOf(Uint8Array);
-            expect(row['secret']).not.toEqual(new TextEncoder().encode('my-secret-password'));
-            expect(row['dob']).toBe('2023-12-25');
-            // Update
-            await repository.update(inserted.id, { name: 'Updated' });
-            const updated = await repository.load(inserted.id);
-            expect(updated.name).toBe('Updated');
-            expect(updated.secret).toBe('my-secret-password'); // Still readable
-            // Soft Delete
-            await repository.delete(inserted.id);
-            const deleted = await repository.tryLoad(inserted.id);
-            expect(deleted).toBeUndefined();
-            const { rows: [deletedRow] } = await db.execute(sql `SELECT delete_timestamp FROM ${sql.identifier(schema)}.${sql.identifier('standard_entities')} WHERE id = ${inserted.id}`);
-            expect(deletedRow['delete_timestamp']).not.toBeNull();
-        });
+        const entity = new StandardEntity();
+        entity.name = 'Test';
+        entity.address = { street: 'Main St', number: 123 };
+        entity.secret = 'my-secret-password';
+        entity.role = UserRole.User;
+        entity.data = { foo: 'bar' };
+        entity.tags = ['a', 'b'];
+        entity.birthday = 19716; // 2023-12-25
+        const inserted = await standardRepository.insert(entity);
+        expect(inserted.id).toBeDefined();
+        expect(inserted.name).toBe('Test');
+        expect(inserted.address.street).toBe('Main St');
+        expect(inserted.secret).toBe('my-secret-password');
+        expect(inserted.role).toBe(UserRole.User);
+        expect(inserted.data).toEqual({ foo: 'bar' });
+        expect(inserted.tags).toEqual(['a', 'b']);
+        expect(inserted.birthday).toBe(19716);
+        // Verify DB encrypted state
+        const { rows: [row] } = await db.execute(sql `SELECT secret, dob FROM ${sql.identifier(schema)}.${sql.identifier('standard_entities')} WHERE id = ${inserted.id}`);
+        expect(row['secret']).toBeInstanceOf(Uint8Array);
+        expect(row['secret']).not.toEqual(new TextEncoder().encode('my-secret-password'));
+        expect(row['dob']).toBe('2023-12-25');
+        // Update
+        await standardRepository.update(inserted.id, { name: 'Updated' });
+        const updated = await standardRepository.load(inserted.id);
+        expect(updated.name).toBe('Updated');
+        expect(updated.secret).toBe('my-secret-password'); // Still readable
+        // Soft Delete
+        await standardRepository.delete(inserted.id);
+        const deleted = await standardRepository.tryLoad(inserted.id);
+        expect(deleted).toBeUndefined();
+        const { rows: [deletedRow] } = await db.execute(sql `SELECT delete_timestamp FROM ${sql.identifier(schema)}.${sql.identifier('standard_entities')} WHERE id = ${inserted.id}`);
+        expect(deletedRow['delete_timestamp']).not.toBeNull();
     });
     test('should support Reference decorator', async () => {
         await db.execute(sql `TRUNCATE TABLE ${sql.identifier(schema)}.${sql.identifier('standard_entities')} CASCADE`);
-        await runInInjectionContext(injector, async () => {
-            const standardRepository = injectRepository(StandardEntity);
-            const postRepository = injectRepository(Post);
-            const author = Object.assign(new StandardEntity(), { name: 'Author', address: { street: 'A', number: 1 }, secret: 's', role: UserRole.User, data: {}, tags: [], birthday: 0 });
-            const insertedAuthor = await standardRepository.insert(author);
-            const post = Object.assign(new Post(), { title: 'Hello World', authorId: insertedAuthor.id });
-            const insertedPost = await postRepository.insert(post);
-            expect(insertedPost.authorId).toBe(insertedAuthor.id);
-            const loadedPost = await postRepository.load(insertedPost.id);
-            expect(loadedPost.authorId).toBe(insertedAuthor.id);
-        });
+        const author = Object.assign(new StandardEntity(), { name: 'Author', address: { street: 'A', number: 1 }, secret: 's', role: UserRole.User, data: {}, tags: [], birthday: 0 });
+        const insertedAuthor = await standardRepository.insert(author);
+        const post = Object.assign(new Post(), { title: 'Hello World', authorId: insertedAuthor.id });
+        const insertedPost = await postRepository.insert(post);
+        expect(insertedPost.authorId).toBe(insertedAuthor.id);
+        const loadedPost = await postRepository.load(insertedPost.id);
+        expect(loadedPost.authorId).toBe(insertedAuthor.id);
     });
     test('should perform insertMany and loadMany', async () => {
         await db.execute(sql `TRUNCATE TABLE ${sql.identifier(schema)}.${sql.identifier('standard_entities')} CASCADE`);
-        await runInInjectionContext(injector, async () => {
-            const repository = injectRepository(StandardEntity);
-            const entities = [
-                Object.assign(new StandardEntity(), { name: 'E1', address: { street: 'S1', number: 1 }, secret: 's1', role: UserRole.User, data: {}, tags: [], birthday: 0 }),
-                Object.assign(new StandardEntity(), { name: 'E2', address: { street: 'S2', number: 2 }, secret: 's2', role: UserRole.Admin, data: {}, tags: [], birthday: 0 }),
-            ];
-            const inserted = await repository.insertMany(entities);
-            expect(inserted).toHaveLength(2);
-            const loaded = await repository.loadMany(inserted.map((e) => e.id));
-            expect(loaded).toHaveLength(2);
-            expect(loaded.map((e) => e.name).sort()).toEqual(['E1', 'E2']);
-        });
+        const entities = [
+            Object.assign(new StandardEntity(), { name: 'E1', address: { street: 'S1', number: 1 }, secret: 's1', role: UserRole.User, data: {}, tags: [], birthday: 0 }),
+            Object.assign(new StandardEntity(), { name: 'E2', address: { street: 'S2', number: 2 }, secret: 's2', role: UserRole.Admin, data: {}, tags: [], birthday: 0 }),
+        ];
+        const inserted = await standardRepository.insertMany(entities);
+        expect(inserted).toHaveLength(2);
+        const loaded = await standardRepository.loadMany(inserted.map((e) => e.id));
+        expect(loaded).toHaveLength(2);
+        expect(loaded.map((e) => e.name).sort()).toEqual(['E1', 'E2']);
     });
     test('should support upsert', async () => {
         await db.execute(sql `TRUNCATE TABLE ${sql.identifier(schema)}.${sql.identifier('standard_entities')} CASCADE`);
-        await runInInjectionContext(injector, async () => {
-            const repository = injectRepository(StandardEntity);
-            const entity = Object.assign(new StandardEntity(), { name: 'Original', address: { street: 'S', number: 1 }, secret: 's', role: UserRole.User, data: {}, tags: [], birthday: 0 });
-            const inserted = await repository.insert(entity);
-            // Upsert: update existing
-            const updateEntity = Object.assign(new StandardEntity(), { id: inserted.id, name: 'Upserted', address: { street: 'S', number: 1 }, secret: 's', role: UserRole.User, data: {}, tags: [], birthday: 0 });
-            const upserted = await repository.upsert('id', updateEntity);
-            expect(upserted.id).toBe(inserted.id);
-            expect(upserted.name).toBe('Upserted');
-            // Verify DB
-            const loaded = await repository.load(inserted.id);
-            expect(loaded.name).toBe('Upserted');
-        });
+        const entity = Object.assign(new StandardEntity(), { name: 'Original', address: { street: 'S', number: 1 }, secret: 's', role: UserRole.User, data: {}, tags: [], birthday: 0 });
+        const inserted = await standardRepository.insert(entity);
+        // Upsert: update existing
+        const updateEntity = Object.assign(new StandardEntity(), { id: inserted.id, name: 'Upserted', address: { street: 'S', number: 1 }, secret: 's', role: UserRole.User, data: {}, tags: [], birthday: 0 });
+        const upserted = await standardRepository.upsert('id', updateEntity);
+        expect(upserted.id).toBe(inserted.id);
+        expect(upserted.name).toBe('Upserted');
+        // Verify DB
+        const loaded = await standardRepository.load(inserted.id);
+        expect(loaded.name).toBe('Upserted');
     });
     test('should support complex queries with $or and $and', async () => {
         await db.execute(sql `TRUNCATE TABLE ${sql.identifier(schema)}.${sql.identifier('standard_entities')} CASCADE`);
-        await runInInjectionContext(injector, async () => {
-            const repository = injectRepository(StandardEntity);
-            await repository.insertMany([
-                Object.assign(new StandardEntity(), { name: 'A', address: { street: 'S1', number: 10 }, secret: 's', role: UserRole.Admin, data: {}, tags: [], birthday: 0 }),
-                Object.assign(new StandardEntity(), { name: 'B', address: { street: 'S2', number: 20 }, secret: 's', role: UserRole.User, data: {}, tags: [], birthday: 0 }),
-                Object.assign(new StandardEntity(), { name: 'C', address: { street: 'S3', number: 30 }, secret: 's', role: UserRole.Admin, data: {}, tags: [], birthday: 0 }),
-            ]);
-            const results = await repository.loadManyByQuery({
-                $or: [
-                    { name: 'B' },
-                    { $and: [{ role: UserRole.Admin }, { 'address.number': { $gt: 25 } }] }
-                ]
-            });
-            expect(results).toHaveLength(2);
-            expect(results.map((r) => r.name).sort()).toEqual(['B', 'C']);
+        await standardRepository.insertMany([
+            Object.assign(new StandardEntity(), { name: 'A', address: { street: 'S1', number: 10 }, secret: 's', role: UserRole.Admin, data: {}, tags: [], birthday: 0 }),
+            Object.assign(new StandardEntity(), { name: 'B', address: { street: 'S2', number: 20 }, secret: 's', role: UserRole.User, data: {}, tags: [], birthday: 0 }),
+            Object.assign(new StandardEntity(), { name: 'C', address: { street: 'S3', number: 30 }, secret: 's', role: UserRole.Admin, data: {}, tags: [], birthday: 0 }),
+        ]);
+        const results = await standardRepository.loadManyByQuery({
+            $or: [
+                { name: 'B' },
+                { $and: [{ role: UserRole.Admin }, { 'address.number': { $gt: 25 } }] }
+            ]
         });
+        expect(results).toHaveLength(2);
+        expect(results.map((r) => r.name).sort()).toEqual(['B', 'C']);
     });
     test('should support hasAll', async () => {
         await db.execute(sql `TRUNCATE TABLE ${sql.identifier(schema)}.${sql.identifier('standard_entities')} CASCADE`);
-        await runInInjectionContext(injector, async () => {
-            const repository = injectRepository(StandardEntity);
-            const inserted = await repository.insertMany([
-                Object.assign(new StandardEntity(), { name: 'E1', address: { street: 'S1', number: 1 }, secret: 's', role: UserRole.User, data: {}, tags: [], birthday: 0 }),
-                Object.assign(new StandardEntity(), { name: 'E2', address: { street: 'S2', number: 2 }, secret: 's', role: UserRole.User, data: {}, tags: [], birthday: 0 }),
-            ]);
-            expect(await repository.hasAll(inserted.map((e) => e.id))).toBe(true);
-            expect(await repository.hasAll([...inserted.map((e) => e.id), '00000000-0000-0000-0000-000000000000'])).toBe(false);
-        });
+        const inserted = await standardRepository.insertMany([
+            Object.assign(new StandardEntity(), { name: 'E1', address: { street: 'S1', number: 1 }, secret: 's', role: UserRole.User, data: {}, tags: [], birthday: 0 }),
+            Object.assign(new StandardEntity(), { name: 'E2', address: { street: 'S2', number: 2 }, secret: 's', role: UserRole.User, data: {}, tags: [], birthday: 0 }),
+        ]);
+        expect(await standardRepository.hasAll(inserted.map((e) => e.id))).toBe(true);
+        expect(await standardRepository.hasAll([...inserted.map((e) => e.id), '00000000-0000-0000-0000-000000000000'])).toBe(false);
     });
     test('should throw NotFoundError on missing load', async () => {
-        await runInInjectionContext(injector, async () => {
-            const repository = injectRepository(StandardEntity);
-            await expect(repository.load('00000000-0000-0000-0000-000000000000')).rejects.toThrow(NotFoundError);
-        });
+        await expect(standardRepository.load('00000000-0000-0000-0000-000000000000')).rejects.toThrow(NotFoundError);
     });
     test('should support upsertMany', async () => {
         await db.execute(sql `TRUNCATE TABLE ${sql.identifier(schema)}.${sql.identifier('standard_entities')} CASCADE`);
-        await runInInjectionContext(injector, async () => {
-            const repository = injectRepository(StandardEntity);
-            const e1 = await repository.insert(Object.assign(new StandardEntity(), { name: 'E1', address: { street: 'S1', number: 1 }, secret: 's', role: UserRole.User, data: {}, tags: [], birthday: 0 }));
-            const upsertData = [
-                Object.assign(new StandardEntity(), { id: e1.id, name: 'E1-Updated', address: { street: 'S1', number: 1 }, secret: 's', role: UserRole.User, data: {}, tags: [], birthday: 0 }),
-                Object.assign(new StandardEntity(), { name: 'E2', address: { street: 'S2', number: 2 }, secret: 's', role: UserRole.User, data: {}, tags: [], birthday: 0 }),
-            ];
-            await repository.upsertMany('id', upsertData);
-            const all = await repository.loadAll();
-            expect(all).toHaveLength(2);
-            expect(all.find((e) => e.id === e1.id).name).toBe('E1-Updated');
-            expect(all.find((e) => e.name === 'E2')).toBeDefined();
-        });
+        const e1 = await standardRepository.insert(Object.assign(new StandardEntity(), { name: 'E1', address: { street: 'S1', number: 1 }, secret: 's', role: UserRole.User, data: {}, tags: [], birthday: 0 }));
+        const upsertData = [
+            Object.assign(new StandardEntity(), { id: e1.id, name: 'E1-Updated', address: { street: 'S1', number: 1 }, secret: 's', role: UserRole.User, data: {}, tags: [], birthday: 0 }),
+            Object.assign(new StandardEntity(), { name: 'E2', address: { street: 'S2', number: 2 }, secret: 's', role: UserRole.User, data: {}, tags: [], birthday: 0 }),
+        ];
+        await standardRepository.upsertMany('id', upsertData);
+        const all = await standardRepository.loadAll();
+        expect(all).toHaveLength(2);
+        expect(all.find((e) => e.id === e1.id).name).toBe('E1-Updated');
+        expect(all.find((e) => e.name === 'E2')).toBeDefined();
     });
     test('should support deleteManyByQuery', async () => {
         await db.execute(sql `TRUNCATE TABLE ${sql.identifier(schema)}.${sql.identifier('standard_entities')} CASCADE`);
-        await runInInjectionContext(injector, async () => {
-            const repository = injectRepository(StandardEntity);
-            await repository.insertMany([
-                Object.assign(new StandardEntity(), { name: 'A', address: { street: 'S', number: 1 }, secret: 's', role: UserRole.User, data: {}, tags: [], birthday: 0 }),
-                Object.assign(new StandardEntity(), { name: 'A', address: { street: 'S', number: 2 }, secret: 's', role: UserRole.User, data: {}, tags: [], birthday: 0 }),
-                Object.assign(new StandardEntity(), { name: 'B', address: { street: 'S', number: 3 }, secret: 's', role: UserRole.User, data: {}, tags: [], birthday: 0 }),
-            ]);
-            await repository.deleteManyByQuery({ name: 'A' });
-            const remaining = await repository.loadAll();
-            expect(remaining).toHaveLength(1);
-            expect(remaining[0].name).toBe('B');
-        });
+        await standardRepository.insertMany([
+            Object.assign(new StandardEntity(), { name: 'A', address: { street: 'S', number: 1 }, secret: 's', role: UserRole.User, data: {}, tags: [], birthday: 0 }),
+            Object.assign(new StandardEntity(), { name: 'A', address: { street: 'S', number: 2 }, secret: 's', role: UserRole.User, data: {}, tags: [], birthday: 0 }),
+            Object.assign(new StandardEntity(), { name: 'B', address: { street: 'S', number: 3 }, secret: 's', role: UserRole.User, data: {}, tags: [], birthday: 0 }),
+        ]);
+        await standardRepository.deleteManyByQuery({ name: 'A' });
+        const remaining = await standardRepository.loadAll();
+        expect(remaining).toHaveLength(1);
+        expect(remaining[0].name).toBe('B');
     });
     test('should support tryInsert', async () => {
         await db.execute(sql `TRUNCATE TABLE ${sql.identifier(schema)}.${sql.identifier('standard_entities')} CASCADE`);
-        await runInInjectionContext(injector, async () => {
-            const repository = injectRepository(StandardEntity);
-            const entity = Object.assign(new StandardEntity(), { name: 'E1', address: { street: 'S', number: 1 }, secret: 's', role: UserRole.User, data: {}, tags: [], birthday: 0 });
-            const inserted = await repository.tryInsert(entity);
-            expect(inserted).toBeDefined();
-            // Conflict
-            const conflict = await repository.tryInsert(Object.assign(new StandardEntity(), { id: inserted.id, name: 'Conflict', address: { street: 'S', number: 1 }, secret: 's', role: UserRole.User, data: {}, tags: [], birthday: 0 }));
-            expect(conflict).toBeUndefined();
-        });
+        const entity = Object.assign(new StandardEntity(), { name: 'E1', address: { street: 'S', number: 1 }, secret: 's', role: UserRole.User, data: {}, tags: [], birthday: 0 });
+        const inserted = await standardRepository.tryInsert(entity);
+        expect(inserted).toBeDefined();
+        // Conflict
+        const conflict = await standardRepository.tryInsert(Object.assign(new StandardEntity(), { id: inserted.id, name: 'Conflict', address: { street: 'S', number: 1 }, secret: 's', role: UserRole.User, data: {}, tags: [], birthday: 0 }));
+        expect(conflict).toBeUndefined();
     });
     test('should support insertManyIfNotExists', async () => {
         await db.execute(sql `TRUNCATE TABLE ${sql.identifier(schema)}.${sql.identifier('standard_entities')} CASCADE`);
-        await runInInjectionContext(injector, async () => {
-            const repository = injectRepository(StandardEntity);
-            const e1 = await repository.insert(Object.assign(new StandardEntity(), { name: 'E1', address: { street: 'S', number: 1 }, secret: 's', role: UserRole.User, data: {}, tags: [], birthday: 0 }));
-            const data = [
-                Object.assign(new StandardEntity(), { id: e1.id, name: 'E1-Conflict', address: { street: 'S', number: 1 }, secret: 's', role: UserRole.User, data: {}, tags: [], birthday: 0 }),
-                Object.assign(new StandardEntity(), { name: 'E2', address: { street: 'S', number: 2 }, secret: 's', role: UserRole.User, data: {}, tags: [], birthday: 0 }),
-            ];
-            const results = await repository.insertManyIfNotExists('id', data);
-            expect(results).toHaveLength(1);
-            expect(results[0].name).toBe('E2');
-        });
+        const e1 = await standardRepository.insert(Object.assign(new StandardEntity(), { name: 'E1', address: { street: 'S1', number: 1 }, secret: 's', role: UserRole.User, data: {}, tags: [], birthday: 0 }));
+        const data = [
+            Object.assign(new StandardEntity(), { id: e1.id, name: 'E1-Conflict', address: { street: 'S1', number: 1 }, secret: 's', role: UserRole.User, data: {}, tags: [], birthday: 0 }),
+            Object.assign(new StandardEntity(), { name: 'E2', address: { street: 'S2', number: 2 }, secret: 's', role: UserRole.User, data: {}, tags: [], birthday: 0 }),
+        ];
+        const results = await standardRepository.insertManyIfNotExists('id', data);
+        expect(results).toHaveLength(1);
+        expect(results[0].name).toBe('E2');
     });
 });

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

@@ -9,16 +9,16 @@ var __metadata = (this && this.__metadata) || function (k, v) {
 };
 import { sql } from 'drizzle-orm';
 import { beforeAll, beforeEach, describe, expect, test } from 'vitest';
-import { Injector, runInInjectionContext } from '../../injector/index.js';
 import { StringProperty } from '../../schema/index.js';
 import { dropTables, setupIntegrationTest, truncateTables } from '../../testing/index.js';
+import { isArray } from '../../utils/type-guards.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 Search', () => {
     let injector;
     let database;
+    let repository;
     const schema = 'test_orm_search';
     let SearchEntity = class SearchEntity extends Entity {
         title;
@@ -37,6 +37,7 @@ describe('ORM Repository Search', () => {
     ], SearchEntity);
     beforeAll(async () => {
         ({ injector, database } = await setupIntegrationTest({ orm: { schema } }));
+        repository = injector.resolve(getRepository(SearchEntity));
         await dropTables(database, schema, ['search_entities']);
         await database.execute(sql `
       CREATE TABLE ${sql.identifier(schema)}.${sql.identifier('search_entities')} (
@@ -55,40 +56,31 @@ describe('ORM Repository Search', () => {
         await truncateTables(database, schema, ['search_entities']);
     });
     test('should support search with score transformer', async () => {
-        await runInInjectionContext(injector, async () => {
-            const repository = injectRepository(SearchEntity);
-            await repository.insert(Object.assign(new SearchEntity(), { title: 'Hello World', content: 'Some content here' }));
-            const results = await repository.search({
-                query: { $tsvector: { fields: ['title'], query: 'hello' } },
-                score: (score) => sql `(${score}) * 100`,
-            });
-            expect(results).toHaveLength(1);
-            expect(results[0].score).toBeGreaterThan(1); // normalized score is small, * 100 should be > 1
+        await repository.insert(Object.assign(new SearchEntity(), { title: 'Hello World', content: 'Some content here' }));
+        const results = await repository.search({
+            query: { $tsvector: { fields: ['title'], query: 'hello' } },
+            score: (score) => sql `(${score}) * 100`,
         });
+        expect(results).toHaveLength(1);
+        expect(results[0].score).toBeGreaterThan(1); // normalized score is small, * 100 should be > 1
     });
     test('should support search with highlight (column names)', async () => {
-        await runInInjectionContext(injector, async () => {
-            const repository = injectRepository(SearchEntity);
-            await repository.insert(Object.assign(new SearchEntity(), { title: 'Highlander', content: 'There can be only one' }));
-            const results = await repository.search({
-                query: { $tsvector: { fields: ['title', 'content'], query: 'Highlander' } },
-                highlight: { source: 'title' },
-            });
-            expect(results).toHaveLength(1);
-            expect(results[0].highlight).toContain('<b>Highlander</b>');
+        await repository.insert(Object.assign(new SearchEntity(), { title: 'Highlander', content: 'There can be only one' }));
+        const results = await repository.search({
+            query: { $tsvector: { fields: ['title', 'content'], query: 'Highlander' } },
+            highlight: { source: 'title' },
         });
+        expect(results).toHaveLength(1);
+        expect(results[0].highlight).toContain('<b>Highlander</b>');
     });
     test('should support search with highlight (raw SQL)', async () => {
-        await runInInjectionContext(injector, async () => {
-            const repository = injectRepository(SearchEntity);
-            await repository.insert(Object.assign(new SearchEntity(), { title: 'SQL Master', content: 'Database wizard' }));
-            const results = await repository.search({
-                query: { $tsvector: { fields: ['title', 'content'], query: 'Master' } },
-                highlight: { source: sql `title || ' ' || content` },
-            });
-            expect(results).toHaveLength(1);
-            expect(results[0].highlight).toContain('<b>Master</b>');
+        await repository.insert(Object.assign(new SearchEntity(), { title: 'SQL Master', content: 'Database wizard' }));
+        const results = await repository.search({
+            query: { $tsvector: { fields: ['title', 'content'], query: 'Master' } },
+            highlight: { source: sql `title || ' ' || content` },
         });
+        expect(results).toHaveLength(1);
+        expect(results[0].highlight).toContain('<b>Master</b>');
     });
     test('should support ParadeDB search with highlightPositions', async () => {
         // This test requires pg_search extension to be installed.
@@ -100,20 +92,14 @@ describe('ORM Repository Search', () => {
             console.warn('ParadeDB (pg_search) not available or index creation failed, skipping ParadeDB test.', e);
             return;
         }
-        await runInInjectionContext(injector, async () => {
-            const repository = injectRepository(SearchEntity);
-            await repository.insert(Object.assign(new SearchEntity(), { title: 'Parade', content: 'ParadeDB is fast' }));
-            const results = await repository.search({
-                query: { $parade: { fields: ['title'], query: 'Parade' } },
-                highlight: { source: 'title', includePositions: true },
-            });
-            expect(results).toHaveLength(1);
-            expect(results[0].highlight).toBeDefined();
-            expect(results[0].highlightPositions).toBeDefined();
-            expect(isArray(results[0].highlightPositions)).toBe(true);
+        await repository.insert(Object.assign(new SearchEntity(), { title: 'Parade', content: 'ParadeDB is fast' }));
+        const results = await repository.search({
+            query: { $parade: { fields: ['title'], query: 'Parade' } },
+            highlight: { source: 'title', includePositions: true },
         });
+        expect(results).toHaveLength(1);
+        expect(results[0].highlight).toBeDefined();
+        expect(results[0].highlightPositions).toBeDefined();
+        expect(isArray(results[0].highlightPositions)).toBe(true);
     });
 });
-function isArray(val) {
-    return Array.isArray(val);
-}