@tstdl/base 0.93.182 → 0.93.184

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

@@ -1,83 +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, beforeEach, describe, expect, test } from 'vitest';
-import { StringProperty } from '../../schema/index.js';
-import { dropTables, setupIntegrationTest, truncateTables } from '../../testing/index.js';
-import { Table } from '../decorators.js';
-import { Entity } from '../entity.js';
-import { getRepository } from '../server/index.js';
-describe('ORM Repository Attributes (Integration)', () => {
-    let injector;
-    let database;
-    let repository;
-    const schema = 'test_orm_attributes';
-    let AttributeEntity = class AttributeEntity extends Entity {
-        name;
-    };
-    __decorate([
-        StringProperty(),
-        __metadata("design:type", String)
-    ], AttributeEntity.prototype, "name", void 0);
-    AttributeEntity = __decorate([
-        Table('attribute_entities', { schema })
-    ], AttributeEntity);
-    beforeAll(async () => {
-        ({ injector, database } = await setupIntegrationTest({ orm: { schema } }));
-        repository = injector.resolve(getRepository(AttributeEntity));
-        await dropTables(database, schema, ['attribute_entities']);
-        await database.execute(sql `
-      CREATE TABLE ${sql.identifier(schema)}.${sql.identifier('attribute_entities')} (
-        id UUID PRIMARY KEY DEFAULT gen_random_uuid(),
-        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 '{}'
-      )
-    `);
-    });
-    beforeEach(async () => {
-        await truncateTables(database, schema, ['attribute_entities']);
-    });
-    test('should support partial attribute updates', async () => {
-        const e1 = await repository.insert(Object.assign(new AttributeEntity(), {
-            name: 'E1',
-            metadata: { attributes: { a: 1, b: 2 } },
-        }));
-        expect(e1.metadata.attributes).toEqual({ a: 1, b: 2 });
-        const updated = await repository.update(e1.id, {
-            metadata: { attributes: { b: 3, c: 4 } },
-        });
-        expect(updated.metadata.attributes).toEqual({ a: 1, b: 3, c: 4 });
-    });
-    test('should update attributes during soft delete', async () => {
-        const e1 = await repository.insert(Object.assign(new AttributeEntity(), {
-            name: 'E1',
-            metadata: { attributes: { initial: true } },
-        }));
-        const deleted = await repository.delete(e1.id, undefined, { attributes: { deleted: true } });
-        expect(deleted.metadata.attributes).toEqual({ initial: true, deleted: true });
-    });
-    test('should support querying by raw SQL on attributes', async () => {
-        await repository.insert(Object.assign(new AttributeEntity(), {
-            name: 'E1',
-            metadata: { attributes: { key: 'value1' } },
-        }));
-        await repository.insert(Object.assign(new AttributeEntity(), {
-            name: 'E2',
-            metadata: { attributes: { key: 'value2' } },
-        }));
-        const results = await repository.loadManyByQuery(sql `attributes->>'key' = 'value1'`);
-        expect(results).toHaveLength(1);
-        expect(results[0].name).toBe('E1');
-    });
-});

package/orm/tests/repository-compound-primary-key.test.d.ts

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

package/orm/tests/repository-compound-primary-key.test.js

