@tstdl/base 0.93.87 → 0.93.90

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

@@ -0,0 +1,303 @@
+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 { 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 { 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';
+describe('ORM Repository Coverage', () => {
+    let injector;
+    let db;
+    const schema = 'test_orm_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 = new Injector('TestCoverage');
+        configureOrm({
+            repositoryConfig: { schema },
+            connection: {
+                host: '127.0.0.1',
+                port: 5432,
+                user: 'tstdl',
+                password: 'wf7rq6glrk5jykne',
+                database: 'tstdl',
+            }
+        });
+        db = injector.resolve(Database);
+        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`);
+        await db.execute(sql `DROP TABLE IF EXISTS ${sql.identifier(schema)}.${sql.identifier('simple_items')} CASCADE`);
+        await db.execute(sql `DROP TABLE IF EXISTS ${sql.identifier(schema)}.${sql.identifier('plain_items')} CASCADE`);
+        await db.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 db.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 db.execute(sql `
+      CREATE TABLE ${sql.identifier(schema)}.${sql.identifier('simple_items')} (
+        id UUID PRIMARY KEY DEFAULT gen_random_uuid(),
+        label 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 '{}'
+      )
+    `);
+        await db.execute(sql `
+      CREATE TABLE ${sql.identifier(schema)}.${sql.identifier('plain_items')} (
+        id UUID PRIMARY KEY DEFAULT gen_random_uuid(),
+        description TEXT NOT NULL
+      )
+    `);
+    });
+    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);
+        });
+    });
+    test('upsertMany with empty array', async () => {
+        await runInInjectionContext(injector, async () => {
+            const repository = injectRepository(PremiumItem);
+            const result = await repository.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([]);
+        });
+    });
+    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();
+        });
+    });
+    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();
+        });
+    });
+    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();
+        });
+    });
+    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();
+        });
+    });
+    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();
+        });
+    });
+    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();
+        });
+    });
+    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();
+        });
+    });
+    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
+        });
+    });
+    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');
+        });
+    });
+    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);
+        });
+    });
+    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');
+        });
+    });
+    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');
+        });
+    });
+    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();
+        });
+    });
+    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');
+        });
+    });
+    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();
+        });
+    });
+    test('deleteByQuery throws NotFoundError', async () => {
+        await runInInjectionContext(injector, async () => {
+            const repository = injectRepository(SimpleItem);
+            await expect(repository.deleteByQuery({ label: 'Ghost' })).rejects.toThrow('SimpleItem not found');
+        });
+    });
+});

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

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

package/orm/tests/repository-cti-complex.test.js

@@ -0,0 +1,170 @@
+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 { sql } from 'drizzle-orm';
+import { beforeAll, describe, expect, test } from 'vitest';
+import { Injector, runInInjectionContext } from '../../injector/index.js';
+import { StringProperty } from '../../schema/index.js';
+import { ChildEntity, Inheritance, Table } from '../decorators.js';
+import { Entity } from '../entity.js';
+import { configureOrm, Database } from '../server/index.js';
+import { injectRepository } from '../server/repository.js';
+describe('ORM Repository CTI Complex', () => {
+    let injector;
+    let db;
+    const schema = 'test_orm_cti_complex';
+    let BaseEntity = class BaseEntity extends Entity {
+        type;
+        baseName;
+    };
+    __decorate([
+        StringProperty(),
+        __metadata("design:type", String)
+    ], BaseEntity.prototype, "type", void 0);
+    __decorate([
+        StringProperty(),
+        __metadata("design:type", String)
+    ], BaseEntity.prototype, "baseName", void 0);
+    BaseEntity = __decorate([
+        Table('base_entities', { schema }),
+        Inheritance({ strategy: 'joined', discriminatorColumn: 'type' })
+    ], BaseEntity);
+    let MiddleEntity = class MiddleEntity extends BaseEntity {
+        middleName;
+    };
+    __decorate([
+        StringProperty(),
+        __metadata("design:type", String)
+    ], MiddleEntity.prototype, "middleName", void 0);
+    MiddleEntity = __decorate([
+        Table('middle_entities', { schema }),
+        ChildEntity('middle')
+    ], MiddleEntity);
+    let LeafEntity = class LeafEntity extends MiddleEntity {
+        leafName;
+    };
+    __decorate([
+        StringProperty(),
+        __metadata("design:type", String)
+    ], LeafEntity.prototype, "leafName", void 0);
+    LeafEntity = __decorate([
+        Table('leaf_entities', { schema }),
+        ChildEntity('leaf')
+    ], LeafEntity);
+    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);
+        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('leaf_entities')} CASCADE`);
+        await db.execute(sql `DROP TABLE IF EXISTS ${sql.identifier(schema)}.${sql.identifier('middle_entities')} CASCADE`);
+        await db.execute(sql `DROP TABLE IF EXISTS ${sql.identifier(schema)}.${sql.identifier('base_entities')} CASCADE`);
+        await db.execute(sql `
+      CREATE TABLE ${sql.identifier(schema)}.${sql.identifier('base_entities')} (
+        id UUID PRIMARY KEY DEFAULT gen_random_uuid(),
+        type TEXT NOT NULL,
+        base_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 db.execute(sql `
+      CREATE TABLE ${sql.identifier(schema)}.${sql.identifier('middle_entities')} (
+        id UUID PRIMARY KEY,
+        type TEXT NOT NULL CHECK (type = 'middle' OR type = 'leaf'),
+        middle_name TEXT NOT NULL,
+        UNIQUE (id, type),
+        FOREIGN KEY (id, type) REFERENCES ${sql.identifier(schema)}.${sql.identifier('base_entities')}(id, type) ON DELETE CASCADE
+      )
+    `);
+        await db.execute(sql `
+      CREATE TABLE ${sql.identifier(schema)}.${sql.identifier('leaf_entities')} (
+        id UUID PRIMARY KEY,
+        type TEXT NOT NULL CHECK (type = 'leaf'),
+        leaf_name TEXT NOT NULL,
+        FOREIGN KEY (id, type) REFERENCES ${sql.identifier(schema)}.${sql.identifier('middle_entities')}(id, type) ON DELETE CASCADE
+      )
+    `);
+    });
+    test('should support deep inheritance (3 levels)', async () => {
+        await runInInjectionContext(injector, async () => {
+            const repository = injectRepository(LeafEntity);
+            const leaf = Object.assign(new LeafEntity(), {
+                baseName: 'Base',
+                middleName: 'Middle',
+                leafName: 'Leaf',
+            });
+            const inserted = await repository.insert(leaf);
+            expect(inserted.id).toBeDefined();
+            expect(inserted.baseName).toBe('Base');
+            expect(inserted.middleName).toBe('Middle');
+            expect(inserted.leafName).toBe('Leaf');
+            const loaded = await repository.load(inserted.id);
+            expect(loaded).toBeInstanceOf(LeafEntity);
+            expect(loaded.baseName).toBe('Base');
+            expect(loaded.middleName).toBe('Middle');
+            expect(loaded.leafName).toBe('Leaf');
+        });
+    });
+    test('should throw error on discriminator mismatch', async () => {
+        await runInInjectionContext(injector, async () => {
+            const middleRepository = injectRepository(MiddleEntity);
+            const leafRepository = injectRepository(LeafEntity);
+            const middle = await middleRepository.insert(Object.assign(new MiddleEntity(), {
+                baseName: 'B',
+                middleName: 'M',
+            }));
+            // Try to load middle as leaf
+            await expect(leafRepository.load(middle.id)).rejects.toThrow();
+        });
+    });
+    test('should upsert correctly on child entities', async () => {
+        await runInInjectionContext(injector, async () => {
+            const repository = injectRepository(MiddleEntity);
+            const e1 = Object.assign(new MiddleEntity(), { baseName: 'B1', middleName: 'M1' });
+            const inserted = await repository.insert(e1);
+            const update = Object.assign(new MiddleEntity(), { id: inserted.id, baseName: 'B1_Updated', middleName: 'M1_Updated' });
+            const upserted = await repository.upsert('id', update);
+            expect(upserted.id).toBe(inserted.id);
+            expect(upserted.baseName).toBe('B1_Updated');
+            expect(upserted.middleName).toBe('M1_Updated');
+        });
+    });
+    test('should handle upsert when parent exists but child does not', async () => {
+        await runInInjectionContext(injector, async () => {
+            const baseRepository = injectRepository(BaseEntity);
+            const middleRepository = injectRepository(MiddleEntity);
+            // Manually insert into base table only
+            const id = '00000000-0000-0000-0000-000000000001';
+            await db.execute(sql `
+        INSERT INTO ${sql.identifier(schema)}.${sql.identifier('base_entities')} (id, type, base_name, revision, revision_timestamp, create_timestamp, attributes)
+        VALUES (${id}, 'middle', 'OnlyBase', 1, now(), now(), '{}')
+      `);
+            // Now upsert via middle repository
+            const update = Object.assign(new MiddleEntity(), { id, baseName: 'Updated', middleName: 'NewMiddle' });
+            // This is expected to fail or behave unexpectedly if not handled, 
+            // because upsert (onConflictDoUpdate) usually targets one table.
+            // In CTI, we might need special handling.
+            const upserted = await middleRepository.upsert('id', update);
+            expect(upserted.id).toBe(id);
+            expect(upserted.middleName).toBe('NewMiddle');
+            const loaded = await middleRepository.load(id);
+            expect(loaded.middleName).toBe('NewMiddle');
+        });
+    });
+});

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

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

package/orm/tests/repository-cti-embedded.test.js

@@ -0,0 +1,188 @@
+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 { 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 { ChildEntity, Column, EmbeddedProperty, Inheritance, Table } from '../decorators.js';
+import { Entity } from '../entity.js';
+import { configureOrm, Database } from '../server/index.js';
+import { injectRepository } from '../server/repository.js';
+describe('ORM Repository CTI Embedded (Integration)', () => {
+    let injector;
+    let db;
+    const schema = 'test_orm_cti_embedded';
+    class Address {
+        street;
+        city;
+    }
+    __decorate([
+        StringProperty(),
+        __metadata("design:type", String)
+    ], Address.prototype, "street", void 0);
+    __decorate([
+        StringProperty(),
+        __metadata("design:type", String)
+    ], Address.prototype, "city", void 0);
+    class Contact {
+        phone;
+        email;
+    }
+    __decorate([
+        StringProperty(),
+        __metadata("design:type", String)
+    ], Contact.prototype, "phone", void 0);
+    __decorate([
+        StringProperty(),
+        __metadata("design:type", String)
+    ], Contact.prototype, "email", void 0);
+    let EntityWithAddress = class EntityWithAddress extends Entity {
+        type;
+        address;
+    };
+    __decorate([
+        StringProperty(),
+        Column({ name: 'type' }),
+        __metadata("design:type", String)
+    ], EntityWithAddress.prototype, "type", void 0);
+    __decorate([
+        EmbeddedProperty(Address, { prefix: 'addr_' }),
+        __metadata("design:type", Address)
+    ], EntityWithAddress.prototype, "address", void 0);
+    EntityWithAddress = __decorate([
+        Table('entities_with_address', { schema }),
+        Inheritance({ strategy: 'joined', discriminatorColumn: 'type' })
+    ], EntityWithAddress);
+    let UserWithContact = class UserWithContact extends EntityWithAddress {
+        name;
+        contact;
+    };
+    __decorate([
+        StringProperty(),
+        __metadata("design:type", String)
+    ], UserWithContact.prototype, "name", void 0);
+    __decorate([
+        EmbeddedProperty(Contact, { prefix: 'contact_' }),
+        __metadata("design:type", Contact)
+    ], UserWithContact.prototype, "contact", void 0);
+    UserWithContact = __decorate([
+        Table('users_with_contact', { schema }),
+        ChildEntity('user')
+    ], UserWithContact);
+    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);
+        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('users_with_contact')} CASCADE`);
+        await db.execute(sql `DROP TABLE IF EXISTS ${sql.identifier(schema)}.${sql.identifier('entities_with_address')} CASCADE`);
+        await db.execute(sql `
+      CREATE TABLE ${sql.identifier(schema)}.${sql.identifier('entities_with_address')} (
+        id UUID PRIMARY KEY DEFAULT gen_random_uuid(),
+        type TEXT NOT NULL,
+        addr_street TEXT NOT NULL,
+        addr_city 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 db.execute(sql `
+      CREATE TABLE ${sql.identifier(schema)}.${sql.identifier('users_with_contact')} (
+        id UUID PRIMARY KEY,
+        type TEXT NOT NULL CHECK (type = 'user'),
+        name TEXT NOT NULL,
+        contact_phone TEXT NOT NULL,
+        contact_email TEXT NOT NULL,
+        FOREIGN KEY (id, type) REFERENCES ${sql.identifier(schema)}.${sql.identifier('entities_with_address')} (id, type) ON DELETE CASCADE
+      )
+    `);
+    });
+    test('should insert and load entities with embedded properties in CTI', async () => {
+        await runInInjectionContext(injector, async () => {
+            const repository = injectRepository(UserWithContact);
+            const user = new UserWithContact();
+            user.address = { street: 'Main St', city: 'London' };
+            user.contact = { phone: '12345', email: 'test@example.com' };
+            user.name = 'John Doe';
+            const inserted = await repository.insert(user);
+            expect(inserted.address.street).toBe('Main St');
+            expect(inserted.contact.email).toBe('test@example.com');
+            const loaded = await repository.load(inserted.id);
+            expect(loaded.address.city).toBe('London');
+            expect(loaded.contact.phone).toBe('12345');
+            expect(loaded.name).toBe('John Doe');
+        });
+    });
+    test('should load polymorphically with embedded properties', async () => {
+        await runInInjectionContext(injector, async () => {
+            const baseRepo = injectRepository(EntityWithAddress);
+            const userRepo = injectRepository(UserWithContact);
+            await userRepo.insert(Object.assign(new UserWithContact(), {
+                name: 'Jane',
+                address: { street: 'High St', city: 'Paris' },
+                contact: { phone: '999', email: 'jane@test.com' },
+            }));
+            const all = await baseRepo.loadAll({ includeSubclasses: true });
+            const jane = all.find((u) => (u instanceof UserWithContact) && (u.name == 'Jane'));
+            expect(jane).toBeDefined();
+            expect(jane.address.city).toBe('Paris');
+            expect(jane.contact.email).toBe('jane@test.com');
+        });
+    });
+    test('should update embedded properties in both tables', async () => {
+        await runInInjectionContext(injector, async () => {
+            const repository = injectRepository(UserWithContact);
+            const user = await repository.insert(Object.assign(new UserWithContact(), {
+                name: 'UpdateMe',
+                address: { street: 'Old St', city: 'Old City' },
+                contact: { phone: '000', email: 'old@test.com' },
+            }));
+            await repository.update(user.id, {
+                address: { street: 'New St', city: 'New City' },
+                contact: { email: 'new@test.com' },
+            });
+            const updated = await repository.load(user.id);
+            expect(updated.address.street).toBe('New St');
+            expect(updated.address.city).toBe('New City');
+            expect(updated.contact.phone).toBe('000'); // Unchanged
+            expect(updated.contact.email).toBe('new@test.com');
+        });
+    });
+    test('should filter by embedded properties across tables', async () => {
+        await runInInjectionContext(injector, async () => {
+            const repository = injectRepository(UserWithContact);
+            await repository.insert(Object.assign(new UserWithContact(), {
+                name: 'Target',
+                address: { street: 'Secret St', city: 'Hidden' },
+                contact: { phone: '123', email: 'target@test.com' },
+            }));
+            // Filter by address (parent table) and contact (child table)
+            const results = await repository.loadManyByQuery({
+                address: { city: 'Hidden' },
+                contact: { email: 'target@test.com' },
+            }); // Type cast might be needed if Query doesn't perfectly map embedded deep objects yet
+            expect(results).toHaveLength(1);
+            expect(results[0].name).toBe('Target');
+        });
+    });
+});

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

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