@tstdl/base 0.93.181 → 0.93.183

package/orm/tests/repository-transactions-nested.test.js

@@ -1,178 +0,0 @@
-var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
-    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
-    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
-    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
-    return c > 3 && r && Object.defineProperty(target, key, r), r;
-};
-var __metadata = (this && this.__metadata) || function (k, v) {
-    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
-};
-import { sql } from 'drizzle-orm';
-import { describe, expect } from 'vitest';
-import { StringProperty } from '../../schema/index.js';
-import { getIntegrationTest } from '../../testing/index.js';
-import { Table } from '../decorators.js';
-import { Entity } from '../entity.js';
-import { injectRepository } from '../server/repository.js';
-const schema = 'test_orm_tx_nested';
-const test = getIntegrationTest({ orm: { schema } });
-describe('ORM Repository Transactions Nested (Integration)', () => {
-    let TxEntity = class TxEntity extends Entity {
-        name;
-    };
-    __decorate([
-        StringProperty(),
-        __metadata("design:type", String)
-    ], TxEntity.prototype, "name", void 0);
-    TxEntity = __decorate([
-        Table('tx_entities', { schema })
-    ], TxEntity);
-    test.beforeEach(async ({ database: db }) => {
-        await db.execute(sql `CREATE SCHEMA IF NOT EXISTS ${sql.identifier(schema)}`);
-        await db.execute(sql `DROP TABLE IF EXISTS ${sql.identifier(schema)}.${sql.identifier('tx_entities')} CASCADE`);
-        await db.execute(sql `
-      CREATE TABLE ${sql.identifier(schema)}.${sql.identifier('tx_entities')} (
-        id UUID PRIMARY KEY DEFAULT gen_random_uuid(),
-        name TEXT NOT NULL,
-        revision INTEGER NOT NULL,
-        revision_timestamp TIMESTAMP WITH TIME ZONE NOT NULL,
-        create_timestamp TIMESTAMP WITH TIME ZONE NOT NULL,
-        delete_timestamp TIMESTAMP WITH TIME ZONE,
-        attributes JSONB NOT NULL DEFAULT '{}'
-      )
-    `);
-    });
-    test('should commit nested transaction', async ({ database: db }) => {
-        const repo = injectRepository(TxEntity);
-        await db.execute(sql `TRUNCATE TABLE ${sql.identifier(schema)}.${sql.identifier('tx_entities')} CASCADE`);
-        await repo.transaction(async (tx1) => {
-            const repo1 = repo.withTransaction(tx1);
-            await repo1.insert(Object.assign(new TxEntity(), { name: 'Outer' }));
-            await repo1.transaction(async (tx2) => {
-                const repo2 = repo1.withTransaction(tx2);
-                await repo2.insert(Object.assign(new TxEntity(), { name: 'Inner' }));
-            });
-        });
-        const count = await repo.count();
-        expect(count).toBe(2);
-    });
-    test('should rollback nested transaction (inner fails)', async ({ database: db }) => {
-        const repo = injectRepository(TxEntity);
-        await db.execute(sql `TRUNCATE TABLE ${sql.identifier(schema)}.${sql.identifier('tx_entities')} CASCADE`);
-        try {
-            await repo.transaction(async (tx1) => {
-                const repo1 = repo.withTransaction(tx1);
-                await repo1.insert(Object.assign(new TxEntity(), { name: 'Outer' }));
-                await repo1.transaction(async (tx2) => {
-                    const repo2 = repo1.withTransaction(tx2);
-                    await repo2.insert(Object.assign(new TxEntity(), { name: 'Inner' }));
-                    throw new Error('Fail Inner');
-                });
-            });
-        }
-        catch (e) {
-            expect(e.message).toBe('Fail Inner');
-        }
-        const count = await repo.count();
-        expect(count).toBe(0); // Outer should rollback too if error propagates
-    });
-    test('should rollback nested transaction but keep outer if caught', async ({ database: db }) => {
-        const repo = injectRepository(TxEntity);
-        await db.execute(sql `TRUNCATE TABLE ${sql.identifier(schema)}.${sql.identifier('tx_entities')} CASCADE`);
-        await repo.transaction(async (tx1) => {
-            const repo1 = repo.withTransaction(tx1);
-            await repo1.insert(Object.assign(new TxEntity(), { name: 'Outer' }));
-            try {
-                await repo1.transaction(async (tx2) => {
-                    const repo2 = repo1.withTransaction(tx2);
-                    await repo2.insert(Object.assign(new TxEntity(), { name: 'Inner' }));
-                    throw new Error('Fail Inner');
-                });
-            }
-            catch {
-                // Swallow error to keep outer alive
-            }
-        });
-        const all = await repo.loadAll();
-        expect(all).toHaveLength(1);
-        expect(all[0].name).toBe('Outer');
-    });
-    test('should rollback outer transaction (outer fails after inner commit)', async ({ database: db }) => {
-        const repo = injectRepository(TxEntity);
-        await db.execute(sql `TRUNCATE TABLE ${sql.identifier(schema)}.${sql.identifier('tx_entities')} CASCADE`);
-        try {
-            await repo.transaction(async (tx1) => {
-                const repo1 = repo.withTransaction(tx1);
-                await repo1.insert(Object.assign(new TxEntity(), { name: 'Outer' }));
-                await repo1.transaction(async (tx2) => {
-                    const repo2 = repo1.withTransaction(tx2);
-                    await repo2.insert(Object.assign(new TxEntity(), { name: 'Inner' }));
-                });
-                throw new Error('Fail Outer');
-            });
-        }
-        catch {
-            // Expected
-        }
-        const count = await repo.count();
-        expect(count).toBe(0);
-    });
-    test('should support multiple nested transactions sequentially', async ({ database: db }) => {
-        const repo = injectRepository(TxEntity);
-        await db.execute(sql `TRUNCATE TABLE ${sql.identifier(schema)}.${sql.identifier('tx_entities')} CASCADE`);
-        await repo.transaction(async (tx1) => {
-            const repo1 = repo.withTransaction(tx1);
-            await repo1.transaction(async (tx2) => {
-                await repo1.withTransaction(tx2).insert(Object.assign(new TxEntity(), { name: 'Inner1' }));
-            });
-            await repo1.transaction(async (tx3) => {
-                await repo1.withTransaction(tx3).insert(Object.assign(new TxEntity(), { name: 'Inner2' }));
-            });
-        });
-        const count = await repo.count();
-        expect(count).toBe(2);
-    });
-    test('should support deep nesting (3 levels)', async ({ database: db }) => {
-        const repo = injectRepository(TxEntity);
-        await db.execute(sql `TRUNCATE TABLE ${sql.identifier(schema)}.${sql.identifier('tx_entities')} CASCADE`);
-        await repo.transaction(async (tx1) => {
-            const r1 = repo.withTransaction(tx1);
-            await r1.insert(Object.assign(new TxEntity(), { name: 'L1' }));
-            await r1.transaction(async (tx2) => {
-                const r2 = r1.withTransaction(tx2);
-                await r2.insert(Object.assign(new TxEntity(), { name: 'L2' }));
-                await r2.transaction(async (tx3) => {
-                    const r3 = r2.withTransaction(tx3);
-                    await r3.insert(Object.assign(new TxEntity(), { name: 'L3' }));
-                });
-            });
-        });
-        const count = await repo.count();
-        expect(count).toBe(3);
-    });
-    test('should rollback deep nesting middle layer', async ({ database: db }) => {
-        const repo = injectRepository(TxEntity);
-        await db.execute(sql `TRUNCATE TABLE ${sql.identifier(schema)}.${sql.identifier('tx_entities')} CASCADE`);
-        await repo.transaction(async (tx1) => {
-            const r1 = repo.withTransaction(tx1);
-            await r1.insert(Object.assign(new TxEntity(), { name: 'L1' }));
-            try {
-                await r1.transaction(async (tx2) => {
-                    const r2 = r1.withTransaction(tx2);
-                    await r2.insert(Object.assign(new TxEntity(), { name: 'L2' }));
-                    await r2.transaction(async (tx3) => {
-                        const r3 = r2.withTransaction(tx3);
-                        await r3.insert(Object.assign(new TxEntity(), { name: 'L3' }));
-                    });
-                    throw new Error('Fail L2');
-                });
-            }
-            catch {
-                // Catch L2 failure
-            }
-        });
-        const all = await repo.loadAll();
-        expect(all).toHaveLength(1);
-        expect(all[0].name).toBe('L1');
-    });
-});

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

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

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

