@tstdl/base 0.93.182 → 0.93.184

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

@@ -1,279 +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 { NumberProperty, 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 Extensive (Integration)', () => {
-    let injector;
-    let db;
-    let personRepo;
-    let empRepo;
-    let mgrRepo;
-    let cntRepo;
-    const schema = 'test_orm_cti_extensive';
-    // --- Entities ---
-    let Person = class Person extends Entity {
-        type;
-        name;
-    };
-    __decorate([
-        StringProperty(),
-        Column({ name: 'type' }),
-        __metadata("design:type", String)
-    ], Person.prototype, "type", void 0);
-    __decorate([
-        StringProperty(),
-        Column({ name: 'name' }),
-        __metadata("design:type", String)
-    ], Person.prototype, "name", void 0);
-    Person = __decorate([
-        Table('persons', { schema }),
-        Inheritance({ strategy: 'joined', discriminatorColumn: 'type' })
-    ], Person);
-    let Employee = class Employee extends Person {
-        salary;
-    };
-    __decorate([
-        NumberProperty(),
-        Column({ name: 'salary' }),
-        __metadata("design:type", Number)
-    ], Employee.prototype, "salary", void 0);
-    Employee = __decorate([
-        Table('employees', { schema }),
-        Inheritance({ strategy: 'joined' }),
-        ChildEntity('employee')
-    ], Employee);
-    let Manager = class Manager extends Employee {
-        department;
-    };
-    __decorate([
-        StringProperty(),
-        Column({ name: 'department' }),
-        __metadata("design:type", String)
-    ], Manager.prototype, "department", void 0);
-    Manager = __decorate([
-        Table('managers', { schema }),
-        ChildEntity('manager')
-    ], Manager);
-    let Contractor = class Contractor extends Person {
-        contractEnd;
-    };
-    __decorate([
-        StringProperty() // Using string for date just for simplicity in this test unless DateProperty handles it well with mapped types, assuming DateProperty -> Date
-        ,
-        Column({ name: 'contract_end' }),
-        __metadata("design:type", String)
-    ], Contractor.prototype, "contractEnd", void 0);
-    Contractor = __decorate([
-        Table('contractors', { schema }),
-        ChildEntity('contractor')
-    ], Contractor);
-    // --- Setup ---
-    beforeAll(async () => {
-        ({ injector, database: db } = await setupIntegrationTest({
-            orm: { schema },
-        }));
-        personRepo = injector.resolve(getRepository(Person));
-        empRepo = injector.resolve(getRepository(Employee));
-        mgrRepo = injector.resolve(getRepository(Manager));
-        cntRepo = injector.resolve(getRepository(Contractor));
-        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('managers')} CASCADE`);
-        await db.execute(sql `DROP TABLE IF EXISTS ${sql.identifier(schema)}.${sql.identifier('employees')} CASCADE`);
-        await db.execute(sql `DROP TABLE IF EXISTS ${sql.identifier(schema)}.${sql.identifier('contractors')} CASCADE`);
-        await db.execute(sql `DROP TABLE IF EXISTS ${sql.identifier(schema)}.${sql.identifier('persons')} CASCADE`);
-        await db.execute(sql `
-      CREATE TABLE ${sql.identifier(schema)}.${sql.identifier('persons')} (
-        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('employees')} (
-        id UUID PRIMARY KEY,
-        type TEXT NOT NULL,
-        salary INTEGER NOT NULL,
-        UNIQUE (id, type),
-        FOREIGN KEY (id, type) REFERENCES ${sql.identifier(schema)}.${sql.identifier('persons')} (id, type) ON DELETE CASCADE
-      )
-    `);
-        await db.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('employees')} (id, type) ON DELETE CASCADE
-      )
-    `);
-        await db.execute(sql `
-      CREATE TABLE ${sql.identifier(schema)}.${sql.identifier('contractors')} (
-        id UUID PRIMARY KEY,
-        type TEXT NOT NULL CHECK (type = 'contractor'),
-        contract_end TEXT NOT NULL,
-        FOREIGN KEY (id, type) REFERENCES ${sql.identifier(schema)}.${sql.identifier('persons')} (id, type) ON DELETE CASCADE
-      )
-    `);
-    });
-    // --- Tests ---
-    test('should insert different subtypes via specific repositories', async () => {
-        await db.execute(sql `TRUNCATE TABLE ${sql.identifier(schema)}.${sql.identifier('persons')} CASCADE`);
-        const e1 = await empRepo.insert(Object.assign(new Employee(), { name: 'E1', salary: 50000 }));
-        const m1 = await mgrRepo.insert(Object.assign(new Manager(), { name: 'M1', salary: 80000, department: 'IT' }));
-        const c1 = await cntRepo.insert(Object.assign(new Contractor(), { name: 'C1', contractEnd: '2025-12-31' }));
-        expect(e1.type).toBe('employee');
-        expect(m1.type).toBe('manager');
-        expect(c1.type).toBe('contractor');
-    });
-    test('should filter by mixed parent and child properties', async () => {
-        await db.execute(sql `TRUNCATE TABLE ${sql.identifier(schema)}.${sql.identifier('persons')} CASCADE`);
-        await mgrRepo.insert(Object.assign(new Manager(), { name: 'Alice', salary: 90000, department: 'IT' }));
-        await mgrRepo.insert(Object.assign(new Manager(), { name: 'Bob', salary: 90000, department: 'HR' }));
-        await mgrRepo.insert(Object.assign(new Manager(), { name: 'Charlie', salary: 60000, department: 'IT' }));
-        // Filter by parent (salary) AND child (department)
-        const richITManagers = await mgrRepo.loadManyByQuery({
-            salary: 90000,
-            department: 'IT',
-        });
-        expect(richITManagers).toHaveLength(1);
-        expect(richITManagers[0].name).toBe('Alice');
-    });
-    test('should sort by parent property then child property', async () => {
-        await db.execute(sql `TRUNCATE TABLE ${sql.identifier(schema)}.${sql.identifier('persons')} CASCADE`);
-        await mgrRepo.insert(Object.assign(new Manager(), { name: 'A', salary: 50000, department: 'Z' }));
-        await mgrRepo.insert(Object.assign(new Manager(), { name: 'B', salary: 50000, department: 'A' }));
-        await mgrRepo.insert(Object.assign(new Manager(), { name: 'C', salary: 90000, department: 'A' }));
-        // Sort by salary (parent) DESC, then department (child) ASC
-        const sorted = await mgrRepo.loadManyByQuery({}, {
-            order: [
-                ['salary', 'desc'],
-                ['department', 'asc'],
-            ],
-        });
-        expect(sorted).toHaveLength(3);
-        expect(sorted[0].name).toBe('C'); // 90000
-        expect(sorted[1].name).toBe('B'); // 50000, A
-        expect(sorted[2].name).toBe('A'); // 50000, Z
-    });
-    test('should paginate polymorphic results correctly', async () => {
-        await db.execute(sql `TRUNCATE TABLE ${sql.identifier(schema)}.${sql.identifier('persons')} CASCADE`);
-        // Insert 5 entities: 2 employees, 2 managers, 1 contractor
-        // Names ordered: A, B, C, D, E
-        await empRepo.insert(Object.assign(new Employee(), { name: 'A_Emp', salary: 1000 }));
-        await mgrRepo.insert(Object.assign(new Manager(), { name: 'B_Mgr', salary: 2000, department: 'D1' }));
-        await cntRepo.insert(Object.assign(new Contractor(), { name: 'C_Cnt', contractEnd: '2025' }));
-        await empRepo.insert(Object.assign(new Employee(), { name: 'D_Emp', salary: 1000 }));
-        await mgrRepo.insert(Object.assign(new Manager(), { name: 'E_Mgr', salary: 2000, department: 'D2' }));
-        // Load page 1 (size 2) sorted by name
-        const page1 = await personRepo.loadManyByQuery({}, {
-            order: [['name', 'asc']],
-            limit: 2,
-            offset: 0,
-            includeSubclasses: [Employee, Manager, Contractor],
-        });
-        expect(page1).toHaveLength(2);
-        expect(page1[0].name).toBe('A_Emp');
-        expect(page1[0]).toBeInstanceOf(Employee);
-        expect(page1[1].name).toBe('B_Mgr');
-        expect(page1[1]).toBeInstanceOf(Manager);
-        // Load page 2 (size 2)
-        const page2 = await personRepo.loadManyByQuery({}, {
-            order: [['name', 'asc']],
-            limit: 2,
-            offset: 2,
-            includeSubclasses: [Employee, Manager, Contractor],
-        });
-        expect(page2).toHaveLength(2);
-        expect(page2[0].name).toBe('C_Cnt');
-        expect(page2[0]).toBeInstanceOf(Contractor);
-        expect(page2[1].name).toBe('D_Emp');
-        expect(page2[1]).toBeInstanceOf(Employee);
-        // Load page 3 (size 2) - should have 1
-        const page3 = await personRepo.loadManyByQuery({}, {
-            order: [['name', 'asc']],
-            limit: 2,
-            offset: 4,
-            includeSubclasses: [Employee, Manager, Contractor],
-        });
-        expect(page3).toHaveLength(1);
-        expect(page3[0].name).toBe('E_Mgr');
-    });
-    test('should rollback whole operation if one child insert fails in bulk insert', async () => {
-        // NOTE: Repositories typically don't support heterogeneous bulk insert via `insertMany` directly if they are typed to one Entity.
-        // But we can test transactional safety when manually doing multiple inserts or if we were to support it.
-        // Here we will test doing multiple operations in a transaction and failing one.
-        await db.execute(sql `TRUNCATE TABLE ${sql.identifier(schema)}.${sql.identifier('persons')} CASCADE`);
-        try {
-            await mgrRepo.transaction(async (tx) => {
-                const txRepo = mgrRepo.withTransaction(tx);
-                await txRepo.insert(Object.assign(new Manager(), { name: 'TxMgr1', salary: 1000, department: 'D1' }));
-                // This one should fail due to constraint violation (missing department is not nullable in DB but maybe optional in class?
-                // In our setup 'department' is NOT NULL.
-                // Let's force a failure by passing a raw invalid object or similar, or just throwing.
-                // A better DB constraint failure: Duplicate ID? Or invalid type?
-                // Let's try inserting a manager with a missing required field using 'any' to bypass TS check.
-                const invalidMgr = new Manager();
-                invalidMgr.name = 'TxMgr2';
-                invalidMgr.salary = 2000;
-                // Missing department
-                await txRepo.insert(invalidMgr);
-            });
-        }
-        catch (e) {
-            // Expected error
-        }
-        const { rows } = await db.execute(sql `SELECT * FROM ${sql.identifier(schema)}.${sql.identifier('persons')}`);
-        expect(rows).toHaveLength(0); // TxMgr1 should not be there
-    });
-    test('should load entities correctly when multiple levels of inheritance share column names', async () => {
-        // It's common to have 'name' or similar fields in child tables (shadowing).
-        // In our current schema we avoided it, but let's see if we can query based on aliasing if it were to happen?
-        // Actually, let's test querying with 'OR' condition across parent and child fields.
-        await db.execute(sql `TRUNCATE TABLE ${sql.identifier(schema)}.${sql.identifier('persons')} CASCADE`);
-        await mgrRepo.insert(Object.assign(new Manager(), { name: 'MatchName', salary: 1000, department: 'Other' }));
-        await mgrRepo.insert(Object.assign(new Manager(), { name: 'OtherName', salary: 1000, department: 'MatchDept' }));
-        await mgrRepo.insert(Object.assign(new Manager(), { name: 'NoMatch', salary: 1000, department: 'Other' }));
-        // Logic: name = 'MatchName' OR department = 'MatchDept'
-        // ORM's `loadManyByQuery` usually takes an object for AND.
-        // We might need to use `loadMany` with a custom query builder or check if `loadManyByQuery` supports arrays for OR?
-        // If not supported easily, we skip this specific complex query for now, or use `loadMany` with simple filters.
-        // Let's stick to simple filters that we know are supported: simple object matches (AND).
-        // Let's test a deeply nested query filter if supported.
-        const results = await mgrRepo.loadManyByQuery({
-            department: 'MatchDept',
-        });
-        expect(results).toHaveLength(1);
-        expect(results[0].name).toBe('OtherName');
-    });
-    test('should correctly count with subclass inclusion', async () => {
-        await db.execute(sql `TRUNCATE TABLE ${sql.identifier(schema)}.${sql.identifier('persons')} CASCADE`);
-        await empRepo.insert(Object.assign(new Employee(), { name: 'E1', salary: 100 }));
-        await mgrRepo.insert(Object.assign(new Manager(), { name: 'M1', salary: 200, department: 'D1' }));
-        // Count on Person should see 2
-        expect(await personRepo.count()).toBe(2);
-        // Count on Employee should see 2 (Manager IS-A Employee)
-        // Wait, does 'count()' on Employee include Managers by default?
-        // Standard CTI usually implies querying the 'employees' table which includes Managers' rows.
-        expect(await empRepo.count()).toBe(2);
-        // Count on Manager should see 1
-        expect(await mgrRepo.count()).toBe(1);
-    });
-});

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

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

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

