@tstdl/base 0.93.87 → 0.93.90

package/orm/tests/schema-generation.test.js

@@ -0,0 +1,127 @@
+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 { getTableConfig } from 'drizzle-orm/pg-core';
+import { StringProperty } from '../../schema/index.js';
+import { Entity } from '../entity.js';
+import { Column, Inheritance, ChildEntity, Table, ParadeIndex } from '../decorators.js';
+import { getDrizzleTableFromType } from '../server/drizzle/schema-converter.js';
+describe('ORM Schema Generation (CTI)', () => {
+    test('should generate correct parent table with discriminator and unique constraint', () => {
+        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);
+        const table = getDrizzleTableFromType(BaseUser);
+        const config = getTableConfig(table);
+        // Check columns
+        const columnNames = config.columns.map(c => c.name);
+        expect(columnNames).toContain('id');
+        expect(columnNames).toContain('type');
+        expect(columnNames).toContain('name');
+        // Check unique constraint
+        const uniqueConstraints = config.uniqueConstraints;
+        const hasCompositeUnique = uniqueConstraints.some(uc => uc.columns.map(c => c.name).sort().join(',') === 'id,type');
+        expect(hasCompositeUnique).toBe(true);
+    });
+    test('should generate correct child table with only own columns and constraints', () => {
+        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 table = getDrizzleTableFromType(Admin);
+        const config = getTableConfig(table);
+        // Check columns: should have id, type, role but NOT name
+        const columnNames = config.columns.map(c => c.name);
+        expect(columnNames).toContain('id');
+        expect(columnNames).toContain('type');
+        expect(columnNames).toContain('role');
+        expect(columnNames).not.toContain('name');
+        expect(columnNames).not.toContain('create_timestamp'); // from Entity
+        // Check check constraint
+        expect(config.checks.length).toBeGreaterThan(0);
+        const typeCheck = config.checks.find(c => c.name.includes('type_check') || c.name.includes('check'));
+        expect(typeCheck).toBeDefined();
+        // Check foreign key
+        expect(config.foreignKeys.length).toBeGreaterThan(0);
+        const compositeFk = config.foreignKeys.find(fk => fk.reference().columns.length === 2);
+        expect(compositeFk).toBeDefined();
+        expect(compositeFk?.reference().columns.map(c => c.name).sort()).toEqual(['id', 'type']);
+    });
+    test('should generate BM25 index with correct config', () => {
+        let SearchableItem = class SearchableItem extends Entity {
+            title;
+            body;
+        };
+        __decorate([
+            StringProperty(),
+            __metadata("design:type", String)
+        ], SearchableItem.prototype, "title", void 0);
+        __decorate([
+            StringProperty(),
+            __metadata("design:type", String)
+        ], SearchableItem.prototype, "body", void 0);
+        SearchableItem = __decorate([
+            Table('searchable', { schema: 'test' }),
+            ParadeIndex({
+                columns: ['title', ['body', { tokenizer: 'simple' }]],
+                naming: 'abbreviated-table'
+            })
+        ], SearchableItem);
+        const table = getDrizzleTableFromType(SearchableItem);
+        const config = getTableConfig(table);
+        // console.log('Indexes:', JSON.stringify(config.indexes, null, 2));
+        const paradeIdx = config.indexes.find(i => i.config.using === 'bm25' || i.config.method === 'bm25');
+        expect(paradeIdx).toBeDefined();
+        const extraConfig = paradeIdx.config.with;
+        expect(extraConfig).toBeDefined();
+        expect(extraConfig.key_field).toBe("'id'");
+    });
+});

package/orm/tests/sql-helpers.test.d.ts

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

package/orm/tests/sql-helpers.test.js

