@tstdl/base 0.93.144 → 0.93.146

package/orm/tests/repository-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,17 +8,19 @@ var __decorate = (this && this.__decorate) || function (decorators, target, key,
 var __metadata = (this && this.__metadata) || function (k, v) {
     if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
 };
-import { Injector, runInInjectionContext } from '../../injector/index.js';
-import { StringProperty } from '../../schema/index.js';
 import { sql } from 'drizzle-orm';
 import { beforeAll, describe, expect, test } from 'vitest';
+import { StringProperty } from '../../schema/index.js';
+import { setupIntegrationTest } from '../../testing/index.js';
 import { ChildEntity, Column, Inheritance, Table } from '../decorators.js';
 import { BaseEntity, 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 Coverage', () => {
     let injector;
     let db;
+    let premiumRepo;
+    let plainRepo;
+    let simpleRepo;
     const schema = 'test_orm_coverage';
     let BaseItem = class BaseItem extends Entity {
         type;
@@ -72,18 +75,12 @@ describe('ORM Repository Coverage', () => {
         Table('plain_items', { schema })
     ], PlainItem);
     beforeAll(async () => {
-        injector = new Injector('TestCoverage');
-        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 },
+        }));
+        premiumRepo = injector.resolve(getRepository(PremiumItem));
+        plainRepo = injector.resolve(getRepository(PlainItem));
+        simpleRepo = injector.resolve(getRepository(SimpleItem));
         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('premium_items')} CASCADE`);
         await db.execute(sql `DROP TABLE IF EXISTS ${sql.identifier(schema)}.${sql.identifier('items')} CASCADE`);
@@ -129,175 +126,117 @@ describe('ORM Repository Coverage', () => {
     `);
     });
     test('upsertMany on CTI without update object (default update)', async () => {
-        await runInInjectionContext(injector, async () => {
-            const repository = injectRepository(PremiumItem);
-            const item1 = Object.assign(new PremiumItem(), { name: 'Item 1', code: 'C1' });
-            const inserted = await repository.insert(item1);
-            // Create a conflict by using the same ID
-            const conflictItem = Object.assign(new PremiumItem(), { id: inserted.id, name: 'Item 1 Updated', code: 'C1' });
-            // This should trigger the code path where `update` is undefined in upsertManyCTI
-            const upserted = await repository.upsertMany(['id'], [conflictItem]);
-            expect(upserted).toHaveLength(1);
-            expect(upserted[0].name).toBe('Item 1 Updated');
-            expect(upserted[0].metadata.revision).toBeGreaterThan(inserted.metadata.revision);
-        });
+        const item1 = Object.assign(new PremiumItem(), { name: 'Item 1', code: 'C1' });
+        const inserted = await premiumRepo.insert(item1);
+        // Create a conflict by using the same ID
+        const conflictItem = Object.assign(new PremiumItem(), { id: inserted.id, name: 'Item 1 Updated', code: 'C1' });
+        // This should trigger the code path where `update` is undefined in upsertManyCTI
+        const upserted = await premiumRepo.upsertMany(['id'], [conflictItem]);
+        expect(upserted).toHaveLength(1);
+        expect(upserted[0].name).toBe('Item 1 Updated');
+        expect(upserted[0].metadata.revision).toBeGreaterThan(inserted.metadata.revision);
     });
     test('upsertMany with empty array', async () => {
-        await runInInjectionContext(injector, async () => {
-            const repository = injectRepository(PremiumItem);
-            const result = await repository.upsertMany(['id'], []);
-            expect(result).toHaveLength(0);
-        });
+        const result = await premiumRepo.upsertMany(['id'], []);
+        expect(result).toHaveLength(0);
     });
     test('updateManyByQuery on CTI with no matching rows', async () => {
-        await runInInjectionContext(injector, async () => {
-            const repository = injectRepository(PremiumItem);
-            // Query matching nothing
-            const results = await repository.updateManyByQuery({ name: 'NonExistent' }, { name: 'NewName' });
-            expect(results).toEqual([]);
-        });
+        // Query matching nothing
+        const results = await premiumRepo.updateManyByQuery({ name: 'NonExistent' }, { name: 'NewName' });
+        expect(results).toEqual([]);
     });
     test('tryUpdate returning undefined (non-CTI, no metadata)', async () => {
-        await runInInjectionContext(injector, async () => {
-            const repository = injectRepository(PlainItem);
-            const result = await repository.tryUpdate('00000000-0000-0000-0000-000000000000', { description: 'New Desc' });
-            expect(result).toBeUndefined();
-        });
+        const result = await plainRepo.tryUpdate('00000000-0000-0000-0000-000000000000', { description: 'New Desc' });
+        expect(result).toBeUndefined();
     });
     test('tryUpdate returning undefined (CTI)', async () => {
-        await runInInjectionContext(injector, async () => {
-            const repository = injectRepository(PremiumItem);
-            const result = await repository.tryUpdate('00000000-0000-0000-0000-000000000000', { name: 'New Name' });
-            expect(result).toBeUndefined();
-        });
+        const result = await premiumRepo.tryUpdate('00000000-0000-0000-0000-000000000000', { name: 'New Name' });
+        expect(result).toBeUndefined();
     });
     test('tryUpdate returning undefined (CTI) - child field only', async () => {
         // This hits line 1163 in tryUpdateCTI (else block where mappedUpdate is empty for base table)
-        await runInInjectionContext(injector, async () => {
-            const repository = injectRepository(PremiumItem);
-            // Update ONLY 'code' (Child field).
-            // Base table update will be empty.
-            const result = await repository.tryUpdate('00000000-0000-0000-0000-000000000000', { code: 'New Code' });
-            expect(result).toBeUndefined();
-        });
+        // Update ONLY 'code' (Child field).
+        // Base table update will be empty.
+        const result = await premiumRepo.tryUpdate('00000000-0000-0000-0000-000000000000', { code: 'New Code' });
+        expect(result).toBeUndefined();
     });
     test('tryDelete returning undefined (non-CTI, has metadata)', async () => {
-        await runInInjectionContext(injector, async () => {
-            const repository = injectRepository(SimpleItem);
-            const result = await repository.tryDelete('00000000-0000-0000-0000-000000000000');
-            expect(result).toBeUndefined();
-        });
+        const result = await simpleRepo.tryDelete('00000000-0000-0000-0000-000000000000');
+        expect(result).toBeUndefined();
     });
     test('tryDelete returning undefined (non-CTI, no metadata)', async () => {
-        await runInInjectionContext(injector, async () => {
-            const repository = injectRepository(PlainItem);
-            // This hits tryHardDelete
-            const result = await repository.tryDelete('00000000-0000-0000-0000-000000000000');
-            expect(result).toBeUndefined();
-        });
+        // This hits tryHardDelete
+        const result = await plainRepo.tryDelete('00000000-0000-0000-0000-000000000000');
+        expect(result).toBeUndefined();
     });
     test('tryDeleteByQuery returning undefined (non-CTI, has metadata)', async () => {
-        await runInInjectionContext(injector, async () => {
-            const repository = injectRepository(SimpleItem);
-            const result = await repository.tryDeleteByQuery({ label: 'NonExistent' });
-            expect(result).toBeUndefined();
-        });
+        const result = await simpleRepo.tryDeleteByQuery({ label: 'NonExistent' });
+        expect(result).toBeUndefined();
     });
     test('tryDeleteByQuery returning undefined (non-CTI, no metadata)', async () => {
-        await runInInjectionContext(injector, async () => {
-            const repository = injectRepository(PlainItem);
-            // This hits tryHardDeleteByQuery
-            const result = await repository.tryDeleteByQuery({ description: 'NonExistent' });
-            expect(result).toBeUndefined();
-        });
+        // This hits tryHardDeleteByQuery
+        const result = await plainRepo.tryDeleteByQuery({ description: 'NonExistent' });
+        expect(result).toBeUndefined();
     });
     test('tryUpsertCTI returning undefined when update condition fails', async () => {
-        await runInInjectionContext(injector, async () => {
-            const repository = injectRepository(PremiumItem);
-            const item = Object.assign(new PremiumItem(), { name: 'Condition Item', code: 'COND' });
-            const inserted = await repository.insert(item);
-            const conflictItem = Object.assign(new PremiumItem(), { id: inserted.id, name: 'Should Not Update', code: 'COND' });
-            // Upsert with a condition that evaluates to false
-            const result = await repository.tryUpsert(['id'], conflictItem, undefined, { set: { name: 'Impossible Name' } } // This query condition on the existing row must fail
-            );
-            expect(result).toBeUndefined();
-            const loaded = await repository.load(inserted.id);
-            expect(loaded.name).toBe('Condition Item'); // Should not have changed
-        });
+        const item = Object.assign(new PremiumItem(), { name: 'Condition Item', code: 'COND' });
+        const inserted = await premiumRepo.insert(item);
+        const conflictItem = Object.assign(new PremiumItem(), { id: inserted.id, name: 'Should Not Update', code: 'COND' });
+        // Upsert with a condition that evaluates to false
+        const result = await premiumRepo.tryUpsert(['id'], conflictItem, undefined, { set: { name: 'Impossible Name' } } // This query condition on the existing row must fail
+        );
+        expect(result).toBeUndefined();
+        const loaded = await premiumRepo.load(inserted.id);
+        expect(loaded.name).toBe('Condition Item'); // Should not have changed
     });
     test('Discriminator mismatch throws error', async () => {
-        await runInInjectionContext(injector, async () => {
-            const repository = injectRepository(PremiumItem);
-            // Simulate a row returned from DB that has wrong type
-            // PremiumItem expects type='premium'
-            const corruptRow = {
-                id: 'some-id',
-                type: 'wrong_type',
-                name: 'Test',
-                code: 'C1',
-                revision: 1,
-                revision_timestamp: new Date(),
-                create_timestamp: new Date(),
-                delete_timestamp: null,
-                attributes: {},
-            };
-            await expect(repository.mapToEntity(corruptRow)).rejects.toThrow('Discriminator mismatch');
-        });
+        // Simulate a row returned from DB that has wrong type
+        // PremiumItem expects type='premium'
+        const corruptRow = {
+            id: 'some-id',
+            type: 'wrong_type',
+            name: 'Test',
+            code: 'C1',
+            revision: 1,
+            revision_timestamp: new Date(),
+            create_timestamp: new Date(),
+            delete_timestamp: null,
+            attributes: {},
+        };
+        await expect(premiumRepo.mapToEntity(corruptRow)).rejects.toThrow('Discriminator mismatch');
     });
     test('updateManyByQuery (CTI) should return empty array if no IDs found', async () => {
-        // This hits line 1524
-        await runInInjectionContext(injector, async () => {
-            const repository = injectRepository(PremiumItem);
-            // Query that returns nothing
-            const result = await repository.updateManyByQuery({ name: 'Ghost' }, { name: 'Buster' });
-            expect(result).toHaveLength(0);
-        });
+        // Query that returns nothing
+        const result = await premiumRepo.updateManyByQuery({ name: 'Ghost' }, { name: 'Buster' });
+        expect(result).toHaveLength(0);
     });
     test('updateManyByQuery on Non-CTI', async () => {
-        await runInInjectionContext(injector, async () => {
-            const repository = injectRepository(SimpleItem);
-            await repository.insert(Object.assign(new SimpleItem(), { label: 'To Update' }));
-            const results = await repository.updateManyByQuery({ label: 'To Update' }, { label: 'Updated' });
-            expect(results).toHaveLength(1);
-            expect(results[0].label).toBe('Updated');
-        });
+        await simpleRepo.insert(Object.assign(new SimpleItem(), { label: 'To Update' }));
+        const results = await simpleRepo.updateManyByQuery({ label: 'To Update' }, { label: 'Updated' });
+        expect(results).toHaveLength(1);
+        expect(results[0].label).toBe('Updated');
     });
     test('updateByQuery throws NotFoundError', async () => {
-        await runInInjectionContext(injector, async () => {
-            const repository = injectRepository(SimpleItem);
-            await expect(repository.updateByQuery({ label: 'Ghost' }, { label: 'Buster' })).rejects.toThrow('SimpleItem not found');
-        });
+        await expect(simpleRepo.updateByQuery({ label: 'Ghost' }, { label: 'Buster' })).rejects.toThrow('SimpleItem not found');
     });
     test('tryUpdateByQuery returns undefined (CTI)', async () => {
-        await runInInjectionContext(injector, async () => {
-            const repository = injectRepository(PremiumItem);
-            const result = await repository.tryUpdateByQuery({ name: 'Ghost' }, { name: 'Buster' });
-            expect(result).toBeUndefined();
-        });
+        const result = await premiumRepo.tryUpdateByQuery({ name: 'Ghost' }, { name: 'Buster' });
+        expect(result).toBeUndefined();
     });
     test('tryUpdateByQuery updates entity (CTI)', async () => {
-        await runInInjectionContext(injector, async () => {
-            const repository = injectRepository(PremiumItem);
-            const item = await repository.insert(Object.assign(new PremiumItem(), { name: 'Target', code: 'T1' }));
-            const result = await repository.tryUpdateByQuery({ name: 'Target' }, { name: 'Updated Target' });
-            expect(result).toBeDefined();
-            expect(result.name).toBe('Updated Target');
-        });
+        const item = await premiumRepo.insert(Object.assign(new PremiumItem(), { name: 'Target', code: 'T1' }));
+        const result = await premiumRepo.tryUpdateByQuery({ name: 'Target' }, { name: 'Updated Target' });
+        expect(result).toBeDefined();
+        expect(result.name).toBe('Updated Target');
     });
     test('deleteManyByQuery (Soft Delete)', async () => {
-        await runInInjectionContext(injector, async () => {
-            const repository = injectRepository(SimpleItem);
-            await repository.insert(Object.assign(new SimpleItem(), { label: 'To Delete' }));
-            const results = await repository.deleteManyByQuery({ label: 'To Delete' });
-            expect(results).toHaveLength(1);
-            expect(results[0].label).toBe('To Delete');
-            expect(results[0].metadata.deleteTimestamp).not.toBeNull();
-        });
+        await simpleRepo.insert(Object.assign(new SimpleItem(), { label: 'To Delete' }));
+        const results = await simpleRepo.deleteManyByQuery({ label: 'To Delete' });
+        expect(results).toHaveLength(1);
+        expect(results[0].label).toBe('To Delete');
+        expect(results[0].metadata.deleteTimestamp).not.toBeNull();
     });
     test('deleteByQuery throws NotFoundError', async () => {
-        await runInInjectionContext(injector, async () => {
-            const repository = injectRepository(SimpleItem);
-            await expect(repository.deleteByQuery({ label: 'Ghost' })).rejects.toThrow('SimpleItem not found');
-        });
+        await expect(simpleRepo.deleteByQuery({ label: 'Ghost' })).rejects.toThrow('SimpleItem not found');
     });
 });

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

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