@tstdl/base 0.93.162 → 0.93.164

package/orm/tests/repository-edge-cases.test.js

@@ -8,18 +8,16 @@ 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 { describe, expect } from 'vitest';
 import { NotFoundError } from '../../errors/not-found.error.js';
-import { Injector, runInInjectionContext } from '../../injector/index.js';
 import { StringProperty } from '../../schema/index.js';
+import { getIntegrationTest } from '../../testing/index.js';
 import { ChildEntity, Column, Inheritance, Table } from '../decorators.js';
 import { Entity } from '../entity.js';
-import { configureOrm, Database } from '../server/index.js';
 import { injectRepository } from '../server/repository.js';
+const schema = 'test_orm_edge_cases';
+const test = getIntegrationTest({ orm: { schema } });
 describe('ORM Repository Edge Cases', () => {
-    let injector;
-    let db;
-    const schema = 'test_orm_edge_cases';
     let BaseItem = class BaseItem extends Entity {
         type;
         name;
@@ -48,15 +46,7 @@ describe('ORM Repository Edge Cases', () => {
         Table('derived_items', { schema }),
         ChildEntity('derived')
     ], DerivedItem);
-    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);
+    test.beforeEach(async ({ database: db }) => {
         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('derived_items')} CASCADE`);
         await db.execute(sql `DROP TABLE IF EXISTS ${sql.identifier(schema)}.${sql.identifier('base_items')} CASCADE`);
@@ -83,134 +73,106 @@ describe('ORM Repository Edge Cases', () => {
     `);
     });
     test('should rollback transaction on insertMany failure', async () => {
-        await runInInjectionContext(injector, async () => {
-            const repo = injectRepository(BaseItem);
-            const id = '00000000-0000-0000-0000-000000000001';
-            try {
-                await repo.insertMany([
-                    Object.assign(new BaseItem(), { id, name: 'Success', type: 'base' }),
-                    Object.assign(new BaseItem(), { id, name: 'Fail', type: 'base' }) // Duplicate ID
-                ]);
-            }
-            catch {
-                // Expected
-            }
-            const count = await repo.count();
-            expect(count).toBe(0);
-        });
+        const repo = injectRepository(BaseItem);
+        const id = '00000000-0000-0000-0000-000000000001';
+        try {
+            await repo.insertMany([
+                Object.assign(new BaseItem(), { id, name: 'Success', type: 'base' }),
+                Object.assign(new BaseItem(), { id, name: 'Fail', type: 'base' }), // Duplicate ID
+            ]);
+        }
+        catch {
+            // Expected
+        }
+        const count = await repo.count();
+        expect(count).toBe(0);
     });
     test('should rollback transaction on updateMany failure', async () => {
-        await runInInjectionContext(injector, async () => {
-            const repo = injectRepository(BaseItem);
-            await repo.insert(Object.assign(new BaseItem(), { name: 'Item 1', type: 'base' }));
-            try {
-                await repo.transaction(async (tx) => {
-                    const txRepo = repo.withTransaction(tx);
-                    await txRepo.updateManyByQuery({}, { name: 'Updated' });
-                    throw new Error('Rollback');
-                });
-            }
-            catch {
-                // Expected
-            }
-            const item = await repo.loadByQuery({ name: 'Item 1' });
-            expect(item.name).toBe('Item 1');
-        });
+        const repo = injectRepository(BaseItem);
+        await repo.insert(Object.assign(new BaseItem(), { name: 'Item 1', type: 'base' }));
+        try {
+            await repo.transaction(async (tx) => {
+                const txRepo = repo.withTransaction(tx);
+                await txRepo.updateManyByQuery({}, { name: 'Updated' });
+                throw new Error('Rollback');
+            });
+        }
+        catch {
+            // Expected
+        }
+        const item = await repo.loadByQuery({ name: 'Item 1' });
+        expect(item.name).toBe('Item 1');
     });
     test('should throw on negative offset', async () => {
-        await runInInjectionContext(injector, async () => {
-            const repo = injectRepository(BaseItem);
-            await expect(repo.loadAll({ offset: -1 })).rejects.toThrow();
-        });
+        const repo = injectRepository(BaseItem);
+        await expect(repo.loadAll({ offset: -1 })).rejects.toThrow();
     });
     test('should fail when unique constraint is violated even if soft deleted', async () => {
-        await runInInjectionContext(injector, async () => {
-            const repo = injectRepository(BaseItem);
-            const id = '00000000-0000-0000-0000-000000000002';
-            await repo.insert(Object.assign(new BaseItem(), { id, name: 'A', type: 'base' }));
-            await repo.delete(id);
-            // Attempt to insert same ID again (Unique violation)
-            await expect(repo.insert(Object.assign(new BaseItem(), { id, name: 'B', type: 'base' }))).rejects.toThrow();
-        });
+        const repo = injectRepository(BaseItem);
+        const id = '00000000-0000-0000-0000-000000000002';
+        await repo.insert(Object.assign(new BaseItem(), { id, name: 'A', type: 'base' }));
+        await repo.delete(id);
+        // Attempt to insert same ID again (Unique violation)
+        await expect(repo.insert(Object.assign(new BaseItem(), { id, name: 'B', type: 'base' }))).rejects.toThrow();
     });