@@ -1,108 +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 Mapping (Integration)', () => {
-    let injector;
-    let db;
-    let repo;
-    const schema = 'test_orm_cti_mapping';
-    let MappedParent = class MappedParent extends Entity {
-        discriminator;
-        displayName;
-    };
-    __decorate([
-        StringProperty(),
-        Column({ name: 'discriminator' }),
-        __metadata("design:type", String)
-    ], MappedParent.prototype, "discriminator", void 0);
-    __decorate([
-        StringProperty(),
-        Column({ name: 'display_name' }),
-        __metadata("design:type", String)
-    ], MappedParent.prototype, "displayName", void 0);
-    MappedParent = __decorate([
-        Table('mapped_parents', { schema }),
-        Inheritance({ strategy: 'joined', discriminatorColumn: 'discriminator' })
-    ], MappedParent);
-    let MappedChild = class MappedChild extends MappedParent {
-        secret;
-    };
-    __decorate([
-        StringProperty(),
-        Column({ name: 'internal_secret' }),
-        __metadata("design:type", String)
-    ], MappedChild.prototype, "secret", void 0);
-    MappedChild = __decorate([
-        Table('mapped_children', { schema }),
-        ChildEntity('child')
-    ], MappedChild);
-    beforeAll(async () => {
-        ({ injector, database: db } = await setupIntegrationTest({
-            orm: { schema },
-        }));
-        repo = injector.resolve(getRepository(MappedChild));
-        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('mapped_children')} CASCADE`);
-        await db.execute(sql `DROP TABLE IF EXISTS ${sql.identifier(schema)}.${sql.identifier('mapped_parents')} CASCADE`);
-        await db.execute(sql `
-      CREATE TABLE ${sql.identifier(schema)}.${sql.identifier('mapped_parents')} (
-        id UUID PRIMARY KEY DEFAULT gen_random_uuid(),
-        discriminator TEXT NOT NULL,
-        display_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, discriminator)
-      )
-    `);
-        await db.execute(sql `
-      CREATE TABLE ${sql.identifier(schema)}.${sql.identifier('mapped_children')} (
-        id UUID PRIMARY KEY,
-        discriminator TEXT NOT NULL CHECK (discriminator = 'child'),
-        internal_secret TEXT NOT NULL,
-        FOREIGN KEY (id, discriminator) REFERENCES ${sql.identifier(schema)}.${sql.identifier('mapped_parents')} (id, discriminator) ON DELETE CASCADE
-      )
-    `);
-    });
-    test('should respect @Column renaming in CTI', async () => {
-        const child = await repo.insert(Object.assign(new MappedChild(), { displayName: 'Visible', secret: 'Hidden' }));
-        expect(child.discriminator).toBe('child');
-        expect(child.displayName).toBe('Visible');
-        expect(child.secret).toBe('Hidden');
-        // Verify DB column names
-        const { rows: parentRows } = await db.execute(sql `SELECT display_name FROM ${sql.identifier(schema)}.${sql.identifier('mapped_parents')} WHERE id = ${child.id}`);
-        expect(parentRows[0]['display_name']).toBe('Visible');
-        const { rows: childRows } = await db.execute(sql `SELECT internal_secret FROM ${sql.identifier(schema)}.${sql.identifier('mapped_children')} WHERE id = ${child.id}`);
-        expect(childRows[0]['internal_secret']).toBe('Hidden');
-        // Load back
-        const loaded = await repo.load(child.id);
-        expect(loaded.displayName).toBe('Visible');
-        expect(loaded.secret).toBe('Hidden');
-    });
-    test('should filter by renamed columns in both tables', async () => {
-        await repo.insert(Object.assign(new MappedChild(), { displayName: 'A', secret: 'S1' }));
-        await repo.insert(Object.assign(new MappedChild(), { displayName: 'B', secret: 'S2' }));
-        const results = await repo.loadManyByQuery({
-            displayName: 'B',
-            secret: 'S2'
-        });
-        expect(results).toHaveLength(1);
-        expect(results[0].displayName).toBe('B');
-    });
-});

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

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

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

@@ -1,141 +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 { Injector, runInInjectionContext } from '../../injector/index.js';
-import { StringProperty } from '../../schema/index.js';
-import { setupIntegrationTest } from '../../testing/index.js';
-import { ChildEntity, Column, GeneratedTsVector, Inheritance, Table } from '../decorators.js';
-import { Entity } from '../entity.js';
-import { injectRepository } from '../server/index.js';
-describe('ORM Repository CTI Search (Integration)', () => {
-    let injector;
-    let database;
-    const schema = 'test_orm_cti_search';
-    let Item = class Item extends Entity {
-        type;
-        title;
-        description;
-        searchVector;
-    };
-    __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);
-    __decorate([
-        StringProperty(),
-        __metadata("design:type", String)
-    ], Item.prototype, "description", void 0);
-    __decorate([
-        StringProperty(),
-        GeneratedTsVector({ sources: ['title', 'description'] }),
-        __metadata("design:type", Object)
-    ], Item.prototype, "searchVector", 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);
-    let Electronic = class Electronic extends Item {
-        brand;
-    };
-    __decorate([
-        StringProperty(),
-        __metadata("design:type", String)
-    ], Electronic.prototype, "brand", void 0);
-    Electronic = __decorate([
-        Table('electronics', { schema }),
-        ChildEntity('electronic')
-    ], Electronic);
-    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('books')} CASCADE`);
-        await database.execute(sql `DROP TABLE IF EXISTS ${sql.identifier(schema)}.${sql.identifier('electronics')} CASCADE`);
-        await database.execute(sql `DROP TABLE IF EXISTS ${sql.identifier(schema)}.${sql.identifier('items')} CASCADE`);
-        await database.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,
-        description TEXT NOT NULL,
-        search_vector tsvector GENERATED ALWAYS AS (to_tsvector('simple', title || ' ' || description)) STORED,
-        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 INDEX items_search_idx ON ${sql.identifier(schema)}.${sql.identifier('items')} USING GIN (search_vector)`);
-        await database.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
-      )
-    `);
-        await database.execute(sql `
-      CREATE TABLE ${sql.identifier(schema)}.${sql.identifier('electronics')} (
-        id UUID PRIMARY KEY,
-        type TEXT NOT NULL CHECK (type = 'electronic'),
-        brand TEXT NOT NULL,
-        FOREIGN KEY (id, type) REFERENCES ${sql.identifier(schema)}.${sql.identifier('items')} (id, type) ON DELETE CASCADE
-      )
-    `);
-    });
-    test('should search polymorphically from base repository', async () => {
-        await runInInjectionContext(injector, async () => {
-            const itemRepo = injectRepository(Item);
-            const bookRepo = injectRepository(Book);
-            const electronicRepo = injectRepository(Electronic);
-            await bookRepo.insert(Object.assign(new Book(), { title: 'The Great Gatsby', description: 'A classic novel', author: 'F. Scott Fitzgerald' }));
-            await electronicRepo.insert(Object.assign(new Electronic(), { title: 'iPhone 15', description: 'Latest smartphone from Apple', brand: 'Apple' }));
-            // Search for "novel" - should find the book
-            const results1 = await itemRepo.search({ query: { $tsvector: { fields: ['searchVector'], query: 'novel' } }, includeSubclasses: true });
-            expect(results1).toHaveLength(1);
-            expect(results1[0].entity).toBeInstanceOf(Book);
-            expect(results1[0].entity.title).toBe('The Great Gatsby');
-            // Search for "smartphone" - should find the electronic
-            const results2 = await itemRepo.search({ query: { $tsvector: { fields: ['searchVector'], query: 'smartphone' } }, includeSubclasses: true });
-            expect(results2).toHaveLength(1);
-            expect(results2[0].entity).toBeInstanceOf(Electronic);
-            expect(results2[0].entity.title).toBe('iPhone 15');
-        });
-    });
-    test('should search in child repository using base search vector', async () => {
-        await runInInjectionContext(injector, async () => {
-            const bookRepo = injectRepository(Book);
-            await bookRepo.insert(Object.assign(new Book(), { title: 'TypeScript Deep Dive', description: 'Comprehensive guide to TS', author: 'Basarat' }));
-            await bookRepo.insert(Object.assign(new Book(), { title: 'Learning Rust', description: 'Systems programming with Rust', author: 'Unknown' }));
-            const results = await bookRepo.search({ query: { $tsvector: { fields: ['searchVector'], query: 'TypeScript' } } });
-            expect(results).toHaveLength(1);
-            expect(results[0].entity.title).toBe('TypeScript Deep Dive');
-            expect((results[0].entity).author).toBe('Basarat');
-        });
-    });
-});

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

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

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