@@ -1,226 +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 { getTableConfig } from 'drizzle-orm/pg-core';
-import { beforeAll, beforeEach, describe, expect, test } from 'vitest';
-import { StringProperty } from '../../schema/index.js';
-import { dropTables, setupIntegrationTest } from '../../testing/index.js';
-import { ChildEntity, Inheritance, PrimaryKey, Table } from '../decorators.js';
-import { Entity } from '../entity.js';
-import { getDrizzleTableFromType } from '../server/drizzle/index.js';
-import { getRepository } from '../server/index.js';
-describe('ORM Repository Compound Primary Key (Integration)', () => {
-    let injector;
-    let database;
-    let compoundRepo;
-    let parentRepo;
-    let childRepo;
-    let grandchildRepo;
-    const schema = 'test_orm_compound_pk';
-    let CompoundEntity = class CompoundEntity extends Entity {
-        namespace;
-        data;
-    };
-    __decorate([
-        StringProperty(),
-        __metadata("design:type", String)
-    ], CompoundEntity.prototype, "namespace", void 0);
-    __decorate([
-        StringProperty(),
-        __metadata("design:type", String)
-    ], CompoundEntity.prototype, "data", void 0);
-    CompoundEntity = __decorate([
-        Table('compound_entities', { schema }),
-        PrimaryKey(['namespace', 'id'])
-    ], CompoundEntity);
-    let ParentEntity = class ParentEntity extends Entity {
-        namespace;
-        type;
-    };
-    __decorate([
-        StringProperty(),
-        __metadata("design:type", String)
-    ], ParentEntity.prototype, "namespace", void 0);
-    __decorate([
-        StringProperty(),
-        __metadata("design:type", String)
-    ], ParentEntity.prototype, "type", void 0);
-    ParentEntity = __decorate([
-        Table('parent_entities', { schema }),
-        PrimaryKey(['namespace', 'id']),
-        Inheritance({ strategy: 'joined', discriminatorColumn: 'type' })
-    ], ParentEntity);
-    let ChildEntityModel = class ChildEntityModel extends ParentEntity {
-        childData;
-    };
-    __decorate([
-        StringProperty(),
-        __metadata("design:type", String)
-    ], ChildEntityModel.prototype, "childData", void 0);
-    ChildEntityModel = __decorate([
-        Table('child_entities', { schema }),
-        ChildEntity('child')
-    ], ChildEntityModel);
-    let GrandchildEntity = class GrandchildEntity extends ChildEntityModel {
-        grandchildData;
-    };
-    __decorate([
-        StringProperty(),
-        __metadata("design:type", String)
-    ], GrandchildEntity.prototype, "grandchildData", void 0);
-    GrandchildEntity = __decorate([
-        Table('grandchild_entities', { schema }),
-        ChildEntity('grandchild')
-    ], GrandchildEntity);
-    beforeAll(async () => {
-        ({ injector, database } = await setupIntegrationTest({ orm: { schema } }));
-        compoundRepo = injector.resolve(getRepository(CompoundEntity));
-        parentRepo = injector.resolve(getRepository(ParentEntity));
-        childRepo = injector.resolve(getRepository(ChildEntityModel));
-        grandchildRepo = injector.resolve(getRepository(GrandchildEntity));
-        await database.execute(sql `CREATE SCHEMA IF NOT EXISTS ${sql.identifier(schema)}`);
-        await dropTables(database, schema, ['grandchild_entities', 'child_entities', 'parent_entities', 'compound_entities']);
-        await database.execute(sql `
-      CREATE TABLE ${sql.identifier(schema)}.${sql.identifier('compound_entities')} (
-        namespace TEXT NOT NULL,
-        id UUID NOT NULL,
-        data 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 '{}',
-        PRIMARY KEY (namespace, id)
-      )
-    `);
-        await database.execute(sql `
-      CREATE TABLE ${sql.identifier(schema)}.${sql.identifier('parent_entities')} (
-        namespace TEXT NOT NULL,
-        id UUID NOT NULL,
-        type 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 '{}',
-        PRIMARY KEY (namespace, id),
-        UNIQUE (namespace, id, type)
-      )
-    `);
-        await database.execute(sql `
-      CREATE TABLE ${sql.identifier(schema)}.${sql.identifier('child_entities')} (
-        namespace TEXT NOT NULL,
-        id UUID NOT NULL,
-        type TEXT NOT NULL CHECK (type IN ('child', 'grandchild')),
-        child_data TEXT NOT NULL,
-        PRIMARY KEY (namespace, id),
-        FOREIGN KEY (namespace, id, type) REFERENCES ${sql.identifier(schema)}.${sql.identifier('parent_entities')} (namespace, id, type) ON DELETE CASCADE,
-        UNIQUE (namespace, id, type)
-      )
-    `);
-        await database.execute(sql `
-      CREATE TABLE ${sql.identifier(schema)}.${sql.identifier('grandchild_entities')} (
-        namespace TEXT NOT NULL,
-        id UUID NOT NULL,
-        type TEXT NOT NULL CHECK (type = 'grandchild'),
-        grandchild_data TEXT NOT NULL,
-        PRIMARY KEY (namespace, id),
-        FOREIGN KEY (namespace, id, type) REFERENCES ${sql.identifier(schema)}.${sql.identifier('child_entities')} (namespace, id, type) ON DELETE CASCADE
-      )
-    `);
-    });
-    beforeEach(async () => {
-        await database.execute(sql `TRUNCATE TABLE ${sql.identifier(schema)}.${sql.identifier('grandchild_entities')}, ${sql.identifier(schema)}.${sql.identifier('child_entities')}, ${sql.identifier(schema)}.${sql.identifier('parent_entities')}, ${sql.identifier(schema)}.${sql.identifier('compound_entities')} CASCADE`);
-    });
-    test('should insert and load compound entity', async () => {
-        const entity = new CompoundEntity();
-        entity.id = '00000000-0000-0000-0000-000000000001';
-        entity.namespace = 'ns1';
-        entity.data = 'test data';
-        await compoundRepo.insert(entity);
-        const loaded = await compoundRepo.loadByQuery({ namespace: 'ns1', id: '00000000-0000-0000-0000-000000000001' });
-        expect(loaded.data).toBe('test data');
-        expect(loaded.namespace).toBe('ns1');
-        expect(loaded.id).toBe('00000000-0000-0000-0000-000000000001');
-    });
-    test('should upsert compound entity', async () => {
-        const entity = new CompoundEntity();
-        entity.id = '00000000-0000-0000-0000-000000000010';
-        entity.namespace = 'ns1';
-        entity.data = 'initial data';
-        await compoundRepo.insert(entity);
-        const updateEntity = new CompoundEntity();
-        updateEntity.id = '00000000-0000-0000-0000-000000000010';
-        updateEntity.namespace = 'ns1';
-        updateEntity.data = 'updated data';
-        await compoundRepo.upsert(['namespace', 'id'], updateEntity);
-        const loaded = await compoundRepo.loadByQuery({ namespace: 'ns1', id: '00000000-0000-0000-0000-000000000010' });
-        expect(loaded.data).toBe('updated data');
-    });
-    test('should insert and load child entity with compound PK', async () => {
-        const entity = new ChildEntityModel();
-        entity.id = '00000000-0000-0000-0000-000000000020';
-        entity.namespace = 'ns2';
-        entity.type = 'child';
-        entity.childData = 'child specific data';
-        await childRepo.insert(entity);
-        const loaded = await childRepo.loadByQuery({ namespace: 'ns2', id: '00000000-0000-0000-0000-000000000020' });
-        expect(loaded.childData).toBe('child specific data');
-        expect(loaded.namespace).toBe('ns2');
-        expect(loaded.id).toBe('00000000-0000-0000-0000-000000000020');
-    });
-    test('should insert and load grandchild entity with compound PK', async () => {
-        const entity = new GrandchildEntity();
-        entity.id = '00000000-0000-0000-0000-000000000050';
-        entity.namespace = 'ns5';
-        entity.type = 'grandchild';
-        entity.childData = 'child part';
-        entity.grandchildData = 'grandchild part';
-        await grandchildRepo.insert(entity);
-        const loaded = await grandchildRepo.loadByQuery({ namespace: 'ns5', id: '00000000-0000-0000-0000-000000000050' });
-        expect(loaded.grandchildData).toBe('grandchild part');
-        expect(loaded.childData).toBe('child part');
-        expect(loaded.namespace).toBe('ns5');
-        expect(loaded.id).toBe('00000000-0000-0000-0000-000000000050');
-    });
-    test('should updateManyByQuery with compound PK', async () => {
-        const entity1 = new CompoundEntity();
-        entity1.id = '00000000-0000-0000-0000-000000000030';
-        entity1.namespace = 'ns3';
-        entity1.data = 'data 1';
-        const entity2 = new CompoundEntity();
-        entity2.id = '00000000-0000-0000-0000-000000000040';
-        entity2.namespace = 'ns3';
-        entity2.data = 'data 2';
-        await compoundRepo.insertMany([entity1, entity2]);
-        await compoundRepo.updateManyByQuery({ namespace: 'ns3' }, { data: 'batch updated' });
-        const entities = await compoundRepo.loadManyByQuery({ namespace: 'ns3' });
-        expect(entities).toHaveLength(2);
-        expect(entities.every(e => e.data === 'batch updated')).toBe(true);
-    });
-    test('should respect custom primary key name', () => {
-        let CustomPkEntity = class CustomPkEntity extends Entity {
-            namespace;
-        };
-        __decorate([
-            StringProperty(),
-            __metadata("design:type", String)
-        ], CustomPkEntity.prototype, "namespace", void 0);
-        CustomPkEntity = __decorate([
-            Table('custom_pk_table', { schema: 'test' }),
-            PrimaryKey(['namespace', 'id'], { name: 'my_custom_pk' })
-        ], CustomPkEntity);
-        const table = getDrizzleTableFromType(CustomPkEntity);
-        const config = getTableConfig(table);
-        expect(config.primaryKeys).toHaveLength(1);
-        expect(config.primaryKeys[0].name).toBe('my_custom_pk');
-    });
-});

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

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

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

