Merge remote-tracking branch 'origin/main' into feat/integrity-checks-izzy

Signed-off-by: izzy <me@insrt.uk>

server/test/fixtures/asset.stub.ts

@@ -48,9 +48,9 @@ const editedFullsizeFile = factory.assetFile({
   isEdited: true,
 });
 
-const files: AssetFile[] = [fullsizeFile, previewFile, thumbnailFile];
+const files = [fullsizeFile, previewFile, thumbnailFile];
 
-const editedFiles: AssetFile[] = [
+const editedFiles = [
   fullsizeFile,
   previewFile,
   thumbnailFile,
@@ -624,14 +624,19 @@ export const assetStub = {
       fileSizeInByte: 100_000,
       timeZone: `America/New_York`,
     },
-    files: [] as AssetFile[],
+    files: [],
     libraryId: null,
     visibility: AssetVisibility.Hidden,
     width: null,
     height: null,
     edits: [] as AssetEditActionItem[],
     isEdited: false,
-  } as MapAsset & { faces: AssetFace[]; files: AssetFile[]; exifInfo: Exif; edits: AssetEditActionItem[] }),
+  } as unknown as MapAsset & {
+    faces: AssetFace[];
+    files: (AssetFile & { isProgressive: boolean })[];
+    exifInfo: Exif;
+    edits: AssetEditActionItem[];
+  }),
 
   livePhotoStillAsset: Object.freeze({
     id: 'live-photo-still-asset',
@@ -653,7 +658,11 @@ export const assetStub = {
     height: null,
     edits: [] as AssetEditActionItem[],
     isEdited: false,
-  } as MapAsset & { faces: AssetFace[]; files: AssetFile[]; edits: AssetEditActionItem[] }),
+  } as unknown as MapAsset & {
+    faces: AssetFace[];
+    files: (AssetFile & { isProgressive: boolean })[];
+    edits: AssetEditActionItem[];
+  }),
 
   livePhotoWithOriginalFileName: Object.freeze({
     id: 'live-photo-still-asset',

server/test/medium.factory.ts

@@ -6,6 +6,7 @@ import { Stats } from 'node:fs';
 import { Writable } from 'node:stream';
 import { AssetFace } from 'src/database';
 import { AuthDto, LoginResponseDto } from 'src/dtos/auth.dto';
+import { AssetEditActionListDto } from 'src/dtos/editing.dto';
 import {
   AlbumUserRole,
   AssetType,
@@ -280,6 +281,11 @@ export class MediumTestContext<S extends BaseService = BaseService> {
     const result = await this.get(TagRepository).upsertAssetIds(tagsAssets);
     return { tagsAssets, result };
   }
+
+  async newEdits(assetId: string, dto: AssetEditActionListDto) {
+    const edits = await this.get(AssetEditRepository).replaceAll(assetId, dto.edits);
+    return { edits };
+  }
 }
 
 export class SyncTestContext extends MediumTestContext<SyncService> {
@@ -601,8 +607,6 @@ const assetJobStatusInsert = (
     duplicatesDetectedAt: date,
     facesRecognizedAt: date,
     metadataExtractedAt: date,
-    previewAt: date,
-    thumbnailAt: date,
   };
 
   return {

server/test/medium/specs/services/asset-media.service.spec.ts

@@ -1,5 +1,7 @@
 import { Kysely } from 'kysely';
 import { AssetMediaStatus } from 'src/dtos/asset-media-response.dto';
+import { AssetMediaSize } from 'src/dtos/asset-media.dto';
+import { AssetFileType } from 'src/enum';
 import { AccessRepository } from 'src/repositories/access.repository';
 import { AssetRepository } from 'src/repositories/asset.repository';
 import { EventRepository } from 'src/repositories/event.repository';
@@ -10,6 +12,7 @@ import { UserRepository } from 'src/repositories/user.repository';
 import { DB } from 'src/schema';
 import { AssetMediaService } from 'src/services/asset-media.service';
 import { AssetService } from 'src/services/asset.service';
+import { ImmichFileResponse } from 'src/utils/file';
 import { mediumFactory, newMediumService } from 'test/medium.factory';
 import { factory } from 'test/small.factory';
 import { getKyselyDB } from 'test/utils';
@@ -97,4 +100,162 @@ describe(AssetService.name, () => {
       });
     });
   });
