@tstdl/base 0.93.146 → 0.93.147

package/orm/repository.types.d.ts

@@ -100,7 +100,18 @@ export type DeleteOptions<_T extends BaseEntity> = {
  */
 export type DeleteManyOptions<T extends BaseEntity> = DeleteOptions<T>;
 /**
- * Options for ranking search results.
+ * Options for undelete operations.
+ * @template T - The entity type.
+ */
+export type UndeleteOptions<_T extends BaseEntity> = Record<never, never>;
+/**
+ * Options for undelete many operations.
+ * @template T - The entity type.
+ */
+export type UndeleteManyOptions<T extends BaseEntity> = UndeleteOptions<T>;
+/**
+ * Represents a single result from a full-text search operation.
+
  */
 export type RankOptions = {
     /**
@@ -224,7 +235,7 @@ export type SearchResult<T extends BaseEntity> = {
  */
 export type UpdateOptions<T extends BaseEntity> = LoadOptions<T>;
 /** Type definition for updating entity metadata attributes, allowing partial updates and SQL expressions. */
-export type EntityMetadataUpdate = WithSql<Partial<UntaggedDeep<Pick<EntityMetadata, 'attributes'>>>>;
+export type EntityMetadataUpdate = WithSql<Partial<UntaggedDeep<Pick<EntityMetadata, 'attributes' | 'deleteTimestamp'>>>>;
 export type EntityMetadataInsert = Partial<Pick<EntityMetadata, 'attributes'>>;
 /**
  * Represents the data structure for creating a new entity.

package/orm/server/repository.d.ts

@@ -5,7 +5,7 @@ import { afterResolve, resolveArgumentType, type Resolvable } from '../../inject
 import type { DeepPartial, Function, OneOrMany, Record, SimplifyObject, Type, TypedOmit } from '../../types/index.js';
 import { Entity, type BaseEntity, type EntityMetadataAttributes, type EntityType } from '../entity.js';
 import type { ParadeSearchQuery, Query, TrigramSearchQuery, TsVectorSearchQuery } from '../query/index.js';
-import type { CountOptions, DeleteOptions, EntityMetadataUpdate, EntityUpdate, HasOptions, LoadManyOptions, LoadOptions, NewEntity, Order, SearchOptions, SearchResult, TargetColumn, TargetColumnPath, UpdateOptions } from '../repository.types.js';
+import type { CountOptions, DeleteOptions, EntityMetadataUpdate, EntityUpdate, HasOptions, LoadManyOptions, LoadOptions, NewEntity, Order, SearchOptions, SearchResult, TargetColumn, TargetColumnPath, UndeleteOptions, UpdateOptions } from '../repository.types.js';
 import type { Database } from './database.js';
 import type { PgTransaction } from './transaction.js';
 import { Transactional } from './transactional.js';
@@ -279,16 +279,18 @@ export declare class EntityRepository<T extends BaseEntity = BaseEntity> extends
      * Updates multiple entities by their IDs.
      * @param ids An array of entity IDs to update.
      * @param update The update to apply to the entities.
+     * @param options Optional update options.
      * @returns A promise that resolves to an array of the updated entities.
      */
-    updateMany(ids: string[], update: EntityUpdate<T>): Promise<T[]>;
+    updateMany(ids: string[], update: EntityUpdate<T>, options?: UpdateOptions<T>): Promise<T[]>;
     /**
      * Updates multiple entities matching a query.
      * @param query The query to filter entities.
      * @param update The update to apply to the entities.
+     * @param options Optional update options.
      * @returns A promise that resolves to an array of the updated entities.
      */
-    updateManyByQuery(query: Query<T>, update: EntityUpdate<T>): Promise<T[]>;
+    updateManyByQuery(query: Query<T>, update: EntityUpdate<T>, options?: UpdateOptions<T>): Promise<T[]>;
     /**
      * Deletes an entity by its ID (soft delete if metadata is available).
      * Throws `NotFoundError` if the entity is not found.
@@ -343,6 +345,60 @@ export declare class EntityRepository<T extends BaseEntity = BaseEntity> extends
      * @returns A promise that resolves to an array of the deleted entities.
      */
     deleteManyByQuery(query: Query<T>, options?: DeleteOptions<T>, metadataUpdate?: EntityMetadataUpdate): Promise<T[]>;
+    /**
+     * Undeletes an entity by its ID (restores from soft-deleted state).
+     * Throws `NotFoundError` if the entity is not found (or not deleted).
+     * @param id The ID of the entity to undelete.
+     * @param options Optional undelete options.
+     * @param metadataUpdate Optional metadata update to apply during undeletion.
+     * @returns A promise that resolves to the undeleted entity.
+     * @throws {NotFoundError} If the entity with the given ID is not found (or not deleted).
+     */
+    undelete(id: string, options?: UndeleteOptions<T>, metadataUpdate?: EntityMetadataUpdate): Promise<T>;
+    /**
+     * Tries to undelete an entity by its ID (restores from soft-deleted state).
+     * Returns `undefined` if the entity is not found (or not deleted).
+     * @param id The ID of the entity to undelete.
+     * @param options Optional undelete options.
+     * @param metadataUpdate Optional metadata update to apply during undeletion.
+     * @returns A promise that resolves to the undeleted entity or `undefined` if not found.
+     */
+    tryUndelete(id: string, options?: UndeleteOptions<T>, metadataUpdate?: EntityMetadataUpdate): Promise<T | undefined>;
+    /**
+     * Undeletes a single entity matching a query (restores from soft-deleted state).
+     * Throws `NotFoundError` if no deleted entity matches the query.
+     * @param query The query to filter entities.
+     * @param options Optional undelete options.
+     * @param metadataUpdate Optional metadata update to apply during undeletion.
+     * @returns A promise that resolves to the undeleted entity.
+     * @throws {NotFoundError} If no deleted entity matches the query.
+     */
+    undeleteByQuery(query: Query<T>, options?: UndeleteOptions<T>, metadataUpdate?: EntityMetadataUpdate): Promise<T>;
+    /**
+     * Tries to undelete a single entity matching a query (restores from soft-deleted state).
+     * Returns `undefined` if no deleted entity matches the query.
+     * @param query The query to filter entities.
+     * @param options Optional undelete options.
+     * @param metadataUpdate Optional metadata update to apply during undeletion.
+     * @returns A promise that resolves to the undeleted entity or `undefined` if not found.
+     */
+    tryUndeleteByQuery(query: Query<T>, options?: UndeleteOptions<T>, metadataUpdate?: EntityMetadataUpdate): Promise<T | undefined>;
+    /**
+     * Undeletes multiple entities by their IDs (restores from soft-deleted state).
+     * @param ids An array of entity IDs to undelete.
+     * @param options Optional undelete options.
+     * @param metadataUpdate Optional metadata update to apply during undeletion.
+     * @returns A promise that resolves to an array of the undeleted entities.
+     */
+    undeleteMany(ids: string[], options?: UndeleteOptions<T>, metadataUpdate?: EntityMetadataUpdate): Promise<T[]>;
+    /**
+     * Undeletes multiple entities matching a query (restores from soft-deleted state).
+     * @param query The query to filter entities.
+     * @param options Optional undelete options.
+     * @param metadataUpdate Optional metadata update to apply during undeletion.
+     * @returns A promise that resolves to an array of the undeleted entities.
+     */
+    undeleteManyByQuery(query: Query<T>, options?: UndeleteOptions<T>, metadataUpdate?: EntityMetadataUpdate): Promise<T[]>;
     /**
      * Hard deletes an entity by its ID (removes from the database).
      * Throws `NotFoundError` if the entity is not found.
@@ -536,7 +592,7 @@ export declare class EntityRepository<T extends BaseEntity = BaseEntity> extends
     protected _mapToInsertColumns(obj: DeepPartial<T> | NewEntity<T>, transformContext: TransformContext): Promise<PgInsertValue<PgTableFromType>>;
     protected _mapToTableUpdate(update: EntityUpdate<T>, transformContext: TransformContext, table: AnyPgTable, definitions?: ColumnDefinition[]): Promise<PgUpdateSetSource<PgTableFromType>>;
     protected _mapUpdate(update: EntityUpdate<T>, transformContext: TransformContext): Promise<PgUpdateSetSource<PgTableFromType>>;
-    protected _getMetadataUpdate(update?: EntityUpdate<T>): PgUpdateSetSource<PgTableFromType<EntityType<Entity>>> | undefined;
+    protected _getMetadataUpdate(update?: EntityMetadataUpdate): PgUpdateSetSource<PgTableFromType<EntityType<Entity>>> | undefined;
     private prepareSubclassJoins;
     private addSubclassColumnsToSelection;
     private applySubclassJoins;

package/orm/server/repository.js

@@ -5,7 +5,7 @@ var __decorate = (this && this.__decorate) || function (decorators, target, key,
     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;
 };
-import { and, asc, count, desc, eq, getTableName, inArray, isNull as isSqlNull, isSQLWrapper, lte, or, SQL, sql } from 'drizzle-orm';
+import { and, asc, count, desc, eq, getTableName, inArray, isNotNull as isSqlNotNull, isNull as isSqlNull, isSQLWrapper, lte, or, SQL, sql } from 'drizzle-orm';
 import { match, P } from 'ts-pattern';
 import { CancellationSignal } from '../../cancellation/token.js';
 import { NotFoundError } from '../../errors/not-found.error.js';
@@ -781,7 +781,7 @@ let EntityRepository = class EntityRepository extends Transactional {
                     ? await this._mapToTableUpdate(update, transformContext, table, columnDefinitions)
                     : {
                         ...fromEntries(columnDefinitions.filter((column) => !primaryKeyColumnNames.includes(column.name)).map((column) => [column.name, sql `excluded.${sql.identifier(resolveTargetColumn(column, table, this.#columnDefinitionsMap).name)}`])),
-                        ...((table == this.#baseTable) ? this._getMetadataUpdate(update) : undefined),
+                        ...((table == this.#baseTable) ? this._getMetadataUpdate(update?.metadata) : undefined),
                     };
                 const targetPaths = toArray(target);
                 const isTargetInTable = targetPaths.every((path) => {
@@ -860,7 +860,7 @@ let EntityRepository = class EntityRepository extends Transactional {
                 ? await this.mapUpdate(update)
                 : {
                     ...this.#upsertManyExcludedMapping,
-                    ...this._getMetadataUpdate(update),
+                    ...this._getMetadataUpdate(update?.metadata),
                 };
             const rows = await this.session
                 .insert(this.#table)
@@ -929,9 +929,9 @@ let EntityRepository = class EntityRepository extends Transactional {
             return await this.mapToEntity(mergedRow);
         });
     }
-    async updateManyCTI(query, update) {
+    async updateManyCTI(query, update, options) {
         return await this.transaction(async (transaction) => {
-            const ids = await this.withTransaction(transaction).loadManyByQuery(query).then((entities) => entities.map((entity) => entity.id));
+            const ids = await this.withTransaction(transaction).loadManyByQuery(query, options).then((entities) => entities.map((entity) => entity.id));
             if (ids.length == 0) {
                 return [];
             }
@@ -945,7 +945,7 @@ let EntityRepository = class EntityRepository extends Transactional {
                         .where(inArray(table.id, ids));
                 }
             }
-            return await this.loadMany(ids);
+            return await this.withTransaction(transaction).loadMany(ids, options);
         });
     }
     /**
@@ -1010,35 +1010,37 @@ let EntityRepository = class EntityRepository extends Transactional {
             }
             return await this.mapToEntity(row);
         }
-        return await this.transaction(async () => {
-            const id = await this.tryLoadByQuery(query, options).then((entity) => entity?.id);
+        return await this.transaction(async (transaction) => {
+            const id = await this.withTransaction(transaction).tryLoadByQuery(query, options).then((entity) => entity?.id);
             if (isUndefined(id)) {
                 return undefined;
             }
-            return await this.tryUpdate(id, update, options);
+            return await this.withTransaction(transaction).tryUpdate(id, update, options);
         });
     }
     /**
      * Updates multiple entities by their IDs.
      * @param ids An array of entity IDs to update.
      * @param update The update to apply to the entities.
+     * @param options Optional update options.
      * @returns A promise that resolves to an array of the updated entities.
      */
-    async updateMany(ids, update) {
+    async updateMany(ids, update, options) {
         if (ids.length == 0) {
             return [];
         }
-        return await this.updateManyByQuery(inArray(this.#table.id, ids), update);
+        return await this.updateManyByQuery(inArray(this.#table.id, ids), update, options);
     }
     /**
      * Updates multiple entities matching a query.
      * @param query The query to filter entities.
      * @param update The update to apply to the entities.
+     * @param options Optional update options.
      * @returns A promise that resolves to an array of the updated entities.
      */
-    async updateManyByQuery(query, update) {
+    async updateManyByQuery(query, update, options) {
         if (!this.#isChild) {
-            const sqlQuery = this.convertQuery(query);
+            const sqlQuery = this.convertQuery(query, options);
             const mappedUpdate = await this.mapUpdate(update);
             const rows = await this.session
                 .update(this.#table)
@@ -1047,7 +1049,7 @@ let EntityRepository = class EntityRepository extends Transactional {
                 .returning();
             return await this.mapManyToEntity(rows);
         }
-        return await this.updateManyCTI(query, update);
+        return await this.updateManyCTI(query, update, options);
     }
     /**
      * Deletes an entity by its ID (soft delete if metadata is available).
@@ -1082,7 +1084,7 @@ let EntityRepository = class EntityRepository extends Transactional {
             .update(this.#baseTableWithMetadata)
             .set({
             deleteTimestamp: TRANSACTION_TIMESTAMP,
-            attributes: this.getAttributesUpdate(metadataUpdate?.attributes),
+            ...this._getMetadataUpdate(metadataUpdate),
         })
             .where(sqlQuery)
             .returning();
@@ -1125,7 +1127,7 @@ let EntityRepository = class EntityRepository extends Transactional {
             .update(this.#baseTableWithMetadata)
             .set({
             deleteTimestamp: TRANSACTION_TIMESTAMP,
-            attributes: this.getAttributesUpdate(metadataUpdate?.attributes),
+            ...this._getMetadataUpdate(metadataUpdate),
         })
             .where(sqlQuery)
             .returning();
@@ -1163,12 +1165,109 @@ let EntityRepository = class EntityRepository extends Transactional {
             .update(this.#baseTableWithMetadata)
             .set({
             deleteTimestamp: TRANSACTION_TIMESTAMP,
-            attributes: this.getAttributesUpdate(metadataUpdate?.attributes),
+            ...this._getMetadataUpdate(metadataUpdate),
         })
             .where(sqlQuery)
             .returning();
         return await this.mapManyToEntity(rows);
     }
+    /**
+     * Undeletes an entity by its ID (restores from soft-deleted state).
+     * Throws `NotFoundError` if the entity is not found (or not deleted).
+     * @param id The ID of the entity to undelete.
+     * @param options Optional undelete options.
+     * @param metadataUpdate Optional metadata update to apply during undeletion.
+     * @returns A promise that resolves to the undeleted entity.
+     * @throws {NotFoundError} If the entity with the given ID is not found (or not deleted).
+     */
+    async undelete(id, options, metadataUpdate) {
+        const entity = await this.tryUndelete(id, options, metadataUpdate);
+        if (isUndefined(entity)) {
+            throw new NotFoundError(`${this.typeName} ${id} not found.`);
+        }
+        return entity;
+    }
+    /**
+     * Tries to undelete an entity by its ID (restores from soft-deleted state).
+     * Returns `undefined` if the entity is not found (or not deleted).
+     * @param id The ID of the entity to undelete.
+     * @param options Optional undelete options.
+     * @param metadataUpdate Optional metadata update to apply during undeletion.
+     * @returns A promise that resolves to the undeleted entity or `undefined` if not found.
+     */
+    async tryUndelete(id, options, metadataUpdate) {
+        return await this.tryUndeleteByQuery(eq(this.#baseTable.id, id), options, metadataUpdate);
+    }
+    /**
+     * Undeletes a single entity matching a query (restores from soft-deleted state).
+     * Throws `NotFoundError` if no deleted entity matches the query.
+     * @param query The query to filter entities.
+     * @param options Optional undelete options.
+     * @param metadataUpdate Optional metadata update to apply during undeletion.
+     * @returns A promise that resolves to the undeleted entity.
+     * @throws {NotFoundError} If no deleted entity matches the query.
+     */
+    async undeleteByQuery(query, options, metadataUpdate) {
+        const entity = await this.tryUndeleteByQuery(query, options, metadataUpdate);
+        if (isUndefined(entity)) {
+            throw new NotFoundError(`${this.typeName} not found.`);
+        }
+        return entity;
+    }
+    /**
+     * Tries to undelete a single entity matching a query (restores from soft-deleted state).
+     * Returns `undefined` if no deleted entity matches the query.
+     * @param query The query to filter entities.
+     * @param options Optional undelete options.
+     * @param metadataUpdate Optional metadata update to apply during undeletion.
+     * @returns A promise that resolves to the undeleted entity or `undefined` if not found.
+     */
+    async tryUndeleteByQuery(query, options, metadataUpdate) {
+        if (!this.hasMetadata) {
+            return undefined;
+        }
+        const undeleteQuery = and(this.convertQuery(query, { withDeleted: true, ...options }), isSqlNotNull(this.#baseTableWithMetadata.deleteTimestamp));
+        const update = {
+            metadata: {
+                ...metadataUpdate,
+                deleteTimestamp: null,
+            },
+        };
+        return await this.tryUpdateByQuery(undeleteQuery, update, { withDeleted: true, ...options });
+    }
+    /**
+     * Undeletes multiple entities by their IDs (restores from soft-deleted state).
+     * @param ids An array of entity IDs to undelete.
+     * @param options Optional undelete options.
+     * @param metadataUpdate Optional metadata update to apply during undeletion.
+     * @returns A promise that resolves to an array of the undeleted entities.
+     */
+    async undeleteMany(ids, options, metadataUpdate) {
+        if (ids.length == 0) {
+            return [];
+        }
+        return await this.undeleteManyByQuery(inArray(this.#table.id, ids), options, metadataUpdate);
+    }
+    /**
+     * Undeletes multiple entities matching a query (restores from soft-deleted state).
+     * @param query The query to filter entities.
+     * @param options Optional undelete options.
+     * @param metadataUpdate Optional metadata update to apply during undeletion.
+     * @returns A promise that resolves to an array of the undeleted entities.
+     */
+    async undeleteManyByQuery(query, options, metadataUpdate) {
+        if (!this.hasMetadata) {
+            return [];
+        }
+        const undeleteQuery = and(this.convertQuery(query, { withDeleted: true, ...options }), isSqlNotNull(this.#baseTableWithMetadata.deleteTimestamp));
+        const update = {
+            metadata: {
+                ...metadataUpdate,
+                deleteTimestamp: null,
+            },
+        };
+        return await this.updateManyByQuery(undeleteQuery, update, { withDeleted: true, ...options });
+    }
     /**
      * Hard deletes an entity by its ID (removes from the database).
      * Throws `NotFoundError` if the entity is not found.
@@ -1577,20 +1676,22 @@ let EntityRepository = class EntityRepository extends Transactional {
         }
         return {
             ...mappedUpdate,
-            ...((table == this.#baseTable) ? this._getMetadataUpdate(update) : undefined),
+            ...((table == this.#baseTable) ? this._getMetadataUpdate(update?.metadata) : undefined),
         };
     }
     async _mapUpdate(update, transformContext) {
         return await this._mapToTableUpdate(update, transformContext, this.#table);
     }
     _getMetadataUpdate(update) {
-        return this.hasMetadata
-            ? {
-                attributes: this.getAttributesUpdate(update?.metadata?.attributes),
-                revision: sql `${this.#baseTableWithMetadata.revision} + 1`,
-                revisionTimestamp: TRANSACTION_TIMESTAMP,
-            }
-            : undefined;
+        if (!this.hasMetadata) {
+            return undefined;
+        }
+        return {
+            attributes: this.getAttributesUpdate(update?.attributes),
+            ...(isDefined(update?.deleteTimestamp) ? { deleteTimestamp: update.deleteTimestamp } : {}),
+            revision: sql `${this.#baseTableWithMetadata.revision} + 1`,
+            revisionTimestamp: TRANSACTION_TIMESTAMP,
+        };
     }
     prepareSubclassJoins(includeSubclassesOption) {
         const includeSubclasses = (includeSubclassesOption == true)

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);
+    });
+});

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tstdl/base",
-  "version": "0.93.146",
+  "version": "0.93.147",
   "author": "Patrick Hein",
   "publishConfig": {
     "access": "public"
@@ -152,8 +152,8 @@
     "type-fest": "^5.4"
   },
   "peerDependencies": {
-    "@aws-sdk/client-s3": "^3.999",
-    "@aws-sdk/s3-request-presigner": "^3.999",
+    "@aws-sdk/client-s3": "^3.1000",
+    "@aws-sdk/s3-request-presigner": "^3.1000",
     "@genkit-ai/google-genai": "^1.29",
     "@google-cloud/storage": "^7.19",
     "@toon-format/toon": "^2.1.0",