@tstdl/base 0.93.181 → 0.93.183

package/orm/tests/query-complex.test.js

@@ -1,172 +0,0 @@
-var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
-    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
-    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
-    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
-    return c > 3 && r && Object.defineProperty(target, key, r), r;
-};
-var __metadata = (this && this.__metadata) || function (k, v) {
-    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
-};
-import { sql } from 'drizzle-orm';
-import { beforeAll, describe, expect, test } from 'vitest';
-import { Integer, StringProperty } from '../../schema/index.js';
-import { setupIntegrationTest } from '../../testing/index.js';
-import { Table } from '../decorators.js';
-import { Entity } from '../entity.js';
-import { getRepository } from '../server/index.js';
-describe('ORM Query Complex (Integration)', () => {
-    let injector;
-    let db;
-    let repo;
-    const schema = 'test_orm_query_complex';
-    let QueryEntity = class QueryEntity extends Entity {
-        tag;
-        score;
-        status;
-    };
-    __decorate([
-        StringProperty(),
-        __metadata("design:type", String)
-    ], QueryEntity.prototype, "tag", void 0);
-    __decorate([
-        Integer(),
-        __metadata("design:type", Number)
-    ], QueryEntity.prototype, "score", void 0);
-    __decorate([
-        StringProperty(),
-        __metadata("design:type", String)
-    ], QueryEntity.prototype, "status", void 0);
-    QueryEntity = __decorate([
-        Table('query_entities', { schema })
-    ], QueryEntity);
-    beforeAll(async () => {
-        ({ injector, database: db } = await setupIntegrationTest({
-            orm: { schema },
-        }));
-        repo = injector.resolve(getRepository(QueryEntity));
-        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('query_entities')} CASCADE`);
-        await db.execute(sql `
-      CREATE TABLE ${sql.identifier(schema)}.${sql.identifier('query_entities')} (
-        id UUID PRIMARY KEY DEFAULT gen_random_uuid(),
-        tag TEXT NOT NULL,
-        score INTEGER NOT NULL,
-        status 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 nested AND/OR logic', async () => {
-        await db.execute(sql `TRUNCATE TABLE ${sql.identifier(schema)}.${sql.identifier('query_entities')} CASCADE`);
-        await repo.insertMany([
-            Object.assign(new QueryEntity(), { tag: 'A', score: 10, status: 'active' }),
-            Object.assign(new QueryEntity(), { tag: 'A', score: 20, status: 'inactive' }),
-            Object.assign(new QueryEntity(), { tag: 'B', score: 10, status: 'active' }),
-            Object.assign(new QueryEntity(), { tag: 'B', score: 20, status: 'inactive' }),
-        ]);
-        // (Tag A AND Active) OR (Tag B AND Inactive)
-        const results = await repo.loadManyByQuery({
-            $or: [
-                { $and: [{ tag: 'A' }, { status: 'active' }] },
-                { $and: [{ tag: 'B' }, { status: 'inactive' }] },
-            ],
-        });
-        expect(results).toHaveLength(2);
-        expect(results.some((r) => r.tag === 'A' && r.status === 'active')).toBe(true);
-        expect(results.some((r) => r.tag === 'B' && r.status === 'inactive')).toBe(true);
-    });
-    test('should support implicit AND', async () => {
-        await db.execute(sql `TRUNCATE TABLE ${sql.identifier(schema)}.${sql.identifier('query_entities')} CASCADE`);
-        await repo.insert(Object.assign(new QueryEntity(), { tag: 'A', score: 10, status: 'active' }));
-        const results = await repo.loadManyByQuery({
-            tag: 'A',
-            score: 10,
-            status: 'active',
-        });
-        expect(results).toHaveLength(1);
-    });
-    test('should support NOT operator', async () => {
-        await db.execute(sql `TRUNCATE TABLE ${sql.identifier(schema)}.${sql.identifier('query_entities')} CASCADE`);
-        await repo.insertMany([
-            Object.assign(new QueryEntity(), { tag: 'A', score: 10, status: 'active' }),
-            Object.assign(new QueryEntity(), { tag: 'B', score: 20, status: 'inactive' }),
-        ]);
-        const results = await repo.loadManyByQuery({
-            tag: { $not: { $eq: 'A' } },
-        });
-        expect(results).toHaveLength(1);
-        expect(results[0].tag).toBe('B');
-    });
-    test('should support IN operator with empty array (should match nothing)', async () => {
-        await db.execute(sql `TRUNCATE TABLE ${sql.identifier(schema)}.${sql.identifier('query_entities')} CASCADE`);
-        await repo.insert(Object.assign(new QueryEntity(), { tag: 'A', score: 10, status: 'active' }));
-        const results = await repo.loadManyByQuery({
-            tag: { $in: [] },
-        });
-        expect(results).toHaveLength(0);
-    });
-    test('should support NOT IN operator with empty array (should match everything)', async () => {
-        await db.execute(sql `TRUNCATE TABLE ${sql.identifier(schema)}.${sql.identifier('query_entities')} CASCADE`);
-        await repo.insert(Object.assign(new QueryEntity(), { tag: 'A', score: 10, status: 'active' }));
-        const results = await repo.loadManyByQuery({
-            tag: { $nin: [] },
-        });
-        expect(results).toHaveLength(1);
-    });
-    test('should support REGEX operator', async () => {
-        await db.execute(sql `TRUNCATE TABLE ${sql.identifier(schema)}.${sql.identifier('query_entities')} CASCADE`);
-        await repo.insertMany([
-            Object.assign(new QueryEntity(), { tag: 'apple', score: 10, status: '' }),
-            Object.assign(new QueryEntity(), { tag: 'banana', score: 10, status: '' }),
-            Object.assign(new QueryEntity(), { tag: 'apricot', score: 10, status: '' }),
-        ]);
-        const results = await repo.loadManyByQuery({
-            tag: { $regex: '^ap' },
-        });
-        expect(results).toHaveLength(2); // apple, apricot
-    });
-    test('should support complex combination of logic and comparison', async () => {
-        await db.execute(sql `TRUNCATE TABLE ${sql.identifier(schema)}.${sql.identifier('query_entities')} CASCADE`);
-        await repo.insertMany([
-            Object.assign(new QueryEntity(), { tag: 'A', score: 5, status: 'ok' }),
-            Object.assign(new QueryEntity(), { tag: 'A', score: 15, status: 'ok' }),
-            Object.assign(new QueryEntity(), { tag: 'A', score: 25, status: 'fail' }),
-            Object.assign(new QueryEntity(), { tag: 'B', score: 5, status: 'ok' }),
-        ]);
-        // Tag A AND (Score > 10 AND Score < 20) AND Status != fail
-        const results = await repo.loadManyByQuery({
-            tag: 'A',
-            $and: [{ score: { $gt: 10 } }, { score: { $lt: 20 } }],
-            status: { $neq: 'fail' },
-        });
-        expect(results).toHaveLength(1);
-        expect(results[0].score).toBe(15);
-    });
-    test('should support NULL check', async () => {
-        await db.execute(sql `TRUNCATE TABLE ${sql.identifier(schema)}.${sql.identifier('query_entities')} CASCADE`);
-        // Manually insert null status (violates NOT NULL usually, but let's assume nullable if we could change schema,
-        // but Entity defines it as string. We can query for null even if no rows can be null (result 0) OR if we use a nullable column).
-        // 'attributes' is JSONB and can be queried.
-        // But query-converter maps properties.
-        // Let's use a non-existent value for $eq which is different from null.
-        // But checking $eq: null generates IS NULL.
-        // Since our columns are NOT NULL, it should return empty.
-        await repo.insert(Object.assign(new QueryEntity(), { tag: 'A', score: 10, status: 'active' }));
-        const results = await repo.loadManyByQuery({
-            status: { $eq: null },
-        });
-        expect(results).toHaveLength(0);
-    });
-    test('should support NOT NULL check', async () => {
-        await db.execute(sql `TRUNCATE TABLE ${sql.identifier(schema)}.${sql.identifier('query_entities')} CASCADE`);
-        await repo.insert(Object.assign(new QueryEntity(), { tag: 'A', score: 10, status: 'active' }));
-        const results = await repo.loadManyByQuery({
-            status: { $neq: null },
-        });
-        expect(results).toHaveLength(1);
-    });
-});

