@tstdl/base 0.93.182 → 0.93.184

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

@@ -1,174 +0,0 @@
-/** biome-ignore-all lint/nursery/noExcessiveClassesPerFile: <explanation> */
-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 { getTableConfig } from 'drizzle-orm/pg-core';
-import { describe, expect, test } from 'vitest';
-import { StringProperty } from '../../schema/index.js';
-import { ChildEntity, Column, Inheritance, ParadeIndex, Table } from '../decorators.js';
-import { Entity, TenantEntity } from '../entity.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 correct parent and child table for TenantEntity with joined inheritance', () => {
-        let BaseTenantUser = class BaseTenantUser extends TenantEntity {
-            type;
-        };
-        __decorate([
-            StringProperty(),
-            Column({ name: 'type' }),
-            __metadata("design:type", String)
-        ], BaseTenantUser.prototype, "type", void 0);
-        BaseTenantUser = __decorate([
-            Table('tenant_users', { schema: 'test' }),
-            Inheritance({ strategy: 'joined', discriminatorColumn: 'type' })
-        ], BaseTenantUser);
-        let TenantAdmin = class TenantAdmin extends BaseTenantUser {
-            role;
-        };
-        __decorate([
-            StringProperty(),
-            __metadata("design:type", String)
-        ], TenantAdmin.prototype, "role", void 0);
-        TenantAdmin = __decorate([
-            Table('tenant_admins', { schema: 'test' }),
-            ChildEntity('admin')
-        ], TenantAdmin);
-        // Test Parent Table
-        const parentTable = getDrizzleTableFromType(BaseTenantUser);
-        const parentConfig = getTableConfig(parentTable);
-        const parentUnique = parentConfig.uniqueConstraints.find((uc) => uc.columns.some((c) => c.name === 'type'));
-        expect(parentUnique).toBeDefined();
-        // Should be tenant_id, type, id (no duplicates)
-        expect(parentUnique.columns.map((c) => c.name)).toEqual(['tenant_id', 'type', 'id']);
-        // UNIQUE identifier should use snake_case column names
-        expect(parentUnique.name).toBe('tenant_users_tenant_id_type_id_unique');
-        // Test Child Table
-        const childTable = getDrizzleTableFromType(TenantAdmin);
-        const childConfig = getTableConfig(childTable);
-        // Child should have tenant_id and id from parent PK, plus type discriminator
-        const childColumnNames = childConfig.columns.map((c) => c.name);
-        expect(childColumnNames).toContain('tenant_id');
-        expect(childColumnNames).toContain('id');
-        expect(childColumnNames).toContain('type');
-        // Child Foreign Key should link correctly with all 3 columns
-        const childFk = childConfig.foreignKeys.find((fk) => fk.reference().columns.length === 3);
-        expect(childFk).toBeDefined();
-        expect(childFk.reference().columns.map((c) => c.name)).toEqual(['tenant_id', 'type', 'id']);
-    });
-    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

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

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

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

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

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

@@ -1,81 +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 { Injector, Singleton, runInInjectionContext } from '../../injector/index.js';
-import { StringProperty } from '../../schema/index.js';
-import { dropTables, setupIntegrationTest } from '../../testing/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

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

package/orm/tests/transactional.test.js

@@ -1,215 +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 { Injector, runInInjectionContext, Singleton } from '../../injector/index.js';
-import { StringProperty } from '../../schema/index.js';
-import { setupIntegrationTest } from '../../testing/index.js';
-import { beforeAll, describe, expect, test } from 'vitest';
-import { Table } from '../decorators.js';
-import { Entity } from '../entity.js';
-import { 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 () => {
-        const encryptionSecret = new Uint8Array(32).fill(1);
-        const context = await setupIntegrationTest({ orm: { schema, encryptionSecret } });
-        injector = context.injector;
-        db = context.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

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

package/orm/tests/utils.test.js

@@ -1,70 +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 { 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/pdf/tests/utils.test.d.ts

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