@@ -1,103 +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 Soft Delete (Integration)', () => {
-    let injector;
-    let db;
-    let baseRepo;
-    let subRepo;
-    const schema = 'test_orm_cti_soft_delete';
-    let Base = class Base extends Entity {
-        type;
-        baseName;
-    };
-    __decorate([
-        StringProperty(),
-        Column({ name: 'type' }),
-        __metadata("design:type", String)
-    ], Base.prototype, "type", void 0);
-    __decorate([
-        StringProperty(),
-        __metadata("design:type", String)
-    ], Base.prototype, "baseName", void 0);
-    Base = __decorate([
-        Table('bases', { schema }),
-        Inheritance({ strategy: 'joined', discriminatorColumn: 'type' })
-    ], Base);
-    let Subtype = class Subtype extends Base {
-        subData;
-    };
-    __decorate([
-        StringProperty(),
-        __metadata("design:type", String)
-    ], Subtype.prototype, "subData", void 0);
-    Subtype = __decorate([
-        Table('subtypes', { schema }),
-        ChildEntity('subtype')
-    ], Subtype);
-    beforeAll(async () => {
-        ({ injector, database: db } = await setupIntegrationTest({
-            orm: { schema },
-        }));
-        baseRepo = injector.resolve(getRepository(Base));
-        subRepo = injector.resolve(getRepository(Subtype));
-        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('subtypes')} CASCADE`);
-        await db.execute(sql `DROP TABLE IF EXISTS ${sql.identifier(schema)}.${sql.identifier('bases')} CASCADE`);
-        await db.execute(sql `
-      CREATE TABLE ${sql.identifier(schema)}.${sql.identifier('bases')} (
-        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('subtypes')} (
-        id UUID PRIMARY KEY,
-        type TEXT NOT NULL CHECK (type = 'subtype'),
-        sub_data TEXT NOT NULL,
-        FOREIGN KEY (id, type) REFERENCES ${sql.identifier(schema)}.${sql.identifier('bases')} (id, type) ON DELETE CASCADE
-      )
-    `);
-    });
-    test('should soft delete from subtype repository', async () => {
-        await db.execute(sql `TRUNCATE TABLE ${sql.identifier(schema)}.${sql.identifier('bases')} CASCADE`);
-        const entity = await subRepo.insert(Object.assign(new Subtype(), { baseName: 'B1', subData: 'S1' }));
-        await subRepo.delete(entity.id);
-        const { rows } = await db.execute(sql `SELECT delete_timestamp FROM ${sql.identifier(schema)}.${sql.identifier('bases')} WHERE id = ${entity.id}`);
-        expect(rows[0]['delete_timestamp']).not.toBeNull();
-        expect(await subRepo.has(entity.id)).toBe(false);
-        expect(await subRepo.loadManyByQuery({ id: entity.id }).then((r) => r[0])).toBeUndefined();
-    });
-    test('should polymorphically filter soft deleted entities', async () => {
-        await db.execute(sql `TRUNCATE TABLE ${sql.identifier(schema)}.${sql.identifier('bases')} CASCADE`);
-        const s1 = await subRepo.insert(Object.assign(new Subtype(), { baseName: 'Active', subData: 'S1' }));
-        const s2 = await subRepo.insert(Object.assign(new Subtype(), { baseName: 'Deleted', subData: 'S2' }));
-        await subRepo.delete(s2.id);
-        const allActive = await baseRepo.loadAll({ includeSubclasses: true });
-        expect(allActive).toHaveLength(1);
-        expect(allActive[0].id).toBe(s1.id);
-        const allIncludingDeleted = await baseRepo.loadAll({ includeSubclasses: true, withDeleted: true });
-        expect(allIncludingDeleted).toHaveLength(2);
-    });
-});

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

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