@tstdl/base 0.93.182 → 0.93.183

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

@@ -1,288 +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 { defineEnum } from '../../enumeration/index.js';
-import { NotFoundError } from '../../errors/not-found.error.js';
-import { Array, Enumeration, Integer, string, StringProperty } from '../../schema/index.js';
-import { setupIntegrationTest } from '../../testing/index.js';
-import { Column, EmbeddedProperty, EncryptedProperty, Reference, Table } from '../decorators.js';
-import { Entity } from '../entity.js';
-import { JsonProperty, NumericDateProperty } from '../schemas/index.js';
-import { getRepository } from '../server/index.js';
-describe('ORM Repository Regression (Integration)', () => {
-    let injector;
-    let db;
-    let standardRepository;
-    let postRepository;
-    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, database: db } = await setupIntegrationTest({
-            orm: { schema },
-        }));
-        standardRepository = injector.resolve(getRepository(StandardEntity));
-        postRepository = injector.resolve(getRepository(Post));
-        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`);
-        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 standardRepository.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 standardRepository.update(inserted.id, { name: 'Updated' });
-        const updated = await standardRepository.load(inserted.id);
-        expect(updated.name).toBe('Updated');
-        expect(updated.secret).toBe('my-secret-password'); // Still readable
-        // Soft Delete
-        await standardRepository.delete(inserted.id);
-        const deleted = await standardRepository.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`);
-        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`);
-        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 standardRepository.insertMany(entities);
-        expect(inserted).toHaveLength(2);
-        const loaded = await standardRepository.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`);
-        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 standardRepository.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 standardRepository.upsert('id', updateEntity);
-        expect(upserted.id).toBe(inserted.id);
-        expect(upserted.name).toBe('Upserted');
-        // Verify DB
-        const loaded = await standardRepository.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 standardRepository.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 standardRepository.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`);
-        const inserted = await standardRepository.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 standardRepository.hasAll(inserted.map((e) => e.id))).toBe(true);
-        expect(await standardRepository.hasAll([...inserted.map((e) => e.id), '00000000-0000-0000-0000-000000000000'])).toBe(false);
-    });
-    test('should throw NotFoundError on missing load', async () => {
-        await expect(standardRepository.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`);
-        const e1 = await standardRepository.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 standardRepository.upsertMany('id', upsertData);
-        const all = await standardRepository.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 standardRepository.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 standardRepository.deleteManyByQuery({ name: 'A' });
-        const remaining = await standardRepository.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`);
-        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 standardRepository.tryInsert(entity);
-        expect(inserted).toBeDefined();
-        // Conflict
-        const conflict = await standardRepository.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`);
-        const e1 = await standardRepository.insert(Object.assign(new StandardEntity(), { name: 'E1', address: { street: 'S1', 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: '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 }),
-        ];
-        const results = await standardRepository.insertManyIfNotExists('id', data);
-        expect(results).toHaveLength(1);
-        expect(results[0].name).toBe('E2');
-    });
-});

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

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

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

