@tstdl/base 0.93.86 → 0.93.89

package/orm/tests/decorators.test.d.ts

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

package/orm/tests/decorators.test.js

@@ -0,0 +1,77 @@
+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 { reflectionRegistry } from '../../reflection/index.js';
+import { Entity } from '../entity.js';
+import { Inheritance, ChildEntity, Column } from '../decorators.js';
+import { StringProperty } from '../../schema/index.js';
+describe('ORM Inheritance Decorators', () => {
+    test('should register inheritance metadata on parent', () => {
+        let BaseUser = class BaseUser extends Entity {
+            kind;
+        };
+        __decorate([
+            StringProperty(),
+            Column({}),
+            __metadata("design:type", String)
+        ], BaseUser.prototype, "kind", void 0);
+        BaseUser = __decorate([
+            Inheritance({ strategy: 'joined', discriminatorColumn: 'kind' })
+        ], BaseUser);
+        const metadata = reflectionRegistry.getMetadata(BaseUser);
+        const ormData = metadata?.data.tryGet('orm');
+        expect(ormData?.inheritance).toBeDefined();
+        expect(ormData?.inheritance?.discriminatorColumn).toBe('kind');
+        expect(ormData?.inheritance?.subclasses).toBeInstanceOf(Array);
+    });
+    test('should register child entity metadata and link to parent', () => {
+        let Vehicle = class Vehicle extends Entity {
+            type;
+        };
+        __decorate([
+            StringProperty(),
+            Column({}),
+            __metadata("design:type", String)
+        ], Vehicle.prototype, "type", void 0);
+        Vehicle = __decorate([
+            Inheritance({ strategy: 'joined', discriminatorColumn: 'type' })
+        ], Vehicle);
+        let Car = class Car extends Vehicle {
+        };
+        Car = __decorate([
+            ChildEntity('car')
+        ], Car);
+        const parentMetadata = reflectionRegistry.getMetadata(Vehicle);
+        const parentOrmData = parentMetadata?.data.tryGet('orm');
+        const childMetadata = reflectionRegistry.getMetadata(Car);
+        const childOrmData = childMetadata?.data.tryGet('orm');
+        // Check Child Metadata
+        expect(childOrmData?.childEntity).toBeDefined();
+        expect(childOrmData?.childEntity?.discriminatorValue).toBe('car');
+        // Check Parent Link
+        expect(parentOrmData?.inheritance?.subclasses).toContain(Car);
+    });
+    test('should use default discriminator column if not provided', () => {
+        let Animal = class Animal extends Entity {
+            type;
+        };
+        __decorate([
+            StringProperty(),
+            Column({}),
+            __metadata("design:type", String)
+        ], Animal.prototype, "type", void 0);
+        Animal = __decorate([
+            Inheritance({ strategy: 'joined' })
+        ], Animal);
+        const metadata = reflectionRegistry.getMetadata(Animal);
+        const ormData = metadata?.data.tryGet('orm');
+        expect(ormData?.inheritance?.discriminatorColumn).toBe('type');
+    });
+});

package/orm/tests/encryption.test.d.ts

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

package/orm/tests/encryption.test.js

@@ -0,0 +1,34 @@
+import { DetailsError } from '../../errors/index.js';
+import { describe, expect, test } from 'vitest';
+import { decryptBytes, encryptBytes } from '../server/encryption.js';
+describe('ORM Encryption', () => {
+    async function generateKey() {
+        return await globalThis.crypto.subtle.generateKey({ name: 'AES-GCM', length: 256 }, true, ['encrypt', 'decrypt']);
+    }
+    test('should encrypt and decrypt correctly', async () => {
+        const key = await generateKey();
+        const data = new TextEncoder().encode('Hello, ORM Encryption!');
+        const encrypted = await encryptBytes(data, key);
+        const decrypted = await decryptBytes(encrypted, key);
+        expect(new TextDecoder().decode(decrypted)).toBe('Hello, ORM Encryption!');
+    });
+    test('should throw DetailsError on corrupted data', async () => {
+        const key = await generateKey();
+        const data = new TextEncoder().encode('Corrupt me');
+        const encrypted = await encryptBytes(data, key);
+        // Corrupt the ciphertext (last byte)
+        const lastIndex = encrypted.length - 1;
+        encrypted[lastIndex] = encrypted[lastIndex] ^ 1;
+        await expect(decryptBytes(encrypted, key)).rejects.toThrow(DetailsError);
+        await expect(decryptBytes(encrypted, key)).rejects.toThrow('Decrypt error');
+    });
+    test('should throw error on invalid version', async () => {
+        const key = await generateKey();
+        const data = new TextEncoder().encode('Wrong version');
+        const encrypted = await encryptBytes(data, key);
+        // Corrupt version byte (set to a very high number)
+        const view = new DataView(encrypted.buffer, encrypted.byteOffset, encrypted.length);
+        view.setUint16(0, 9999);
+        await expect(decryptBytes(encrypted, key)).rejects.toThrow('Invalid encryption version.');
+    });
+});

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

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

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

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

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

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