@@ -0,0 +1,67 @@
+import { describe, expect, test } from 'vitest';
+import { sql, Column, Table as DrizzleTable } from 'drizzle-orm';
+import { PgDialect, pgTable, text, integer } from 'drizzle-orm/pg-core';
+import { exclusiveColumn, enumerationCaseWhen, interval, coalesce, numNulls, numNonNulls, greatest, least } from '../sqls/sqls.js';
+import { defineEnum } from '../../enumeration/index.js';
+describe('ORM SQL Helpers', () => {
+    const dialect = new PgDialect();
+    const TestEnum = defineEnum('TestEnum', { A: 'a', B: 'b' });
+    const testTable = pgTable('test', {
+        id: text('id').primaryKey(),
+        type: text('type'),
+        colA: text('col_a'),
+        colB: text('col_b'),
+        val: integer('val')
+    });
+    test('exclusiveColumn should generate correct CASE statement', () => {
+        const query = exclusiveColumn(TestEnum, testTable.type, {
+            [TestEnum.A]: testTable.colA,
+            [TestEnum.B]: testTable.colB,
+        });
+        const sqlStr = dialect.sqlToQuery(query).sql.toLowerCase();
+        expect(sqlStr).toContain('case "test"."type"');
+        expect(sqlStr).toContain("when 'a'");
+        expect(sqlStr).toContain("col_a\" is not null");
+        expect(sqlStr).toContain("col_b\" is null");
+        expect(sqlStr).toContain("when 'b'");
+        expect(sqlStr).toContain("col_b\" is not null");
+        expect(sqlStr).toContain("col_a\" is null");
+        expect(sqlStr).toContain('else false end');
+    });
+    test('enumerationCaseWhen should map enum values to conditions', () => {
+        const query = enumerationCaseWhen(TestEnum, testTable.type, {
+            [TestEnum.A]: true,
+            [TestEnum.B]: sql `"val" > 10`
+        });
+        const sqlStr = dialect.sqlToQuery(query).sql;
+        expect(sqlStr).toContain('WHEN \'a\'');
+        expect(sqlStr).toContain('THEN TRUE');
+        expect(sqlStr).toContain('WHEN \'b\'');
+        expect(sqlStr).toContain('"val" > 10');
+    });
+    test('interval should generate postgres interval syntax', () => {
+        const i = interval(5, 'days');
+        const sqlStr = dialect.sqlToQuery(i).sql;
+        expect(sqlStr).toContain("||' days')::interval");
+    });
+    test('coalesce should join multiple columns', () => {
+        const c = coalesce(testTable.colA, testTable.colB, sql `'default'`);
+        const sqlStr = dialect.sqlToQuery(c).sql;
+        expect(sqlStr).toContain('coalesce(');
+        expect(sqlStr).toContain('"test"."col_a"');
+        expect(sqlStr).toContain('"test"."col_b"');
+        expect(sqlStr).toContain("'default'");
+    });
+    test('numNulls and numNonNulls', () => {
+        const n = numNulls(testTable.colA, testTable.colB);
+        expect(dialect.sqlToQuery(n).sql).toContain('num_nulls(');
+        const nn = numNonNulls(testTable.colA, testTable.colB);
+        expect(dialect.sqlToQuery(nn).sql).toContain('num_nonnulls(');
+    });
+    test('greatest and least', () => {
+        const g = greatest(testTable.val, 100);
+        expect(dialect.sqlToQuery(g).sql).toContain('greatest(');
+        const l = least(testTable.val, sql `0`);
+        expect(dialect.sqlToQuery(l).sql).toContain('least(');
+    });
+});

package/orm/tests/transaction-safety.test.d.ts

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

package/orm/tests/transaction-safety.test.js