package/orm/tests/query-converter-complex.test.d.ts

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

package/orm/tests/query-converter-complex.test.js

@@ -1,131 +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 { PgDialect } from 'drizzle-orm/pg-core';
-import { Integer, StringProperty } from '../../schema/index.js';
-import { describe, expect, test } from 'vitest';
-import { Table } from '../decorators.js';
-import { Entity } from '../entity.js';
-import { getColumnDefinitionsMap, getDrizzleTableFromType } from '../server/drizzle/schema-converter.js';
-import { convertQuery } from '../server/query-converter.js';
-describe('ORM Query Converter Complex', () => {
-    const dialect = new PgDialect();
-    let ComplexItem = class ComplexItem extends Entity {
-        name;
-        description;
-        value;
-    };
-    __decorate([
-        StringProperty(),
-        __metadata("design:type", String)
-    ], ComplexItem.prototype, "name", void 0);
-    __decorate([
-        StringProperty(),
-        __metadata("design:type", String)
-    ], ComplexItem.prototype, "description", void 0);
-    __decorate([
-        Integer(),
-        __metadata("design:type", Number)
-    ], ComplexItem.prototype, "value", void 0);
-    ComplexItem = __decorate([
-        Table('complex_items', { schema: 'test' })
-    ], ComplexItem);
-    const table = getDrizzleTableFromType(ComplexItem);
-    const colMap = getColumnDefinitionsMap(table);
-    test('should handle $tsvector with explicit weights', () => {
-        const q = {
-            $tsvector: {
-                fields: [['name', 'A'], ['description', 'B']],
-                query: 'search term',
-                language: 'english',
-                parser: 'websearch',
-            },
-        };
-        const condition = convertQuery(q, table, colMap);
-        const { sql, params } = dialect.sqlToQuery(condition);
-        expect(sql).toContain('setweight(to_tsvector($1, "test"."complex_items"."name"), \'A\')');
-        expect(sql).toContain('setweight(to_tsvector($2, "test"."complex_items"."description"), \'B\')');
-        expect(sql).toContain('websearch_to_tsquery($3, $4)');
-        expect(params).toEqual(['english', 'english', 'english', 'search term']);
-    });
-    test('should handle ParadeDB $parade match with tokenizer', () => {
-        const q = {
-            name: {
-                $parade: {
-                    match: {
-                        value: 'test',
-                        tokenizer: { type: 'ngram', min_gram: 3, max_gram: 3 },
-                    },
-                },
-            },
-        };
-        const condition = convertQuery(q, table, colMap);
-        const { sql, params } = dialect.sqlToQuery(condition);
-        // Tokenizer is supported via JSON object syntax
-        expect(sql).toContain('"test"."complex_items"."name" @@@ jsonb_build_object($1::text, jsonb_build_object($2::text, to_jsonb($3::text), $4::text, jsonb_build_object($5::text, to_jsonb($6::text), $7::text, to_jsonb($8::numeric), $9::text, to_jsonb($10::numeric))))::pdb.query');
-        expect(params).toEqual(['match', 'value', 'test', 'tokenizer', 'type', 'ngram', 'min_gram', 3, 'max_gram', 3]);
-    });
-    test('should handle ParadeDB $parade range', () => {
-        const q = {
-            value: {
-                $parade: {
-                    range: {
-                        lowerBound: { included: 10 },
-                        upperBound: { excluded: 20 },
-                    },
-                },
-            },
-        };
-        const condition = convertQuery(q, table, colMap);
-        const { sql, params } = dialect.sqlToQuery(condition);
-        // This should fall back to convertParadeComparisonQuery with recursive jsonb build
-        expect(sql).toContain('"test"."complex_items"."value" @@@ jsonb_build_object($1::text, jsonb_build_object($2::text, jsonb_build_object($3::text, to_jsonb($4::numeric)), $5::text, jsonb_build_object($6::text, to_jsonb($7::numeric))))::pdb.query');
-        expect(params).toEqual(['range', 'lower_bound', 'included', 10, 'upper_bound', 'excluded', 20]);
-    });
-    test('should handle ParadeDB $parade phrasePrefix', () => {
-        const q = {
-            name: {
-                $parade: {
-                    phrasePrefix: { phrases: ['hello', 'wor'], maxExpansions: 10 },
-                },
-            },
-        };
-        const condition = convertQuery(q, table, colMap);
-        const { sql, params } = dialect.sqlToQuery(condition);
-        expect(sql).toContain('"test"."complex_items"."name" @@@ jsonb_build_object($1::text, jsonb_build_object($2::text, jsonb_build_array(to_jsonb($3::text), to_jsonb($4::text)), $5::text, to_jsonb($6::numeric)))::pdb.query');
-        expect(params).toEqual(['phrase_prefix', 'phrases', 'hello', 'wor', 'max_expansions', 10]);
-    });
-    test('should handle ParadeDB $parade regexPhrase', () => {
-        const q = {
-            name: {
-                $parade: {
-                    regexPhrase: { regexes: ['he.*', 'wo.*'], slop: 1 },
-                },
-            },
-        };
-        const condition = convertQuery(q, table, colMap);
-        const { sql, params } = dialect.sqlToQuery(condition);
-        expect(sql).toContain('"test"."complex_items"."name" @@@ jsonb_build_object($1::text, jsonb_build_object($2::text, jsonb_build_array(to_jsonb($3::text), to_jsonb($4::text)), $5::text, to_jsonb($6::numeric)))::pdb.query');
-        expect(params).toEqual(['regex_phrase', 'regexes', 'he.*', 'wo.*', 'slop', 1]);
-    });
-    test('should handle ParadeDB top-level moreLikeThis', () => {
-        const q = {
-            $parade: {
-                moreLikeThis: {
-                    keyValue: '123',
-                    fields: ['name', 'description'],
-                },
-            },
-        };
-        const condition = convertQuery(q, table, colMap);
-        const { sql, params } = dialect.sqlToQuery(condition);
-        expect(sql).toContain('"test"."complex_items"."id" @@@ jsonb_build_object($1::text, jsonb_build_object($2::text, to_jsonb($3::text), $4::text, to_jsonb(ARRAY[$5, $6])))::pdb.query');
-        expect(params).toEqual(['more_like_this', 'key_value', '123', 'fields', 'name', 'description']);
-    });
-});

