@tstdl/base 0.93.87 → 0.93.90

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

@@ -0,0 +1,232 @@
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+import { Injector, runInInjectionContext } from '../../injector/index.js';
+import { Integer, StringProperty } from '../../schema/index.js';
+import { toArrayAsync } from '../../utils/async-iterable-helpers/to-array.js';
+import { sql } from 'drizzle-orm';
+import { beforeAll, describe, expect, test } from 'vitest';
+import { Table } from '../decorators.js';
+import { Entity } from '../entity.js';
+import { configureOrm, Database } from '../server/index.js';
+import { injectRepository } from '../server/repository.js';
+describe('ORM Repository Advanced (Integration)', () => {
+    let injector;
+    let db;
+    const schema = 'test_orm_advanced';
+    let AdvancedEntity = class AdvancedEntity extends Entity {
+        name;
+        value;
+    };
+    __decorate([
+        StringProperty(),
+        __metadata("design:type", String)
+    ], AdvancedEntity.prototype, "name", void 0);
+    __decorate([
+        Integer(),
+        __metadata("design:type", Number)
+    ], AdvancedEntity.prototype, "value", void 0);
+    AdvancedEntity = __decorate([
+        Table('advanced_entities', { schema })
+    ], AdvancedEntity);
+    beforeAll(async () => {
+        injector = new Injector('Test');
+        configureOrm({
+            repositoryConfig: { schema },
+            connection: {
+                host: '127.0.0.1', port: 5432, user: 'tstdl', password: 'wf7rq6glrk5jykne', database: 'tstdl',
+            },
+        });
+        db = injector.resolve(Database);
+        await db.execute(sql `CREATE SCHEMA IF NOT EXISTS ${sql.identifier(schema)}`);
+        await db.execute(sql `DROP TABLE IF EXISTS ${sql.identifier(schema)}.${sql.identifier('advanced_entities')} CASCADE`);
+        await db.execute(sql `
+      CREATE TABLE ${sql.identifier(schema)}.${sql.identifier('advanced_entities')} (
+        id UUID PRIMARY KEY DEFAULT gen_random_uuid(),
+        name TEXT NOT NULL,
+        value INTEGER 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 '{}'
+      )
+    `);
+    });
+    test('should support loadManyCursor', async () => {
+        await db.execute(sql `TRUNCATE TABLE ${sql.identifier(schema)}.${sql.identifier('advanced_entities')} CASCADE`);
+        await runInInjectionContext(injector, async () => {
+            const repository = injectRepository(AdvancedEntity);
+            const e1 = await repository.insert(Object.assign(new AdvancedEntity(), { name: 'E1', value: 1 }));
+            const e2 = await repository.insert(Object.assign(new AdvancedEntity(), { name: 'E2', value: 2 }));
+            const cursor = repository.loadManyCursor([e1.id, e2.id]);
+            const results = await toArrayAsync(cursor);
+            expect(results).toHaveLength(2);
+            expect(results.map((r) => r.name).sort()).toEqual(['E1', 'E2']);
+        });
+    });
+    test('should support loadAllCursor', async () => {
+        await db.execute(sql `TRUNCATE TABLE ${sql.identifier(schema)}.${sql.identifier('advanced_entities')} CASCADE`);
+        await runInInjectionContext(injector, async () => {
+            const repository = injectRepository(AdvancedEntity);
+            await repository.insertMany([
+                Object.assign(new AdvancedEntity(), { name: 'E1', value: 1 }),
+                Object.assign(new AdvancedEntity(), { name: 'E2', value: 2 }),
+            ]);
+            const cursor = repository.loadAllCursor();
+            const results = await toArrayAsync(cursor);
+            expect(results).toHaveLength(2);
+        });
+    });
+    test('should support countByQuery with various filters', async () => {
+        await db.execute(sql `TRUNCATE TABLE ${sql.identifier(schema)}.${sql.identifier('advanced_entities')} CASCADE`);
+        await runInInjectionContext(injector, async () => {
+            const repository = injectRepository(AdvancedEntity);
+            await repository.insertMany([
+                Object.assign(new AdvancedEntity(), { name: 'A', value: 10 }),
+                Object.assign(new AdvancedEntity(), { name: 'B', value: 20 }),
+                Object.assign(new AdvancedEntity(), { name: 'C', value: 30 }),
+            ]);
+            expect(await repository.countByQuery({ value: { $gt: 15 } })).toBe(2);
+            expect(await repository.countByQuery({ value: { $lt: 25 } })).toBe(2);
+            expect(await repository.countByQuery({ name: 'A' })).toBe(1);
+        });
+    });
+    test('should support has and hasByQuery', async () => {
+        await db.execute(sql `TRUNCATE TABLE ${sql.identifier(schema)}.${sql.identifier('advanced_entities')} CASCADE`);
+        await runInInjectionContext(injector, async () => {
+            const repository = injectRepository(AdvancedEntity);
+            const e1 = await repository.insert(Object.assign(new AdvancedEntity(), { name: 'E1', value: 1 }));
+            expect(await repository.has(e1.id)).toBe(true);
+            expect(await repository.has('00000000-0000-0000-0000-000000000000')).toBe(false);
+            expect(await repository.hasByQuery({ name: 'E1' })).toBe(true);
+            expect(await repository.hasByQuery({ name: 'E2' })).toBe(false);
+        });
+    });
+    test('should support tryUpdate', async () => {
+        await db.execute(sql `TRUNCATE TABLE ${sql.identifier(schema)}.${sql.identifier('advanced_entities')} CASCADE`);
+        await runInInjectionContext(injector, async () => {
+            const repository = injectRepository(AdvancedEntity);
+            const e1 = await repository.insert(Object.assign(new AdvancedEntity(), { name: 'E1', value: 1 }));
+            const updated = await repository.tryUpdate(e1.id, { name: 'E1-Updated' });
+            expect(updated.name).toBe('E1-Updated');
+            const missing = await repository.tryUpdate('00000000-0000-0000-0000-000000000000', { name: 'X' });
+            expect(missing).toBeUndefined();
+        });
+    });
+    test('should support tryUpdateByQuery', async () => {
+        await db.execute(sql `TRUNCATE TABLE ${sql.identifier(schema)}.${sql.identifier('advanced_entities')} CASCADE`);
+        await runInInjectionContext(injector, async () => {
+            const repository = injectRepository(AdvancedEntity);
+            await repository.insert(Object.assign(new AdvancedEntity(), { name: 'E1', value: 1 }));
+            const updated = await repository.tryUpdateByQuery({ name: 'E1' }, { value: 100 });
+            expect(updated.value).toBe(100);
+            const missing = await repository.tryUpdateByQuery({ name: 'Missing' }, { value: 0 });
+            expect(missing).toBeUndefined();
+        });
+    });
+    test('should support insertIfNotExists', async () => {
+        await db.execute(sql `TRUNCATE TABLE ${sql.identifier(schema)}.${sql.identifier('advanced_entities')} CASCADE`);
+        await runInInjectionContext(injector, async () => {
+            const repository = injectRepository(AdvancedEntity);
+            const e1 = await repository.insert(Object.assign(new AdvancedEntity(), { name: 'E1', value: 1 }));
+            // Conflict on ID
+            const conflict = await repository.insertIfNotExists('id', Object.assign(new AdvancedEntity(), { id: e1.id, name: 'Conflict', value: 2 }));
+            expect(conflict).toBeUndefined();
+            // No conflict
+            const success = await repository.insertIfNotExists('id', Object.assign(new AdvancedEntity(), { name: 'E2', value: 2 }));
+            expect(success).toBeDefined();
+            expect(success.name).toBe('E2');
+        });
+    });
+    test('should support pagination (limit/offset)', async () => {
+        await db.execute(sql `TRUNCATE TABLE ${sql.identifier(schema)}.${sql.identifier('advanced_entities')} CASCADE`);
+        await runInInjectionContext(injector, async () => {
+            const repository = injectRepository(AdvancedEntity);
+            await repository.insertMany([
+                Object.assign(new AdvancedEntity(), { name: 'E1', value: 1 }),
+                Object.assign(new AdvancedEntity(), { name: 'E2', value: 2 }),
+                Object.assign(new AdvancedEntity(), { name: 'E3', value: 3 }),
+            ]);
+            const p1 = await repository.loadAll({ limit: 2, order: { value: 'asc' } });
+            expect(p1).toHaveLength(2);
+            expect(p1[0].name).toBe('E1');
+            expect(p1[1].name).toBe('E2');
+            const p2 = await repository.loadAll({ limit: 2, offset: 2, order: { value: 'asc' } });
+            expect(p2).toHaveLength(1);
+            expect(p2[0].name).toBe('E3');
+        });
+    });
+    test('should support complex ordering', async () => {
+        await db.execute(sql `TRUNCATE TABLE ${sql.identifier(schema)}.${sql.identifier('advanced_entities')} CASCADE`);
+        await runInInjectionContext(injector, async () => {
+            const repository = injectRepository(AdvancedEntity);
+            await repository.insertMany([
+                Object.assign(new AdvancedEntity(), { name: 'B', value: 10 }),
+                Object.assign(new AdvancedEntity(), { name: 'A', value: 20 }),
+                Object.assign(new AdvancedEntity(), { name: 'A', value: 10 }),
+            ]);
+            const results = await repository.loadAll({
+                order: [
+                    ['name', 'asc'],
+                    ['value', 'desc'],
+                ],
+            });
+            expect(results[0].name).toBe('A');
+            expect(results[0].value).toBe(20);
+            expect(results[1].name).toBe('A');
+            expect(results[1].value).toBe(10);
+            expect(results[2].name).toBe('B');
+        });
+    });
+    test('should return empty array for empty loadMany', async () => {
+        await runInInjectionContext(injector, async () => {
+            const repository = injectRepository(AdvancedEntity);
+            const results = await repository.loadMany([]);
+            expect(results).toEqual([]);
+        });
+    });
+    test('should fail on duplicate ID insert', async () => {
+        await db.execute(sql `TRUNCATE TABLE ${sql.identifier(schema)}.${sql.identifier('advanced_entities')} CASCADE`);
+        await runInInjectionContext(injector, async () => {
+            const repository = injectRepository(AdvancedEntity);
+            const id = '00000000-0000-0000-0000-000000000001';
+            await repository.insert(Object.assign(new AdvancedEntity(), { id, name: 'E1', value: 1 }));
+            await expect(repository.insert(Object.assign(new AdvancedEntity(), { id, name: 'E2', value: 2 }))).rejects.toThrow();
+        });
+    });
+    test('should support explicit transaction usage', async () => {
+        await db.execute(sql `TRUNCATE TABLE ${sql.identifier(schema)}.${sql.identifier('advanced_entities')} CASCADE`);
+        await runInInjectionContext(injector, async () => {
+            const repository = injectRepository(AdvancedEntity);
+            await repository.transaction(async (tx) => {
+                const txRepo = repository.withTransaction(tx);
+                await txRepo.insert(Object.assign(new AdvancedEntity(), { name: 'TxEntity', value: 100 }));
+                // Should be visible in tx
+                expect(await txRepo.count()).toBe(1);
+            });
+            // Should be committed
+            expect(await repository.count()).toBe(1);
+        });
+    });
+    test('should exclude soft-deleted entities by default', async () => {
+        await db.execute(sql `TRUNCATE TABLE ${sql.identifier(schema)}.${sql.identifier('advanced_entities')} CASCADE`);
+        await runInInjectionContext(injector, async () => {
+            const repository = injectRepository(AdvancedEntity);
+            const e1 = await repository.insert(Object.assign(new AdvancedEntity(), { name: 'E1', value: 1 }));
+            await repository.insert(Object.assign(new AdvancedEntity(), { name: 'E2', value: 2 }));
+            await repository.delete(e1.id);
+            const all = await repository.loadAll();
+            expect(all).toHaveLength(1);
+            expect(all[0].name).toBe('E2');
+            const withDeleted = await repository.loadManyByQuery({}, { withDeleted: true });
+            expect(withDeleted).toHaveLength(2);
+        });
+    });
+});

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

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

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