+
+  describe('viewThumbnail', () => {
+    it('should return original thumbnail by default when both exist', async () => {
+      const { sut, ctx } = setup();
+
+      const { user } = await ctx.newUser();
+      const { asset } = await ctx.newAsset({ ownerId: user.id });
+
+      // Create both original and edited thumbnails
+      await ctx.newAssetFile({
+        assetId: asset.id,
+        type: AssetFileType.Preview,
+        path: '/original/preview.jpg',
+        isEdited: false,
+      });
+      await ctx.newAssetFile({
+        assetId: asset.id,
+        type: AssetFileType.Preview,
+        path: '/edited/preview.jpg',
+        isEdited: true,
+      });
+
+      const auth = factory.auth({ user: { id: user.id } });
+      const result = await sut.viewThumbnail(auth, asset.id, { size: AssetMediaSize.PREVIEW });
+
+      expect(result).toBeInstanceOf(ImmichFileResponse);
+      expect((result as ImmichFileResponse).path).toBe('/original/preview.jpg');
+    });
+
+    it('should return edited thumbnail when edited=true', async () => {
+      const { sut, ctx } = setup();
+
+      const { user } = await ctx.newUser();
+      const { asset } = await ctx.newAsset({ ownerId: user.id });
+
+      // Create both original and edited thumbnails
+      await ctx.newAssetFile({
+        assetId: asset.id,
+        type: AssetFileType.Preview,
+        path: '/original/preview.jpg',
+        isEdited: false,
+      });
+      await ctx.newAssetFile({
+        assetId: asset.id,
+        type: AssetFileType.Preview,
+        path: '/edited/preview.jpg',
+        isEdited: true,
+      });
+
+      const auth = factory.auth({ user: { id: user.id } });
+      const result = await sut.viewThumbnail(auth, asset.id, { size: AssetMediaSize.PREVIEW, edited: true });
+
+      expect(result).toBeInstanceOf(ImmichFileResponse);
+      expect((result as ImmichFileResponse).path).toBe('/edited/preview.jpg');
+    });
+
+    it('should return original thumbnail when edited=false', async () => {
+      const { sut, ctx } = setup();
+
+      const { user } = await ctx.newUser();
+      const { asset } = await ctx.newAsset({ ownerId: user.id });
+
+      // Create both original and edited thumbnails
+      await ctx.newAssetFile({
+        assetId: asset.id,
+        type: AssetFileType.Preview,
+        path: '/original/preview.jpg',
+        isEdited: false,
+      });
+      await ctx.newAssetFile({
+        assetId: asset.id,
+        type: AssetFileType.Preview,
+        path: '/edited/preview.jpg',
+        isEdited: true,
+      });
+
+      const auth = factory.auth({ user: { id: user.id } });
+      const result = await sut.viewThumbnail(auth, asset.id, { size: AssetMediaSize.PREVIEW, edited: false });
+
+      expect(result).toBeInstanceOf(ImmichFileResponse);
+      expect((result as ImmichFileResponse).path).toBe('/original/preview.jpg');
+    });
+
+    it('should return original thumbnail when only original exists and edited=false', async () => {
+      const { sut, ctx } = setup();
+
+      const { user } = await ctx.newUser();
+      const { asset } = await ctx.newAsset({ ownerId: user.id });
+
+      // Create only original thumbnail
+      await ctx.newAssetFile({
+        assetId: asset.id,
+        type: AssetFileType.Preview,
+        path: '/original/preview.jpg',
+        isEdited: false,
+      });
+
+      const auth = factory.auth({ user: { id: user.id } });
+      const result = await sut.viewThumbnail(auth, asset.id, { size: AssetMediaSize.PREVIEW, edited: false });
+
+      expect(result).toBeInstanceOf(ImmichFileResponse);
+      expect((result as ImmichFileResponse).path).toBe('/original/preview.jpg');
+    });
+
+    it('should return original thumbnail when only original exists and edited=true', async () => {
+      const { sut, ctx } = setup();
+
+      const { user } = await ctx.newUser();
+      const { asset } = await ctx.newAsset({ ownerId: user.id });
+
+      // Create only original thumbnail
+      await ctx.newAssetFile({
+        assetId: asset.id,
+        type: AssetFileType.Preview,
+        path: '/original/preview.jpg',
+        isEdited: false,
+      });
+
+      const auth = factory.auth({ user: { id: user.id } });
+      const result = await sut.viewThumbnail(auth, asset.id, { size: AssetMediaSize.PREVIEW, edited: true });
+
+      expect(result).toBeInstanceOf(ImmichFileResponse);
+      expect((result as ImmichFileResponse).path).toBe('/original/preview.jpg');
+    });
+
+    it('should work with thumbnail size', async () => {
+      const { sut, ctx } = setup();
+
+      const { user } = await ctx.newUser();
+      const { asset } = await ctx.newAsset({ ownerId: user.id });
+
+      // Create both original and edited thumbnails
+      await ctx.newAssetFile({
+        assetId: asset.id,
+        type: AssetFileType.Thumbnail,
+        path: '/original/thumbnail.jpg',
+        isEdited: false,
+      });
+      await ctx.newAssetFile({
+        assetId: asset.id,
+        type: AssetFileType.Thumbnail,
+        path: '/edited/thumbnail.jpg',
+        isEdited: true,
+      });
+
+      const auth = factory.auth({ user: { id: user.id } });
+
+      // Test default (should get original)
+      const resultDefault = await sut.viewThumbnail(auth, asset.id, { size: AssetMediaSize.THUMBNAIL });
+      expect(resultDefault).toBeInstanceOf(ImmichFileResponse);
+      expect((resultDefault as ImmichFileResponse).path).toBe('/original/thumbnail.jpg');
+
+      // Test edited=true (should get edited)
+      const resultEdited = await sut.viewThumbnail(auth, asset.id, { size: AssetMediaSize.THUMBNAIL, edited: true });
+      expect(resultEdited).toBeInstanceOf(ImmichFileResponse);
+      expect((resultEdited as ImmichFileResponse).path).toBe('/edited/thumbnail.jpg');
+    });
+  });
 });

server/test/medium/specs/services/asset.service.spec.ts

@@ -1,5 +1,5 @@
 import { Kysely } from 'kysely';
-import { AssetFileType, AssetMetadataKey, JobName, SharedLinkType } from 'src/enum';
+import { AssetFileType, AssetMetadataKey, AssetStatus, JobName, SharedLinkType } from 'src/enum';
 import { AccessRepository } from 'src/repositories/access.repository';
 import { AlbumRepository } from 'src/repositories/album.repository';
 import { AssetJobRepository } from 'src/repositories/asset-job.repository';
@@ -246,6 +246,66 @@ describe(AssetService.name, () => {
       });
     });
 
