@tstdl/base 0.93.181 → 0.93.183

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

@@ -1,112 +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 { beforeAll, describe, expect, test } from 'vitest';
-import { Singleton } from '../../injector/decorators.js';
-import { StringProperty } from '../../schema/index.js';
-import { setupIntegrationTest } from '../../testing/index.js';
-import { ChildEntity, Column, Inheritance, Table } from '../decorators.js';
-import { Entity } from '../entity.js';
-import { getRepository } from '../server/repository.js';
-import { Transactional } from '../server/transactional.js';
-describe('ORM Repository CTI Transactions (Integration)', () => {
-    let injector;
-    let db;
-    let service;
-    const schema = 'test_orm_cti_transactions';
-    let Parent = class Parent extends Entity {
-        type;
-        name;
-    };
-    __decorate([
-        StringProperty(),
-        Column({ name: 'type' }),
-        __metadata("design:type", String)
-    ], Parent.prototype, "type", void 0);
-    __decorate([
-        StringProperty(),
-        __metadata("design:type", String)
-    ], Parent.prototype, "name", void 0);
-    Parent = __decorate([
-        Table('parents', { schema }),
-        Inheritance({ strategy: 'joined', discriminatorColumn: 'type' })
-    ], Parent);
-    let Child = class Child extends Parent {
-        childData;
-    };
-    __decorate([
-        StringProperty(),
-        __metadata("design:type", String)
-    ], Child.prototype, "childData", void 0);
-    Child = __decorate([
-        Table('children', { schema }),
-        ChildEntity('child')
-    ], Child);
-    let TestService = class TestService extends Transactional {
-        #childRepo = getRepository(Child);
-        async createTwo(name1, name2, failSecond) {
-            await this.transaction(async (tx) => {
-                const repo = injector.resolve(this.#childRepo).withTransaction(tx);
-                await repo.insert(Object.assign(new Child(), { name: name1, childData: 'data1' }));
-                if (failSecond) {
-                    throw new Error('Planned failure');
-                }
-                await repo.insert(Object.assign(new Child(), { name: name2, childData: 'data2' }));
-            });
-        }
-    };
-    TestService = __decorate([
-        Singleton()
-    ], TestService);
-    beforeAll(async () => {
-        ({ injector, database: db } = await setupIntegrationTest({
-            orm: { schema },
-        }));
-        service = injector.resolve(TestService);
-        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('children')} CASCADE`);
-        await db.execute(sql `DROP TABLE IF EXISTS ${sql.identifier(schema)}.${sql.identifier('parents')} CASCADE`);
-        await db.execute(sql `
-      CREATE TABLE ${sql.identifier(schema)}.${sql.identifier('parents')} (
-        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('children')} (
-        id UUID PRIMARY KEY,
-        type TEXT NOT NULL CHECK (type = 'child'),
-        child_data TEXT NOT NULL,
-        FOREIGN KEY (id, type) REFERENCES ${sql.identifier(schema)}.${sql.identifier('parents')} (id, type) ON DELETE CASCADE
-      )
-    `);
-    });
-    test('should rollback inheritance inserts across multiple tables on service error', async () => {
-        await expect(service.createTwo('ShouldRollback', 'Fails', true)).rejects.toThrow('Planned failure');
-        const { rows: parentRows } = await db.execute(sql `SELECT * FROM ${sql.identifier(schema)}.${sql.identifier('parents')}`);
-        const { rows: childRows } = await db.execute(sql `SELECT * FROM ${sql.identifier(schema)}.${sql.identifier('children')}`);
-        expect(parentRows).toHaveLength(0);
-        expect(childRows).toHaveLength(0);
-    });
-    test('should commit inheritance inserts across multiple tables on success', async () => {
-        await service.createTwo('C1', 'C2', false);
-        const { rows: parentRows } = await db.execute(sql `SELECT * FROM ${sql.identifier(schema)}.${sql.identifier('parents')}`);
-        const { rows: childRows } = await db.execute(sql `SELECT * FROM ${sql.identifier(schema)}.${sql.identifier('children')}`);
-        expect(parentRows).toHaveLength(2);
-        expect(childRows).toHaveLength(2);
-    });
-});

package/orm/tests/repository-cti-upsert-many.test.d.ts

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

package/orm/tests/repository-cti-upsert-many.test.js

@@ -1,115 +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 { Entity } from '../entity.js';
-import { getRepository } from '../server/index.js';
-describe('ORM Repository CTI UpsertMany (Integration)', () => {
-    let injector;
-    let db;
-    let itemRepo;
-    let bookRepo;
-    const schema = 'test_orm_cti_upsert_many';
-    let Item = class Item extends Entity {
-        type;
-        title;
-    };
-    __decorate([
-        StringProperty(),
-        Column({ name: 'type' }),
-        __metadata("design:type", String)
-    ], Item.prototype, "type", void 0);
-    __decorate([
-        StringProperty(),
-        __metadata("design:type", String)
-    ], Item.prototype, "title", void 0);
-    Item = __decorate([
-        Table('items', { schema }),
-        Inheritance({ strategy: 'joined', discriminatorColumn: 'type' })
-    ], Item);
-    let Book = class Book extends Item {
-        author;
-    };
-    __decorate([
-        StringProperty(),
-        __metadata("design:type", String)
-    ], Book.prototype, "author", void 0);
-    Book = __decorate([
-        Table('books', { schema }),
-        ChildEntity('book')
-    ], Book);
-    beforeAll(async () => {
-        ({ injector, database: db } = await setupIntegrationTest({
-            orm: { schema },
-        }));
-        itemRepo = injector.resolve(getRepository(Item));
-        bookRepo = injector.resolve(getRepository(Book));
-        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('books')} CASCADE`);
-        await db.execute(sql `DROP TABLE IF EXISTS ${sql.identifier(schema)}.${sql.identifier('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,
-        title 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('books')} (
-        id UUID PRIMARY KEY,
-        type TEXT NOT NULL CHECK (type = 'book'),
-        author TEXT NOT NULL,
-        FOREIGN KEY (id, type) REFERENCES ${sql.identifier(schema)}.${sql.identifier('items')} (id, type) ON DELETE CASCADE
-      )
-    `);
-    });
-    test('should upsertMany child entities (insert and update mixed)', async () => {
-        // 1. Insert initial books
-        const book1 = Object.assign(new Book(), { title: 'Book 1', author: 'Author 1' });
-        const book2 = Object.assign(new Book(), { title: 'Book 2', author: 'Author 2' });
-        const [inserted1, inserted2] = await bookRepo.insertMany([book1, book2]);
-        // 2. Prepare upsert payload: update book1, new book3
-        const update1 = Object.assign(new Book(), { id: inserted1.id, title: 'Book 1 Updated', author: 'Author 1 Updated' });
-        const book3 = Object.assign(new Book(), { title: 'Book 3', author: 'Author 3' });
-        const results = await bookRepo.upsertMany('id', [update1, book3]);
-        expect(results).toHaveLength(2);
-        const updated1 = results.find((b) => b.id === inserted1.id);
-        const inserted3 = results.find((b) => b.title === 'Book 3');
-        expect(updated1).toBeDefined();
-        expect(updated1.title).toBe('Book 1 Updated');
-        expect(updated1.author).toBe('Author 1 Updated');
-        expect(inserted3).toBeDefined();
-        expect(inserted3.id).toBeDefined();
-        expect(inserted3.author).toBe('Author 3');
-        // Verify book2 is untouched
-        const loaded2 = await bookRepo.load(inserted2.id);
-        expect(loaded2.title).toBe('Book 2');
-    });
-    test('should polymorphic tryLoadByQuery', async () => {
-        await bookRepo.insert(Object.assign(new Book(), { title: 'Unique Book', author: 'Unique Author' }));
-        // Load via Item repo using a book-specific property (should fail if not joined, but here we query by title)
-        // Querying by book-specific property requires casting query or using raw sql if repository type doesn't have it.
-        // But we can query by base property 'title'.
-        const loaded = await itemRepo.tryLoadByQuery({ title: 'Unique Book' }, { includeSubclasses: true });
-        expect(loaded).toBeDefined();
-        expect(loaded).toBeInstanceOf(Book);
-        expect(loaded.author).toBe('Unique Author');
-    });
-});

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

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

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