@@ -0,0 +1,81 @@
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+import { Injector, Singleton, runInInjectionContext } from '../../injector/index.js';
+import { StringProperty } from '../../schema/index.js';
+import { dropTables, setupIntegrationTest } from '../../unit-test/index.js';
+import { sql } from 'drizzle-orm';
+import { beforeAll, describe, expect, test } from 'vitest';
+import { Entity, Table } from '../index.js';
+import { Database, Transactional, injectRepository } from '../server/index.js';
+describe('Transaction Safety (Integration)', () => {
+    let injector;
+    let database;
+    const schema = 'test_orm_tx';
+    let TxEntity = class TxEntity extends Entity {
+        val;
+    };
+    __decorate([
+        StringProperty(),
+        __metadata("design:type", String)
+    ], TxEntity.prototype, "val", void 0);
+    TxEntity = __decorate([
+        Table('tx_test', { schema })
+    ], TxEntity);
+    let TxService = class TxService extends Transactional {
+        repo = injectRepository(TxEntity);
+        async successOp() {
+            await this.transaction(async (tx) => {
+                await this.repo.withTransaction(tx).insert({ val: 'success' });
+            });
+        }
+        async failOp() {
+            return await this.transaction(async (tx) => {
+                await this.repo.withTransaction(tx).insert({ val: 'should_rollback' });
+                throw new Error('Planned Failure');
+            });
+        }
+    };
+    TxService = __decorate([
+        Singleton()
+    ], TxService);
+    beforeAll(async () => {
+        ({ injector, database } = await setupIntegrationTest({ orm: { schema } }));
+        await dropTables(database, schema, ['tx_test']);
+        await database.execute(sql `
+      CREATE TABLE ${sql.identifier(schema)}.${sql.identifier('tx_test')} (
+        id UUID PRIMARY KEY DEFAULT gen_random_uuid(),
+        val 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 rollback changes on error', async () => {
+        await runInInjectionContext(injector, async () => {
+            const service = injector.resolve(TxService);
+            const startCount = await service.repo.count();
+            await expect(service.failOp()).rejects.toThrow('Planned Failure');
+            const endCount = await service.repo.count();
+            expect(endCount).toBe(startCount);
+        });
+    });
+    test('should commit changes on success', async () => {
+        await runInInjectionContext(injector, async () => {
+            const service = injector.resolve(TxService);
+            const startCount = await service.repo.count();
+            await service.successOp();
+            const endCount = await service.repo.count();
+            expect(endCount).toBe(startCount + 1);
+        });
+    });
+});

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

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

package/orm/tests/transactional.test.js

@@ -0,0 +1,224 @@
+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 { Injector, runInInjectionContext, Singleton } from '../../injector/index.js';
+import { StringProperty } from '../../schema/index.js';
+import { beforeAll, describe, expect, test } from 'vitest';
+import { Table } from '../decorators.js';
+import { Entity } from '../entity.js';
+import { configureOrm, Database } from '../server/index.js';
+import { getRepository } from '../server/repository.js';
+import { Transactional } from '../server/transactional.js';
+describe('ORM Transactional (Integration)', () => {
+    let injector;
+    let db;
+    const schema = 'test_orm_transactional';
+    let TransactionalItem = class TransactionalItem extends Entity {
+        name;
+    };
+    __decorate([
+        StringProperty(),
+        __metadata("design:type", String)
+    ], TransactionalItem.prototype, "name", void 0);
+    TransactionalItem = __decorate([
+        Table('transactional_items', { schema })
+    ], TransactionalItem);
+    let TransactionalService = class TransactionalService extends Transactional {
+        repository = getRepository(TransactionalItem);
+        async create(name) {
+            const repo = injector.resolve(this.repository).withSession(this.session);
+            const item = new TransactionalItem();
+            item.name = name;
+            return await repo.insert(item);
+        }
+        async count() {
+            const repo = injector.resolve(this.repository).withSession(this.session);
+            return await repo.count();
+        }
+    };
+    TransactionalService = __decorate([
+        Singleton()
+    ], TransactionalService);
+    beforeAll(async () => {
+        injector = new Injector('Test');
+        const encryptionSecret = new Uint8Array(32).fill(1);
+        configureOrm({
+            repositoryConfig: { schema },
+            connection: {
+                host: '127.0.0.1',
+                port: 5432,
+                user: 'tstdl',
+                password: 'wf7rq6glrk5jykne',
+                database: 'tstdl',
+            },
+            encryptionSecret,
+        });
+        db = injector.resolve(Database);
+        await db.execute(sql `CREATE SCHEMA IF NOT EXISTS ${sql.identifier(schema)}`);
+        await db.execute(sql `DROP TABLE IF EXISTS ${sql.identifier(schema)}.${sql.identifier('transactional_items')} CASCADE`);
+        await db.execute(sql `
+      CREATE TABLE ${sql.identifier(schema)}.${sql.identifier('transactional_items')} (
+        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 '{}'
+      )
+    `);
+        injector.register(TransactionalService, { useClass: TransactionalService });
+    });
+    test('should handle nested transactions (savepoints by default)', async () => {
+        await db.execute(sql `TRUNCATE TABLE ${sql.identifier(schema)}.${sql.identifier('transactional_items')} CASCADE`);
+        await runInInjectionContext(injector, async () => {
+            const service = injector.resolve(TransactionalService);
+            await service.transaction(async (tx1) => {
+                await service.withTransaction(tx1).create('Outer');
+                await service.withTransaction(tx1).transaction(async (tx2) => {
+                    // Default behavior: create new transaction (savepoint)
+                    expect(tx1).not.toBe(tx2);
+                    await service.withTransaction(tx2).create('Inner');
+                });
+            });
+            const count = await service.count();
+            expect(count).toBe(2);
+        });
+    });
+    test('should handle nested transactions with rollback (savepoints by default)', async () => {
+        await db.execute(sql `TRUNCATE TABLE ${sql.identifier(schema)}.${sql.identifier('transactional_items')} CASCADE`);
+        await runInInjectionContext(injector, async () => {
+            const service = injector.resolve(TransactionalService);
+            await service.transaction(async (tx1) => {
+                await service.withTransaction(tx1).create('Outer');
+                try {
+                    await service.withTransaction(tx1).transaction(async (tx2) => {
+                        await service.withTransaction(tx2).create('Inner');
+                        throw new Error('Fail Inner');
+                    });
+                }
+                catch (e) {
+                    expect(e.message).toBe('Fail Inner');
+                }
+            });
+            // Should roll back only inner (savepoint), keeping Outer
+            const count = await service.count();
+            expect(count).toBe(1);
+        });
+    });
+    test('should handle independent transactions (savepoints) with useExisting: false', async () => {
+        await db.execute(sql `TRUNCATE TABLE ${sql.identifier(schema)}.${sql.identifier('transactional_items')} CASCADE`);
+        await runInInjectionContext(injector, async () => {
+            const service = injector.resolve(TransactionalService);
+            await service.transaction(async (tx1) => {
+                await service.withTransaction(tx1).create('Outer');
+                await service.withTransaction(tx1).transaction(async (tx2) => {
+                    expect(tx1).not.toBe(tx2); // Should be different wrapper (savepoint)
+                    await service.withTransaction(tx2).create('Inner');
+                }, { useExisting: false });
+            });
+            const count = await service.count();
+            expect(count).toBe(2);
+        });
+    });
+    test('should rollback only inner transaction when useExisting: false', async () => {
+        await db.execute(sql `TRUNCATE TABLE ${sql.identifier(schema)}.${sql.identifier('transactional_items')} CASCADE`);
+        await runInInjectionContext(injector, async () => {
+            const service = injector.resolve(TransactionalService);
+            await service.transaction(async (tx1) => {
+                await service.withTransaction(tx1).create('Outer');
+                try {
+                    await service.withTransaction(tx1).transaction(async (tx2) => {
+                        await service.withTransaction(tx2).create('Inner');
+                        throw new Error('Fail Inner');
+                    }, { useExisting: false });
+                }
+                catch {
+                    // Swallow error to allow outer to continue
+                }
+            });
+            const count = await service.count();
+            // Outer should exist, Inner should be rolled back (savepoint behavior)
+            expect(count).toBe(1);
+            const repo = injector.resolve(service.repository);
+            const items = await repo.loadAll();
+            expect(items[0].name).toBe('Outer');
+        });
+    });
+    test('should reuse existing transaction when useExisting: true', async () => {
+        await db.execute(sql `TRUNCATE TABLE ${sql.identifier(schema)}.${sql.identifier('transactional_items')} CASCADE`);
+        await runInInjectionContext(injector, async () => {
+            const service = injector.resolve(TransactionalService);
+            await service.transaction(async (tx1) => {
+                await service.withTransaction(tx1).transaction(async (tx2) => {
+                    expect(tx1).toBe(tx2);
+                }, { useExisting: true });
+            });
+        });
+    });
+    test('should defer afterCommit of nested transaction until root commits', async () => {
+        await db.execute(sql `TRUNCATE TABLE ${sql.identifier(schema)}.${sql.identifier('transactional_items')} CASCADE`);
+        await runInInjectionContext(injector, async () => {
+            const service = injector.resolve(TransactionalService);
+            let innerCommitted = false;
+            let outerCommitted = false;
+            await service.transaction(async (tx1) => {
+                tx1.afterCommit.register(() => { outerCommitted = true; });
+                await service.withTransaction(tx1).transaction(async (tx2) => {
+                    tx2.afterCommit.register(() => { innerCommitted = true; });
+                    await service.withTransaction(tx2).create('Inner');
+                });
+                // Inner transaction finished, but should not have triggered hooks yet
+                expect(innerCommitted).toBe(false);
+            });
+            expect(outerCommitted).toBe(true);
+            expect(innerCommitted).toBe(true);
+        });
+    });
+    test('should NOT trigger afterCommit if outer transaction rolls back', async () => {
+        await db.execute(sql `TRUNCATE TABLE ${sql.identifier(schema)}.${sql.identifier('transactional_items')} CASCADE`);
+        await runInInjectionContext(injector, async () => {
+            const service = injector.resolve(TransactionalService);
+            let innerCommitted = false;
+            try {
+                await service.transaction(async (tx1) => {
+                    await service.withTransaction(tx1).transaction(async (tx2) => {
+                        tx2.afterCommit.register(() => { innerCommitted = true; });
+                        await service.withTransaction(tx2).create('Inner');
+                    });
+                    // Inner committed successfully.
+                    // Now rollback outer.
+                    throw new Error('Rollback Outer');
+                });
+            }
+            catch {
+                // Ignore
+            }
+            // Hook should not have fired
+            expect(innerCommitted).toBe(false);
+        });
+    });
+    test('should support withManualCommit', async () => {
+        await db.execute(sql `TRUNCATE TABLE ${sql.identifier(schema)}.${sql.identifier('transactional_items')} CASCADE`);
+        await runInInjectionContext(injector, async () => {
+            const service = injector.resolve(TransactionalService);
+            await service.transaction(async (tx) => {
+                tx.withManualCommit();
+                await service.create('Manual');
+                // If we don't commit, it would hang if we tried to exit?
+                // Or if we check DB outside, it's locked?
+                // We just verify it works when we DO commit.
+                await tx.commit();
+            });
+            const count = await service.count();
+            expect(count).toBe(1);
+        });
+    });
+});

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

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

package/orm/tests/utils.test.js

@@ -0,0 +1,70 @@
+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 { Entity } from '../entity.js';
+import { Column, Inheritance, ChildEntity } from '../decorators.js';
+import { getOwnProperties } from '../utils.js';
+describe('ORM Utils', () => {
+    describe('getOwnProperties', () => {
+        test('should return only own properties and primary key for child entity', () => {
+            let Vehicle = class Vehicle extends Entity {
+                type;
+                model;
+            };
+            __decorate([
+                Column({}),
+                __metadata("design:type", String)
+            ], Vehicle.prototype, "type", void 0);
+            __decorate([
+                Column({ name: 'model' }),
+                __metadata("design:type", String)
+            ], Vehicle.prototype, "model", void 0);
+            Vehicle = __decorate([
+                Inheritance({ strategy: 'joined', discriminatorColumn: 'type' })
+            ], Vehicle);
+            let Car = class Car extends Vehicle {
+                doors;
+            };
+            __decorate([
+                Column({ name: 'doors' }),
+                __metadata("design:type", Number)
+            ], Car.prototype, "doors", void 0);
+            Car = __decorate([
+                ChildEntity('car')
+            ], Car);
+            const ownProps = getOwnProperties(Car);
+            const propKeys = ownProps.map(p => p.key);
+            expect(propKeys).toContain('id'); // Inherited PK is required
+            expect(propKeys).toContain('doors'); // Own property
+            expect(propKeys).not.toContain('model'); // Inherited property should be excluded
+        });
+        test('should return all properties for base entity', () => {
+            let Vehicle = class Vehicle extends Entity {
+                type;
+                model;
+            };
+            __decorate([
+                Column({}),
+                __metadata("design:type", String)
+            ], Vehicle.prototype, "type", void 0);
+            __decorate([
+                Column({ name: 'model' }),
+                __metadata("design:type", String)
+            ], Vehicle.prototype, "model", void 0);
+            Vehicle = __decorate([
+                Inheritance({ strategy: 'joined', discriminatorColumn: 'type' })
+            ], Vehicle);
+            const ownProps = getOwnProperties(Vehicle);
+            const propKeys = ownProps.map(p => p.key);
+            expect(propKeys).toContain('id');
+            expect(propKeys).toContain('model');
+        });
+    });
+});

package/orm/utils.d.ts

@@ -2,6 +2,9 @@
  * @module
  * Provides utility functions for working with ORM entities.
  */
+import { type PropertyMetadata } from '../reflection/registry.js';
+import type { AbstractConstructor } from '../types/index.js';
+import type { InheritanceMetadata } from './decorators.js';
 import type { BaseEntity, Entity } from './entity.js';
 /**
  * Converts an array of entities into a Map keyed by entity ID.
@@ -10,6 +13,7 @@ import type { BaseEntity, Entity } from './entity.js';
  * @returns A Map where keys are entity IDs and values are the corresponding entities.
  */
 export declare function getEntityMap<T extends Entity | BaseEntity>(entities: T[]): Map<string, T>;
+export declare function getEntityMap<T extends Entity | BaseEntity, S>(entities: T[], selector: (entity: T) => S): Map<S, T>;
 /**
  * Extracts the IDs from an array of entities.
  * @template T - The entity type, must extend `Entity` (i.e., have an `id` property).
@@ -17,3 +21,6 @@ export declare function getEntityMap<T extends Entity | BaseEntity>(entities: T[
  * @returns An array containing the IDs of the entities.
  */
 export declare function getEntityIds(entities: (Entity | BaseEntity)[]): string[];
+export declare function isChildEntity(type: AbstractConstructor): boolean;
+export declare function getInheritanceMetadata(type: AbstractConstructor): InheritanceMetadata | undefined;
+export declare function getOwnProperties(type: AbstractConstructor): PropertyMetadata[];

package/orm/utils.js

@@ -1,11 +1,12 @@
 /**
- * Converts an array of entities into a Map keyed by entity ID.
- * @template T - The entity type, must extend `Entity` (i.e., have an `id` property).
- * @param entities - An array of entities.
- * @returns A Map where keys are entity IDs and values are the corresponding entities.
+ * @module
+ * Provides utility functions for working with ORM entities.
  */
-export function getEntityMap(entities) {
-    return new Map(entities.map((entity) => [entity.id, entity]));
+import { reflectionRegistry } from '../reflection/registry.js';
+import { isDefined, isNotNullOrUndefined, isUndefined } from '../utils/type-guards.js';
+export function getEntityMap(entities, selector = (entity) => entity.id) {
+    const entries = entities.map((entity) => [selector(entity), entity]);
+    return new Map(entries);
 }
 /**
  * Extracts the IDs from an array of entities.
@@ -16,3 +17,22 @@ export function getEntityMap(entities) {
 export function getEntityIds(entities) {
     return entities.map((entity) => entity.id);
 }
+export function isChildEntity(type) {
+    return isDefined(reflectionRegistry.getMetadata(type)?.data.tryGet('orm')?.childEntity);
+}
+export function getInheritanceMetadata(type) {
+    for (let currentMetadata = reflectionRegistry.getMetadata(type); isNotNullOrUndefined(currentMetadata); currentMetadata = isNotNullOrUndefined(currentMetadata.parent) ? reflectionRegistry.getMetadata(currentMetadata.parent) : undefined) {
+        const inheritance = currentMetadata.data.tryGet('orm')?.inheritance;
+        if (isDefined(inheritance)) {
+            return inheritance;
+        }
+    }
+    return undefined;
+}
+export function getOwnProperties(type) {
+    const metadata = reflectionRegistry.getMetadata(type);
+    if (isUndefined(metadata)) {
+        return [];
+    }
+    return [...metadata.properties.values()].filter((property) => !property.inherited || (property.key == 'id'));
+}