@@ -0,0 +1,126 @@
+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 { sql } from 'drizzle-orm';
+import { PgDialect } from 'drizzle-orm/pg-core';
+import { StringProperty, Integer } from '../../schema/index.js';
+import { Entity } from '../entity.js';
+import { Column, Table } from '../decorators.js';
+import { getDrizzleTableFromType, getColumnDefinitionsMap } 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 sqlStr = dialect.sqlToQuery(condition).sql;
+        expect(sqlStr).toContain('setweight(to_tsvector($1, "test"."complex_items"."name"), \'A\')');
+        expect(sqlStr).toContain('setweight(to_tsvector($2, "test"."complex_items"."description"), \'B\')');
+        expect(sqlStr).toContain('websearch_to_tsquery($3, $4)');
+    });
+    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 sqlStr = dialect.sqlToQuery(condition).sql;
+        // Tokenizer is supported via JSON object syntax
+        expect(sqlStr).toContain('"test"."complex_items"."name" @@@ jsonb_build_object(\'match\', jsonb_build_object(\'value\', $1, \'tokenizer\', jsonb_build_object(\'type\', $2, \'min_gram\', $3, \'max_gram\', $4)))::pdb.query');
+    });
+    test('should handle ParadeDB $parade range', () => {
+        const q = {
+            value: {
+                $parade: {
+                    range: {
+                        lowerBound: { included: 10 },
+                        upperBound: { excluded: 20 },
+                    },
+                },
+            },
+        };
+        const condition = convertQuery(q, table, colMap);
+        const sqlStr = dialect.sqlToQuery(condition).sql;
+        // This should fall back to convertParadeComparisonQuery with recursive jsonb build
+        expect(sqlStr).toContain('"test"."complex_items"."value" @@@ jsonb_build_object(\'range\', jsonb_build_object(\'lower_bound\', jsonb_build_object(\'included\', $1), \'upper_bound\', jsonb_build_object(\'excluded\', $2)))::pdb.query');
+    });
+    test('should handle ParadeDB $parade phrasePrefix', () => {
+        const q = {
+            name: {
+                $parade: {
+                    phrasePrefix: { phrases: ['hello', 'wor'], maxExpansions: 10 },
+                },
+            },
+        };
+        const condition = convertQuery(q, table, colMap);
+        const sqlStr = dialect.sqlToQuery(condition).sql;
+        expect(sqlStr).toContain('"test"."complex_items"."name" @@@ jsonb_build_object(\'phrase_prefix\', jsonb_build_object(\'phrases\', jsonb_build_array($1, $2), \'max_expansions\', $3))::pdb.query');
+    });
+    test('should handle ParadeDB $parade regexPhrase', () => {
+        const q = {
+            name: {
+                $parade: {
+                    regexPhrase: { regexes: ['he.*', 'wo.*'], slop: 1 },
+                },
+            },
+        };
+        const condition = convertQuery(q, table, colMap);
+        const sqlStr = dialect.sqlToQuery(condition).sql;
+        expect(sqlStr).toContain('"test"."complex_items"."name" @@@ jsonb_build_object(\'regex_phrase\', jsonb_build_object(\'regexes\', jsonb_build_array($1, $2), \'slop\', $3))::pdb.query');
+    });
+    test('should handle ParadeDB top-level moreLikeThis', () => {
+        const q = {
+            $parade: {
+                moreLikeThis: {
+                    keyValue: '123',
+                    fields: ['name', 'description'],
+                },
+            },
+        };
+        const condition = convertQuery(q, table, colMap);
+        const sqlStr = dialect.sqlToQuery(condition).sql;
+        expect(sqlStr).toContain('"test"."complex_items"."id" @@@ jsonb_build_object(\'more_like_this\', jsonb_build_object(\'key_value\', $1, \'fields\', ARRAY[$2, $3]))::pdb.query');
+    });
+});

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

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

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

@@ -0,0 +1,123 @@
+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

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