@@ -1,184 +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 { Array, BooleanProperty, Integer, NumberProperty, string, StringProperty } from '../../schema/index.js';
-import { setupIntegrationTest } from '../../testing/index.js';
-import { Table } from '../decorators.js';
-import { Entity } from '../entity.js';
-import { JsonProperty, NumericDateProperty, TimestampProperty } from '../schemas/index.js';
-import { getRepository } from '../server/index.js';
-describe('ORM Repository Types (Integration)', () => {
-    let injector;
-    let db;
-    let repo;
-    const schema = 'test_orm_types';
-    let TypeEntity = class TypeEntity extends Entity {
-        text;
-        int;
-        float;
-        bool;
-        numericDate;
-        timestamp;
-        json;
-        tags;
-    };
-    __decorate([
-        StringProperty(),
-        __metadata("design:type", String)
-    ], TypeEntity.prototype, "text", void 0);
-    __decorate([
-        Integer(),
-        __metadata("design:type", Number)
-    ], TypeEntity.prototype, "int", void 0);
-    __decorate([
-        NumberProperty(),
-        __metadata("design:type", Number)
-    ], TypeEntity.prototype, "float", void 0);
-    __decorate([
-        BooleanProperty(),
-        __metadata("design:type", Boolean)
-    ], TypeEntity.prototype, "bool", void 0);
-    __decorate([
-        NumericDateProperty(),
-        __metadata("design:type", Number)
-    ], TypeEntity.prototype, "numericDate", void 0);
-    __decorate([
-        TimestampProperty(),
-        __metadata("design:type", Date)
-    ], TypeEntity.prototype, "timestamp", void 0);
-    __decorate([
-        JsonProperty(),
-        __metadata("design:type", Object)
-    ], TypeEntity.prototype, "json", void 0);
-    __decorate([
-        Array(string()),
-        __metadata("design:type", Array)
-    ], TypeEntity.prototype, "tags", void 0);
-    TypeEntity = __decorate([
-        Table('type_entities', { schema })
-    ], TypeEntity);
-    beforeAll(async () => {
-        ({ injector, database: db } = await setupIntegrationTest({
-            orm: { schema },
-        }));
-        repo = injector.resolve(getRepository(TypeEntity));
-        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('type_entities')} CASCADE`);
-        await db.execute(sql `
-      CREATE TABLE ${sql.identifier(schema)}.${sql.identifier('type_entities')} (
-        id UUID PRIMARY KEY DEFAULT gen_random_uuid(),
-        text TEXT NOT NULL,
-        int INTEGER NOT NULL,
-        float DOUBLE PRECISION NOT NULL,
-        bool BOOLEAN NOT NULL,
-        numeric_date DATE NOT NULL,
-        timestamp TIMESTAMP WITH TIME ZONE NOT NULL,
-        json JSONB NOT NULL,
-        tags 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 persist and retrieve boolean values (true)', async () => {
-        const entity = await repo.insert(Object.assign(new TypeEntity(), {
-            text: 't', int: 1, float: 1.1, bool: true, numericDate: 0, timestamp: new Date(), json: {}, tags: [],
-        }));
-        const loaded = await repo.load(entity.id);
-        expect(loaded.bool).toBe(true);
-    });
-    test('should persist and retrieve boolean values (false)', async () => {
-        const entity = await repo.insert(Object.assign(new TypeEntity(), {
-            text: 'f', int: 1, float: 1.1, bool: false, numericDate: 0, timestamp: new Date(), json: {}, tags: [],
-        }));
-        const loaded = await repo.load(entity.id);
-        expect(loaded.bool).toBe(false);
-    });
-    test('should persist and retrieve integer boundaries', async () => {
-        const maxInt = 2147483647;
-        const minInt = -2147483648;
-        const e1 = await repo.insert(Object.assign(new TypeEntity(), {
-            text: 'max', int: maxInt, float: 0, bool: true, numericDate: 0, timestamp: new Date(), json: {}, tags: [],
-        }));
-        const l1 = await repo.load(e1.id);
-        expect(l1.int).toBe(maxInt);
-        const e2 = await repo.insert(Object.assign(new TypeEntity(), {
-            text: 'min', int: minInt, float: 0, bool: true, numericDate: 0, timestamp: new Date(), json: {}, tags: [],
-        }));
-        const l2 = await repo.load(e2.id);
-        expect(l2.int).toBe(minInt);
-    });
-    test('should persist and retrieve float precision', async () => {
-        const pi = 3.1415926535;
-        const entity = await repo.insert(Object.assign(new TypeEntity(), {
-            text: 'pi', int: 0, float: pi, bool: true, numericDate: 0, timestamp: new Date(), json: {}, tags: [],
-        }));
-        const loaded = await repo.load(entity.id);
-        expect(loaded.float).toBeCloseTo(pi);
-    });
-    test('should persist and retrieve numeric dates', async () => {
-        const today = 19723; // 2024-01-01
-        const entity = await repo.insert(Object.assign(new TypeEntity(), {
-            text: 'date', int: 0, float: 0, bool: true, numericDate: today, timestamp: new Date(), json: {}, tags: [],
-        }));
-        const loaded = await repo.load(entity.id);
-        expect(loaded.numericDate).toBe(today);
-    });
-    test('should persist and retrieve timestamps', async () => {
-        const now = new Date();
-        const entity = await repo.insert(Object.assign(new TypeEntity(), {
-            text: 'ts', int: 0, float: 0, bool: true, numericDate: 0, timestamp: now, json: {}, tags: [],
-        }));
-        const loaded = await repo.load(entity.id);
-        // Postgres stores microsecond precision, JS Date has millisecond.
-        // Drizzle custom type returns number (milliseconds).
-        // We accept a small difference due to precision loss or round-trip.
-        expect(typeof loaded.timestamp).toBe('number');
-        expect(Math.abs(loaded.timestamp - now.getTime())).toBeLessThan(2);
-    });
-    test('should persist and retrieve complex JSON', async () => {
-        const data = {
-            foo: 'bar',
-            nested: { a: 1, b: [true, false] },
-            nullVal: null,
-        };
-        const entity = await repo.insert(Object.assign(new TypeEntity(), {
-            text: 'json', int: 0, float: 0, bool: true, numericDate: 0, timestamp: new Date(), json: data, tags: [],
-        }));
-        const loaded = await repo.load(entity.id);
-        expect(loaded.json).toEqual(data);
-    });
-    test('should persist and retrieve arrays', async () => {
-        const tags = ['a', 'b', 'c'];
-        const entity = await repo.insert(Object.assign(new TypeEntity(), {
-            text: 'array', int: 0, float: 0, bool: true, numericDate: 0, timestamp: new Date(), json: {}, tags,
-        }));
-        const loaded = await repo.load(entity.id);
-        expect(loaded.tags).toEqual(tags);
-    });
-    test('should persist and retrieve empty arrays', async () => {
-        const entity = await repo.insert(Object.assign(new TypeEntity(), {
-            text: 'empty-array', int: 0, float: 0, bool: true, numericDate: 0, timestamp: new Date(), json: {}, tags: [],
-        }));
-        const loaded = await repo.load(entity.id);
-        expect(loaded.tags).toEqual([]);
-    });
-    test('should fail on integer overflow', async () => {
-        // Max int is 2147483647
-        const overflow = 3000000000;
-        await expect(repo.insert(Object.assign(new TypeEntity(), {
-            text: 'overflow', int: overflow, float: 0, bool: true, numericDate: 0, timestamp: new Date(), json: {}, tags: [],
-        }))).rejects.toThrow(); // Postgres should reject
-    });
-});

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

