feat(server): trash asset (#4015)

* refactor(server): delete assets endpoint * fix: formatting * chore: cleanup * chore: open api * chore(mobile): replace DeleteAssetDTO with BulkIdsDTOs * feat: trash an asset * chore(server): formatting * chore: open api * chore: wording * chore: open-api * feat(server): add withDeleted to getAssets queries * WIP: mobile-recycle-bin * feat(server): recycle-bin to system config * feat(web): use recycle-bin system config * chore(server): domain assetcore removed * chore(server): rename recycle-bin to trash * chore(web): rename recycle-bin to trash * chore(server): always send soft deleted assets for getAllByUserId * chore(web): formatting * feat(server): permanent delete assets older than trashed period * feat(web): trash empty placeholder image * feat(server): empty trash * feat(web): empty trash * WIP: mobile-recycle-bin * refactor(server): empty / restore trash to separate endpoint * test(server): handle failures * test(server): fix e2e server-info test * test(server): deletion test refactor * feat(mobile): use map settings from server-config to enable / disable map * feat(mobile): trash asset * fix(server): operations on assets in trash * feat(web): show trash statistics * fix(web): handle trash enabled * fix(mobile): restore updates from trash * fix(server): ignore trashed assets for person * fix(server): add / remove search index when trashed / restored * chore(web): format * fix(server): asset service test * fix(server): include trashed assts for duplicates from uploads * feat(mobile): no dialog for trash, always dialog for permanent delete * refactor(mobile): use isar where instead of dart filter * refactor(mobile): asset provide - handle deletes in single db txn * chore(mobile): review changes * feat(web): confirmation before empty trash * server: review changes * fix(server): handle library changes * fix: filter external assets from getting trashed / deleted * fix(server): empty-bin * feat: broadcast config update events through ws * change order of trash button on mobile * styling * fix(mobile): do not show trashed toast for local only assets --------- Co-authored-by: Jason Rasmussen <jrasm91@gmail.com> Co-authored-by: Alex Tran <alex.tran1502@gmail.com>
2025-12-08 20:29:05 +00:00 · 2023-10-06 07:01:14 +00:00
parent fc93762230
commit 4a8887f37b
117 changed files with 3155 additions and 928 deletions
--- a/server/src/domain/asset/asset.repository.ts
+++ b/server/src/domain/asset/asset.repository.ts
@@ -6,10 +6,12 @@ export type AssetStats = Record<AssetType, number>;
 export interface AssetStatsOptions {
  isFavorite?: boolean;
  isArchived?: boolean;
+  isTrashed?: boolean;
 }

 export interface AssetSearchOptions {
  isVisible?: boolean;
+  trashedBefore?: Date;
  type?: AssetType;
  order?: 'ASC' | 'DESC';
 }
@@ -58,6 +60,7 @@ export interface TimeBucketOptions {
  size: TimeBucketSize;
  isArchived?: boolean;
  isFavorite?: boolean;
+  isTrashed?: boolean;
  albumId?: string;
  personId?: string;
  userId?: string;
@@ -98,7 +101,8 @@ export interface IAssetRepository {
  getByDayOfYear(ownerId: string, monthDay: MonthDay): Promise<AssetEntity[]>;
  getByChecksum(userId: string, checksum: Buffer): Promise<AssetEntity | null>;
  getByAlbumId(pagination: PaginationOptions, albumId: string): Paginated<AssetEntity>;
-  getByUserId(pagination: PaginationOptions, userId: string): Paginated<AssetEntity>;
+  getByUserId(pagination: PaginationOptions, userId: string, options?: AssetSearchOptions): Paginated<AssetEntity>;
+  getById(id: string): Promise<AssetEntity | null>;
  getWithout(pagination: PaginationOptions, property: WithoutProperty): Paginated<AssetEntity>;
  getWith(pagination: PaginationOptions, property: WithProperty, libraryId?: string): Paginated<AssetEntity>;
  getRandom(userId: string, count: number): Promise<AssetEntity[]>;
@@ -110,12 +114,13 @@ export interface IAssetRepository {
  getAll(pagination: PaginationOptions, options?: AssetSearchOptions): Paginated<AssetEntity>;
  updateAll(ids: string[], options: Partial<AssetEntity>): Promise<void>;
  save(asset: Pick<AssetEntity, 'id'> & Partial<AssetEntity>): Promise<AssetEntity>;
+  remove(asset: AssetEntity): Promise<void>;
+  softDeleteAll(ids: string[]): Promise<void>;
+  restoreAll(ids: string[]): Promise<void>;
  findLivePhotoMatch(options: LivePhotoSearchOptions): Promise<AssetEntity | null>;
  getMapMarkers(ownerId: string, options?: MapMarkerSearchOptions): Promise<MapMarker[]>;
  getStatistics(ownerId: string, options: AssetStatsOptions): Promise<AssetStats>;
  getTimeBuckets(options: TimeBucketOptions): Promise<TimeBucketItem[]>;
  getByTimeBucket(timeBucket: string, options: TimeBucketOptions): Promise<AssetEntity[]>;
-  remove(asset: AssetEntity): Promise<AssetEntity>;
-  getById(assetId: string): Promise<AssetEntity>;
  upsertExif(exif: Partial<ExifEntity>): Promise<void>;
 }
--- a/server/src/domain/asset/asset.service.spec.ts
+++ b/server/src/domain/asset/asset.service.spec.ts
@@ -1,20 +1,23 @@
-import { AssetType } from '@app/infra/entities';
+import { AssetEntity, AssetType } from '@app/infra/entities';
 import { BadRequestException, UnauthorizedException } from '@nestjs/common';
 import {
  IAccessRepositoryMock,
  assetStub,
  authStub,
+  faceStub,
  newAccessRepositoryMock,
  newAssetRepositoryMock,
  newCryptoRepositoryMock,
  newJobRepositoryMock,
  newStorageRepositoryMock,
+  newSystemConfigRepositoryMock,
 } from '@test';
 import { when } from 'jest-when';
 import { Readable } from 'stream';
 import { ICryptoRepository } from '../crypto';
-import { IJobRepository, JobName } from '../job';
+import { IJobRepository, JobItem, JobName } from '../job';
 import { IStorageRepository } from '../storage';
+import { ISystemConfigRepository } from '../system-config';
 import { AssetStats, IAssetRepository, TimeBucketSize } from './asset.repository';
 import { AssetService, UploadFieldName } from './asset.service';
 import { AssetJobName, AssetStatsResponseDto, DownloadResponseDto } from './dto';
@@ -150,6 +153,7 @@ describe(AssetService.name, () => {
  let cryptoMock: jest.Mocked<ICryptoRepository>;
  let jobMock: jest.Mocked<IJobRepository>;
  let storageMock: jest.Mocked<IStorageRepository>;
+  let configMock: jest.Mocked<ISystemConfigRepository>;

  it('should work', () => {
    expect(sut).toBeDefined();
@@ -161,7 +165,15 @@ describe(AssetService.name, () => {
    cryptoMock = newCryptoRepositoryMock();
    jobMock = newJobRepositoryMock();
    storageMock = newStorageRepositoryMock();
-    sut = new AssetService(accessMock, assetMock, cryptoMock, jobMock, storageMock);
+    configMock = newSystemConfigRepositoryMock();
+    sut = new AssetService(accessMock, assetMock, cryptoMock, jobMock, configMock, storageMock);
+
+    when(assetMock.getById)
+      .calledWith(assetStub.livePhotoStillAsset.id)
+      .mockResolvedValue(assetStub.livePhotoStillAsset as AssetEntity);
+    when(assetMock.getById)
+      .calledWith(assetStub.livePhotoMotionAsset.id)
+      .mockResolvedValue(assetStub.livePhotoMotionAsset as AssetEntity);
  });

  describe('canUpload', () => {
@@ -476,7 +488,9 @@ describe(AssetService.name, () => {
        downloadResponse,
      );

-      expect(assetMock.getByUserId).toHaveBeenCalledWith({ take: 2500, skip: 0 }, authStub.admin.id);
+      expect(assetMock.getByUserId).toHaveBeenCalledWith({ take: 2500, skip: 0 }, authStub.admin.id, {
+        isVisible: true,
+      });
    });

    it('should split archives by size', async () => {
@@ -596,6 +610,203 @@ describe(AssetService.name, () => {
    });
  });

+  describe('deleteAll', () => {
+    it('should required asset delete access for all ids', async () => {
+      accessMock.asset.hasOwnerAccess.mockResolvedValue(false);
+      await expect(
+        sut.deleteAll(authStub.user1, {
+          ids: ['asset-1'],
+        }),
+      ).rejects.toBeInstanceOf(BadRequestException);
+    });
+
+    it('should force delete a batch of assets', async () => {
+      accessMock.asset.hasOwnerAccess.mockResolvedValue(true);
+
+      await sut.deleteAll(authStub.user1, { ids: ['asset1', 'asset2'], force: true });
+
+      expect(jobMock.queue.mock.calls).toEqual([
+        [{ name: JobName.ASSET_DELETION, data: { id: 'asset1' } }],
+        [{ name: JobName.ASSET_DELETION, data: { id: 'asset2' } }],
+      ]);
+    });
+
+    it('should soft delete a batch of assets', async () => {
+      accessMock.asset.hasOwnerAccess.mockResolvedValue(true);
+
+      await sut.deleteAll(authStub.user1, { ids: ['asset1', 'asset2'], force: false });
+
+      expect(assetMock.softDeleteAll).toHaveBeenCalledWith(['asset1', 'asset2']);
+      expect(jobMock.queue.mock.calls).toEqual([
+        [
+          {
+            name: JobName.SEARCH_REMOVE_ASSET,
+            data: { ids: ['asset1', 'asset2'] },
+          },
+        ],
+      ]);
+    });
+  });
+
+  describe('restoreAll', () => {
+    it('should required asset restore access for all ids', async () => {
+      accessMock.asset.hasOwnerAccess.mockResolvedValue(false);
+      await expect(
+        sut.deleteAll(authStub.user1, {
+          ids: ['asset-1'],
+        }),
+      ).rejects.toBeInstanceOf(BadRequestException);
+    });
+
+    it('should restore a batch of assets', async () => {
+      accessMock.asset.hasOwnerAccess.mockResolvedValue(true);
+
+      await sut.restoreAll(authStub.user1, { ids: ['asset1', 'asset2'] });
+
+      expect(assetMock.restoreAll).toHaveBeenCalledWith(['asset1', 'asset2']);
+      expect(jobMock.queue.mock.calls).toEqual([
+        [
+          {
+            name: JobName.SEARCH_INDEX_ASSET,
+            data: { ids: ['asset1', 'asset2'] },
+          },
+        ],
+      ]);
+    });
+  });
+
+  describe('handleAssetDeletion', () => {
+    beforeEach(() => {
+      when(jobMock.queue)
+        .calledWith(
+          expect.objectContaining({
+            name: JobName.ASSET_DELETION,
+          }),
+        )
+        .mockImplementation(async (item: JobItem) => {
+          const jobData = (item as { data?: any })?.data || {};
+          await sut.handleAssetDeletion(jobData);
+        });
+    });
+
+    it('should remove faces', async () => {
+      const assetWithFace = { ...(assetStub.image as AssetEntity), faces: [faceStub.face1, faceStub.mergeFace1] };
+
+      when(assetMock.getById).calledWith(assetWithFace.id).mockResolvedValue(assetWithFace);
+
+      await sut.handleAssetDeletion({ id: assetWithFace.id });
+
+      expect(jobMock.queue.mock.calls).toEqual([
+        [
+          {
+            name: JobName.SEARCH_REMOVE_FACE,
+            data: { assetId: faceStub.face1.assetId, personId: faceStub.face1.personId },
+          },
+        ],
+        [
+          {
+            name: JobName.SEARCH_REMOVE_FACE,
+            data: { assetId: faceStub.mergeFace1.assetId, personId: faceStub.mergeFace1.personId },
+          },
+        ],
+        [{ name: JobName.SEARCH_REMOVE_ASSET, data: { ids: [assetWithFace.id] } }],
+        [
+          {
+            name: JobName.DELETE_FILES,
+            data: {
+              files: [
+                assetWithFace.webpPath,
+                assetWithFace.resizePath,
+                assetWithFace.encodedVideoPath,
+                assetWithFace.sidecarPath,
+                assetWithFace.originalPath,
+              ],
+            },
+          },
+        ],
+      ]);
+
+      expect(assetMock.remove).toHaveBeenCalledWith(assetWithFace);
+    });
+
+    it('should not schedule delete-files job for readonly assets', async () => {
+      when(assetMock.getById)
+        .calledWith(assetStub.readOnly.id)
+        .mockResolvedValue(assetStub.readOnly as AssetEntity);
+
+      await sut.handleAssetDeletion({ id: assetStub.readOnly.id });
+
+      expect(jobMock.queue.mock.calls).toEqual([
+        [{ name: JobName.SEARCH_REMOVE_ASSET, data: { ids: [assetStub.readOnly.id] } }],
+      ]);
+
+      expect(assetMock.remove).toHaveBeenCalledWith(assetStub.readOnly);
+    });
+
+    it('should not process assets from external library without fromExternal flag', async () => {
+      when(assetMock.getById)
+        .calledWith(assetStub.external.id)
+        .mockResolvedValue(assetStub.external as AssetEntity);
+
+      await sut.handleAssetDeletion({ id: assetStub.external.id });
+
+      expect(jobMock.queue).not.toBeCalled();
+      expect(assetMock.remove).not.toBeCalled();
+    });
+
+    it('should process assets from external library with fromExternal flag', async () => {
+      when(assetMock.getById)
+        .calledWith(assetStub.external.id)
+        .mockResolvedValue(assetStub.external as AssetEntity);
+
+      await sut.handleAssetDeletion({ id: assetStub.external.id, fromExternal: true });
+
+      expect(assetMock.remove).toHaveBeenCalledWith(assetStub.external);
+      expect(jobMock.queue.mock.calls).toEqual([
+        [{ name: JobName.SEARCH_REMOVE_ASSET, data: { ids: [assetStub.external.id] } }],
+        [
+          {
+            name: JobName.DELETE_FILES,
+            data: {
+              files: [
+                assetStub.external.webpPath,
+                assetStub.external.resizePath,
+                assetStub.external.encodedVideoPath,
+                assetStub.external.sidecarPath,
+              ],
+            },
+          },
+        ],
+      ]);
+    });
+
+    it('should delete a live photo', async () => {
+      await sut.handleAssetDeletion({ id: assetStub.livePhotoStillAsset.id });
+
+      expect(jobMock.queue.mock.calls).toEqual([
+        [{ name: JobName.SEARCH_REMOVE_ASSET, data: { ids: [assetStub.livePhotoStillAsset.id] } }],
+        [{ name: JobName.ASSET_DELETION, data: { id: assetStub.livePhotoMotionAsset.id } }],
+        [{ name: JobName.SEARCH_REMOVE_ASSET, data: { ids: [assetStub.livePhotoMotionAsset.id] } }],
+        [
+          {
+            name: JobName.DELETE_FILES,
+            data: {
+              files: [undefined, undefined, undefined, undefined, 'fake_path/asset_1.mp4'],
+            },
+          },
+        ],
+        [
+          {
+            name: JobName.DELETE_FILES,
+            data: {
+              files: [undefined, undefined, undefined, undefined, 'fake_path/asset_1.jpeg'],
+            },
+          },
+        ],
+      ]);
+    });
+  });
+
  describe('run', () => {
    it('should run the refresh metadata job', async () => {
      accessMock.asset.hasOwnerAccess.mockResolvedValue(true);
--- a/server/src/domain/asset/asset.service.ts
+++ b/server/src/domain/asset/asset.service.ts
@@ -1,6 +1,7 @@
-import { AssetEntity } from '@app/infra/entities';
+import { AssetEntity, LibraryType } from '@app/infra/entities';
 import { BadRequestException, Inject, Logger } from '@nestjs/common';
 import _ from 'lodash';
+import { DateTime, Duration } from 'luxon';
 import { extname } from 'path';
 import sanitize from 'sanitize-filename';
 import { AccessCore, IAccessRepository, Permission } from '../access';
@@ -8,10 +9,12 @@ import { AuthUserDto } from '../auth';
 import { ICryptoRepository } from '../crypto';
 import { mimeTypes } from '../domain.constant';
 import { HumanReadableSize, usePagination } from '../domain.util';
-import { IJobRepository, JobName } from '../job';
+import { IAssetDeletionJob, IJobRepository, JOBS_ASSET_PAGINATION_SIZE, JobName } from '../job';
 import { IStorageRepository, ImmichReadStream, StorageCore, StorageFolder } from '../storage';
+import { ISystemConfigRepository, SystemConfigCore } from '../system-config';
 import { IAssetRepository } from './asset.repository';
 import {
+  AssetBulkDeleteDto,
  AssetBulkUpdateDto,
  AssetIdsDto,
  AssetJobName,
@@ -24,11 +27,13 @@ import {
  MemoryLaneDto,
  TimeBucketAssetDto,
  TimeBucketDto,
+  TrashAction,
  UpdateAssetDto,
  mapStats,
 } from './dto';
 import {
  AssetResponseDto,
+  BulkIdsDto,
  MapMarkerResponseDto,
  MemoryLaneResponseDto,
  TimeBucketResponseDto,
@@ -57,6 +62,7 @@ export interface UploadFile {
 export class AssetService {
  private logger = new Logger(AssetService.name);
  private access: AccessCore;
+  private configCore: SystemConfigCore;
  private storageCore: StorageCore;

  constructor(
@@ -64,10 +70,12 @@ export class AssetService {
    @Inject(IAssetRepository) private assetRepository: IAssetRepository,
    @Inject(ICryptoRepository) private cryptoRepository: ICryptoRepository,
    @Inject(IJobRepository) private jobRepository: IJobRepository,
+    @Inject(ISystemConfigRepository) configRepository: ISystemConfigRepository,
    @Inject(IStorageRepository) private storageRepository: IStorageRepository,
  ) {
    this.access = new AccessCore(accessRepository);
    this.storageCore = new StorageCore(storageRepository);
+    this.configCore = new SystemConfigCore(configRepository);
  }

  canUploadFile({ authUser, fieldName, file }: UploadRequest): true {
@@ -274,7 +282,9 @@ export class AssetService {
    if (dto.userId) {
      const userId = dto.userId;
      await this.access.requirePermission(authUser, Permission.TIMELINE_DOWNLOAD, userId);
-      return usePagination(PAGINATION_SIZE, (pagination) => this.assetRepository.getByUserId(pagination, userId));
+      return usePagination(PAGINATION_SIZE, (pagination) =>
+        this.assetRepository.getByUserId(pagination, userId, { isVisible: true }),
+      );
    }

    throw new BadRequestException('assetIds, albumId, or userId is required');
@@ -303,13 +313,119 @@ export class AssetService {
    return mapAsset(asset);
  }

-  async updateAll(authUser: AuthUserDto, dto: AssetBulkUpdateDto) {
+  async updateAll(authUser: AuthUserDto, dto: AssetBulkUpdateDto): Promise<void> {
    const { ids, ...options } = dto;
    await this.access.requirePermission(authUser, Permission.ASSET_UPDATE, ids);
    await this.jobRepository.queue({ name: JobName.SEARCH_INDEX_ASSET, data: { ids } });
    await this.assetRepository.updateAll(ids, options);
  }

+  async handleAssetDeletionCheck() {
+    const config = await this.configCore.getConfig();
+    const trashedDays = config.trash.enabled ? config.trash.days : 0;
+    const trashedBefore = DateTime.now()
+      .minus(Duration.fromObject({ days: trashedDays }))
+      .toJSDate();
+    const assetPagination = usePagination(JOBS_ASSET_PAGINATION_SIZE, (pagination) =>
+      this.assetRepository.getAll(pagination, { trashedBefore }),
+    );
+
+    for await (const assets of assetPagination) {
+      for (const asset of assets) {
+        await this.jobRepository.queue({ name: JobName.ASSET_DELETION, data: { id: asset.id } });
+      }
+    }
+
+    return true;
+  }
+
+  async handleAssetDeletion(job: IAssetDeletionJob) {
+    const { id, fromExternal } = job;
+
+    const asset = await this.assetRepository.getById(id);
+    if (!asset) {
+      return false;
+    }
+
+    // Ignore requests that are not from external library job but is for an external asset
+    if (!fromExternal && (!asset.library || asset.library.type === LibraryType.EXTERNAL)) {
+      return false;
+    }
+
+    if (asset.faces) {
+      await Promise.all(
+        asset.faces.map(({ assetId, personId }) =>
+          this.jobRepository.queue({ name: JobName.SEARCH_REMOVE_FACE, data: { assetId, personId } }),
+        ),
+      );
+    }
+
+    await this.assetRepository.remove(asset);
+    await this.jobRepository.queue({ name: JobName.SEARCH_REMOVE_ASSET, data: { ids: [asset.id] } });
+
+    // TODO refactor this to use cascades
+    if (asset.livePhotoVideoId) {
+      await this.jobRepository.queue({ name: JobName.ASSET_DELETION, data: { id: asset.livePhotoVideoId } });
+    }
+
+    const files = [asset.webpPath, asset.resizePath, asset.encodedVideoPath, asset.sidecarPath];
+    if (!fromExternal) {
+      files.push(asset.originalPath);
+    }
+
+    if (!asset.isReadOnly) {
+      await this.jobRepository.queue({ name: JobName.DELETE_FILES, data: { files } });
+    }
+
+    return true;
+  }
+
+  async deleteAll(authUser: AuthUserDto, dto: AssetBulkDeleteDto): Promise<void> {
+    const { ids, force } = dto;
+
+    await this.access.requirePermission(authUser, Permission.ASSET_DELETE, ids);
+
+    if (force) {
+      for (const id of ids) {
+        await this.jobRepository.queue({ name: JobName.ASSET_DELETION, data: { id } });
+      }
+    } else {
+      await this.assetRepository.softDeleteAll(ids);
+      await this.jobRepository.queue({ name: JobName.SEARCH_REMOVE_ASSET, data: { ids } });
+    }
+  }
+
+  async handleTrashAction(authUser: AuthUserDto, action: TrashAction): Promise<void> {
+    const assetPagination = usePagination(JOBS_ASSET_PAGINATION_SIZE, (pagination) =>
+      this.assetRepository.getByUserId(pagination, authUser.id, { trashedBefore: DateTime.now().toJSDate() }),
+    );
+
+    if (action == TrashAction.RESTORE_ALL) {
+      for await (const assets of assetPagination) {
+        const ids = assets.map((a) => a.id);
+        await this.assetRepository.restoreAll(ids);
+        await this.jobRepository.queue({ name: JobName.SEARCH_INDEX_ASSET, data: { ids } });
+      }
+      return;
+    }
+
+    if (action == TrashAction.EMPTY_ALL) {
+      for await (const assets of assetPagination) {
+        for (const asset of assets) {
+          await this.jobRepository.queue({ name: JobName.ASSET_DELETION, data: { id: asset.id } });
+        }
+      }
+      return;
+    }
+  }
+
+  async restoreAll(authUser: AuthUserDto, dto: BulkIdsDto): Promise<void> {
+    const { ids } = dto;
+    await this.access.requirePermission(authUser, Permission.ASSET_RESTORE, ids);
+    await this.assetRepository.restoreAll(ids);
+    await this.jobRepository.queue({ name: JobName.SEARCH_INDEX_ASSET, data: { ids } });
+  }
+
  async run(authUser: AuthUserDto, dto: AssetJobsDto) {
    await this.access.requirePermission(authUser, Permission.ASSET_UPDATE, dto.assetIds);

--- a/server/src/domain/asset/dto/asset-statistics.dto.ts
+++ b/server/src/domain/asset/dto/asset-statistics.dto.ts
@@ -15,6 +15,11 @@ export class AssetStatsDto {
  @Transform(toBoolean)
  @Optional()
  isFavorite?: boolean;
+
+  @IsBoolean()
+  @Transform(toBoolean)
+  @Optional()
+  isTrashed?: boolean;
 }

 export class AssetStatsResponseDto {
--- a/server/src/domain/asset/dto/asset.dto.ts
+++ b/server/src/domain/asset/dto/asset.dto.ts
@@ -34,3 +34,14 @@ export class RandomAssetsDto {
  @Type(() => Number)
  count?: number;
 }
+
+export enum TrashAction {
+  EMPTY_ALL = 'empty-all',
+  RESTORE_ALL = 'restore-all',
+}
+
+export class AssetBulkDeleteDto extends BulkIdsDto {
+  @Optional()
+  @IsBoolean()
+  force?: boolean;
+}
--- a/server/src/domain/asset/dto/time-bucket.dto.ts
+++ b/server/src/domain/asset/dto/time-bucket.dto.ts
@@ -28,6 +28,11 @@ export class TimeBucketDto {
  @IsBoolean()
  @Transform(toBoolean)
  isFavorite?: boolean;
+
+  @Optional()
+  @IsBoolean()
+  @Transform(toBoolean)
+  isTrashed?: boolean;
 }

 export class TimeBucketAssetDto extends TimeBucketDto {
--- a/server/src/domain/asset/response-dto/asset-response.dto.ts
+++ b/server/src/domain/asset/response-dto/asset-response.dto.ts
@@ -26,6 +26,7 @@ export class AssetResponseDto {
  updatedAt!: Date;
  isFavorite!: boolean;
  isArchived!: boolean;
+  isTrashed!: boolean;
  localDateTime!: Date;
  isOffline!: boolean;
  isExternal!: boolean;
@@ -59,6 +60,7 @@ function _map(entity: AssetEntity, withExif: boolean): AssetResponseDto {
    updatedAt: entity.updatedAt,
    isFavorite: entity.isFavorite,
    isArchived: entity.isArchived,
+    isTrashed: !!entity.deletedAt,
    duration: entity.duration ?? '0:00:00.00000',
    exifInfo: withExif ? (entity.exifInfo ? mapExif(entity.exifInfo) : undefined) : undefined,
    smartInfo: entity.smartInfo ? mapSmartInfo(entity.smartInfo) : undefined,