@tstdl/base 0.93.145 → 0.93.147

package/orm/tests/repository-soft-delete.test.js

@@ -7,17 +7,17 @@ var __decorate = (this && this.__decorate) || function (decorators, target, key,
 var __metadata = (this && this.__metadata) || function (k, v) {
     if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
 };
-import { Injector, runInInjectionContext } from '../../injector/index.js';
-import { StringProperty } from '../../schema/index.js';
 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 { Table } from '../decorators.js';
 import { Entity } from '../entity.js';
-import { configureOrm, Database } from '../server/index.js';
-import { injectRepository } from '../server/repository.js';
+import { getRepository } from '../server/index.js';
 describe('ORM Repository Soft Delete (Integration)', () => {
     let injector;
     let db;
+    let repository;
     const schema = 'test_orm_soft_delete';
     let SoftDeleteEntity = class SoftDeleteEntity extends Entity {
         name;
@@ -30,14 +30,10 @@ describe('ORM Repository Soft Delete (Integration)', () => {
         Table('soft_delete_entities', { schema })
     ], SoftDeleteEntity);
     beforeAll(async () => {
-        injector = new Injector('Test');
-        configureOrm({
-            repositoryConfig: { schema },
-            connection: {
-                host: '127.0.0.1', port: 5432, user: 'tstdl', password: 'wf7rq6glrk5jykne', database: 'tstdl',
-            }
-        });
-        db = injector.resolve(Database);
+        ({ injector, database: db } = await setupIntegrationTest({
+            orm: { schema },
+        }));
+        repository = injector.resolve(getRepository(SoftDeleteEntity));
         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('soft_delete_entities')} CASCADE`);
         await db.execute(sql `
@@ -54,90 +50,69 @@ describe('ORM Repository Soft Delete (Integration)', () => {
     });
     test('should soft delete an entity by ID', async () => {
         await db.execute(sql `TRUNCATE TABLE ${sql.identifier(schema)}.${sql.identifier('soft_delete_entities')} CASCADE`);
-        await runInInjectionContext(injector, async () => {
-            const repository = injectRepository(SoftDeleteEntity);
-            const e1 = await repository.insert(Object.assign(new SoftDeleteEntity(), { name: 'E1' }));
-            const deleted = await repository.delete(e1.id);
-            expect(deleted.id).toBe(e1.id);
-            expect(deleted.metadata.deleteTimestamp).toBeDefined();
-            expect(await repository.has(e1.id)).toBe(false);
-            expect(await repository.tryLoad(e1.id)).toBeUndefined();
-            expect(await repository.count()).toBe(0);
-            const allWithDeleted = await repository.loadAll({ withDeleted: true });
-            expect(allWithDeleted).toHaveLength(1);
-            expect(allWithDeleted[0].id).toBe(e1.id);
-        });
+        const e1 = await repository.insert(Object.assign(new SoftDeleteEntity(), { name: 'E1' }));
+        const deleted = await repository.delete(e1.id);
+        expect(deleted.id).toBe(e1.id);
+        expect(deleted.metadata.deleteTimestamp).toBeDefined();
+        expect(await repository.has(e1.id)).toBe(false);
+        expect(await repository.tryLoad(e1.id)).toBeUndefined();
+        expect(await repository.count()).toBe(0);
+        const allWithDeleted = await repository.loadAll({ withDeleted: true });
+        expect(allWithDeleted).toHaveLength(1);
+        expect(allWithDeleted[0].id).toBe(e1.id);
     });
     test('should soft delete multiple entities by IDs', async () => {
         await db.execute(sql `TRUNCATE TABLE ${sql.identifier(schema)}.${sql.identifier('soft_delete_entities')} CASCADE`);
-        await runInInjectionContext(injector, async () => {
-            const repository = injectRepository(SoftDeleteEntity);
-            const e1 = await repository.insert(Object.assign(new SoftDeleteEntity(), { name: 'E1' }));
-            const e2 = await repository.insert(Object.assign(new SoftDeleteEntity(), { name: 'E2' }));
-            const deleted = await repository.deleteMany([e1.id, e2.id]);
-            expect(deleted).toHaveLength(2);
-            expect(await repository.count()).toBe(0);
-            expect(await repository.countByQuery({}, { withDeleted: true })).toBe(2);
-        });
+        const e1 = await repository.insert(Object.assign(new SoftDeleteEntity(), { name: 'E1' }));
+        const e2 = await repository.insert(Object.assign(new SoftDeleteEntity(), { name: 'E2' }));
+        const deleted = await repository.deleteMany([e1.id, e2.id]);
+        expect(deleted).toHaveLength(2);
+        expect(await repository.count()).toBe(0);
+        expect(await repository.countByQuery({}, { withDeleted: true })).toBe(2);
     });
     test('should soft delete entities by query', async () => {
         await db.execute(sql `TRUNCATE TABLE ${sql.identifier(schema)}.${sql.identifier('soft_delete_entities')} CASCADE`);
-        await runInInjectionContext(injector, async () => {
-            const repository = injectRepository(SoftDeleteEntity);
-            await repository.insertMany([
-                Object.assign(new SoftDeleteEntity(), { name: 'A' }),
-                Object.assign(new SoftDeleteEntity(), { name: 'B' }),
-                Object.assign(new SoftDeleteEntity(), { name: 'A' }),
-            ]);
-            const deleted = await repository.deleteManyByQuery({ name: 'A' });
-            expect(deleted).toHaveLength(2);
-            expect(await repository.count()).toBe(1);
-            expect(await repository.countByQuery({}, { withDeleted: true })).toBe(3);
-        });
+        await repository.insertMany([
+            Object.assign(new SoftDeleteEntity(), { name: 'A' }),
+            Object.assign(new SoftDeleteEntity(), { name: 'B' }),
+            Object.assign(new SoftDeleteEntity(), { name: 'A' }),
+        ]);
+        const deleted = await repository.deleteManyByQuery({ name: 'A' });
+        expect(deleted).toHaveLength(2);
+        expect(await repository.count()).toBe(1);
+        expect(await repository.countByQuery({}, { withDeleted: true })).toBe(3);
     });
     test('should not update soft-deleted entities by default', async () => {
         await db.execute(sql `TRUNCATE TABLE ${sql.identifier(schema)}.${sql.identifier('soft_delete_entities')} CASCADE`);
-        await runInInjectionContext(injector, async () => {
-            const repository = injectRepository(SoftDeleteEntity);
-            const e1 = await repository.insert(Object.assign(new SoftDeleteEntity(), { name: 'E1' }));
-            await repository.delete(e1.id);
-            const updated = await repository.tryUpdate(e1.id, { name: 'Updated' });
-            expect(updated).toBeUndefined();
-            const loaded = await repository.tryLoad(e1.id, { withDeleted: true });
-            expect(loaded.name).toBe('E1');
-        });
+        const e1 = await repository.insert(Object.assign(new SoftDeleteEntity(), { name: 'E1' }));
+        await repository.delete(e1.id);
+        const updated = await repository.tryUpdate(e1.id, { name: 'Updated' });
+        expect(updated).toBeUndefined();
+        const loaded = await repository.tryLoad(e1.id, { withDeleted: true });
+        expect(loaded.name).toBe('E1');
     });
     test('should support hard delete on soft-deleted entities', async () => {
         await db.execute(sql `TRUNCATE TABLE ${sql.identifier(schema)}.${sql.identifier('soft_delete_entities')} CASCADE`);
-        await runInInjectionContext(injector, async () => {
-            const repository = injectRepository(SoftDeleteEntity);
-            const e1 = await repository.insert(Object.assign(new SoftDeleteEntity(), { name: 'E1' }));
-            await repository.delete(e1.id);
-            const hardDeleted = await repository.hardDelete(e1.id);
-            expect(hardDeleted.id).toBe(e1.id);
-            expect(await repository.countByQuery({}, { withDeleted: true })).toBe(0);
-        });
+        const e1 = await repository.insert(Object.assign(new SoftDeleteEntity(), { name: 'E1' }));
+        await repository.delete(e1.id);
+        const hardDeleted = await repository.hardDelete(e1.id);
+        expect(hardDeleted.id).toBe(e1.id);
+        expect(await repository.countByQuery({}, { withDeleted: true })).toBe(0);
     });
     test('should ignore already soft-deleted entities when deleting again', async () => {
         await db.execute(sql `TRUNCATE TABLE ${sql.identifier(schema)}.${sql.identifier('soft_delete_entities')} CASCADE`);
-        await runInInjectionContext(injector, async () => {
-            const repository = injectRepository(SoftDeleteEntity);
-            const e1 = await repository.insert(Object.assign(new SoftDeleteEntity(), { name: 'E1' }));
-            await repository.delete(e1.id);
-            const secondDelete = await repository.tryDelete(e1.id);
-            expect(secondDelete).toBeUndefined();
-        });
+        const e1 = await repository.insert(Object.assign(new SoftDeleteEntity(), { name: 'E1' }));
+        await repository.delete(e1.id);
+        const secondDelete = await repository.tryDelete(e1.id);
+        expect(secondDelete).toBeUndefined();
     });
     test('should hard delete multiple entities by query (including soft-deleted)', async () => {
         await db.execute(sql `TRUNCATE TABLE ${sql.identifier(schema)}.${sql.identifier('soft_delete_entities')} CASCADE`);
-        await runInInjectionContext(injector, async () => {
-            const repository = injectRepository(SoftDeleteEntity);
-            const e1 = await repository.insert(Object.assign(new SoftDeleteEntity(), { name: 'E1' }));
-            const e2 = await repository.insert(Object.assign(new SoftDeleteEntity(), { name: 'E2' }));
-            await repository.delete(e1.id); // Soft delete E1
-            const hardDeleted = await repository.hardDeleteManyByQuery({});
-            expect(hardDeleted).toHaveLength(2); // Should hard delete both
-            expect(await repository.countByQuery({}, { withDeleted: true })).toBe(0);
-        });
+        const e1 = await repository.insert(Object.assign(new SoftDeleteEntity(), { name: 'E1' }));
+        const e2 = await repository.insert(Object.assign(new SoftDeleteEntity(), { name: 'E2' }));
+        await repository.delete(e1.id); // Soft delete E1
+        const hardDeleted = await repository.hardDeleteManyByQuery({});
+        expect(hardDeleted).toHaveLength(2); // Should hard delete both
+        expect(await repository.countByQuery({}, { withDeleted: true })).toBe(0);
     });
 });

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

@@ -9,16 +9,16 @@ var __metadata = (this && this.__metadata) || function (k, v) {
 };
 import { sql } from 'drizzle-orm';
 import { beforeAll, describe, expect, test } from 'vitest';
-import { Injector, runInInjectionContext } from '../../injector/index.js';
 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 { configureOrm, Database } from '../server/index.js';
-import { injectRepository } from '../server/repository.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;
@@ -66,14 +66,10 @@ describe('ORM Repository Types (Integration)', () => {
         Table('type_entities', { schema })
     ], TypeEntity);
     beforeAll(async () => {
-        injector = new Injector('Test');
-        configureOrm({
-            repositoryConfig: { schema },
-            connection: {
-                host: '127.0.0.1', port: 5432, user: 'tstdl', password: 'wf7rq6glrk5jykne', database: 'tstdl',
-            },
-        });
-        db = injector.resolve(Database);
+        ({ 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 `
@@ -96,123 +92,93 @@ describe('ORM Repository Types (Integration)', () => {
     `);
     });
     test('should persist and retrieve boolean values (true)', async () => {
-        await runInInjectionContext(injector, async () => {
-            const repo = injectRepository(TypeEntity);
-            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);
-        });
+        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 () => {
-        await runInInjectionContext(injector, async () => {
-            const repo = injectRepository(TypeEntity);
-            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);
-        });
+        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 () => {
-        await runInInjectionContext(injector, async () => {
-            const repo = injectRepository(TypeEntity);
-            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);
-        });
+        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 () => {
-        await runInInjectionContext(injector, async () => {
-            const repo = injectRepository(TypeEntity);
-            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);
-        });
+        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 () => {
-        await runInInjectionContext(injector, async () => {
-            const repo = injectRepository(TypeEntity);
-            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);
-        });
+        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 () => {
-        await runInInjectionContext(injector, async () => {
-            const repo = injectRepository(TypeEntity);
-            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);
-        });
+        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 () => {
-        await runInInjectionContext(injector, async () => {
-            const repo = injectRepository(TypeEntity);
-            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);
-        });
+        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 () => {
-        await runInInjectionContext(injector, async () => {
-            const repo = injectRepository(TypeEntity);
-            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);
-        });
+        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 () => {
-        await runInInjectionContext(injector, async () => {
-            const repo = injectRepository(TypeEntity);
-            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([]);
-        });
+        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 () => {
-        await runInInjectionContext(injector, async () => {
-            const repo = injectRepository(TypeEntity);
-            // 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
-        });
+        // 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

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

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

@@ -0,0 +1,201 @@
+/** 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);
+    });
+});