@@ -1,390 +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, beforeEach, describe, expect, test } from 'vitest';
-import { StringProperty } from '../../schema/index.js';
-import { dropTables, setupIntegrationTest, truncateTables } from '../../testing/index.js';
-import { ChildEntity, Column, Inheritance, Table } from '../decorators.js';
-import { Entity } from '../entity.js';
-import { getRepository } from '../server/index.js';
-describe('ORM Repository CTI (Integration)', () => {
-    let injector;
-    let database;
-    let adminRepository;
-    let guestRepository;
-    let userRepository;
-    let managerRepository;
-    const schema = 'test_orm_cti';
-    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 }),
-        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 }),
-        ChildEntity('admin')
-    ], Admin);
-    let Guest = class Guest extends BaseUser {
-        permissions;
-    };
-    __decorate([
-        StringProperty(),
-        Column({ name: 'permissions' }),
-        __metadata("design:type", String)
-    ], Guest.prototype, "permissions", void 0);
-    Guest = __decorate([
-        Table('guests', { schema }),
-        ChildEntity('guest')
-    ], Guest);
-    let Staff = class Staff extends BaseUser {
-        employeeId;
-    };
-    __decorate([
-        StringProperty(),
-        Column({ name: 'employee_id' }),
-        __metadata("design:type", String)
-    ], Staff.prototype, "employeeId", void 0);
-    Staff = __decorate([
-        Table('staff', { schema }),
-        Inheritance({ strategy: 'joined' }),
-        ChildEntity('staff')
-    ], Staff);
-    let Manager = class Manager extends Staff {
-        department;
-    };
-    __decorate([
-        StringProperty(),
-        Column({ name: 'department' }),
-        __metadata("design:type", String)
-    ], Manager.prototype, "department", void 0);
-    Manager = __decorate([
-        Table('managers', { schema }),
-        ChildEntity('manager')
-    ], Manager);
-    beforeAll(async () => {
-        ({ injector, database } = await setupIntegrationTest({ orm: { schema } }));
-        adminRepository = injector.resolve(getRepository(Admin));
-        guestRepository = injector.resolve(getRepository(Guest));
-        userRepository = injector.resolve(getRepository(BaseUser));
-        managerRepository = injector.resolve(getRepository(Manager));
-        await database.execute(sql `CREATE SCHEMA IF NOT EXISTS ${sql.identifier(schema)}`);
-        await dropTables(database, schema, ['managers', 'staff', 'guests', 'admins', 'users']);
-        await database.execute(sql `
-      CREATE TABLE ${sql.identifier(schema)}.${sql.identifier('users')} (
-        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('admins')} (
-        id UUID PRIMARY KEY,
-        type TEXT NOT NULL CHECK (type = 'admin'),
-        role TEXT NOT NULL,
-        FOREIGN KEY (id, type) REFERENCES ${sql.identifier(schema)}.${sql.identifier('users')} (id, type) ON DELETE CASCADE
-      )
-    `);
-        await database.execute(sql `
-      CREATE TABLE ${sql.identifier(schema)}.${sql.identifier('guests')} (
-        id UUID PRIMARY KEY,
-        type TEXT NOT NULL CHECK (type = 'guest'),
-        permissions TEXT NOT NULL,
-        FOREIGN KEY (id, type) REFERENCES ${sql.identifier(schema)}.${sql.identifier('users')} (id, type) ON DELETE CASCADE
-      )
-    `);
-        await database.execute(sql `
-      CREATE TABLE ${sql.identifier(schema)}.${sql.identifier('staff')} (
-        id UUID PRIMARY KEY,
-        type TEXT NOT NULL,
-        employee_id TEXT NOT NULL,
-        UNIQUE (id, type),
-        FOREIGN KEY (id, type) REFERENCES ${sql.identifier(schema)}.${sql.identifier('users')} (id, type) ON DELETE CASCADE
-      )
-    `);
-        await database.execute(sql `
-      CREATE TABLE ${sql.identifier(schema)}.${sql.identifier('managers')} (
-        id UUID PRIMARY KEY,
-        type TEXT NOT NULL CHECK (type = 'manager'),
-        department TEXT NOT NULL,
-        FOREIGN KEY (id, type) REFERENCES ${sql.identifier(schema)}.${sql.identifier('staff')} (id, type) ON DELETE CASCADE
-      )
-    `);
-    });
-    beforeEach(async () => {
-        await truncateTables(database, schema, ['users']);
-    });
-    test('should insert into both parent and child tables', async () => {
-        const newAdmin = new Admin();
-        newAdmin.name = 'Alice';
-        newAdmin.role = 'SuperAdmin';
-        const inserted = await adminRepository.insert(newAdmin);
-        expect(inserted).toBeInstanceOf(Admin);
-        expect(inserted.id).toBeDefined();
-        expect(inserted.name).toBe('Alice');
-        expect(inserted.role).toBe('SuperAdmin');
-        expect(inserted.type).toBe('admin');
-        expect(inserted.metadata.revision).toBe(1);
-        // Verify DB state
-        const { rows: [userRow] } = await database.execute(sql `SELECT * FROM ${sql.identifier(schema)}.${sql.identifier('users')} WHERE id = ${inserted.id}`);
-        expect(userRow).toBeDefined();
-        expect(userRow['type']).toBe('admin');
-        expect(userRow['name']).toBe('Alice');
-        expect(userRow['revision']).toBe(1);
-        const { rows: [adminRow] } = await database.execute(sql `SELECT * FROM ${sql.identifier(schema)}.${sql.identifier('admins')} WHERE id = ${inserted.id}`);
-        expect(adminRow).toBeDefined();
-        expect(adminRow['type']).toBe('admin');
-        expect(adminRow['role']).toBe('SuperAdmin');
-    });
-    test('should insert many into both parent and child tables', async () => {
-        const admins = [
-            Object.assign(new Admin(), { name: 'Bob', role: 'Admin' }),
-            Object.assign(new Admin(), { name: 'Charlie', role: 'Moderator' }),
-        ];
-        const insertedAdmins = await adminRepository.insertMany(admins);
-        expect(insertedAdmins).toHaveLength(2);
-        expect(insertedAdmins[0].name).toBe('Bob');
-        expect(insertedAdmins[1].name).toBe('Charlie');
-        expect(insertedAdmins[0].type).toBe('admin');
-        expect(insertedAdmins[1].type).toBe('admin');
-        for (const inserted of insertedAdmins) {
-            const { rows: [userRow] } = await database.execute(sql `SELECT * FROM ${sql.identifier(schema)}.${sql.identifier('users')} WHERE id = ${inserted.id}`);
-            expect(userRow['name']).toBe(inserted.name);
-            const { rows: [adminRow] } = await database.execute(sql `SELECT * FROM ${sql.identifier(schema)}.${sql.identifier('admins')} WHERE id = ${inserted.id}`);
-            expect(adminRow['role']).toBe(inserted.role);
-        }
-    });
-    test('should update both parent and child tables', async () => {
-        const newAdmin = Object.assign(new Admin(), { name: 'Alice', role: 'SuperAdmin' });
-        const inserted = await adminRepository.insert(newAdmin);
-        const update = { name: 'Alice Updated', role: 'MegaAdmin' };
-        const updated = await adminRepository.update(inserted.id, update);
-        expect(updated.name).toBe('Alice Updated');
-        expect(updated.role).toBe('MegaAdmin');
-        expect(updated.metadata.revision).toBe(2);
-        // Verify DB state
-        const { rows: [userRow] } = await database.execute(sql `SELECT * FROM ${sql.identifier(schema)}.${sql.identifier('users')} WHERE id = ${inserted.id}`);
-        expect(userRow['name']).toBe('Alice Updated');
-        expect(userRow['revision']).toBe(2);
-        const { rows: [adminRow] } = await database.execute(sql `SELECT * FROM ${sql.identifier(schema)}.${sql.identifier('admins')} WHERE id = ${inserted.id}`);
-        expect(adminRow['role']).toBe('MegaAdmin');
-    });
-    test('should soft delete from parent table', async () => {
-        const newAdmin = Object.assign(new Admin(), { name: 'Alice', role: 'SuperAdmin' });
-        const inserted = await adminRepository.insert(newAdmin);
-        await adminRepository.delete(inserted.id);
-        // Verify DB state
-        const { rows: [userRow] } = await database.execute(sql `SELECT * FROM ${sql.identifier(schema)}.${sql.identifier('users')} WHERE id = ${inserted.id}`);
-        expect(userRow['delete_timestamp']).not.toBeNull();
-        // Child table should still have the row (soft delete only affects parent)
-        const { rows: [adminRow] } = await database.execute(sql `SELECT * FROM ${sql.identifier(schema)}.${sql.identifier('admins')} WHERE id = ${inserted.id}`);
-        expect(adminRow).toBeDefined();
-    });
-    test('should hard delete from both tables via cascade', async () => {
-        const newAdmin = Object.assign(new Admin(), { name: 'Alice', role: 'SuperAdmin' });
-        const inserted = await adminRepository.insert(newAdmin);
-        await adminRepository.hardDelete(inserted.id);
-        // Verify DB state
-        const { rows: userRows } = await database.execute(sql `SELECT * FROM ${sql.identifier(schema)}.${sql.identifier('users')} WHERE id = ${inserted.id}`);
-        expect(userRows).toHaveLength(0);
-        const { rows: adminRows } = await database.execute(sql `SELECT * FROM ${sql.identifier(schema)}.${sql.identifier('admins')} WHERE id = ${inserted.id}`);
-        expect(adminRows).toHaveLength(0);
-    });
-    test('should load entities polymorphically from parent repository', async () => {
-        await adminRepository.insert(Object.assign(new Admin(), { name: 'Admin1', role: 'Super' }));
-        await guestRepository.insert(Object.assign(new Guest(), { name: 'Guest1', permissions: 'Read' }));
-        // Load without subclasses (default)
-        const users = await userRepository.loadAll();
-        expect(users).toHaveLength(2);
-        expect(users[0]).toBeInstanceOf(BaseUser);
-        expect(users[1]).toBeInstanceOf(BaseUser);
-        expect(users[0].role).toBeUndefined();
-        // Load with subclasses
-        const polymorphicUsers = await userRepository.loadAll({ includeSubclasses: true });
-        expect(polymorphicUsers).toHaveLength(2);
-        const admin = polymorphicUsers.find((u) => u instanceof Admin);
-        const guest = polymorphicUsers.find((u) => u instanceof Guest);
-        expect(admin).toBeDefined();
-        expect(admin).toBeInstanceOf(Admin);
-        expect(admin.name).toBe('Admin1');
-        expect(admin.role).toBe('Super');
-        expect(guest).toBeDefined();
-        expect(guest).toBeInstanceOf(Guest);
-        expect(guest.name).toBe('Guest1');
-        expect(guest).toBeInstanceOf(Guest);
-        expect(guest.name).toBe('Guest1');
-        expect(guest.permissions).toBe('Read');
-    });
-    test('should load polymorphic subset from parent repository', async () => {
-        await adminRepository.insert(Object.assign(new Admin(), { name: 'Admin1', role: 'Super' }));
-        await guestRepository.insert(Object.assign(new Guest(), { name: 'Guest1', permissions: 'Read' }));
-        // Load ONLY Admins polymorphically
-        const onlyAdmins = await userRepository.loadManyByQuery({}, { includeSubclasses: [Admin] });
-        expect(onlyAdmins).toHaveLength(2); // Still returns all users from base table
-        const admin = onlyAdmins.find((u) => u instanceof Admin);
-        const guestAsBase = onlyAdmins.find((u) => u.name === 'Guest1');
-        expect(admin).toBeInstanceOf(Admin);
-        expect(admin.role).toBe('Super');
-        expect(guestAsBase).not.toBeInstanceOf(Guest);
-        expect(guestAsBase).toBeInstanceOf(BaseUser);
-    });
-    test('should count and check existence for child entities', async () => {
-        await adminRepository.insert(Object.assign(new Admin(), { name: 'Admin1', role: 'Super' }));
-        await adminRepository.insert(Object.assign(new Admin(), { name: 'Admin2', role: 'Normal' }));
-        await guestRepository.insert(Object.assign(new Guest(), { name: 'Guest1', permissions: 'Read' }));
-        expect(await adminRepository.count()).toBe(2);
-        expect(await guestRepository.count()).toBe(1);
-        const admins = await adminRepository.loadAll();
-        expect(await adminRepository.has(admins[0].id)).toBe(true);
-        expect(await adminRepository.hasByQuery({ name: 'Admin2' })).toBe(true);
-        expect(await adminRepository.hasByQuery({ name: 'Guest1' })).toBe(false); // Different table
-    });
-    test('should query child entities by parent fields', async () => {
-        await adminRepository.insert(Object.assign(new Admin(), { name: 'TargetAdmin', role: 'Super' }));
-        await adminRepository.insert(Object.assign(new Admin(), { name: 'OtherAdmin', role: 'Normal' }));
-        const results = await adminRepository.loadManyByQuery({ name: 'TargetAdmin' });
-        expect(results).toHaveLength(1);
-        expect(results[0].name).toBe('TargetAdmin');
-        expect(results[0].role).toBe('Super');
-    });
-    test('should perform partial updates on parent or child fields', async () => {
-        const inserted = await adminRepository.insert(Object.assign(new Admin(), { name: 'Alice', role: 'Super' }));
-        // Update only parent field
-        await adminRepository.update(inserted.id, { name: 'Alice Renamed' });
-        let updated = await adminRepository.load(inserted.id);
-        expect(updated.name).toBe('Alice Renamed');
-        expect(updated.role).toBe('Super');
-        // Update only child field
-        await adminRepository.update(inserted.id, { role: 'Demoted' });
-        updated = await adminRepository.load(inserted.id);
-        expect(updated.name).toBe('Alice Renamed');
-        expect(updated.role).toBe('Demoted');
-    });
-    test('should fail when violating discriminator check constraint', async () => {
-        // Attempt manual insert with mismatched type
-        const query = database.execute(sql `
-      INSERT INTO ${sql.identifier(schema)}.${sql.identifier('admins')} (id, type, role)
-      VALUES (gen_random_uuid(), 'guest', 'Invalid')
-    `);
-        await expect(query).rejects.toThrow();
-    });
-    test('should fail when violating composite foreign key', async () => {
-        // Insert user with type 'guest'
-        const userId = '00000000-0000-0000-0000-000000000001';
-        await database.execute(sql `
-      INSERT INTO ${sql.identifier(schema)}.${sql.identifier('users')} (id, type, name, revision, revision_timestamp, create_timestamp)
-      VALUES (${userId}, 'guest', 'Guest User', 1, now(), now())
-    `);
-        // Attempt to insert admin pointing to that user (mismatched type 'admin' vs 'guest')
-        const query = database.execute(sql `
-      INSERT INTO ${sql.identifier(schema)}.${sql.identifier('admins')} (id, type, role)
-      VALUES (${userId}, 'admin', 'Admin Role')
-    `);
-        await expect(query).rejects.toThrow();
-    });
-    test('should support nested inheritance', async () => {
-        const manager = new Manager();
-        manager.name = 'Big Boss';
-        manager.employeeId = 'EMP001';
-        manager.department = 'Executive';
-        const inserted = await managerRepository.insert(manager);
-        expect(inserted.name).toBe('Big Boss');
-        expect(inserted.employeeId).toBe('EMP001');
-        expect(inserted.department).toBe('Executive');
-        expect(inserted.type).toBe('manager');
-        // Verify DB state - all 3 tables should have rows
-        const { rows: [userRow] } = await database.execute(sql `SELECT * FROM ${sql.identifier(schema)}.${sql.identifier('users')} WHERE id = ${inserted.id}`);
-        expect(userRow['name']).toBe('Big Boss');
-        const { rows: [staffRow] } = await database.execute(sql `SELECT * FROM ${sql.identifier(schema)}.${sql.identifier('staff')} WHERE id = ${inserted.id}`);
-        expect(staffRow['employee_id']).toBe('EMP001');
-        const { rows: [managerRow] } = await database.execute(sql `SELECT * FROM ${sql.identifier(schema)}.${sql.identifier('managers')} WHERE id = ${inserted.id}`);
-        expect(managerRow['department']).toBe('Executive');
-    });
-    test('should rollback parent insert if child insert fails', async () => {
-        // Attempt to insert an admin with a missing role (should fail because of NOT NULL)
-        const invalidAdmin = new Admin();
-        invalidAdmin.name = 'Broken Admin';
-        // role is missing
-        await expect(adminRepository.insert(invalidAdmin)).rejects.toThrow();
-        // Verify that NO row was created in the users table
-        const { rows } = await database.execute(sql `SELECT * FROM ${sql.identifier(schema)}.${sql.identifier('users')}`);
-        expect(rows).toHaveLength(0);
-    });
-    test('should count and check existence polymorphically', async () => {
-        await adminRepository.insert(Object.assign(new Admin(), { name: 'A1', role: 'R1' }));
-        await guestRepository.insert(Object.assign(new Guest(), { name: 'G1', permissions: 'P1' }));
-        expect(await userRepository.count()).toBe(2);
-        expect(await userRepository.hasByQuery({ name: 'A1' })).toBe(true);
-        expect(await userRepository.hasByQuery({ name: 'G1' })).toBe(true);
-    });
-    test('should load many by IDs polymorphically', async () => {
-        const a1 = await adminRepository.insert(Object.assign(new Admin(), { name: 'A1', role: 'R1' }));
-        const g1 = await guestRepository.insert(Object.assign(new Guest(), { name: 'G1', permissions: 'P1' }));
-        const results = await userRepository.loadMany([a1.id, g1.id], { includeSubclasses: true });
-        expect(results).toHaveLength(2);
-        expect(results.find((u) => u.id === a1.id)).toBeInstanceOf(Admin);
-        expect(results.find((u) => u.id === g1.id)).toBeInstanceOf(Guest);
-    });
-    test('should update many child entities', async () => {
-        const a1 = await adminRepository.insert(Object.assign(new Admin(), { name: 'A1', role: 'Old' }));
-        const a2 = await adminRepository.insert(Object.assign(new Admin(), { name: 'A2', role: 'Old' }));
-        await adminRepository.updateMany([a1.id, a2.id], { role: 'New' });
-        const results = await adminRepository.loadMany([a1.id, a2.id]);
-        expect(results[0].role).toBe('New');
-        expect(results[1].role).toBe('New');
-    });
-    test('should update nested inheritance fields', async () => {
-        const manager = Object.assign(new Manager(), { name: 'Boss', employeeId: 'E1', department: 'D1' });
-        const inserted = await managerRepository.insert(manager);
-        await managerRepository.update(inserted.id, { name: 'New Boss', employeeId: 'E2', department: 'D2' });
-        const updated = await managerRepository.load(inserted.id);
-        expect(updated.name).toBe('New Boss');
-        expect(updated.employeeId).toBe('E2');
-        expect(updated.department).toBe('D2');
-    });
-    test('should delete from nested inheritance tables', async () => {
-        const manager = Object.assign(new Manager(), { name: 'Boss', employeeId: 'E1', department: 'D1' });
-        const inserted = await managerRepository.insert(manager);
-        await managerRepository.hardDelete(inserted.id);
-        const { rows: userRows } = await database.execute(sql `SELECT * FROM ${sql.identifier(schema)}.${sql.identifier('users')} WHERE id = ${inserted.id}`);
-        const { rows: staffRows } = await database.execute(sql `SELECT * FROM ${sql.identifier(schema)}.${sql.identifier('staff')} WHERE id = ${inserted.id}`);
-        const { rows: managerRows } = await database.execute(sql `SELECT * FROM ${sql.identifier(schema)}.${sql.identifier('managers')} WHERE id = ${inserted.id}`);
-        expect(userRows).toHaveLength(0);
-        expect(staffRows).toHaveLength(0);
-        expect(managerRows).toHaveLength(0);
-    });
-});

package/orm/tests/repository-edge-cases.test.d.ts

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