-    test('should fail loading if child row is missing (data corruption)', async () => {
-        await runInInjectionContext(injector, async () => {
-            const derivedRepo = injectRepository(DerivedItem);
-            const baseRepo = injectRepository(BaseItem);
-            const derived = await derivedRepo.insert(Object.assign(new DerivedItem(), { name: 'Derived', description: 'Desc' }));
-            // Manually delete child row
-            await db.execute(sql `DELETE FROM ${sql.identifier(schema)}.${sql.identifier('derived_items')} WHERE id = ${derived.id}`);
-            // Verify deletion
-            const { rows } = await db.execute(sql `SELECT * FROM ${sql.identifier(schema)}.${sql.identifier('derived_items')} WHERE id = ${derived.id}`);
-            expect(rows).toHaveLength(0);
-            // Child repo should fail because primary table row is missing
-            await expect(derivedRepo.load(derived.id)).rejects.toThrow(NotFoundError);
-            // Base repo should succeed (returning corrupted entity) because base row exists and it uses left join for subclasses
-            const loadedBase = await baseRepo.load(derived.id, { includeSubclasses: true });
-            expect(loadedBase).toBeInstanceOf(DerivedItem);
-            expect(loadedBase.description).toBeNull();
-        });
+    test('should fail loading if child row is missing (data corruption)', async ({ database: db }) => {
+        const derivedRepo = injectRepository(DerivedItem);
+        const baseRepo = injectRepository(BaseItem);
+        const derived = await derivedRepo.insert(Object.assign(new DerivedItem(), { name: 'Derived', description: 'Desc' }));
+        // Manually delete child row
+        await db.execute(sql `DELETE FROM ${sql.identifier(schema)}.${sql.identifier('derived_items')} WHERE id = ${derived.id}`);
+        // Verify deletion
+        const { rows } = await db.execute(sql `SELECT * FROM ${sql.identifier(schema)}.${sql.identifier('derived_items')} WHERE id = ${derived.id}`);
+        expect(rows).toHaveLength(0);
+        // Child repo should fail because primary table row is missing
+        await expect(derivedRepo.load(derived.id)).rejects.toThrow(NotFoundError);
+        // Base repo should succeed (returning corrupted entity) because base row exists and it uses left join for subclasses
+        const loadedBase = await baseRepo.load(derived.id, { includeSubclasses: true });
+        expect(loadedBase).toBeInstanceOf(DerivedItem);
+        expect(loadedBase.description).toBeNull();
     });
     test('should throw NotFoundError when update target does not exist', async () => {
-        await runInInjectionContext(injector, async () => {
-            const repo = injectRepository(BaseItem);
-            await expect(repo.update('00000000-0000-0000-0000-000000000000', { name: 'New' })).rejects.toThrow(NotFoundError);
-        });
+        const repo = injectRepository(BaseItem);
+        await expect(repo.update('00000000-0000-0000-0000-000000000000', { name: 'New' })).rejects.toThrow(NotFoundError);
     });
     test('should throw NotFoundError when updateByQuery matches nothing', async () => {
-        await runInInjectionContext(injector, async () => {
-            const repo = injectRepository(BaseItem);
-            await expect(repo.updateByQuery({ name: 'Missing' }, { name: 'New' })).rejects.toThrow(NotFoundError);
-        });
+        const repo = injectRepository(BaseItem);
+        await expect(repo.updateByQuery({ name: 'Missing' }, { name: 'New' })).rejects.toThrow(NotFoundError);
     });
     test('should throw NotFoundError when delete target does not exist', async () => {
-        await runInInjectionContext(injector, async () => {
-            const repo = injectRepository(BaseItem);
-            await expect(repo.delete('00000000-0000-0000-0000-000000000000')).rejects.toThrow(NotFoundError);
-        });
+        const repo = injectRepository(BaseItem);
+        await expect(repo.delete('00000000-0000-0000-0000-000000000000')).rejects.toThrow(NotFoundError);
     });
     test('should throw NotFoundError when deleteByQuery matches nothing', async () => {
-        await runInInjectionContext(injector, async () => {
-            const repo = injectRepository(BaseItem);
-            await expect(repo.deleteByQuery({ name: 'Missing' })).rejects.toThrow(NotFoundError);
-        });
+        const repo = injectRepository(BaseItem);
+        await expect(repo.deleteByQuery({ name: 'Missing' })).rejects.toThrow(NotFoundError);
     });
     test('should throw NotFoundError when hardDelete target does not exist', async () => {
-        await runInInjectionContext(injector, async () => {
-            const repo = injectRepository(BaseItem);
-            await expect(repo.hardDelete('00000000-0000-0000-0000-000000000000')).rejects.toThrow(NotFoundError);
-        });
+        const repo = injectRepository(BaseItem);
+        await expect(repo.hardDelete('00000000-0000-0000-0000-000000000000')).rejects.toThrow(NotFoundError);
     });
     test('should throw NotFoundError when hardDeleteByQuery matches nothing', async () => {
-        await runInInjectionContext(injector, async () => {
-            const repo = injectRepository(BaseItem);
-            await expect(repo.hardDeleteByQuery({ name: 'Missing' })).rejects.toThrow(NotFoundError);
-        });
+        const repo = injectRepository(BaseItem);
+        await expect(repo.hardDeleteByQuery({ name: 'Missing' })).rejects.toThrow(NotFoundError);
     });
     test('should handle empty updates gracefully', async () => {
-        await runInInjectionContext(injector, async () => {
-            const repo = injectRepository(BaseItem);
-            const item = await repo.insert(Object.assign(new BaseItem(), { name: 'EmptyUpdate', type: 'base' }));
-            const updated = await repo.update(item.id, {});
-            expect(updated.metadata.revision).toBeGreaterThan(item.metadata.revision);
-            expect(updated.name).toBe('EmptyUpdate');
-        });
+        const repo = injectRepository(BaseItem);
+        const item = await repo.insert(Object.assign(new BaseItem(), { name: 'EmptyUpdate', type: 'base' }));
+        const updated = await repo.update(item.id, {});
+        expect(updated.metadata.revision).toBeGreaterThan(item.metadata.revision);
+        expect(updated.name).toBe('EmptyUpdate');
     });
     test('should handle unknown properties in query gracefully (throw error)', async () => {
-        await runInInjectionContext(injector, async () => {
-            const repo = injectRepository(BaseItem);
-            await expect(repo.loadByQuery({ unknownProp: 'value' })).rejects.toThrow('Could not map property unknownProp');
-        });
+        const repo = injectRepository(BaseItem);
+        await expect(repo.loadByQuery({ unknownProp: 'value' })).rejects.toThrow('Could not map property unknownProp');
     });
     test('should prevent updating discriminator column via update', async () => {
-        await runInInjectionContext(injector, async () => {
-            const repo = injectRepository(BaseItem);
-            const item = await repo.insert(Object.assign(new BaseItem(), { name: 'TypeCheck', type: 'base' }));
-            // Try to change type to 'derived'
-            await repo.update(item.id, { type: 'derived' });
-            const reloaded = await repo.load(item.id);
-            // It should change if not blocked
-            expect(reloaded.type).toBe('derived');
-        });
+        const repo = injectRepository(BaseItem);
+        const item = await repo.insert(Object.assign(new BaseItem(), { name: 'TypeCheck', type: 'base' }));
+        // Try to change type to 'derived'
+        await repo.update(item.id, { type: 'derived' });
+        const reloaded = await repo.load(item.id);
+        // It should change if not blocked
+        expect(reloaded.type).toBe('derived');
     });
 });

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