@@ -1,162 +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 { Integer, StringProperty } from '../../schema/index.js';
-import { setupIntegrationTest } from '../../testing/index.js';
-import { GeneratedTsVector, Table } from '../decorators.js';
-import { Entity } from '../entity.js';
-import { getRepository, injectRepository } from '../server/index.js';
-describe('ORM Repository Comprehensive Options & Edge Cases', () => {
-    let injector;
-    let db;
-    let repository;
-    const schema = 'test_orm_comprehensive';
-    let ComprehensiveEntity = class ComprehensiveEntity extends Entity {
-        name;
-        category;
-        value;
-        searchVector;
-    };
-    __decorate([
-        StringProperty(),
-        __metadata("design:type", String)
-    ], ComprehensiveEntity.prototype, "name", void 0);
-    __decorate([
-        StringProperty(),
-        __metadata("design:type", String)
-    ], ComprehensiveEntity.prototype, "category", void 0);
-    __decorate([
-        Integer(),
-        __metadata("design:type", Number)
-    ], ComprehensiveEntity.prototype, "value", void 0);
-    __decorate([
-        StringProperty(),
-        GeneratedTsVector({ sources: ['name', 'category'] }),
-        __metadata("design:type", Object)
-    ], ComprehensiveEntity.prototype, "searchVector", void 0);
-    ComprehensiveEntity = __decorate([
-        Table('comprehensive_entities', { schema })
-    ], ComprehensiveEntity);
-    beforeAll(async () => {
-        ({ injector, database: db } = await setupIntegrationTest({
-            orm: { schema },
-        }));
-        repository = injector.resolve(getRepository(ComprehensiveEntity));
-        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('comprehensive_entities')} CASCADE`);
-        await db.execute(sql `
-      CREATE TABLE ${sql.identifier(schema)}.${sql.identifier('comprehensive_entities')} (
-        id UUID PRIMARY KEY DEFAULT gen_random_uuid(),
-        name TEXT NOT NULL,
-        category TEXT NOT NULL,
-        value INTEGER NOT NULL,
-        search_vector tsvector GENERATED ALWAYS AS (to_tsvector('simple', name || ' ' || category)) 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 '{}'
-      )
-    `);
-        await db.execute(sql `CREATE INDEX idx_comprehensive_search ON ${sql.identifier(schema)}.${sql.identifier('comprehensive_entities')} USING GIN (search_vector)`);
-    });
-    test('should support DISTINCT ON loading', async () => {
-        await db.execute(sql `TRUNCATE TABLE ${sql.identifier(schema)}.${sql.identifier('comprehensive_entities')} CASCADE`);
-        await repository.insertMany([
-            Object.assign(new ComprehensiveEntity(), { name: 'A1', category: 'Cat1', value: 10 }),
-            Object.assign(new ComprehensiveEntity(), { name: 'A2', category: 'Cat1', value: 20 }),
-            Object.assign(new ComprehensiveEntity(), { name: 'B1', category: 'Cat2', value: 30 }),
-        ]);
-        // Load distinct by category, order by category and value desc to get the one with highest value per category
-        const results = await repository.loadManyByQuery({}, {
-            distinct: ['category'],
-            order: [['category', 'asc'], ['value', 'desc']],
-        });
-        expect(results).toHaveLength(2);
-        expect(results.find((r) => r.category === 'Cat1').name).toBe('A2'); // Value 20 > 10
-        expect(results.find((r) => r.category === 'Cat2').name).toBe('B1');
-    });
-    test('should support search with filter and distinct', async () => {
-        await db.execute(sql `TRUNCATE TABLE ${sql.identifier(schema)}.${sql.identifier('comprehensive_entities')} CASCADE`);
-        await repository.insertMany([
-            Object.assign(new ComprehensiveEntity(), { name: 'Apple One', category: 'Fruit', value: 5 }),
-            Object.assign(new ComprehensiveEntity(), { name: 'Apple Two', category: 'Fruit', value: 15 }),
-            Object.assign(new ComprehensiveEntity(), { name: 'Apple Three', category: 'Tech', value: 25 }),
-        ]);
-        // Search "Apple", filter value > 10, distinct category
-        const results = await repository.search({
-            query: { $tsvector: { fields: ['searchVector'], query: 'Apple' } },
-            filter: { value: { $gt: 10 } },
-            distinct: ['category'],
-            order: [['category', 'asc'], ['value', 'desc']], // Distinct on requires matching order prefix
-        });
-        expect(results).toHaveLength(2);
-        const categories = results.map((r) => r.entity.category).sort();
-        expect(categories).toEqual(['Fruit', 'Tech']);
-        const fruit = results.find((r) => r.entity.category === 'Fruit');
-        expect(fruit.entity.name).toBe('Apple Two'); // Value 15 > 10, Apple One filtered out or lower
-    });
-    test('should handle soft deletes correctly in updates', async () => {
-        await db.execute(sql `TRUNCATE TABLE ${sql.identifier(schema)}.${sql.identifier('comprehensive_entities')} CASCADE`);
-        const entity = await repository.insert(Object.assign(new ComprehensiveEntity(), { name: 'To Delete', category: 'Test', value: 1 }));
-        await repository.delete(entity.id);
-        // Try update without withDeleted (should fail/return undefined)
-        const tryUpdateResult = await repository.tryUpdate(entity.id, { name: 'Resurrected?' });
-        expect(tryUpdateResult).toBeUndefined();
-        // Ensure DB is unchanged
-        const row = await repository.tryLoad(entity.id, { withDeleted: true });
-        expect(row.name).toBe('To Delete');
-        // Update WITH withDeleted (should work)
-        const updateResult = await repository.update(entity.id, { name: 'Zombie' }, { withDeleted: true });
-        expect(updateResult.name).toBe('Zombie');
-        expect(updateResult.metadata.deleteTimestamp).not.toBeNull(); // Still deleted
-    });
-    test('should handle count with and without deleted', async () => {
-        await db.execute(sql `TRUNCATE TABLE ${sql.identifier(schema)}.${sql.identifier('comprehensive_entities')} CASCADE`);
-        await repository.insert(Object.assign(new ComprehensiveEntity(), { name: 'Alive', category: 'A', value: 1 }));
-        const dead = await repository.insert(Object.assign(new ComprehensiveEntity(), { name: 'Dead', category: 'A', value: 2 }));
-        await repository.delete(dead.id);
-        expect(await repository.count()).toBe(1);
-        expect(await repository.count({ withDeleted: true })).toBe(2);
-        expect(await repository.countByQuery({ category: 'A' })).toBe(1);
-        expect(await repository.countByQuery({ category: 'A' }, { withDeleted: true })).toBe(2);
-    });
-    test('should fail gracefully (return undefined) for missing entities in tryLoad operations', async () => {
-        expect(await repository.tryLoad('00000000-0000-0000-0000-000000000000')).toBeUndefined();
-        expect(await repository.tryLoadByQuery({ name: 'NonExistent' })).toBeUndefined();
-    });
-    test('should return empty array for empty search results', async () => {
-        const results = await repository.search({ query: { $tsvector: { fields: ['name'], query: 'NonExistentTerm' } } });
-        expect(results).toEqual([]);
-    });
-    test('should support complex ordering with multiple fields', async () => {
-        await db.execute(sql `TRUNCATE TABLE ${sql.identifier(schema)}.${sql.identifier('comprehensive_entities')} CASCADE`);
-        await repository.insertMany([
-            Object.assign(new ComprehensiveEntity(), { name: 'A', category: 'X', value: 1 }),
-            Object.assign(new ComprehensiveEntity(), { name: 'B', category: 'X', value: 2 }),
-            Object.assign(new ComprehensiveEntity(), { name: 'A', category: 'Y', value: 3 }),
-        ]);
-        // Order by Name ASC, then Value DESC
-        const results = await repository.loadAll({
-            order: [['name', 'asc'], ['value', 'desc']],
-        });
-        expect(results).toHaveLength(3);
-        expect(results[0].name).toBe('A');
-        expect(results[0].value).toBe(3); // Y (3) comes before X (1) because both are A? No, wait.
-        // Name A (Y, 3) and Name A (X, 1).
-        // Order: Name ASC. A, A, B.
-        // Tie-break Name: Value DESC. 3, 1.
-        // So A(3) then A(1).
-        expect(results[1].name).toBe('A');
-        expect(results[1].value).toBe(1);
-        expect(results[2].name).toBe('B');
-    });
-});

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

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