+    it('should delete a stacked primary asset (2 assets)', async () => {
+      const { sut, ctx } = setup();
+      ctx.getMock(EventRepository).emit.mockResolvedValue();
+      ctx.getMock(JobRepository).queue.mockResolvedValue();
+      const { user } = await ctx.newUser();
+      const { asset: asset1 } = await ctx.newAsset({ ownerId: user.id });
+      const { asset: asset2 } = await ctx.newAsset({ ownerId: user.id });
+      const { stack, result } = await ctx.newStack({ ownerId: user.id }, [asset1.id, asset2.id]);
+
+      const stackRepo = ctx.get(StackRepository);
+
+      expect(result).toMatchObject({ primaryAssetId: asset1.id });
+
+      await sut.handleAssetDeletion({ id: asset1.id, deleteOnDisk: true });
+
+      // stack is deleted as well
+      await expect(stackRepo.getById(stack.id)).resolves.toBe(undefined);
+    });
+
+    it('should delete a stacked primary asset (3 assets)', async () => {
+      const { sut, ctx } = setup();
+      ctx.getMock(EventRepository).emit.mockResolvedValue();
+      ctx.getMock(JobRepository).queue.mockResolvedValue();
+      const { user } = await ctx.newUser();
+      const { asset: asset1 } = await ctx.newAsset({ ownerId: user.id });
+      const { asset: asset2 } = await ctx.newAsset({ ownerId: user.id });
+      const { asset: asset3 } = await ctx.newAsset({ ownerId: user.id });
+      const { stack, result } = await ctx.newStack({ ownerId: user.id }, [asset1.id, asset2.id, asset3.id]);
+
+      expect(result).toMatchObject({ primaryAssetId: asset1.id });
+
+      await sut.handleAssetDeletion({ id: asset1.id, deleteOnDisk: true });
+
+      // new primary asset is picked
+      await expect(ctx.get(StackRepository).getById(stack.id)).resolves.toMatchObject({ primaryAssetId: asset2.id });
+    });
+
+    it('should delete a stacked primary asset (3 trashed assets)', async () => {
+      const { sut, ctx } = setup();
+      ctx.getMock(EventRepository).emit.mockResolvedValue();
+      ctx.getMock(JobRepository).queue.mockResolvedValue();
+      const { user } = await ctx.newUser();
+      const { asset: asset1 } = await ctx.newAsset({ ownerId: user.id });
+      const { asset: asset2 } = await ctx.newAsset({ ownerId: user.id });
+      const { asset: asset3 } = await ctx.newAsset({ ownerId: user.id });
+      const { stack, result } = await ctx.newStack({ ownerId: user.id }, [asset1.id, asset2.id, asset3.id]);
+
+      await ctx.get(AssetRepository).updateAll([asset1.id, asset2.id, asset3.id], {
+        deletedAt: new Date(),
+        status: AssetStatus.Deleted,
+      });
+
+      expect(result).toMatchObject({ primaryAssetId: asset1.id });
+
+      await sut.handleAssetDeletion({ id: asset1.id, deleteOnDisk: true });
+
+      // stack is deleted as well
+      await expect(ctx.get(StackRepository).getById(stack.id)).resolves.toBe(undefined);
+    });
+
     it('should not delete offline assets', async () => {
       const { sut, ctx } = setup();
       ctx.getMock(EventRepository).emit.mockResolvedValue();
@@ -396,6 +456,47 @@ describe(AssetService.name, () => {
       );
     });
 
+    it('should relatively update an assets with timezone', async () => {
+      const { sut, ctx } = setup();
+      ctx.getMock(JobRepository).queueAll.mockResolvedValue();
+      const { user } = await ctx.newUser();
+      const auth = factory.auth({ user });
+      const { asset } = await ctx.newAsset({ ownerId: user.id });
+      await ctx.newExif({ assetId: asset.id, dateTimeOriginal: '2023-11-19T18:11:00', timeZone: 'UTC+5' });
+
+      await sut.updateAll(auth, { ids: [asset.id], dateTimeRelative: -1441 });
+
+      await expect(ctx.get(AssetRepository).getById(asset.id, { exifInfo: true })).resolves.toEqual(
+        expect.objectContaining({
+          exifInfo: expect.objectContaining({
+            dateTimeOriginal: '2023-11-18T18:10:00+00:00',
+            timeZone: 'UTC+5',
+            lockedProperties: ['timeZone', 'dateTimeOriginal'],
+          }),
+        }),
+      );
+    });
+
+    it('should relatively update an assets and set a timezone', async () => {
+      const { sut, ctx } = setup();
+      ctx.getMock(JobRepository).queueAll.mockResolvedValue();
+      const { user } = await ctx.newUser();
+      const auth = factory.auth({ user });
+      const { asset } = await ctx.newAsset({ ownerId: user.id });
+      await ctx.newExif({ assetId: asset.id, dateTimeOriginal: '2023-11-19T18:11:00' });
+
+      await sut.updateAll(auth, { ids: [asset.id], dateTimeRelative: -11, timeZone: 'UTC+5' });
+
+      await expect(ctx.get(AssetRepository).getById(asset.id, { exifInfo: true })).resolves.toEqual(
+        expect.objectContaining({
+          exifInfo: expect.objectContaining({
+            dateTimeOriginal: '2023-11-19T18:00:00+00:00',
+            timeZone: 'UTC+5',
+          }),
+        }),
+      );
+    });
+
     it('should update dateTimeOriginal', async () => {
       const { sut, ctx } = setup();
       ctx.getMock(JobRepository).queueAll.mockResolvedValue();

server/test/medium/specs/services/person.service.spec.ts

@@ -1,5 +1,9 @@
 import { Kysely } from 'kysely';
+import { AssetEditAction, MirrorAxis } from 'src/dtos/editing.dto';
+import { AssetFaceCreateDto } from 'src/dtos/person.dto';
 import { AccessRepository } from 'src/repositories/access.repository';
+import { AssetEditRepository } from 'src/repositories/asset-edit.repository';
+import { AssetRepository } from 'src/repositories/asset.repository';
 import { DatabaseRepository } from 'src/repositories/database.repository';
 import { LoggingRepository } from 'src/repositories/logging.repository';
 import { PersonRepository } from 'src/repositories/person.repository';
@@ -15,7 +19,7 @@ let defaultDatabase: Kysely<DB>;
 const setup = (db?: Kysely<DB>) => {
   return newMediumService(PersonService, {
     database: db || defaultDatabase,
-    real: [AccessRepository, DatabaseRepository, PersonRepository],
+    real: [AccessRepository, DatabaseRepository, PersonRepository, AssetRepository, AssetEditRepository],
     mock: [LoggingRepository, StorageRepository],
   });
 };
@@ -77,4 +81,609 @@ describe(PersonService.name, () => {
       expect(storageMock.unlink).toHaveBeenCalledWith(person2.thumbnailPath);
     });
   });
+
+  describe('createFace', () => {
+    it('should store and retrieve the face as-is when there are no edits', async () => {
+      const { sut, ctx } = setup();
+      const { user } = await ctx.newUser();
+      const { person } = await ctx.newPerson({ ownerId: user.id });
+      const { asset } = await ctx.newAsset({ id: factory.uuid(), ownerId: user.id, width: 200, height: 200 });
+      await ctx.newExif({ assetId: asset.id, exifImageHeight: 200, exifImageWidth: 200 });
+
+      const auth = factory.auth({ user });
+
+      const dto: AssetFaceCreateDto = {
+        imageWidth: 200,
+        imageHeight: 200,
+        x: 50,
+        y: 50,
+        width: 150,
+        height: 150,
+        personId: person.id,
+        assetId: asset.id,
+      };
+
+      await sut.createFace(auth, dto);
+
+      // retrieve an asset's faces
+      const faces = sut.getFacesById(auth, { id: asset.id });
+
+      await expect(faces).resolves.toHaveLength(1);
+      await expect(faces).resolves.toEqual(
+        expect.arrayContaining([
+          expect.objectContaining({
+            person: expect.objectContaining({ id: person.id }),
+            boundingBoxX1: 50,
+            boundingBoxY1: 50,
+            boundingBoxX2: 200,
+            boundingBoxY2: 200,
+          }),
+        ]),
+      );
+    });
+
+    it('should properly transform the coordinates when the asset is edited (Crop)', async () => {
+      const { sut, ctx } = setup();
+      const { user } = await ctx.newUser();
+      const { person } = await ctx.newPerson({ ownerId: user.id });
+      const { asset } = await ctx.newAsset({ id: factory.uuid(), ownerId: user.id, width: 150, height: 200 });
+      await ctx.newExif({ assetId: asset.id, exifImageHeight: 200, exifImageWidth: 200 });
+
+      await ctx.newEdits(asset.id, {
+        edits: [
+          {
+            action: AssetEditAction.Crop,
+            parameters: {
+              x: 50,
+              y: 50,
+              width: 150,
+              height: 200,
+            },
+          },
+        ],
+      });
+
+      const auth = factory.auth({ user });
+
+      const dto: AssetFaceCreateDto = {
+        imageWidth: 150,
+        imageHeight: 200,
+        x: 0,
+        y: 0,
+        width: 100,
+        height: 100,
+        personId: person.id,
+        assetId: asset.id,
+      };
+
+      await sut.createFace(auth, dto);
+
+      // retrieve an asset's faces
+      const faces = sut.getFacesById(auth, { id: asset.id });
+
+      await expect(faces).resolves.toHaveLength(1);
+      await expect(faces).resolves.toEqual(
+        expect.arrayContaining([
+          expect.objectContaining({
+            person: expect.objectContaining({ id: person.id }),
+            boundingBoxX1: 0,
+            boundingBoxY1: 0,
+            boundingBoxX2: 100,
+            boundingBoxY2: 100,
+          }),
+        ]),
+      );
+
+      // remove edits and verify the stored coordinates map to the original image
+      await ctx.newEdits(asset.id, { edits: [] });
+
+      const facesAfterRemovingEdits = sut.getFacesById(auth, { id: asset.id });
+
+      await expect(facesAfterRemovingEdits).resolves.toHaveLength(1);
+      await expect(facesAfterRemovingEdits).resolves.toEqual(
+        expect.arrayContaining([
+          expect.objectContaining({
+            person: expect.objectContaining({ id: person.id }),
+            boundingBoxX1: 50,
+            boundingBoxY1: 50,
+            boundingBoxX2: 150,
+            boundingBoxY2: 150,
+          }),
+        ]),
+      );
+    });
+
+    it('should properly transform the coordinates when the asset is edited (Rotate 90)', async () => {
+      const { sut, ctx } = setup();
+      const { user } = await ctx.newUser();
+      const { person } = await ctx.newPerson({ ownerId: user.id });
+      const { asset } = await ctx.newAsset({ id: factory.uuid(), ownerId: user.id, width: 100, height: 200 });
+      await ctx.newExif({ assetId: asset.id, exifImageWidth: 200, exifImageHeight: 100 });
+
+      await ctx.newEdits(asset.id, {
+        edits: [
+          {
+            action: AssetEditAction.Rotate,
+            parameters: {
+              angle: 90,
+            },
+          },
+        ],
+      });
+
+      const auth = factory.auth({ user });
+
+      const dto: AssetFaceCreateDto = {
+        imageWidth: 100,
+        imageHeight: 200,
+        x: 25,
+        y: 50,
+        width: 10,
+        height: 10,
+        personId: person.id,
+        assetId: asset.id,
+      };
+
+      await sut.createFace(auth, dto);
+
+      const faces = sut.getFacesById(auth, { id: asset.id });
+      await expect(faces).resolves.toHaveLength(1);
+      await expect(faces).resolves.toEqual(
+        expect.arrayContaining([
+          expect.objectContaining({
+            person: expect.objectContaining({ id: person.id }),
+            boundingBoxX1: expect.closeTo(25, 1),
+            boundingBoxY1: expect.closeTo(50, 1),
+            boundingBoxX2: expect.closeTo(35, 1),
+            boundingBoxY2: expect.closeTo(60, 1),
+          }),
+        ]),
+      );
+
+      // remove edits and verify the stored coordinates map to the original image
+      await ctx.newEdits(asset.id, { edits: [] });
+      const facesAfterRemovingEdits = sut.getFacesById(auth, { id: asset.id });
+
+      await expect(facesAfterRemovingEdits).resolves.toEqual(
+        expect.arrayContaining([
+          expect.objectContaining({
+            person: expect.objectContaining({ id: person.id }),
+            boundingBoxX1: 50,
+            boundingBoxY1: 65,
+            boundingBoxX2: 60,
+            boundingBoxY2: 75,
+          }),
+        ]),
+      );
+    });
+
+    it('should properly transform the coordinates when the asset is edited (Mirror Horizontal)', async () => {
+      const { sut, ctx } = setup();
+      const { user } = await ctx.newUser();
+      const { person } = await ctx.newPerson({ ownerId: user.id });
+      const { asset } = await ctx.newAsset({ id: factory.uuid(), ownerId: user.id, width: 200, height: 100 });
+      await ctx.newExif({ assetId: asset.id, exifImageHeight: 100, exifImageWidth: 200 });
+
+      await ctx.newEdits(asset.id, {
+        edits: [
+          {
+            action: AssetEditAction.Mirror,
+            parameters: {
+              axis: MirrorAxis.Horizontal,
+            },
+          },
+        ],
+      });
+
+      const auth = factory.auth({ user });
+
+      const dto: AssetFaceCreateDto = {
+        imageWidth: 200,
+        imageHeight: 100,
+        x: 50,
+        y: 25,
+        width: 100,
+        height: 50,
+        personId: person.id,
+        assetId: asset.id,
+      };
+
+      await sut.createFace(auth, dto);
+
+      const faces = sut.getFacesById(auth, { id: asset.id });
+      await expect(faces).resolves.toHaveLength(1);
+      await expect(faces).resolves.toEqual(
+        expect.arrayContaining([
+          expect.objectContaining({
+            person: expect.objectContaining({ id: person.id }),
+            boundingBoxX1: 50,
+            boundingBoxY1: 25,
+            boundingBoxX2: 150,
+            boundingBoxY2: 75,
+          }),
+        ]),
+      );
+
+      // remove edits and verify the stored coordinates map to the original image
+      await ctx.newEdits(asset.id, { edits: [] });
+      const facesAfterRemovingEdits = sut.getFacesById(auth, { id: asset.id });
+
+      await expect(facesAfterRemovingEdits).resolves.toEqual(
+        expect.arrayContaining([
+          expect.objectContaining({
+            person: expect.objectContaining({ id: person.id }),
+            boundingBoxX1: 50,
+            boundingBoxY1: 25,
+            boundingBoxX2: 150,
+            boundingBoxY2: 75,
+          }),
+        ]),
+      );
+    });
+
+    it('should properly transform the coordinates when the asset is edited (Crop + Rotate)', async () => {
+      const { sut, ctx } = setup();
+      const { user } = await ctx.newUser();
+      const { person } = await ctx.newPerson({ ownerId: user.id });
+      const { asset } = await ctx.newAsset({ id: factory.uuid(), ownerId: user.id, width: 200, height: 150 });
+      await ctx.newExif({ assetId: asset.id, exifImageHeight: 200, exifImageWidth: 200 });
+
+      await ctx.newEdits(asset.id, {
+        edits: [
+          {
+            action: AssetEditAction.Crop,
+            parameters: {
+              x: 50,
+              y: 0,
+              width: 150,
+              height: 200,
+            },
+          },
+          {
+            action: AssetEditAction.Rotate,
+            parameters: {
+              angle: 90,
+            },
+          },
+        ],
+      });
+
+      const auth = factory.auth({ user });
+
+      const dto: AssetFaceCreateDto = {
+        imageWidth: 200,
+        imageHeight: 150,
+        x: 50,
+        y: 25,
+        width: 10,
+        height: 20,
+        personId: person.id,
+        assetId: asset.id,
+      };
+
+      await sut.createFace(auth, dto);
+
+      const faces = sut.getFacesById(auth, { id: asset.id });
+      await expect(faces).resolves.toHaveLength(1);
+      await expect(faces).resolves.toEqual(
+        expect.arrayContaining([
+          expect.objectContaining({
+            person: expect.objectContaining({ id: person.id }),
+            boundingBoxX1: expect.closeTo(50, 1),
+            boundingBoxY1: expect.closeTo(25, 1),
+            boundingBoxX2: expect.closeTo(60, 1),
+            boundingBoxY2: expect.closeTo(45, 1),
+          }),
+        ]),
+      );
+
+      // remove edits and verify the stored coordinates map to the original image
+      await ctx.newEdits(asset.id, { edits: [] });
+      const facesAfterRemovingEdits = sut.getFacesById(auth, { id: asset.id });
+
+      await expect(facesAfterRemovingEdits).resolves.toEqual(
+        expect.arrayContaining([
+          expect.objectContaining({
+            person: expect.objectContaining({ id: person.id }),
+            boundingBoxX1: 75,
+            boundingBoxY1: 140,
+            boundingBoxX2: 95,
+            boundingBoxY2: 150,
+          }),
+        ]),
+      );
+    });
+
+    it('should properly transform the coordinates when the asset is edited (Crop + Mirror)', async () => {
+      const { sut, ctx } = setup();
+      const { user } = await ctx.newUser();
+      const { person } = await ctx.newPerson({ ownerId: user.id });
+      const { asset } = await ctx.newAsset({ id: factory.uuid(), ownerId: user.id, width: 150, height: 100 });
+      await ctx.newExif({ assetId: asset.id, exifImageHeight: 100, exifImageWidth: 200 });
+
+      await ctx.newEdits(asset.id, {
+        edits: [
+          {
+            action: AssetEditAction.Crop,
+            parameters: {
+              x: 50,
+              y: 0,
+              width: 150,
+              height: 100,
+            },
+          },
+          {
+            action: AssetEditAction.Mirror,
+            parameters: {
+              axis: MirrorAxis.Horizontal,
+            },
+          },
+        ],
+      });
+
+      const auth = factory.auth({ user });
+
+      const dto: AssetFaceCreateDto = {
+        imageWidth: 150,
+        imageHeight: 100,
+        x: 25,
+        y: 25,
+        width: 75,
+        height: 50,
+        personId: person.id,
+        assetId: asset.id,
+      };
+
+      await sut.createFace(auth, dto);
+
+      const faces = sut.getFacesById(auth, { id: asset.id });
+      await expect(faces).resolves.toHaveLength(1);
+      await expect(faces).resolves.toEqual(
+        expect.arrayContaining([
+          expect.objectContaining({
+            person: expect.objectContaining({ id: person.id }),
+            boundingBoxX1: 25,
+            boundingBoxY1: 25,
+            boundingBoxX2: 100,
+            boundingBoxY2: 75,
+          }),
+        ]),
+      );
+
+      // remove edits and verify the stored coordinates map to the original image
+      await ctx.newEdits(asset.id, { edits: [] });
+      const facesAfterRemovingEdits = sut.getFacesById(auth, { id: asset.id });
+
+      await expect(facesAfterRemovingEdits).resolves.toEqual(
+        expect.arrayContaining([
+          expect.objectContaining({
+            person: expect.objectContaining({ id: person.id }),
+            boundingBoxX1: 100,
+            boundingBoxY1: 25,
+            boundingBoxX2: 175,
+            boundingBoxY2: 75,
+          }),
+        ]),
+      );
+    });
+
+    it('should properly transform the coordinates when the asset is edited (Rotate + Mirror)', async () => {
+      const { sut, ctx } = setup();
+      const { user } = await ctx.newUser();
+      const { person } = await ctx.newPerson({ ownerId: user.id });
+      const { asset } = await ctx.newAsset({ id: factory.uuid(), ownerId: user.id, width: 200, height: 150 });
+      await ctx.newExif({ assetId: asset.id, exifImageHeight: 200, exifImageWidth: 150 });
+
+      await ctx.newEdits(asset.id, {
+        edits: [
+          {
+            action: AssetEditAction.Rotate,
+            parameters: {
+              angle: 90,
+            },
+          },
+          {
+            action: AssetEditAction.Mirror,
+            parameters: {
+              axis: MirrorAxis.Horizontal,
+            },
+          },
+        ],
+      });
+
+      const auth = factory.auth({ user });
+
+      const dto: AssetFaceCreateDto = {
+        imageWidth: 200,
+        imageHeight: 150,
+        x: 50,
+        y: 25,
+        width: 15,
+        height: 20,
+        personId: person.id,
+        assetId: asset.id,
+      };
+
+      await sut.createFace(auth, dto);
+
+      const faces = sut.getFacesById(auth, { id: asset.id });
+      await expect(faces).resolves.toHaveLength(1);
+      await expect(faces).resolves.toEqual(
+        expect.arrayContaining([
+          expect.objectContaining({
+            person: expect.objectContaining({ id: person.id }),
+            boundingBoxX1: expect.closeTo(50, 1),
+            boundingBoxY1: expect.closeTo(25, 1),
+            boundingBoxX2: expect.closeTo(65, 1),
+            boundingBoxY2: expect.closeTo(45, 1),
+          }),
+        ]),
+      );
+
+      // remove edits and verify the stored coordinates map to the original image
+      await ctx.newEdits(asset.id, { edits: [] });
+      const facesAfterRemovingEdits = sut.getFacesById(auth, { id: asset.id });
+
+      await expect(facesAfterRemovingEdits).resolves.toEqual(
+        expect.arrayContaining([
+          expect.objectContaining({
+            person: expect.objectContaining({ id: person.id }),
+            boundingBoxX1: 25,
+            boundingBoxY1: 50,
+            boundingBoxX2: 45,
+            boundingBoxY2: 65,
+          }),
+        ]),
+      );
+    });
+
+    it('should properly transform the coordinates when the asset is edited (Crop + Rotate + Mirror)', async () => {
+      const { sut, ctx } = setup();
+      const { user } = await ctx.newUser();
+      const { person } = await ctx.newPerson({ ownerId: user.id });
+      const { asset } = await ctx.newAsset({ id: factory.uuid(), ownerId: user.id, width: 150, height: 100 });
+      await ctx.newExif({ assetId: asset.id, exifImageHeight: 200, exifImageWidth: 200 });
+
+      await ctx.newEdits(asset.id, {
+        edits: [
+          {
+            action: AssetEditAction.Crop,
+            parameters: {
+              x: 50,
+              y: 25,
+              width: 100,
+              height: 150,
+            },
+          },
+          {
+            action: AssetEditAction.Rotate,
+            parameters: {
+              angle: 270,
+            },
+          },
+          {
+            action: AssetEditAction.Mirror,
+            parameters: {
+              axis: MirrorAxis.Horizontal,
+            },
+          },
+        ],
+      });
+
+      const auth = factory.auth({ user });
+
+      const dto: AssetFaceCreateDto = {
+        imageWidth: 150,
+        imageHeight: 150,
+        x: 25,
+        y: 50,
+        width: 75,
+        height: 50,
+        personId: person.id,
+        assetId: asset.id,
+      };
+
+      await sut.createFace(auth, dto);
+
+      const faces = sut.getFacesById(auth, { id: asset.id });
+      await expect(faces).resolves.toHaveLength(1);
+      await expect(faces).resolves.toEqual(
+        expect.arrayContaining([
+          expect.objectContaining({
+            person: expect.objectContaining({ id: person.id }),
+            boundingBoxX1: expect.closeTo(25, 1),
+            boundingBoxY1: expect.closeTo(50, 1),
+            boundingBoxX2: expect.closeTo(100, 1),
+            boundingBoxY2: expect.closeTo(100, 1),
+          }),
+        ]),
+      );
+
+      // remove edits and verify the stored coordinates map to the original image
+      await ctx.newEdits(asset.id, { edits: [] });
+      const facesAfterRemovingEdits = sut.getFacesById(auth, { id: asset.id });
+
+      await expect(facesAfterRemovingEdits).resolves.toEqual(
+        expect.arrayContaining([
+          expect.objectContaining({
+            person: expect.objectContaining({ id: person.id }),
+            boundingBoxX1: 50,
+            boundingBoxY1: 75,
+            boundingBoxX2: 100,
+            boundingBoxY2: 150,
+          }),
+        ]),
+      );
+    });
+
+    it('should properly transform the coordinates with multiple mirrors in sequence', async () => {
+      const { sut, ctx } = setup();
+      const { user } = await ctx.newUser();
+      const { person } = await ctx.newPerson({ ownerId: user.id });
+      const { asset } = await ctx.newAsset({ id: factory.uuid(), ownerId: user.id, width: 100, height: 100 });
+      await ctx.newExif({ assetId: asset.id, exifImageHeight: 100, exifImageWidth: 100 });
+
+      await ctx.newEdits(asset.id, {
+        edits: [
+          {
+            action: AssetEditAction.Mirror,
+            parameters: {
+              axis: MirrorAxis.Horizontal,
+            },
+          },
+          {
+            action: AssetEditAction.Mirror,
+            parameters: {
+              axis: MirrorAxis.Vertical,
+            },
+          },
+        ],
+      });
+
+      const auth = factory.auth({ user });
+
+      const dto: AssetFaceCreateDto = {
+        imageWidth: 100,
+        imageHeight: 100,
+        x: 10,
+        y: 10,
+        width: 80,
+        height: 80,
+        personId: person.id,
+        assetId: asset.id,
+      };
+
+      await sut.createFace(auth, dto);
+
+      const faces = sut.getFacesById(auth, { id: asset.id });
+      await expect(faces).resolves.toHaveLength(1);
+      await expect(faces).resolves.toEqual(
+        expect.arrayContaining([
+          expect.objectContaining({
+            person: expect.objectContaining({ id: person.id }),
+            boundingBoxX1: 10,
+            boundingBoxY1: 10,
+            boundingBoxX2: 90,
+            boundingBoxY2: 90,
+          }),
+        ]),
+      );
+
+      // remove edits and verify the stored coordinates map to the original image
+      await ctx.newEdits(asset.id, { edits: [] });
+      const facesAfterRemovingEdits = sut.getFacesById(auth, { id: asset.id });
+
+      await expect(facesAfterRemovingEdits).resolves.toEqual(
+        expect.arrayContaining([
+          expect.objectContaining({
+            person: expect.objectContaining({ id: person.id }),
+            boundingBoxX1: 10,
+            boundingBoxY1: 10,
+            boundingBoxX2: 90,
+            boundingBoxY2: 90,
+          }),
+        ]),
+      );
+    });
+  });
 });