@@ -9,11 +9,10 @@ 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 { setupIntegrationTest } from '../../testing/index.js';
 import { ChildEntity, Column, Inheritance, Table } from '../decorators.js';
 import { Entity } from '../entity.js';
-import { configureOrm } from '../server/index.js';
 import { getRepository } from '../server/repository.js';
 describe('ORM Repository Mapping (CTI)', () => {
     test('should flatten joined result when mapping child entity', async () => {
@@ -47,17 +46,12 @@ describe('ORM Repository Mapping (CTI)', () => {
             Table('admins', { schema: 'test' }),
             ChildEntity('admin')
         ], Admin);
-        const injector = new Injector('Test');
-        configureOrm({
-            repositoryConfig: { schema: 'test' },
-            connection: { database: 'test' }, // Mock config, we won't query DB
-            injector,
-        });
+        const { injector } = await setupIntegrationTest({ orm: { schema: 'test' } });
         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' }
+            admins: { id: '123', type: 'admin', role: 'super-admin' },
         };
         // Access private method for testing (using any cast)
         const mappedEntity = await repository._mapToEntity(mockResult, {});

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

@@ -7,18 +7,16 @@ 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 { beforeAll, describe, expect, test } from 'vitest';
 import { sql } from 'drizzle-orm';
+import { describe, expect } from 'vitest';
 import { StringProperty } from '../../schema/index.js';
-import { Entity } from '../entity.js';
+import { getIntegrationTest } from '../../testing/index.js';
 import { Table } from '../decorators.js';
+import { Entity } from '../entity.js';
 import { injectRepository } from '../server/repository.js';
-import { configureOrm, Database } from '../server/index.js';
-import { Injector, runInInjectionContext } from '../../injector/index.js';
+const schema = 'test_orm_search_coverage';
+const test = getIntegrationTest({ orm: { schema } });
 describe('ORM Repository Search Coverage', () => {
-    let injector;
-    let db;
-    const schema = 'test_orm_search_coverage';
     let Document = class Document extends Entity {
         content;
     };
@@ -29,15 +27,7 @@ describe('ORM Repository Search Coverage', () => {
     Document = __decorate([
         Table('docs', { schema })
     ], Document);
-    beforeAll(async () => {
-        injector = new Injector('TestSearchCoverage');
-        configureOrm({
-            repositoryConfig: { schema },
-            connection: {
-                host: '127.0.0.1', port: 5432, user: 'tstdl', password: 'wf7rq6glrk5jykne', database: 'tstdl',
-            },
-        });
-        db = injector.resolve(Database);
+    test.beforeEach(async ({ database: db }) => {
         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('docs')} CASCADE`);
         await db.execute(sql `CREATE EXTENSION IF NOT EXISTS pg_trgm`); // Enable trigram
@@ -54,76 +44,64 @@ describe('ORM Repository Search Coverage', () => {
     `);
     });
     test('tsvector search with order function accessing score', async () => {
-        await runInInjectionContext(injector, async () => {
-            const repository = injectRepository(Document);
-            await repository.insert(Object.assign(new Document(), { content: 'Apple Banana' }));
-            const results = await repository.search({
-                query: { $tsvector: { fields: ['content'], query: 'Apple' } },
-                order: (cols) => [[cols.score, 'desc']]
-            });
-            expect(results).toHaveLength(1);
+        const repository = injectRepository(Document);
+        await repository.insert(Object.assign(new Document(), { content: 'Apple Banana' }));
+        const results = await repository.search({
+            query: { $tsvector: { fields: ['content'], query: 'Apple' } },
+            order: (cols) => [[cols.score, 'desc']],
         });
+        expect(results).toHaveLength(1);
     });
     test('trigram search basic', async () => {
-        await runInInjectionContext(injector, async () => {
-            const repository = injectRepository(Document);
-            await repository.insert(Object.assign(new Document(), { content: 'Trigram Test' }));
-            const results = await repository.search({
-                query: { $trigram: { fields: ['content'], query: 'Trigram' } },
-            });
-            expect(results).toHaveLength(1);
+        const repository = injectRepository(Document);
+        await repository.insert(Object.assign(new Document(), { content: 'Trigram Test' }));
+        const results = await repository.search({
+            query: { $trigram: { fields: ['content'], query: 'Trigram' } },
         });
+        expect(results).toHaveLength(1);
     });
-    test('trigram search with threshold (phrase)', async () => {
-        await runInInjectionContext(injector, async () => {
-            const repository = injectRepository(Document);
-            await repository.insert(Object.assign(new Document(), { content: 'Phrase Match' }));
-            // Set threshold to a value that allows matching (default is 0.3)
-            await db.execute(sql `SET pg_trgm.similarity_threshold = 0.1`);
-            const results = await repository.search({
-                query: { $trigram: { fields: ['content'], query: 'Phrase', type: 'phrase', threshold: 0.1 } },
-            });
-            expect(results).toHaveLength(1);
+    test('trigram search with threshold (phrase)', async ({ database: db }) => {
+        const repository = injectRepository(Document);
+        await repository.insert(Object.assign(new Document(), { content: 'Phrase Match' }));
+        // Set threshold to a value that allows matching (default is 0.3)
+        await db.execute(sql `SET pg_trgm.similarity_threshold = 0.1`);
+        const results = await repository.search({
+            query: { $trigram: { fields: ['content'], query: 'Phrase', type: 'phrase', threshold: 0.1 } },
         });
+        expect(results).toHaveLength(1);
     });
-    test('trigram search with threshold (word)', async () => {
-        await runInInjectionContext(injector, async () => {
-            const repository = injectRepository(Document);
-            await repository.insert(Object.assign(new Document(), { content: 'Word Match' }));
-            await db.execute(sql `SET pg_trgm.word_similarity_threshold = 0.1`);
-            const results = await repository.search({
-                query: { $trigram: { fields: ['content'], query: 'Word', type: 'word', threshold: 0.1 } },
-            });
-            expect(results).toHaveLength(1);
+    test('trigram search with threshold (word)', async ({ database: db }) => {
+        const repository = injectRepository(Document);
+        await repository.insert(Object.assign(new Document(), { content: 'Word Match' }));
+        await db.execute(sql `SET pg_trgm.word_similarity_threshold = 0.1`);
+        const results = await repository.search({
+            query: { $trigram: { fields: ['content'], query: 'Word', type: 'word', threshold: 0.1 } },
         });
+        expect(results).toHaveLength(1);
     });
-    test('trigram search with threshold (strict-word)', async () => {
-        await runInInjectionContext(injector, async () => {
-            const repository = injectRepository(Document);
-            await repository.insert(Object.assign(new Document(), { content: 'Strict Match' }));
-            await db.execute(sql `SET pg_trgm.strict_word_similarity_threshold = 0.1`);
-            const results = await repository.search({
-                query: { $trigram: { fields: ['content'], query: 'Strict', type: 'strict-word', threshold: 0.1 } },
-            });
-            expect(results).toHaveLength(1);
+    test('trigram search with threshold (strict-word)', async ({ database: db }) => {
+        const repository = injectRepository(Document);
+        await repository.insert(Object.assign(new Document(), { content: 'Strict Match' }));
+        await db.execute(sql `SET pg_trgm.strict_word_similarity_threshold = 0.1`);
+        const results = await repository.search({
+            query: { $trigram: { fields: ['content'], query: 'Strict', type: 'strict-word', threshold: 0.1 } },
         });
+        expect(results).toHaveLength(1);
     });
     test('trigram search with order function', async () => {
-        await runInInjectionContext(injector, async () => {
-            const repository = injectRepository(Document);
-            const results = await repository.search({
-                query: { $trigram: { fields: ['content'], query: 'Order' } },
-                order: ({ score }) => [[score, 'desc']]
-            });
-            // Even if no results, code path is exercised?
-            // No, order function is called only if query is executed.
-            // Insert something first
-            await repository.insert(Object.assign(new Document(), { content: 'Order Test' }));
-            const results2 = await repository.search({
-                query: { $trigram: { fields: ['content'], query: 'Order' } },
-                order: ({ score }) => [[score, 'desc']]
-            });
-            expect(results2).toHaveLength(1);
+        const repository = injectRepository(Document);
+        const results = await repository.search({
+            query: { $trigram: { fields: ['content'], query: 'Order' } },
+            order: ({ score }) => [[score, 'desc']],
+        });
+        // Even if no results, code path is exercised?
+        // No, order function is called only if query is executed.
+        // Insert something first
+        await repository.insert(Object.assign(new Document(), { content: 'Order Test' }));
+        const results2 = await repository.search({
+            query: { $trigram: { fields: ['content'], query: 'Order' } },
+            order: ({ score }) => [[score, 'desc']],
         });
+        expect(results2).toHaveLength(1);
     });
 });