package/orm/tests/query-converter.test.d.ts

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

package/orm/tests/query-converter.test.js

@@ -1,123 +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 { describe, expect, test } from 'vitest';
-import { eq, sql } from 'drizzle-orm';
-import { getTableConfig, PgDialect } from 'drizzle-orm/pg-core';
-import { StringProperty } from '../../schema/index.js';
-import { Entity } from '../entity.js';
-import { Column, Inheritance, ChildEntity, Table } from '../decorators.js';
-import { getDrizzleTableFromType, getColumnDefinitionsMap } from '../server/drizzle/schema-converter.js';
-import { convertQuery } from '../server/query-converter.js';
-describe('ORM Query Converter (CTI)', () => {
-    test('should resolve columns to correct table in joined query', () => {
-        let BaseUser = class BaseUser extends Entity {
-            type;
-            name;
-        };
-        __decorate([
-            StringProperty(),
-            Column({ name: 'type' }),
-            __metadata("design:type", String)
-        ], BaseUser.prototype, "type", void 0);
-        __decorate([
-            StringProperty(),
-            Column({ name: 'name' }),
-            __metadata("design:type", String)
-        ], BaseUser.prototype, "name", void 0);
-        BaseUser = __decorate([
-            Table('users', { schema: 'test' }),
-            Inheritance({ strategy: 'joined', discriminatorColumn: 'type' })
-        ], BaseUser);
-        let Admin = class Admin extends BaseUser {
-            role;
-        };
-        __decorate([
-            StringProperty(),
-            Column({ name: 'role' }),
-            __metadata("design:type", String)
-        ], Admin.prototype, "role", void 0);
-        Admin = __decorate([
-            Table('admins', { schema: 'test' }),
-            ChildEntity('admin')
-        ], Admin);
-        const parentTable = getDrizzleTableFromType(BaseUser);
-        const childTable = getDrizzleTableFromType(Admin);
-        const columnDefinitionsMap = getColumnDefinitionsMap(childTable);
-        const dialect = new PgDialect();
-        // Query on child property
-        const query1 = { role: 'super' };
-        const sql1 = convertQuery(query1, childTable, columnDefinitionsMap);
-        const sqlString1 = dialect.sqlToQuery(sql1).sql;
-        expect(sqlString1).toContain('"admins"."role" = $1');
-        // Query on parent property
-        const query2 = { name: 'admin' };
-        const sql2 = convertQuery(query2, childTable, columnDefinitionsMap);
-        const sqlString2 = dialect.sqlToQuery(sql2).sql;
-        expect(sqlString2).toContain('"users"."name" = $1');
-        expect(sqlString2).not.toContain('"admins"."name"');
-    });
-    test('should handle $regex with flags', () => {
-        let Item = class Item extends Entity {
-            name;
-        };
-        __decorate([
-            StringProperty(),
-            __metadata("design:type", String)
-        ], Item.prototype, "name", void 0);
-        Item = __decorate([
-            Table('items', { schema: 'test' })
-        ], Item);
-        const table = getDrizzleTableFromType(Item);
-        const colMap = getColumnDefinitionsMap(table);
-        const dialect = new PgDialect();
-        const q = convertQuery({ name: { $regex: { pattern: '^test', flags: 'i' } } }, table, colMap);
-        const sqlStr = dialect.sqlToQuery(q).sql;
-        expect(sqlStr).toContain('"items"."name" ~* $1');
-    });
-    test('should handle $nin (not in)', () => {
-        let Item = class Item extends Entity {
-            name;
-        };
-        __decorate([
-            StringProperty(),
-            __metadata("design:type", String)
-        ], Item.prototype, "name", void 0);
-        Item = __decorate([
-            Table('items', { schema: 'test' })
-        ], Item);
-        const table = getDrizzleTableFromType(Item);
-        const colMap = getColumnDefinitionsMap(table);
-        const dialect = new PgDialect();
-        const q = convertQuery({ name: { $nin: ['a', 'b'] } }, table, colMap);
-        const sqlStr = dialect.sqlToQuery(q).sql;
-        expect(sqlStr.toLowerCase()).toContain('"items"."name" not in ($1, $2)');
-    });
-    test('should handle logical $nor', () => {
-        let Item = class Item extends Entity {
-            name;
-        };
-        __decorate([
-            StringProperty(),
-            __metadata("design:type", String)
-        ], Item.prototype, "name", void 0);
-        Item = __decorate([
-            Table('items', { schema: 'test' })
-        ], Item);
-        const table = getDrizzleTableFromType(Item);
-        const colMap = getColumnDefinitionsMap(table);
-        const dialect = new PgDialect();
-        const q = convertQuery({ $nor: [{ name: 'a' }, { name: 'b' }] }, table, colMap);
-        const sqlStr = dialect.sqlToQuery(q).sql.toLowerCase();
-        expect(sqlStr).toContain('not');
-        expect(sqlStr).toContain('"items"."name" = $1');
-        expect(sqlStr).toContain('"items"."name" = $2');
-        expect(sqlStr).toContain('or');
-    });
-});

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

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

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

@@ -1,189 +0,0 @@
-var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
-    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
-    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
-    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
-    return c > 3 && r && Object.defineProperty(target, key, r), r;
-};
-var __metadata = (this && this.__metadata) || function (k, v) {
-    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
-};
-import { sql } from 'drizzle-orm';
-import { beforeAll, describe, expect, test } from 'vitest';
-import { Integer, StringProperty } from '../../schema/index.js';
-import { setupIntegrationTest } from '../../testing/index.js';
-import { toArrayAsync } from '../../utils/async-iterable-helpers/to-array.js';
-import { Table } from '../decorators.js';
-import { Entity } from '../entity.js';
-import { getRepository } from '../server/index.js';
-describe('ORM Repository Advanced (Integration)', () => {
-    let injector;
-    let db;
-    let repository;
-    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, database: db } = await setupIntegrationTest({
-            orm: { schema },
-        }));
-        repository = injector.resolve(getRepository(AdvancedEntity));
-        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`);
-        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 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 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`);
-        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`);
-        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 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`);
-        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 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 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 () => {
-        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`);
-        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 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`);
-        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

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