server/test/repositories/asset.repository.mock.ts

@@ -50,5 +50,8 @@ export const newAssetRepositoryMock = (): Mocked<RepositoryInterface<AssetReposi
     upsertBulkMetadata: vitest.fn(),
     deleteMetadataByKey: vitest.fn(),
     deleteBulkMetadata: vitest.fn(),
+    getForOriginal: vitest.fn(),
+    getForThumbnail: vitest.fn(),
+    getForVideo: vitest.fn(),
   };
 };

server/test/small.factory.ts

@@ -1,6 +1,8 @@
 import {
   Activity,
+  Album,
   ApiKey,
+  AssetFace,
   AssetFile,
   AuthApiKey,
   AuthSharedLink,
@@ -9,24 +11,30 @@ import {
   Library,
   Memory,
   Partner,
+  Person,
   Session,
+  Stack,
+  Tag,
   User,
   UserAdmin,
 } from 'src/database';
 import { MapAsset } from 'src/dtos/asset-response.dto';
 import { AuthDto } from 'src/dtos/auth.dto';
+import { AssetEditAction, AssetEditActionItem, MirrorAxis } from 'src/dtos/editing.dto';
 import { QueueStatisticsDto } from 'src/dtos/queue.dto';
 import {
   AssetFileType,
+  AssetOrder,
   AssetStatus,
   AssetType,
   AssetVisibility,
   MemoryType,
   Permission,
+  SourceType,
   UserMetadataKey,
   UserStatus,
 } from 'src/enum';
-import { OnThisDayData, UserMetadataItem } from 'src/types';
+import { DeepPartial, OnThisDayData, UserMetadataItem } from 'src/types';
 import { v4, v7 } from 'uuid';
 
 export const newUuid = () => v4();
@@ -160,11 +168,18 @@ const queueStatisticsFactory = (dto?: Partial<QueueStatisticsDto>) => ({
   ...dto,
 });
 
-const stackFactory = () => ({
-  id: newUuid(),
-  ownerId: newUuid(),
-  primaryAssetId: newUuid(),
-});
+const stackFactory = ({ owner, assets, ...stack }: DeepPartial<Stack> = {}): Stack => {
+  const ownerId = newUuid();
+
+  return {
+    id: newUuid(),
+    primaryAssetId: assets?.[0].id ?? newUuid(),
+    ownerId,
+    owner: userFactory(owner ?? { id: ownerId }),
+    assets: assets?.map((asset) => assetFactory(asset)) ?? [],
+    ...stack,
+  };
+};
 
 const userFactory = (user: Partial<User> = {}) => ({
   id: newUuid(),
@@ -223,39 +238,43 @@ const userAdminFactory = (user: Partial<UserAdmin> = {}) => {
   };
 };
 
-const assetFactory = (asset: Partial<MapAsset> = {}) => ({
-  id: newUuid(),
-  createdAt: newDate(),
-  updatedAt: newDate(),
-  deletedAt: null,
-  updateId: newUuidV7(),
-  status: AssetStatus.Active,
-  checksum: newSha1(),
-  deviceAssetId: '',
-  deviceId: '',
-  duplicateId: null,
-  duration: null,
-  encodedVideoPath: null,
-  fileCreatedAt: newDate(),
-  fileModifiedAt: newDate(),
-  isExternal: false,
-  isFavorite: false,
-  isOffline: false,
-  libraryId: null,
-  livePhotoVideoId: null,
-  localDateTime: newDate(),
-  originalFileName: 'IMG_123.jpg',
-  originalPath: `/data/12/34/IMG_123.jpg`,
-  ownerId: newUuid(),
-  stackId: null,
-  thumbhash: null,
-  type: AssetType.Image,
-  visibility: AssetVisibility.Timeline,
-  width: null,
-  height: null,
-  isEdited: false,
-  ...asset,
-});
+const assetFactory = (
+  asset: Omit<DeepPartial<MapAsset>, 'exifInfo' | 'owner' | 'stack' | 'tags' | 'faces' | 'files' | 'edits'> = {},
+) => {
+  return {
+    id: newUuid(),
+    createdAt: newDate(),
+    updatedAt: newDate(),
+    deletedAt: null,
+    updateId: newUuidV7(),
+    status: AssetStatus.Active,
+    checksum: newSha1(),
+    deviceAssetId: '',
+    deviceId: '',
+    duplicateId: null,
+    duration: null,
+    encodedVideoPath: null,
+    fileCreatedAt: newDate(),
+    fileModifiedAt: newDate(),
+    isExternal: false,
+    isFavorite: false,
+    isOffline: false,
+    libraryId: null,
+    livePhotoVideoId: null,
+    localDateTime: newDate(),
+    originalFileName: 'IMG_123.jpg',
+    originalPath: `/data/12/34/IMG_123.jpg`,
+    ownerId: newUuid(),
+    stackId: null,
+    thumbhash: null,
+    type: AssetType.Image,
+    visibility: AssetVisibility.Timeline,
+    width: null,
+    height: null,
+    isEdited: false,
+    ...asset,
+  };
+};
 
 const activityFactory = (activity: Partial<Activity> = {}) => {
   const userId = activity.userId || newUuid();
@@ -344,6 +363,7 @@ const assetSidecarWriteFactory = () => {
       latitude: 12,
       longitude: 12,
       dateTimeOriginal: '2023-11-22T04:56:12.196Z',
+      timeZone: 'UTC-6',
     } as unknown as Exif,
   };
 };
@@ -383,14 +403,129 @@ const assetOcrFactory = (
   ...ocr,
 });
 
