@tstdl/base 0.93.86 → 0.93.89

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

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

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

@@ -0,0 +1 @@
+export {};

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

@@ -0,0 +1,71 @@
+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);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+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 { StringProperty } from '../../schema/index.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';
+describe('ORM Repository Mapping (CTI)', () => {
+    test('should flatten joined result when mapping child entity', async () => {
+        let BaseUser = class BaseUser extends Entity {
+            type;
+            name;
+        };
+        __decorate([
+            StringProperty(),
+            Column({ name: 'type' }),
+            __metadata("design:type", String)
+        ], BaseUser.prototype, "type", void 0);
+        __decorate([
+            StringProperty(),
+            Column({ name: 'name' }),
+            __metadata("design:type", String)
+        ], BaseUser.prototype, "name", void 0);
+        BaseUser = __decorate([
+            Table('users', { schema: 'test' }),
+            Inheritance({ strategy: 'joined', discriminatorColumn: 'type' })
+        ], BaseUser);
+        let Admin = class Admin extends BaseUser {
+            role;
+        };
+        __decorate([
+            StringProperty(),
+            Column({ name: 'role' }),
+            __metadata("design:type", String)
+        ], Admin.prototype, "role", void 0);
+        Admin = __decorate([
+            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
+        });
+        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);
+        });
+    });
+});

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

@@ -0,0 +1 @@
+export {};