@@ -0,0 +1,99 @@
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+import { Injector, runInInjectionContext } from '../../injector/index.js';
+import { StringProperty } from '../../schema/index.js';
+import { sql } from 'drizzle-orm';
+import { beforeAll, describe, expect, test } from 'vitest';
+import { Table } from '../decorators.js';
+import { Entity } from '../entity.js';
+import { configureOrm, Database } from '../server/index.js';
+import { injectRepository } from '../server/repository.js';
+describe('ORM Repository Attributes (Integration)', () => {
+    let injector;
+    let db;
+    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 = new Injector('Test');
+        configureOrm({
+            repositoryConfig: { schema },
+            connection: {
+                host: '127.0.0.1', port: 5432, user: 'tstdl', password: 'wf7rq6glrk5jykne', database: 'tstdl',
+            },
+        });
+        db = injector.resolve(Database);
+        await db.execute(sql `CREATE SCHEMA IF NOT EXISTS ${sql.identifier(schema)}`);
+        await db.execute(sql `DROP TABLE IF EXISTS ${sql.identifier(schema)}.${sql.identifier('attribute_entities')} CASCADE`);
+        await db.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 '{}'
+      )
+    `);
+    });
+    test('should support partial attribute updates', async () => {
+        await db.execute(sql `TRUNCATE TABLE ${sql.identifier(schema)}.${sql.identifier('attribute_entities')} CASCADE`);
+        await runInInjectionContext(injector, async () => {
+            const repository = injectRepository(AttributeEntity);
+            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 () => {
+        await db.execute(sql `TRUNCATE TABLE ${sql.identifier(schema)}.${sql.identifier('attribute_entities')} CASCADE`);
+        await runInInjectionContext(injector, async () => {
+            const repository = injectRepository(AttributeEntity);
+            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 db.execute(sql `TRUNCATE TABLE ${sql.identifier(schema)}.${sql.identifier('attribute_entities')} CASCADE`);
+        await runInInjectionContext(injector, async () => {
+            const repository = injectRepository(AttributeEntity);
+            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-comprehensive.test.d.ts

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

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

@@ -0,0 +1,187 @@
+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 { Integer, StringProperty } from '../../schema/index.js';
+import { GeneratedTsVector, Table } from '../decorators.js';
+import { Entity } from '../entity.js';
+import { configureOrm, Database } from '../server/index.js';
+import { injectRepository } from '../server/repository.js';
+describe('ORM Repository Comprehensive Options & Edge Cases', () => {
+    let injector;
+    let db;
+    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 = new Injector('Test');
+        configureOrm({
+            repositoryConfig: { schema },
+            connection: {
+                host: '127.0.0.1', port: 5432, user: 'tstdl', password: 'wf7rq6glrk5jykne', database: 'tstdl',
+            },
+        });
+        db = injector.resolve(Database);
+        await db.execute(sql `CREATE SCHEMA IF NOT EXISTS ${sql.identifier(schema)}`);
+        await db.execute(sql `DROP TABLE IF EXISTS ${sql.identifier(schema)}.${sql.identifier('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 runInInjectionContext(injector, async () => {
+            const repository = injectRepository(ComprehensiveEntity);
+            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 runInInjectionContext(injector, async () => {
+            const repository = injectRepository(ComprehensiveEntity);
+            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`);
+        await runInInjectionContext(injector, async () => {
+            const repository = injectRepository(ComprehensiveEntity);
+            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 runInInjectionContext(injector, async () => {
+            const repository = injectRepository(ComprehensiveEntity);
+            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 () => {
+        await runInInjectionContext(injector, async () => {
+            const repository = injectRepository(ComprehensiveEntity);
+            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 () => {
+        await runInInjectionContext(injector, async () => {
+            const repository = injectRepository(ComprehensiveEntity);
+            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 runInInjectionContext(injector, async () => {
+            const repository = injectRepository(ComprehensiveEntity);
+            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

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