-const assetFileFactory = (file: Partial<AssetFile> = {}): AssetFile => ({
+const assetFileFactory = (file: Partial<AssetFile> = {}) => ({
   id: newUuid(),
   type: AssetFileType.Preview,
   path: '/uploads/user-id/thumbs/path.jpg',
   isEdited: false,
+  isProgressive: false,
   ...file,
 });
 
+const exifFactory = (exif: Partial<Exif> = {}) => ({
+  assetId: newUuid(),
+  autoStackId: null,
+  bitsPerSample: null,
+  city: 'Austin',
+  colorspace: null,
+  country: 'United States of America',
+  dateTimeOriginal: newDate(),
+  description: '',
+  exifImageHeight: 420,
+  exifImageWidth: 42,
+  exposureTime: null,
+  fileSizeInByte: 69,
+  fNumber: 1.7,
+  focalLength: 4.38,
+  fps: null,
+  iso: 947,
+  latitude: 30.267_334_570_570_195,
+  longitude: -97.789_833_534_282_07,
+  lensModel: null,
+  livePhotoCID: null,
+  make: 'Google',
+  model: 'Pixel 7',
+  modifyDate: newDate(),
+  orientation: '1',
+  profileDescription: null,
+  projectionType: null,
+  rating: 4,
+  state: 'Texas',
+  tags: ['parent/child'],
+  timeZone: 'UTC-6',
+  ...exif,
+});
+
+const tagFactory = (tag: Partial<Tag>): Tag => ({
+  id: newUuid(),
+  color: null,
+  createdAt: newDate(),
+  parentId: null,
+  updatedAt: newDate(),
+  value: `tag-${newUuid()}`,
+  ...tag,
+});
+
+const faceFactory = ({ person, ...face }: DeepPartial<AssetFace> = {}): AssetFace => ({
+  assetId: newUuid(),
+  boundingBoxX1: 1,
+  boundingBoxX2: 2,
+  boundingBoxY1: 1,
+  boundingBoxY2: 2,
+  deletedAt: null,
+  id: newUuid(),
+  imageHeight: 420,
+  imageWidth: 42,
+  isVisible: true,
+  personId: null,
+  sourceType: SourceType.MachineLearning,
+  updatedAt: newDate(),
+  updateId: newUuidV7(),
+  person: person === null ? null : personFactory(person),
+  ...face,
+});
+
+const assetEditFactory = (edit?: Partial<AssetEditActionItem>): AssetEditActionItem => {
+  switch (edit?.action) {
+    case AssetEditAction.Crop: {
+      return { action: AssetEditAction.Crop, parameters: { height: 42, width: 42, x: 0, y: 10 }, ...edit };
+    }
+    case AssetEditAction.Mirror: {
+      return { action: AssetEditAction.Mirror, parameters: { axis: MirrorAxis.Horizontal }, ...edit };
+    }
+    case AssetEditAction.Rotate: {
+      return { action: AssetEditAction.Rotate, parameters: { angle: 90 }, ...edit };
+    }
+    default: {
+      return { action: AssetEditAction.Mirror, parameters: { axis: MirrorAxis.Vertical } };
+    }
+  }
+};
+
+const personFactory = (person?: Partial<Person>): Person => ({
+  birthDate: newDate(),
+  color: null,
+  createdAt: newDate(),
+  faceAssetId: null,
+  id: newUuid(),
+  isFavorite: false,
+  isHidden: false,
+  name: 'person',
+  ownerId: newUuid(),
+  thumbnailPath: '/path/to/person/thumbnail.jpg',
+  updatedAt: newDate(),
+  updateId: newUuidV7(),
+  ...person,
+});
+
+const albumFactory = (album?: Partial<Omit<Album, 'assets'>>) => ({
+  albumName: 'My Album',
+  albumThumbnailAssetId: null,
+  albumUsers: [],
+  assets: [],
+  createdAt: newDate(),
+  deletedAt: null,
+  description: 'Album description',
+  id: newUuid(),
+  isActivityEnabled: false,
+  order: AssetOrder.Desc,
+  ownerId: newUuid(),
+  sharedLinks: [],
+  updatedAt: newDate(),
+  updateId: newUuidV7(),
+  ...album,
+});
+
 export const factory = {
   activity: activityFactory,
   apiKey: apiKeyFactory,
@@ -412,7 +547,14 @@ export const factory = {
   jobAssets: {
     sidecarWrite: assetSidecarWriteFactory,
   },
+  exif: exifFactory,
+  face: faceFactory,
+  person: personFactory,
+  assetEdit: assetEditFactory,
+  tag: tagFactory,
+  album: albumFactory,
   uuid: newUuid,
+  buffer: () => Buffer.from('this is a fake buffer'),
   date: newDate,
   responses: {
     badRequest: (message: any = null) => ({

server/test/vitest.config.mjs

@@ -2,9 +2,6 @@ import swc from 'unplugin-swc';
 import tsconfigPaths from 'vite-tsconfig-paths';
 import { defineConfig } from 'vitest/config';
 
-// Set the timezone to UTC to avoid timezone issues during testing
-process.env.TZ = 'UTC';
-
 export default defineConfig({
   test: {
     root: './',
@@ -25,6 +22,9 @@ export default defineConfig({
         fallbackCJS: true,
       },
     },
+    env: {
+      TZ: 'UTC',
+    },
   },
   plugins: [swc.vite(), tsconfigPaths()],
 });