@@ -1,2 +0,0 @@
-/** biome-ignore-all lint/nursery/noExcessiveClassesPerFile: <explanation> */
-export {};

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

@@ -1,201 +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 { sql } from 'drizzle-orm';
-import { beforeAll, describe, expect, test } from 'vitest';
-import { StringProperty } from '../../schema/index.js';
-import { setupIntegrationTest } from '../../testing/index.js';
-import { ChildEntity, Column, Inheritance, Table } from '../decorators.js';
-import { Entity } from '../entity.js';
-import { getRepository } from '../server/index.js';
-describe('ORM Repository Undelete (Integration)', () => {
-    let injector;
-    let db;
-    let repository;
-    let baseRepo;
-    let subRepo;
-    const schema = 'test_orm_undelete';
-    let UndeleteEntity = class UndeleteEntity extends Entity {
-        name;
-    };
-    __decorate([
-        StringProperty(),
-        __metadata("design:type", String)
-    ], UndeleteEntity.prototype, "name", void 0);
-    UndeleteEntity = __decorate([
-        Table('undelete_entities', { schema })
-    ], UndeleteEntity);
-    let Base = class Base extends Entity {
-        type;
-        baseName;
-    };
-    __decorate([
-        StringProperty(),
-        Column({ name: 'type' }),
-        __metadata("design:type", String)
-    ], Base.prototype, "type", void 0);
-    __decorate([
-        StringProperty(),
-        __metadata("design:type", String)
-    ], Base.prototype, "baseName", void 0);
-    Base = __decorate([
-        Table('bases', { schema }),
-        Inheritance({ strategy: 'joined', discriminatorColumn: 'type' })
-    ], Base);
-    let Subtype = class Subtype extends Base {
-        subData;
-    };
-    __decorate([
-        StringProperty(),
-        __metadata("design:type", String)
-    ], Subtype.prototype, "subData", void 0);
-    Subtype = __decorate([
-        Table('subtypes', { schema }),
-        ChildEntity('subtype')
-    ], Subtype);
-    beforeAll(async () => {
-        ({ injector, database: db } = await setupIntegrationTest({ orm: { schema } }));
-        repository = injector.resolve(getRepository(UndeleteEntity));
-        baseRepo = injector.resolve(getRepository(Base));
-        subRepo = injector.resolve(getRepository(Subtype));
-        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('undelete_entities')} CASCADE`);
-        await db.execute(sql `DROP TABLE IF EXISTS ${sql.identifier(schema)}.${sql.identifier('subtypes')} CASCADE`);
-        await db.execute(sql `DROP TABLE IF EXISTS ${sql.identifier(schema)}.${sql.identifier('bases')} CASCADE`);
-        await db.execute(sql `
-      CREATE TABLE ${sql.identifier(schema)}.${sql.identifier('undelete_entities')} (
-        id UUID PRIMARY KEY DEFAULT gen_random_uuid(),
-        name TEXT NOT NULL,
-        revision INTEGER NOT NULL,
-        revision_timestamp TIMESTAMP WITH TIME ZONE NOT NULL,
-        create_timestamp TIMESTAMP WITH TIME ZONE NOT NULL,
-        delete_timestamp TIMESTAMP WITH TIME ZONE,
-        attributes JSONB NOT NULL DEFAULT '{}'
-      )
-    `);
-        await db.execute(sql `
-      CREATE TABLE ${sql.identifier(schema)}.${sql.identifier('bases')} (
-        id UUID PRIMARY KEY DEFAULT gen_random_uuid(),
-        type TEXT NOT NULL,
-        base_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 '{}',
-        UNIQUE (id, type)
-      )
-    `);
-        await db.execute(sql `
-      CREATE TABLE ${sql.identifier(schema)}.${sql.identifier('subtypes')} (
-        id UUID PRIMARY KEY,
-        type TEXT NOT NULL CHECK (type = 'subtype'),
-        sub_data TEXT NOT NULL,
-        FOREIGN KEY (id, type) REFERENCES ${sql.identifier(schema)}.${sql.identifier('bases')} (id, type) ON DELETE CASCADE
-      )
-    `);
-    });
-    test('should undelete an entity by ID', async () => {
-        await db.execute(sql `TRUNCATE TABLE ${sql.identifier(schema)}.${sql.identifier('undelete_entities')} CASCADE`);
-        const e1 = await repository.insert(Object.assign(new UndeleteEntity(), { name: 'E1' }));
-        await repository.delete(e1.id);
-        expect(await repository.has(e1.id)).toBe(false);
-        const undeleted = await repository.undelete(e1.id);
-        expect(undeleted.id).toBe(e1.id);
-        expect(undeleted.metadata.deleteTimestamp).toBeNull();
-        expect(undeleted.metadata.revision).toBe(3); // Insert (1) -> Delete (2) -> Undelete (3)
-        expect(await repository.has(e1.id)).toBe(true);
-        const loaded = await repository.load(e1.id);
-        expect(loaded.name).toBe('E1');
-        expect(loaded.metadata.deleteTimestamp).toBeNull();
-    });
-    test('should undelete multiple entities by IDs', async () => {
-        await db.execute(sql `TRUNCATE TABLE ${sql.identifier(schema)}.${sql.identifier('undelete_entities')} CASCADE`);
-        const e1 = await repository.insert(Object.assign(new UndeleteEntity(), { name: 'E1' }));
-        const e2 = await repository.insert(Object.assign(new UndeleteEntity(), { name: 'E2' }));
-        await repository.deleteMany([e1.id, e2.id]);
-        const undeleted = await repository.undeleteMany([e1.id, e2.id]);
-        expect(undeleted).toHaveLength(2);
-        expect(await repository.count()).toBe(2);
-    });
-    test('should undelete entities by query', async () => {
-        await db.execute(sql `TRUNCATE TABLE ${sql.identifier(schema)}.${sql.identifier('undelete_entities')} CASCADE`);
-        const e1 = await repository.insert(Object.assign(new UndeleteEntity(), { name: 'A' }));
-        const e2 = await repository.insert(Object.assign(new UndeleteEntity(), { name: 'B' }));
-        const e3 = await repository.insert(Object.assign(new UndeleteEntity(), { name: 'A' }));
-        await repository.deleteManyByQuery({ name: 'A' });
-        expect(await repository.count()).toBe(1);
-        const undeleted = await repository.undeleteManyByQuery({ name: 'A' });
-        expect(undeleted).toHaveLength(2);
-        expect(await repository.count()).toBe(3);
-    });
-    test('should ignore already active entities when undeleting', async () => {
-        await db.execute(sql `TRUNCATE TABLE ${sql.identifier(schema)}.${sql.identifier('undelete_entities')} CASCADE`);
-        const e1 = await repository.insert(Object.assign(new UndeleteEntity(), { name: 'E1' }));
-        const result = await repository.tryUndelete(e1.id);
-        expect(result).toBeUndefined();
-        expect(await repository.count()).toBe(1);
-    });
-    test('should support metadata updates during undeletion', async () => {
-        await db.execute(sql `TRUNCATE TABLE ${sql.identifier(schema)}.${sql.identifier('undelete_entities')} CASCADE`);
-        const e1 = await repository.insert(Object.assign(new UndeleteEntity(), { name: 'E1' }));
-        await repository.delete(e1.id);
-        const undeleted = await repository.undelete(e1.id, {}, { attributes: { restored: true } });
-        expect(undeleted.metadata.attributes).toEqual({ restored: true });
-        const loaded = await repository.load(e1.id);
-        expect(loaded.metadata.attributes).toEqual({ restored: true });
-    });
-    test('should throw NotFoundError if entity does not exist or is not deleted', async () => {
-        await db.execute(sql `TRUNCATE TABLE ${sql.identifier(schema)}.${sql.identifier('undelete_entities')} CASCADE`);
-        await expect(repository.undelete('00000000-0000-0000-0000-000000000000')).rejects.toThrow();
-        const e1 = await repository.insert(Object.assign(new UndeleteEntity(), { name: 'E1' }));
-        await expect(repository.undelete(e1.id)).rejects.toThrow();
-    });
-    test('should undelete from subtype repository (CTI)', async () => {
-        await db.execute(sql `TRUNCATE TABLE ${sql.identifier(schema)}.${sql.identifier('bases')} CASCADE`);
-        const entity = await subRepo.insert(Object.assign(new Subtype(), { baseName: 'B1', subData: 'S1' }));
-        await subRepo.delete(entity.id);
-        expect(await subRepo.has(entity.id)).toBe(false);
-        const undeleted = await subRepo.undelete(entity.id);
-        expect(undeleted.id).toBe(entity.id);
-        expect(undeleted.metadata.deleteTimestamp).toBeNull();
-        expect(undeleted.metadata.revision).toBe(3);
-        expect(await subRepo.has(entity.id)).toBe(true);
-        const loaded = await subRepo.load(entity.id);
-        expect(loaded.baseName).toBe('B1');
-        expect(loaded.subData).toBe('S1');
-    });
-    test('should undelete polymorphically from base repository (CTI)', async () => {
-        await db.execute(sql `TRUNCATE TABLE ${sql.identifier(schema)}.${sql.identifier('bases')} CASCADE`);
-        const entity = await subRepo.insert(Object.assign(new Subtype(), { baseName: 'B1', subData: 'S1' }));
-        await subRepo.delete(entity.id);
-        expect(await baseRepo.has(entity.id)).toBe(false);
-        const undeleted = await baseRepo.undelete(entity.id);
-        expect(undeleted.id).toBe(entity.id);
-        expect(undeleted.metadata.deleteTimestamp).toBeNull();
-        expect(await baseRepo.has(entity.id)).toBe(true);
-        const loaded = await baseRepo.load(entity.id, { includeSubclasses: true });
-        expect(loaded).toBeInstanceOf(Subtype);
-        expect(loaded.subData).toBe('S1');
-    });
-    test('should undelete multiple entities polymorphically (CTI)', async () => {
-        await db.execute(sql `TRUNCATE TABLE ${sql.identifier(schema)}.${sql.identifier('bases')} CASCADE`);
-        const e1 = await subRepo.insert(Object.assign(new Subtype(), { baseName: 'B1', subData: 'S1' }));
-        const e2 = await subRepo.insert(Object.assign(new Subtype(), { baseName: 'B2', subData: 'S2' }));
-        await baseRepo.deleteMany([e1.id, e2.id]);
-        expect(await baseRepo.count()).toBe(0);
-        const undeleted = await baseRepo.undeleteMany([e1.id, e2.id]);
-        expect(undeleted).toHaveLength(2);
-        expect(await baseRepo.count()).toBe(2);
-        const loadedAll = await baseRepo.loadAll({ includeSubclasses: true });
-        expect(loadedAll).toHaveLength(2);
-        expect(loadedAll.every((e) => e instanceof Subtype)).toBe(true);
-    });
-});

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

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

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

@@ -1,82 +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 { StringProperty } from '../../schema/index.js';
-import { getTableConfig } from 'drizzle-orm/pg-core';
-import { describe, expect, test } from 'vitest';
-import { Column, Index, PrimaryKeyProperty, Table } from '../decorators.js';
-import { Entity } from '../entity.js';
-import { getDrizzleTableFromType } from '../server/drizzle/schema-converter.js';
-let Parent = class Parent extends Entity {
-    code;
-};
-__decorate([
-    StringProperty(),
-    Column({ name: 'code' }),
-    __metadata("design:type", String)
-], Parent.prototype, "code", void 0);
-Parent = __decorate([
-    Table('parent_table', { schema: 'test' })
-], Parent);
-describe('ORM Schema Generation - Detailed Configurations', () => {
-    test('should generate partial index with where clause', () => {
-        let PartialIndexEntity = class PartialIndexEntity extends Entity {
-            status;
-        };
-        __decorate([
-            StringProperty(),
-            Index({ where: () => ({ status: 'active' }) }),
-            __metadata("design:type", String)
-        ], PartialIndexEntity.prototype, "status", void 0);
-        PartialIndexEntity = __decorate([
-            Table('partial_index_test', { schema: 'test' })
-        ], PartialIndexEntity);
-        const table = getDrizzleTableFromType(PartialIndexEntity);
-        const config = getTableConfig(table);
-        expect(config.indexes.length).toBeGreaterThan(0);
-        const idx = config.indexes[0];
-        expect(idx).toBeDefined();
-        expect(idx.config.name).toContain('partial_idx');
-        expect(idx.config.where).toBeDefined();
-    });
-    test('should handle index with nulls ordering', () => {
-        let NullOrderingEntity = class NullOrderingEntity extends Entity {
-            val;
-        };
-        __decorate([
-            StringProperty(),
-            Index({ nulls: 'first' }),
-            __metadata("design:type", String)
-        ], NullOrderingEntity.prototype, "val", void 0);
-        NullOrderingEntity = __decorate([
-            Table('null_ordering_test', { schema: 'test' })
-        ], NullOrderingEntity);
-        const table = getDrizzleTableFromType(NullOrderingEntity);
-        const config = getTableConfig(table);
-        expect(config.indexes.length).toBeGreaterThan(0);
-    });
-    test('should handle renamed id column', () => {
-        let RenamedIdEntity = class RenamedIdEntity extends Entity {
-        };
-        __decorate([
-            StringProperty(),
-            Column({ name: 'custom_id' }),
-            PrimaryKeyProperty(),
-            __metadata("design:type", String)
-        ], RenamedIdEntity.prototype, "id", void 0);
-        RenamedIdEntity = __decorate([
-            Table('renamed_id_test', { schema: 'test' })
-        ], RenamedIdEntity);
-        const table = getDrizzleTableFromType(RenamedIdEntity);
-        const config = getTableConfig(table);
-        const idCol = config.columns.find(c => c.name === 'custom_id');
-        expect(idCol).toBeDefined();
-        expect(idCol.primary).toBe(true);
-    });
-});

package/orm/tests/schema-generation.test.d.ts

@@ -1,2 +0,0 @@
-/** biome-ignore-all lint/nursery/noExcessiveClassesPerFile: <explanation> */
-export {};