@tstdl/base 0.93.86 → 0.93.89

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

@@ -0,0 +1,330 @@
+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 { defineEnum } from '../../enumeration/index.js';
+import { NotFoundError } from '../../errors/not-found.error.js';
+import { Injector, runInInjectionContext } from '../../injector/index.js';
+import { Array, Enumeration, Integer, string, StringProperty } from '../../schema/index.js';
+import { sql } from 'drizzle-orm';
+import { beforeAll, describe, expect, test } from 'vitest';
+import { Column, EmbeddedProperty, EncryptedProperty, Reference, Table } from '../decorators.js';
+import { Entity } from '../entity.js';
+import { JsonProperty, NumericDateProperty } from '../schemas/index.js';
+import { configureOrm, Database } from '../server/index.js';
+import { injectRepository } from '../server/repository.js';
+describe('ORM Repository Regression (Integration)', () => {
+    let injector;
+    let db;
+    const schema = 'test_orm_regression';
+    const UserRole = defineEnum('UserRole', {
+        Admin: 'admin',
+        User: 'user',
+    });
+    class Address {
+        street;
+        number;
+    }
+    __decorate([
+        StringProperty(),
+        __metadata("design:type", String)
+    ], Address.prototype, "street", void 0);
+    __decorate([
+        Integer(),
+        __metadata("design:type", Number)
+    ], Address.prototype, "number", void 0);
+    let StandardEntity = class StandardEntity extends Entity {
+        name;
+        address;
+        secret;
+        role;
+        data;
+        tags;
+        birthday;
+    };
+    __decorate([
+        StringProperty(),
+        Column({ name: 'display_name' }),
+        __metadata("design:type", String)
+    ], StandardEntity.prototype, "name", void 0);
+    __decorate([
+        EmbeddedProperty(Address),
+        __metadata("design:type", Address)
+    ], StandardEntity.prototype, "address", void 0);
+    __decorate([
+        StringProperty(),
+        EncryptedProperty(),
+        __metadata("design:type", String)
+    ], StandardEntity.prototype, "secret", void 0);
+    __decorate([
+        Enumeration(UserRole),
+        __metadata("design:type", String)
+    ], StandardEntity.prototype, "role", void 0);
+    __decorate([
+        JsonProperty(),
+        __metadata("design:type", Object)
+    ], StandardEntity.prototype, "data", void 0);
+    __decorate([
+        Array(string()),
+        __metadata("design:type", Array)
+    ], StandardEntity.prototype, "tags", void 0);
+    __decorate([
+        NumericDateProperty(),
+        Column({ name: 'dob' }),
+        __metadata("design:type", Number)
+    ], StandardEntity.prototype, "birthday", void 0);
+    StandardEntity = __decorate([
+        Table('standard_entities', { schema })
+    ], StandardEntity);
+    let Post = class Post extends Entity {
+        title;
+        authorId;
+    };
+    __decorate([
+        StringProperty(),
+        __metadata("design:type", String)
+    ], Post.prototype, "title", void 0);
+    __decorate([
+        StringProperty(),
+        Column({ name: 'author_id' }),
+        Reference(() => StandardEntity),
+        __metadata("design:type", String)
+    ], Post.prototype, "authorId", void 0);
+    Post = __decorate([
+        Table('posts', { schema })
+    ], Post);
+    beforeAll(async () => {
+        injector = new Injector('Test');
+        const encryptionSecret = new Uint8Array(32).fill(1);
+        configureOrm({
+            repositoryConfig: { schema },
+            connection: {
+                host: '127.0.0.1',
+                port: 5432,
+                user: 'tstdl',
+                password: 'wf7rq6glrk5jykne',
+                database: 'tstdl',
+            },
+            encryptionSecret
+        });
+        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('posts')} CASCADE`);
+        await db.execute(sql `DROP TABLE IF EXISTS ${sql.identifier(schema)}.${sql.identifier('standard_entities')} CASCADE`);
+        await db.execute(sql `DROP TYPE IF EXISTS ${sql.identifier(schema)}.${sql.identifier('user_role')} CASCADE`);
+        await db.execute(sql `CREATE TYPE ${sql.identifier(schema)}.${sql.identifier('user_role')} AS ENUM ('admin', 'user')`);
+        await db.execute(sql `
+      CREATE TABLE ${sql.identifier(schema)}.${sql.identifier('standard_entities')} (
+        id UUID PRIMARY KEY DEFAULT gen_random_uuid(),
+        display_name TEXT NOT NULL,
+        address_street TEXT NOT NULL,
+        address_number INTEGER NOT NULL,
+        secret BYTEA NOT NULL,
+        role ${sql.identifier(schema)}.${sql.identifier('user_role')} NOT NULL,
+        data JSONB NOT NULL,
+        tags TEXT[] NOT NULL,
+        dob DATE NOT NULL,
+        revision INTEGER NOT NULL,
+        revision_timestamp TIMESTAMP WITH TIME ZONE NOT NULL,
+        create_timestamp TIMESTAMP WITH TIME ZONE NOT NULL,
+        delete_timestamp TIMESTAMP WITH TIME ZONE,
+        attributes JSONB NOT NULL DEFAULT '{}'
+      )
+    `);
+        await db.execute(sql `
+      CREATE TABLE ${sql.identifier(schema)}.${sql.identifier('posts')} (
+        id UUID PRIMARY KEY DEFAULT gen_random_uuid(),
+        title TEXT NOT NULL,
+        author_id UUID NOT NULL REFERENCES ${sql.identifier(schema)}.${sql.identifier('standard_entities')} (id),
+        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 perform basic CRUD on standard entity', async () => {
+        await db.execute(sql `TRUNCATE TABLE ${sql.identifier(schema)}.${sql.identifier('standard_entities')} CASCADE`);
+        await runInInjectionContext(injector, async () => {
+            const repository = injectRepository(StandardEntity);
+            const entity = new StandardEntity();
+            entity.name = 'Test';
+            entity.address = { street: 'Main St', number: 123 };
+            entity.secret = 'my-secret-password';
+            entity.role = UserRole.User;
+            entity.data = { foo: 'bar' };
+            entity.tags = ['a', 'b'];
+            entity.birthday = 19716; // 2023-12-25
+            const inserted = await repository.insert(entity);
+            expect(inserted.id).toBeDefined();
+            expect(inserted.name).toBe('Test');
+            expect(inserted.address.street).toBe('Main St');
+            expect(inserted.secret).toBe('my-secret-password');
+            expect(inserted.role).toBe(UserRole.User);
+            expect(inserted.data).toEqual({ foo: 'bar' });
+            expect(inserted.tags).toEqual(['a', 'b']);
+            expect(inserted.birthday).toBe(19716);
+            // Verify DB encrypted state
+            const { rows: [row] } = await db.execute(sql `SELECT secret, dob FROM ${sql.identifier(schema)}.${sql.identifier('standard_entities')} WHERE id = ${inserted.id}`);
+            expect(row['secret']).toBeInstanceOf(Uint8Array);
+            expect(row['secret']).not.toEqual(new TextEncoder().encode('my-secret-password'));
+            expect(row['dob']).toBe('2023-12-25');
+            // Update
+            await repository.update(inserted.id, { name: 'Updated' });
+            const updated = await repository.load(inserted.id);
+            expect(updated.name).toBe('Updated');
+            expect(updated.secret).toBe('my-secret-password'); // Still readable
+            // Soft Delete
+            await repository.delete(inserted.id);
+            const deleted = await repository.tryLoad(inserted.id);
+            expect(deleted).toBeUndefined();
+            const { rows: [deletedRow] } = await db.execute(sql `SELECT delete_timestamp FROM ${sql.identifier(schema)}.${sql.identifier('standard_entities')} WHERE id = ${inserted.id}`);
+            expect(deletedRow['delete_timestamp']).not.toBeNull();
+        });
+    });
+    test('should support Reference decorator', async () => {
+        await db.execute(sql `TRUNCATE TABLE ${sql.identifier(schema)}.${sql.identifier('standard_entities')} CASCADE`);
+        await runInInjectionContext(injector, async () => {
+            const standardRepository = injectRepository(StandardEntity);
+            const postRepository = injectRepository(Post);
+            const author = Object.assign(new StandardEntity(), { name: 'Author', address: { street: 'A', number: 1 }, secret: 's', role: UserRole.User, data: {}, tags: [], birthday: 0 });
+            const insertedAuthor = await standardRepository.insert(author);
+            const post = Object.assign(new Post(), { title: 'Hello World', authorId: insertedAuthor.id });
+            const insertedPost = await postRepository.insert(post);
+            expect(insertedPost.authorId).toBe(insertedAuthor.id);
+            const loadedPost = await postRepository.load(insertedPost.id);
+            expect(loadedPost.authorId).toBe(insertedAuthor.id);
+        });
+    });
+    test('should perform insertMany and loadMany', async () => {
+        await db.execute(sql `TRUNCATE TABLE ${sql.identifier(schema)}.${sql.identifier('standard_entities')} CASCADE`);
+        await runInInjectionContext(injector, async () => {
+            const repository = injectRepository(StandardEntity);
+            const entities = [
+                Object.assign(new StandardEntity(), { name: 'E1', address: { street: 'S1', number: 1 }, secret: 's1', role: UserRole.User, data: {}, tags: [], birthday: 0 }),
+                Object.assign(new StandardEntity(), { name: 'E2', address: { street: 'S2', number: 2 }, secret: 's2', role: UserRole.Admin, data: {}, tags: [], birthday: 0 }),
+            ];
+            const inserted = await repository.insertMany(entities);
+            expect(inserted).toHaveLength(2);
+            const loaded = await repository.loadMany(inserted.map((e) => e.id));
+            expect(loaded).toHaveLength(2);
+            expect(loaded.map((e) => e.name).sort()).toEqual(['E1', 'E2']);
+        });
+    });
+    test('should support upsert', async () => {
+        await db.execute(sql `TRUNCATE TABLE ${sql.identifier(schema)}.${sql.identifier('standard_entities')} CASCADE`);
+        await runInInjectionContext(injector, async () => {
+            const repository = injectRepository(StandardEntity);
+            const entity = Object.assign(new StandardEntity(), { name: 'Original', address: { street: 'S', number: 1 }, secret: 's', role: UserRole.User, data: {}, tags: [], birthday: 0 });
+            const inserted = await repository.insert(entity);
+            // Upsert: update existing
+            const updateEntity = Object.assign(new StandardEntity(), { id: inserted.id, name: 'Upserted', address: { street: 'S', number: 1 }, secret: 's', role: UserRole.User, data: {}, tags: [], birthday: 0 });
+            const upserted = await repository.upsert('id', updateEntity);
+            expect(upserted.id).toBe(inserted.id);
+            expect(upserted.name).toBe('Upserted');
+            // Verify DB
+            const loaded = await repository.load(inserted.id);
+            expect(loaded.name).toBe('Upserted');
+        });
+    });
+    test('should support complex queries with $or and $and', async () => {
+        await db.execute(sql `TRUNCATE TABLE ${sql.identifier(schema)}.${sql.identifier('standard_entities')} CASCADE`);
+        await runInInjectionContext(injector, async () => {
+            const repository = injectRepository(StandardEntity);
+            await repository.insertMany([
+                Object.assign(new StandardEntity(), { name: 'A', address: { street: 'S1', number: 10 }, secret: 's', role: UserRole.Admin, data: {}, tags: [], birthday: 0 }),
+                Object.assign(new StandardEntity(), { name: 'B', address: { street: 'S2', number: 20 }, secret: 's', role: UserRole.User, data: {}, tags: [], birthday: 0 }),
+                Object.assign(new StandardEntity(), { name: 'C', address: { street: 'S3', number: 30 }, secret: 's', role: UserRole.Admin, data: {}, tags: [], birthday: 0 }),
+            ]);
+            const results = await repository.loadManyByQuery({
+                $or: [
+                    { name: 'B' },
+                    { $and: [{ role: UserRole.Admin }, { 'address.number': { $gt: 25 } }] }
+                ]
+            });
+            expect(results).toHaveLength(2);
+            expect(results.map((r) => r.name).sort()).toEqual(['B', 'C']);
+        });
+    });
+    test('should support hasAll', async () => {
+        await db.execute(sql `TRUNCATE TABLE ${sql.identifier(schema)}.${sql.identifier('standard_entities')} CASCADE`);
+        await runInInjectionContext(injector, async () => {
+            const repository = injectRepository(StandardEntity);
+            const inserted = await repository.insertMany([
+                Object.assign(new StandardEntity(), { name: 'E1', address: { street: 'S1', number: 1 }, secret: 's', role: UserRole.User, data: {}, tags: [], birthday: 0 }),
+                Object.assign(new StandardEntity(), { name: 'E2', address: { street: 'S2', number: 2 }, secret: 's', role: UserRole.User, data: {}, tags: [], birthday: 0 }),
+            ]);
+            expect(await repository.hasAll(inserted.map((e) => e.id))).toBe(true);
+            expect(await repository.hasAll([...inserted.map((e) => e.id), '00000000-0000-0000-0000-000000000000'])).toBe(false);
+        });
+    });
+    test('should throw NotFoundError on missing load', async () => {
+        await runInInjectionContext(injector, async () => {
+            const repository = injectRepository(StandardEntity);
+            await expect(repository.load('00000000-0000-0000-0000-000000000000')).rejects.toThrow(NotFoundError);
+        });
+    });
+    test('should support upsertMany', async () => {
+        await db.execute(sql `TRUNCATE TABLE ${sql.identifier(schema)}.${sql.identifier('standard_entities')} CASCADE`);
+        await runInInjectionContext(injector, async () => {
+            const repository = injectRepository(StandardEntity);
+            const e1 = await repository.insert(Object.assign(new StandardEntity(), { name: 'E1', address: { street: 'S1', number: 1 }, secret: 's', role: UserRole.User, data: {}, tags: [], birthday: 0 }));
+            const upsertData = [
+                Object.assign(new StandardEntity(), { id: e1.id, name: 'E1-Updated', address: { street: 'S1', number: 1 }, secret: 's', role: UserRole.User, data: {}, tags: [], birthday: 0 }),
+                Object.assign(new StandardEntity(), { name: 'E2', address: { street: 'S2', number: 2 }, secret: 's', role: UserRole.User, data: {}, tags: [], birthday: 0 }),
+            ];
+            await repository.upsertMany('id', upsertData);
+            const all = await repository.loadAll();
+            expect(all).toHaveLength(2);
+            expect(all.find((e) => e.id === e1.id).name).toBe('E1-Updated');
+            expect(all.find((e) => e.name === 'E2')).toBeDefined();
+        });
+    });
+    test('should support deleteManyByQuery', async () => {
+        await db.execute(sql `TRUNCATE TABLE ${sql.identifier(schema)}.${sql.identifier('standard_entities')} CASCADE`);
+        await runInInjectionContext(injector, async () => {
+            const repository = injectRepository(StandardEntity);
+            await repository.insertMany([
+                Object.assign(new StandardEntity(), { name: 'A', address: { street: 'S', number: 1 }, secret: 's', role: UserRole.User, data: {}, tags: [], birthday: 0 }),
+                Object.assign(new StandardEntity(), { name: 'A', address: { street: 'S', number: 2 }, secret: 's', role: UserRole.User, data: {}, tags: [], birthday: 0 }),
+                Object.assign(new StandardEntity(), { name: 'B', address: { street: 'S', number: 3 }, secret: 's', role: UserRole.User, data: {}, tags: [], birthday: 0 }),
+            ]);
+            await repository.deleteManyByQuery({ name: 'A' });
+            const remaining = await repository.loadAll();
+            expect(remaining).toHaveLength(1);
+            expect(remaining[0].name).toBe('B');
+        });
+    });
+    test('should support tryInsert', async () => {
+        await db.execute(sql `TRUNCATE TABLE ${sql.identifier(schema)}.${sql.identifier('standard_entities')} CASCADE`);
+        await runInInjectionContext(injector, async () => {
+            const repository = injectRepository(StandardEntity);
+            const entity = Object.assign(new StandardEntity(), { name: 'E1', address: { street: 'S', number: 1 }, secret: 's', role: UserRole.User, data: {}, tags: [], birthday: 0 });
+            const inserted = await repository.tryInsert(entity);
+            expect(inserted).toBeDefined();
+            // Conflict
+            const conflict = await repository.tryInsert(Object.assign(new StandardEntity(), { id: inserted.id, name: 'Conflict', address: { street: 'S', number: 1 }, secret: 's', role: UserRole.User, data: {}, tags: [], birthday: 0 }));
+            expect(conflict).toBeUndefined();
+        });
+    });
+    test('should support insertManyIfNotExists', async () => {
+        await db.execute(sql `TRUNCATE TABLE ${sql.identifier(schema)}.${sql.identifier('standard_entities')} CASCADE`);
+        await runInInjectionContext(injector, async () => {
+            const repository = injectRepository(StandardEntity);
+            const e1 = await repository.insert(Object.assign(new StandardEntity(), { name: 'E1', address: { street: 'S', number: 1 }, secret: 's', role: UserRole.User, data: {}, tags: [], birthday: 0 }));
+            const data = [
+                Object.assign(new StandardEntity(), { id: e1.id, name: 'E1-Conflict', address: { street: 'S', number: 1 }, secret: 's', role: UserRole.User, data: {}, tags: [], birthday: 0 }),
+                Object.assign(new StandardEntity(), { name: 'E2', address: { street: 'S', number: 2 }, secret: 's', role: UserRole.User, data: {}, tags: [], birthday: 0 }),
+            ];
+            const results = await repository.insertManyIfNotExists('id', data);
+            expect(results).toHaveLength(1);
+            expect(results[0].name).toBe('E2');
+        });
+    });
+});

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

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

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