@@ -1,107 +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 { describe, expect } from 'vitest';
-import { StringProperty } from '../../schema/index.js';
-import { getIntegrationTest } from '../../testing/index.js';
-import { Table } from '../decorators.js';
-import { Entity } from '../entity.js';
-import { injectRepository } from '../server/repository.js';
-const schema = 'test_orm_search_coverage';
-const test = getIntegrationTest({ orm: { schema } });
-describe('ORM Repository 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);
-    test.beforeEach(async ({ database: db }) => {
-        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 () => {
-        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 () => {
-        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 ({ database: db }) => {
-        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 ({ database: db }) => {
-        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 ({ database: db }) => {
-        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 () => {
-        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

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

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

@@ -1,105 +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 { isArray } from '../../utils/type-guards.js';
-import { Table } from '../decorators.js';
-import { Entity } from '../entity.js';
-import { getRepository } from '../server/index.js';
-describe('ORM Repository Search', () => {
-    let injector;
-    let database;
-    let repository;
-    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 } }));
-        repository = injector.resolve(getRepository(SearchEntity));
-        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 '{}'
-      )
-    `);
-    });
-    beforeEach(async () => {
-        await truncateTables(database, schema, ['search_entities']);
-    });
-    test('should support search with score transformer', async () => {
-        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 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 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 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);
-    });
-});

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

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

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

@@ -1,118 +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 { StringProperty } from '../../schema/index.js';
-import { setupIntegrationTest } from '../../testing/index.js';
-import { Table } from '../decorators.js';
-import { Entity } from '../entity.js';
-import { getRepository } from '../server/index.js';
-describe('ORM Repository Soft Delete (Integration)', () => {
-    let injector;
-    let db;
-    let repository;
-    const schema = 'test_orm_soft_delete';
-    let SoftDeleteEntity = class SoftDeleteEntity extends Entity {
-        name;
-    };
-    __decorate([
-        StringProperty(),
-        __metadata("design:type", String)
-    ], SoftDeleteEntity.prototype, "name", void 0);
-    SoftDeleteEntity = __decorate([
-        Table('soft_delete_entities', { schema })
-    ], SoftDeleteEntity);
-    beforeAll(async () => {
-        ({ injector, database: db } = await setupIntegrationTest({
-            orm: { schema },
-        }));
-        repository = injector.resolve(getRepository(SoftDeleteEntity));
-        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('soft_delete_entities')} CASCADE`);
-        await db.execute(sql `
-      CREATE TABLE ${sql.identifier(schema)}.${sql.identifier('soft_delete_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 soft delete an entity by ID', async () => {
-        await db.execute(sql `TRUNCATE TABLE ${sql.identifier(schema)}.${sql.identifier('soft_delete_entities')} CASCADE`);
-        const e1 = await repository.insert(Object.assign(new SoftDeleteEntity(), { name: 'E1' }));
-        const deleted = await repository.delete(e1.id);
-        expect(deleted.id).toBe(e1.id);
-        expect(deleted.metadata.deleteTimestamp).toBeDefined();
-        expect(await repository.has(e1.id)).toBe(false);
-        expect(await repository.tryLoad(e1.id)).toBeUndefined();
-        expect(await repository.count()).toBe(0);
-        const allWithDeleted = await repository.loadAll({ withDeleted: true });
-        expect(allWithDeleted).toHaveLength(1);
-        expect(allWithDeleted[0].id).toBe(e1.id);
-    });
-    test('should soft delete multiple entities by IDs', async () => {
-        await db.execute(sql `TRUNCATE TABLE ${sql.identifier(schema)}.${sql.identifier('soft_delete_entities')} CASCADE`);
-        const e1 = await repository.insert(Object.assign(new SoftDeleteEntity(), { name: 'E1' }));
-        const e2 = await repository.insert(Object.assign(new SoftDeleteEntity(), { name: 'E2' }));
-        const deleted = await repository.deleteMany([e1.id, e2.id]);
-        expect(deleted).toHaveLength(2);
-        expect(await repository.count()).toBe(0);
-        expect(await repository.countByQuery({}, { withDeleted: true })).toBe(2);
-    });
-    test('should soft delete entities by query', async () => {
-        await db.execute(sql `TRUNCATE TABLE ${sql.identifier(schema)}.${sql.identifier('soft_delete_entities')} CASCADE`);
-        await repository.insertMany([
-            Object.assign(new SoftDeleteEntity(), { name: 'A' }),
-            Object.assign(new SoftDeleteEntity(), { name: 'B' }),
-            Object.assign(new SoftDeleteEntity(), { name: 'A' }),
-        ]);
-        const deleted = await repository.deleteManyByQuery({ name: 'A' });
-        expect(deleted).toHaveLength(2);
-        expect(await repository.count()).toBe(1);
-        expect(await repository.countByQuery({}, { withDeleted: true })).toBe(3);
-    });
-    test('should not update soft-deleted entities by default', async () => {
-        await db.execute(sql `TRUNCATE TABLE ${sql.identifier(schema)}.${sql.identifier('soft_delete_entities')} CASCADE`);
-        const e1 = await repository.insert(Object.assign(new SoftDeleteEntity(), { name: 'E1' }));
-        await repository.delete(e1.id);
-        const updated = await repository.tryUpdate(e1.id, { name: 'Updated' });
-        expect(updated).toBeUndefined();
-        const loaded = await repository.tryLoad(e1.id, { withDeleted: true });
-        expect(loaded.name).toBe('E1');
-    });
-    test('should support hard delete on soft-deleted entities', async () => {
-        await db.execute(sql `TRUNCATE TABLE ${sql.identifier(schema)}.${sql.identifier('soft_delete_entities')} CASCADE`);
-        const e1 = await repository.insert(Object.assign(new SoftDeleteEntity(), { name: 'E1' }));
-        await repository.delete(e1.id);
-        const hardDeleted = await repository.hardDelete(e1.id);
-        expect(hardDeleted.id).toBe(e1.id);
-        expect(await repository.countByQuery({}, { withDeleted: true })).toBe(0);
-    });
-    test('should ignore already soft-deleted entities when deleting again', async () => {
-        await db.execute(sql `TRUNCATE TABLE ${sql.identifier(schema)}.${sql.identifier('soft_delete_entities')} CASCADE`);
-        const e1 = await repository.insert(Object.assign(new SoftDeleteEntity(), { name: 'E1' }));
-        await repository.delete(e1.id);
-        const secondDelete = await repository.tryDelete(e1.id);
-        expect(secondDelete).toBeUndefined();
-    });
-    test('should hard delete multiple entities by query (including soft-deleted)', async () => {
-        await db.execute(sql `TRUNCATE TABLE ${sql.identifier(schema)}.${sql.identifier('soft_delete_entities')} CASCADE`);
-        const e1 = await repository.insert(Object.assign(new SoftDeleteEntity(), { name: 'E1' }));
-        const e2 = await repository.insert(Object.assign(new SoftDeleteEntity(), { name: 'E2' }));
-        await repository.delete(e1.id); // Soft delete E1
-        const hardDeleted = await repository.hardDeleteManyByQuery({});
-        expect(hardDeleted).toHaveLength(2); // Should hard delete both
-        expect(await repository.countByQuery({}, { withDeleted: true })).toBe(0);
-    });
-});

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

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