@tstdl/base 0.93.182 → 0.93.183

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

@@ -1,242 +0,0 @@
-/** 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);
-    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 { 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 { 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;
-        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: 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`);
-        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 () => {
-        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 () => {
-        const result = await premiumRepo.upsertMany(['id'], []);
-        expect(result).toHaveLength(0);
-    });
-    test('updateManyByQuery on CTI with no matching rows', async () => {
-        // Query matching nothing
-        const results = await premiumRepo.updateManyByQuery({ name: 'NonExistent' }, { name: 'NewName' });
-        expect(results).toEqual([]);
-    });
-    test('tryUpdate returning undefined (non-CTI, no metadata)', async () => {
-        const result = await plainRepo.tryUpdate('00000000-0000-0000-0000-000000000000', { description: 'New Desc' });
-        expect(result).toBeUndefined();
-    });
-    test('tryUpdate returning undefined (CTI)', async () => {
-        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)
-        // 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 () => {
-        const result = await simpleRepo.tryDelete('00000000-0000-0000-0000-000000000000');
-        expect(result).toBeUndefined();
-    });
-    test('tryDelete returning undefined (non-CTI, no metadata)', async () => {
-        // 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 () => {
-        const result = await simpleRepo.tryDeleteByQuery({ label: 'NonExistent' });
-        expect(result).toBeUndefined();
-    });
-    test('tryDeleteByQuery returning undefined (non-CTI, no metadata)', async () => {
-        // This hits tryHardDeleteByQuery
-        const result = await plainRepo.tryDeleteByQuery({ description: 'NonExistent' });
-        expect(result).toBeUndefined();
-    });
-    test('tryUpsertCTI returning undefined when update condition fails', async () => {
-        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 () => {
-        // 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 () => {
-        // Query that returns nothing
-        const result = await premiumRepo.updateManyByQuery({ name: 'Ghost' }, { name: 'Buster' });
-        expect(result).toHaveLength(0);
-    });
-    test('updateManyByQuery on Non-CTI', async () => {
-        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 expect(simpleRepo.updateByQuery({ label: 'Ghost' }, { label: 'Buster' })).rejects.toThrow('SimpleItem not found');
-    });
-    test('tryUpdateByQuery returns undefined (CTI)', async () => {
-        const result = await premiumRepo.tryUpdateByQuery({ name: 'Ghost' }, { name: 'Buster' });
-        expect(result).toBeUndefined();
-    });
-    test('tryUpdateByQuery updates entity (CTI)', async () => {
-        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 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 expect(simpleRepo.deleteByQuery({ label: 'Ghost' })).rejects.toThrow('SimpleItem not found');
-    });
-});

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

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

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

@@ -1,151 +0,0 @@
-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 { describe, expect } from 'vitest';
-import { StringProperty } from '../../schema/index.js';
-import { getIntegrationTest } from '../../testing/index.js';
-import { ChildEntity, Inheritance, Table } from '../decorators.js';
-import { Entity } from '../entity.js';
-import { injectRepository } from '../server/repository.js';
-const schema = 'test_orm_cti_complex';
-const test = getIntegrationTest({ orm: { schema } });
-describe('ORM Repository 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);
-    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('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 () => {
-        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 () => {
-        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 () => {
-        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 ({ database: db }) => {
-        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

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

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

@@ -1,178 +0,0 @@
-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 { setupIntegrationTest } from '../../testing/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 { Database } from '../server/index.js';
-import { injectRepository } from '../server/repository.js';
-describe('ORM Repository CTI Embedded (Integration)', () => {
-    let injector;
-    let database;
-    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, database } = await setupIntegrationTest({ orm: { schema } }));
-        await database.execute(sql `CREATE SCHEMA IF NOT EXISTS ${sql.identifier(schema)}`);
-        await database.execute(sql `DROP TABLE IF EXISTS ${sql.identifier(schema)}.${sql.identifier('users_with_contact')} CASCADE`);
-        await database.execute(sql `DROP TABLE IF EXISTS ${sql.identifier(schema)}.${sql.identifier('entities_with_address')} CASCADE`);
-        await database.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 database.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

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