@@ -0,0 +1,129 @@
+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 { beforeAll, describe, expect, test } from 'vitest';
+import { sql } from 'drizzle-orm';
+import { StringProperty } from '../../schema/index.js';
+import { Entity } from '../entity.js';
+import { Table } from '../decorators.js';
+import { injectRepository } from '../server/repository.js';
+import { configureOrm, Database } from '../server/index.js';
+import { Injector, runInInjectionContext } from '../../injector/index.js';
+describe('ORM Repository Search Coverage', () => {
+    let injector;
+    let db;
+    const schema = 'test_orm_search_coverage';
+    let Document = class Document extends Entity {
+        content;
+    };
+    __decorate([
+        StringProperty(),
+        __metadata("design:type", String)
+    ], Document.prototype, "content", void 0);
+    Document = __decorate([
+        Table('docs', { schema })
+    ], Document);
+    beforeAll(async () => {
+        injector = new Injector('TestSearchCoverage');
+        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('docs')} CASCADE`);
+        await db.execute(sql `CREATE EXTENSION IF NOT EXISTS pg_trgm`); // Enable trigram
+        await db.execute(sql `
+      CREATE TABLE ${sql.identifier(schema)}.${sql.identifier('docs')} (
+        id UUID PRIMARY KEY DEFAULT gen_random_uuid(),
+        content 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('tsvector search with order function accessing score', async () => {
+        await runInInjectionContext(injector, async () => {
+            const repository = injectRepository(Document);
+            await repository.insert(Object.assign(new Document(), { content: 'Apple Banana' }));
+            const results = await repository.search({
+                query: { $tsvector: { fields: ['content'], query: 'Apple' } },
+                order: (cols) => [[cols.score, 'desc']]
+            });
+            expect(results).toHaveLength(1);
+        });
+    });
+    test('trigram search basic', async () => {
+        await runInInjectionContext(injector, async () => {
+            const repository = injectRepository(Document);
+            await repository.insert(Object.assign(new Document(), { content: 'Trigram Test' }));
+            const results = await repository.search({
+                query: { $trigram: { fields: ['content'], query: 'Trigram' } },
+            });
+            expect(results).toHaveLength(1);
+        });
+    });
+    test('trigram search with threshold (phrase)', async () => {
+        await runInInjectionContext(injector, async () => {
+            const repository = injectRepository(Document);
+            await repository.insert(Object.assign(new Document(), { content: 'Phrase Match' }));
+            // Set threshold to a value that allows matching (default is 0.3)
+            await db.execute(sql `SET pg_trgm.similarity_threshold = 0.1`);
+            const results = await repository.search({
+                query: { $trigram: { fields: ['content'], query: 'Phrase', type: 'phrase', threshold: 0.1 } },
+            });
+            expect(results).toHaveLength(1);
+        });
+    });
+    test('trigram search with threshold (word)', async () => {
+        await runInInjectionContext(injector, async () => {
+            const repository = injectRepository(Document);
+            await repository.insert(Object.assign(new Document(), { content: 'Word Match' }));
+            await db.execute(sql `SET pg_trgm.word_similarity_threshold = 0.1`);
+            const results = await repository.search({
+                query: { $trigram: { fields: ['content'], query: 'Word', type: 'word', threshold: 0.1 } },
+            });
+            expect(results).toHaveLength(1);
+        });
+    });
+    test('trigram search with threshold (strict-word)', async () => {
+        await runInInjectionContext(injector, async () => {
+            const repository = injectRepository(Document);
+            await repository.insert(Object.assign(new Document(), { content: 'Strict Match' }));
+            await db.execute(sql `SET pg_trgm.strict_word_similarity_threshold = 0.1`);
+            const results = await repository.search({
+                query: { $trigram: { fields: ['content'], query: 'Strict', type: 'strict-word', threshold: 0.1 } },
+            });
+            expect(results).toHaveLength(1);
+        });
+    });
+    test('trigram search with order function', async () => {
+        await runInInjectionContext(injector, async () => {
+            const repository = injectRepository(Document);
+            const results = await repository.search({
+                query: { $trigram: { fields: ['content'], query: 'Order' } },
+                order: ({ score }) => [[score, 'desc']]
+            });
+            // Even if no results, code path is exercised?
+            // No, order function is called only if query is executed.
+            // Insert something first
+            await repository.insert(Object.assign(new Document(), { content: 'Order Test' }));
+            const results2 = await repository.search({
+                query: { $trigram: { fields: ['content'], query: 'Order' } },
+                order: ({ score }) => [[score, 'desc']]
+            });
+            expect(results2).toHaveLength(1);
+        });
+    });
+});

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

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

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

@@ -0,0 +1,116 @@
+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 { dropTables, setupIntegrationTest } from '../../unit-test/index.js';
+import { Table } from '../decorators.js';
+import { Entity } from '../entity.js';
+import { Database } from '../server/index.js';
+import { injectRepository } from '../server/repository.js';
+describe('ORM Repository Search', () => {
+    let injector;
+    let database;
+    const schema = 'test_orm_search';
+    let SearchEntity = class SearchEntity extends Entity {
+        title;
+        content;
+    };
+    __decorate([
+        StringProperty(),
+        __metadata("design:type", String)
+    ], SearchEntity.prototype, "title", void 0);
+    __decorate([
+        StringProperty(),
+        __metadata("design:type", String)
+    ], SearchEntity.prototype, "content", void 0);
+    SearchEntity = __decorate([
+        Table('search_entities', { schema })
+    ], SearchEntity);
+    beforeAll(async () => {
+        ({ injector, database } = await setupIntegrationTest({ orm: { schema } }));
+        await dropTables(database, schema, ['search_entities']);
+        await database.execute(sql `
+      CREATE TABLE ${sql.identifier(schema)}.${sql.identifier('search_entities')} (
+        id UUID PRIMARY KEY DEFAULT gen_random_uuid(),
+        title TEXT NOT NULL,
+        content 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 search with score transformer', async () => {
+        await runInInjectionContext(injector, async () => {
+            const repository = injectRepository(SearchEntity);
+            await repository.insert(Object.assign(new SearchEntity(), { title: 'Hello World', content: 'Some content here' }));
+            const results = await repository.search({
+                query: { $tsvector: { fields: ['title'], query: 'hello' } },
+                score: (score) => sql `(${score}) * 100`,
+            });
+            expect(results).toHaveLength(1);
+            expect(results[0].score).toBeGreaterThan(1); // normalized score is small, * 100 should be > 1
+        });
+    });
+    test('should support search with highlight (column names)', async () => {
+        await runInInjectionContext(injector, async () => {
+            const repository = injectRepository(SearchEntity);
+            await repository.insert(Object.assign(new SearchEntity(), { title: 'Highlander', content: 'There can be only one' }));
+            const results = await repository.search({
+                query: { $tsvector: { fields: ['title', 'content'], query: 'Highlander' } },
+                highlight: { source: 'title' },
+            });
+            expect(results).toHaveLength(1);
+            expect(results[0].highlight).toContain('<b>Highlander</b>');
+        });
+    });
+    test('should support search with highlight (raw SQL)', async () => {
+        await runInInjectionContext(injector, async () => {
+            const repository = injectRepository(SearchEntity);
+            await repository.insert(Object.assign(new SearchEntity(), { title: 'SQL Master', content: 'Database wizard' }));
+            const results = await repository.search({
+                query: { $tsvector: { fields: ['title', 'content'], query: 'Master' } },
+                highlight: { source: sql `title || ' ' || content` },
+            });
+            expect(results).toHaveLength(1);
+            expect(results[0].highlight).toContain('<b>Master</b>');
+        });
+    });
+    test('should support ParadeDB search with highlightPositions', async () => {
+        // This test requires pg_search extension to be installed.
+        try {
+            await database.execute(sql `CREATE EXTENSION IF NOT EXISTS pg_search`);
+            await database.execute(sql `CREATE INDEX idx_search_parade ON ${sql.identifier(schema)}.${sql.identifier('search_entities')} USING bm25 (id, title, content) WITH (key_field='id')`);
+        }
+        catch (e) {
+            console.warn('ParadeDB (pg_search) not available or index creation failed, skipping ParadeDB test.', e);
+            return;
+        }
+        await runInInjectionContext(injector, async () => {
+            const repository = injectRepository(SearchEntity);
+            await repository.insert(Object.assign(new SearchEntity(), { title: 'Parade', content: 'ParadeDB is fast' }));
+            const results = await repository.search({
+                query: { $parade: { fields: ['title'], query: 'Parade' } },
+                highlight: { source: 'title', includePositions: true },
+            });
+            expect(results).toHaveLength(1);
+            expect(results[0].highlight).toBeDefined();
+            expect(results[0].highlightPositions).toBeDefined();
+            expect(isArray(results[0].highlightPositions)).toBe(true);
+        });
+    });
+});
+function isArray(val) {
+    return Array.isArray(val);
+}

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

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