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

2026-05-18 03:10:24 +03:00 · 2026-02-24 17:08:35 +00:00
parent f6d88ffa96 caebe5166a
commit a44a886121
505 changed files with 24540 additions and 10979 deletions
@@ -0,0 +1,47 @@
+import { Selectable } from 'kysely';
+import { SourceType } from 'src/enum';
+import { AssetFaceTable } from 'src/schema/tables/asset-face.table';
+import { build } from 'test/factories/builder.factory';
+import { PersonFactory } from 'test/factories/person.factory';
+import { AssetFaceLike, FactoryBuilder, PersonLike } from 'test/factories/types';
+import { newDate, newUuid, newUuidV7 } from 'test/small.factory';
+
+export class AssetFaceFactory {
+  #person: PersonFactory | null = null;
+
+  private constructor(private readonly value: Selectable<AssetFaceTable>) {}
+
+  static create(dto: AssetFaceLike = {}) {
+    return AssetFaceFactory.from(dto).build();
+  }
+
+  static from(dto: AssetFaceLike = {}) {
+    return new AssetFaceFactory({
+      assetId: newUuid(),
+      boundingBoxX1: 100,
+      boundingBoxX2: 200,
+      boundingBoxY1: 100,
+      boundingBoxY2: 200,
+      deletedAt: null,
+      id: newUuid(),
+      imageHeight: 500,
+      imageWidth: 400,
+      isVisible: true,
+      personId: null,
+      sourceType: SourceType.MachineLearning,
+      updatedAt: newDate(),
+      updateId: newUuidV7(),
+      ...dto,
+    });
+  }
+
+  person(dto: PersonLike = {}, builder?: FactoryBuilder<PersonFactory>) {
+    this.#person = build(PersonFactory.from(dto), builder);
+    this.value.personId = this.#person.build().id;
+    return this;
+  }
+
+  build() {
+    return { ...this.value, person: this.#person?.build() ?? null };
+  }
+}
@@ -1,12 +1,23 @@
 import { Selectable } from 'kysely';
 import { AssetFileType, AssetStatus, AssetType, AssetVisibility } from 'src/enum';
-import { AssetFaceTable } from 'src/schema/tables/asset-face.table';
 import { AssetTable } from 'src/schema/tables/asset.table';
+import { StackTable } from 'src/schema/tables/stack.table';
 import { AssetEditFactory } from 'test/factories/asset-edit.factory';
 import { AssetExifFactory } from 'test/factories/asset-exif.factory';
+import { AssetFaceFactory } from 'test/factories/asset-face.factory';
 import { AssetFileFactory } from 'test/factories/asset-file.factory';
 import { build } from 'test/factories/builder.factory';
-import { AssetEditLike, AssetExifLike, AssetFileLike, AssetLike, FactoryBuilder, UserLike } from 'test/factories/types';
+import { StackFactory } from 'test/factories/stack.factory';
+import {
+  AssetEditLike,
+  AssetExifLike,
+  AssetFaceLike,
+  AssetFileLike,
+  AssetLike,
+  FactoryBuilder,
+  StackLike,
+  UserLike,
+} from 'test/factories/types';
 import { UserFactory } from 'test/factories/user.factory';
 import { newDate, newSha1, newUuid, newUuidV7 } from 'test/small.factory';

@@ -15,6 +26,8 @@ export class AssetFactory {
  #assetExif?: AssetExifFactory;
  #files: AssetFileFactory[] = [];
  #edits: AssetEditFactory[] = [];
+  #faces: AssetFaceFactory[] = [];
+  #stack?: Selectable<StackTable> & { assets: Selectable<AssetTable>[]; primaryAsset: Selectable<AssetTable> };

  private constructor(private readonly value: Selectable<AssetTable>) {
    value.ownerId ??= newUuid();
@@ -28,7 +41,7 @@ export class AssetFactory {
  static from(dto: AssetLike = {}) {
    const id = dto.id ?? newUuid();

-    const originalFileName = dto.originalFileName ?? `IMG_${id}.jpg`;
+    const originalFileName = dto.originalFileName ?? (dto.type === AssetType.Video ? `MOV_${id}.mp4` : `IMG_${id}.jpg`);

    return new AssetFactory({
      id,
@@ -82,6 +95,11 @@ export class AssetFactory {
    return this;
  }

+  face(dto: AssetFaceLike = {}, builder?: FactoryBuilder<AssetFaceFactory>) {
+    this.#faces.push(build(AssetFaceFactory.from({ assetId: this.value?.id, ...dto }), builder));
+    return this;
+  }
+
  file(dto: AssetFileLike = {}, builder?: FactoryBuilder<AssetFileFactory>) {
    this.#files.push(build(AssetFileFactory.from(dto).asset(this.value), builder));
    return this;
@@ -111,6 +129,12 @@ export class AssetFactory {
    return this;
  }

+  stack(dto: StackLike = {}, builder?: FactoryBuilder<StackFactory>) {
+    this.#stack = build(StackFactory.from(dto).primaryAsset(this.value), builder).build();
+    this.value.stackId = this.#stack.id;
+    return this;
+  }
+
  build() {
    const exif = this.#assetExif?.build();

@@ -120,7 +144,9 @@ export class AssetFactory {
      exifInfo: exif as NonNullable<typeof exif>,
      files: this.#files.map((file) => file.build()),
      edits: this.#edits.map((edit) => edit.build()),
-      faces: [] as Selectable<AssetFaceTable>[],
+      faces: this.#faces.map((face) => face.build()),
+      stack: this.#stack ?? null,
+      tags: [],
    };
  }
 }
@@ -0,0 +1,34 @@
+import { Selectable } from 'kysely';
+import { PersonTable } from 'src/schema/tables/person.table';
+import { PersonLike } from 'test/factories/types';
+import { newDate, newUuid, newUuidV7 } from 'test/small.factory';
+
+export class PersonFactory {
+  private constructor(private readonly value: Selectable<PersonTable>) {}
+
+  static create(dto: PersonLike = {}) {
+    return PersonFactory.from(dto).build();
+  }
+
+  static from(dto: PersonLike = {}) {
+    return new PersonFactory({
+      birthDate: null,
+      color: null,
+      createdAt: newDate(),
+      faceAssetId: null,
+      id: newUuid(),
+      isFavorite: false,
+      isHidden: false,
+      name: 'person',
+      ownerId: newUuid(),
+      thumbnailPath: '/data/thumbs/person-thumbnail.jpg',
+      updatedAt: newDate(),
+      updateId: newUuidV7(),
+      ...dto,
+    });
+  }
+
+  build() {
+    return { ...this.value };
+  }
+}
@@ -2,14 +2,16 @@ import { Selectable } from 'kysely';
 import { SharedLinkType } from 'src/enum';
 import { SharedLinkTable } from 'src/schema/tables/shared-link.table';
 import { AlbumFactory } from 'test/factories/album.factory';
+import { AssetFactory } from 'test/factories/asset.factory';
 import { build } from 'test/factories/builder.factory';
-import { AlbumLike, FactoryBuilder, SharedLinkLike, UserLike } from 'test/factories/types';
+import { AlbumLike, AssetLike, FactoryBuilder, SharedLinkLike, UserLike } from 'test/factories/types';
 import { UserFactory } from 'test/factories/user.factory';
 import { factory, newDate, newUuid } from 'test/small.factory';

 export class SharedLinkFactory {
  #owner: UserFactory;
  #album?: AlbumFactory;
+  #assets: AssetFactory[] = [];

  private constructor(private readonly value: Selectable<SharedLinkTable>) {
    value.userId ??= newUuid();
@@ -52,12 +54,18 @@ export class SharedLinkFactory {
    return this;
  }

+  asset(dto: AssetLike = {}, builder?: FactoryBuilder<AssetFactory>) {
+    const asset = build(AssetFactory.from(dto), builder);
+    this.#assets.push(asset);
+    return this;
+  }
+
  build() {
    return {
      ...this.value,
      owner: this.#owner.build(),
-      album: this.#album?.build(),
-      assets: [],
+      album: this.#album?.build() ?? null,
+      assets: this.#assets.map((asset) => asset.build()),
    };
  }
 }
@@ -0,0 +1,52 @@
+import { Selectable } from 'kysely';
+import { StackTable } from 'src/schema/tables/stack.table';
+import { AssetFactory } from 'test/factories/asset.factory';
+import { build } from 'test/factories/builder.factory';
+import { AssetLike, FactoryBuilder, StackLike } from 'test/factories/types';
+import { newDate, newUuid, newUuidV7 } from 'test/small.factory';
+
+export class StackFactory {
+  #assets: AssetFactory[] = [];
+  #primaryAsset: AssetFactory;
+
+  private constructor(private readonly value: Selectable<StackTable>) {
+    this.#primaryAsset = AssetFactory.from();
+    this.value.primaryAssetId = this.#primaryAsset.build().id;
+  }
+
+  static create(dto: StackLike = {}) {
+    return StackFactory.from(dto).build();
+  }
+
+  static from(dto: StackLike = {}) {
+    return new StackFactory({
+      createdAt: newDate(),
+      id: newUuid(),
+      ownerId: newUuid(),
+      primaryAssetId: newUuid(),
+      updatedAt: newDate(),
+      updateId: newUuidV7(),
+      ...dto,
+    });
+  }
+
+  asset(dto: AssetLike = {}, builder?: FactoryBuilder<AssetFactory>) {
+    this.#assets.push(build(AssetFactory.from(dto), builder));
+    return this;
+  }
+
+  primaryAsset(dto: AssetLike = {}, builder?: FactoryBuilder<AssetFactory>) {
+    this.#primaryAsset = build(AssetFactory.from(dto), builder);
+    this.value.primaryAssetId = this.#primaryAsset.build().id;
+    this.#assets.push(this.#primaryAsset);
+    return this;
+  }
+
+  build() {
+    return {
+      ...this.value,
+      assets: this.#assets.map((asset) => asset.build()),
+      primaryAsset: this.#primaryAsset.build(),
+    };
+  }
+}
@@ -3,9 +3,12 @@ import { AlbumUserTable } from 'src/schema/tables/album-user.table';
 import { AlbumTable } from 'src/schema/tables/album.table';
 import { AssetEditTable } from 'src/schema/tables/asset-edit.table';
 import { AssetExifTable } from 'src/schema/tables/asset-exif.table';
+import { AssetFaceTable } from 'src/schema/tables/asset-face.table';
 import { AssetFileTable } from 'src/schema/tables/asset-file.table';
 import { AssetTable } from 'src/schema/tables/asset.table';
+import { PersonTable } from 'src/schema/tables/person.table';
 import { SharedLinkTable } from 'src/schema/tables/shared-link.table';
+import { StackTable } from 'src/schema/tables/stack.table';
 import { UserTable } from 'src/schema/tables/user.table';

 export type FactoryBuilder<T, R extends T = T> = (builder: T) => R;
@@ -18,3 +21,6 @@ export type AlbumLike = Partial<Selectable<AlbumTable>>;
 export type AlbumUserLike = Partial<Selectable<AlbumUserTable>>;
 export type SharedLinkLike = Partial<Selectable<SharedLinkTable>>;
 export type UserLike = Partial<Selectable<UserTable>>;
+export type AssetFaceLike = Partial<Selectable<AssetFaceTable>>;
+export type PersonLike = Partial<Selectable<PersonTable>>;
+export type StackLike = Partial<Selectable<StackTable>>;
@@ -1,723 +0,0 @@
-import { AssetFace, AssetFile, Exif } from 'src/database';
-import { MapAsset } from 'src/dtos/asset-response.dto';
-import { AssetEditAction, AssetEditActionItem } from 'src/dtos/editing.dto';
-import { AssetFileType, AssetStatus, AssetType, AssetVisibility } from 'src/enum';
-import { StorageAsset } from 'src/types';
-import { authStub } from 'test/fixtures/auth.stub';
-import { fileStub } from 'test/fixtures/file.stub';
-import { userStub } from 'test/fixtures/user.stub';
-import { factory } from 'test/small.factory';
-
-export const previewFile = factory.assetFile({ type: AssetFileType.Preview });
-
-const thumbnailFile = factory.assetFile({
-  type: AssetFileType.Thumbnail,
-  path: '/uploads/user-id/webp/path.ext',
-});
-
-const fullsizeFile = factory.assetFile({
-  type: AssetFileType.FullSize,
-  path: '/uploads/user-id/fullsize/path.webp',
-});
-
-const files = [fullsizeFile, previewFile, thumbnailFile];
-
-export const stackStub = (stackId: string, assets: (MapAsset & { exifInfo: Exif })[]) => {
-  return {
-    id: stackId,
-    assets,
-    ownerId: assets[0].ownerId,
-    primaryAsset: assets[0],
-    primaryAssetId: assets[0].id,
-    createdAt: new Date('2023-02-23T05:06:29.716Z'),
-    updatedAt: new Date('2023-02-23T05:06:29.716Z'),
-    updateId: expect.any(String),
-  };
-};
-
-export const assetStub = {
-  storageAsset: (asset: Partial<StorageAsset> = {}) => ({
-    id: 'asset-id',
-    ownerId: 'user-id',
-    livePhotoVideoId: null,
-    type: AssetType.Image,
-    isExternal: false,
-    checksum: Buffer.from('file hash'),
-    timeZone: null,
-    fileCreatedAt: new Date('2022-06-19T23:41:36.910Z'),
-    originalPath: '/original/path.jpg',
-    originalFileName: 'IMG_123.jpg',
-    fileSizeInByte: 12_345,
-    files: [],
-    make: 'FUJIFILM',
-    model: 'X-T50',
-    lensModel: 'XF27mm F2.8 R WR',
-    isEdited: false,
-    ...asset,
-  }),
-  noResizePath: Object.freeze({
-    id: 'asset-id',
-    status: AssetStatus.Active,
-    originalFileName: 'IMG_123.jpg',
-    deviceAssetId: 'device-asset-id',
-    fileModifiedAt: new Date('2023-02-23T05:06:29.716Z'),
-    fileCreatedAt: new Date('2023-02-23T05:06:29.716Z'),
-    owner: userStub.user1,
-    ownerId: 'user-id',
-    deviceId: 'device-id',
-    originalPath: '/data/library/IMG_123.jpg',
-    files: [thumbnailFile],
-    checksum: Buffer.from('file hash', 'utf8'),
-    type: AssetType.Image,
-    thumbhash: Buffer.from('blablabla', 'base64'),
-    encodedVideoPath: null,
-    createdAt: new Date('2023-02-23T05:06:29.716Z'),
-    updatedAt: new Date('2023-02-23T05:06:29.716Z'),
-    localDateTime: new Date('2023-02-23T05:06:29.716Z'),
-    isFavorite: true,
-    duration: null,
-    livePhotoVideo: null,
-    livePhotoVideoId: null,
-    sharedLinks: [],
-    faces: [],
-    exifInfo: {} as Exif,
-    deletedAt: null,
-    isExternal: false,
-    duplicateId: null,
-    isOffline: false,
-    libraryId: null,
-    stackId: null,
-    updateId: '42',
-    visibility: AssetVisibility.Timeline,
-    width: null,
-    height: null,
-    edits: [],
-    isEdited: false,
-  }),
-
-  primaryImage: Object.freeze({
-    id: 'primary-asset-id',
-    status: AssetStatus.Active,
-    deviceAssetId: 'device-asset-id',
-    fileModifiedAt: new Date('2023-02-23T05:06:29.716Z'),
-    fileCreatedAt: new Date('2023-02-23T05:06:29.716Z'),
-    owner: userStub.admin,
-    ownerId: 'admin-id',
-    deviceId: 'device-id',
-    originalPath: '/original/path.jpg',
-    checksum: Buffer.from('file hash', 'utf8'),
-    files,
-    type: AssetType.Image,
-    thumbhash: Buffer.from('blablabla', 'base64'),
-    encodedVideoPath: null,
-    createdAt: new Date('2023-02-23T05:06:29.716Z'),
-    updatedAt: new Date('2023-02-23T05:06:29.716Z'),
-    localDateTime: new Date('2023-02-23T05:06:29.716Z'),
-    isFavorite: true,
-    duration: null,
-    isExternal: false,
-    livePhotoVideo: null,
-    livePhotoVideoId: null,
-    sharedLinks: [],
-    originalFileName: 'asset-id.jpg',
-    faces: [],
-    deletedAt: null,
-    exifInfo: {
-      fileSizeInByte: 5000,
-      exifImageHeight: 1000,
-      exifImageWidth: 1000,
-    } as Exif,
-    stackId: 'stack-1',
-    stack: stackStub('stack-1', [
-      { id: 'primary-asset-id' } as MapAsset & { exifInfo: Exif },
-      { id: 'stack-child-asset-1' } as MapAsset & { exifInfo: Exif },
-      { id: 'stack-child-asset-2' } as MapAsset & { exifInfo: Exif },
-    ]),
-    duplicateId: null,
-    isOffline: false,
-    updateId: '42',
-    libraryId: null,
-    visibility: AssetVisibility.Timeline,
-    width: null,
-    height: null,
-    edits: [],
-    isEdited: false,
-  }),
-
-  image: Object.freeze({
-    id: 'asset-id',
-    status: AssetStatus.Active,
-    deviceAssetId: 'device-asset-id',
-    fileModifiedAt: new Date('2023-02-23T05:06:29.716Z'),
-    fileCreatedAt: new Date('2023-02-23T05:06:29.716Z'),
-    owner: userStub.user1,
-    ownerId: 'user-id',
-    deviceId: 'device-id',
-    originalPath: '/original/path.jpg',
-    files,
-    checksum: Buffer.from('file hash', 'utf8'),
-    type: AssetType.Image,
-    thumbhash: Buffer.from('blablabla', 'base64'),
-    encodedVideoPath: null,
-    createdAt: new Date('2023-02-23T05:06:29.716Z'),
-    updatedAt: new Date('2023-02-23T05:06:29.716Z'),
-    localDateTime: new Date('2025-01-01T01:02:03.456Z'),
-    isFavorite: true,
-    duration: null,
-    isExternal: false,
-    livePhotoVideo: null,
-    livePhotoVideoId: null,
-    updateId: 'foo',
-    libraryId: null,
-    stackId: null,
-    sharedLinks: [],
-    originalFileName: 'asset-id.jpg',
-    faces: [],
-    deletedAt: null,
-    exifInfo: {
-      fileSizeInByte: 5000,
-      exifImageHeight: 3840,
-      exifImageWidth: 2160,
-    } as Exif,
-    duplicateId: null,
-    isOffline: false,
-    stack: null,
-    orientation: '',
-    projectionType: null,
-    height: null,
-    width: null,
-    visibility: AssetVisibility.Timeline,
-    edits: [],
-    isEdited: false,
-  }),
-
-  trashed: Object.freeze({
-    id: 'asset-id',
-    deviceAssetId: 'device-asset-id',
-    fileModifiedAt: new Date('2023-02-23T05:06:29.716Z'),
-    fileCreatedAt: new Date('2023-02-23T05:06:29.716Z'),
-    owner: userStub.user1,
-    ownerId: 'user-id',
-    deviceId: 'device-id',
-    originalPath: '/original/path.jpg',
-    checksum: Buffer.from('file hash', 'utf8'),
-    type: AssetType.Image,
-    files,
-    thumbhash: Buffer.from('blablabla', 'base64'),
-    encodedVideoPath: null,
-    createdAt: new Date('2023-02-23T05:06:29.716Z'),
-    updatedAt: new Date('2023-02-23T05:06:29.716Z'),
-    deletedAt: new Date('2023-02-24T05:06:29.716Z'),
-    localDateTime: new Date('2023-02-23T05:06:29.716Z'),
-    isFavorite: false,
-    duration: null,
-    isExternal: false,
-    livePhotoVideo: null,
-    livePhotoVideoId: null,
-    sharedLinks: [],
-    originalFileName: 'asset-id.jpg',
-    faces: [],
-    exifInfo: {
-      fileSizeInByte: 5000,
-      exifImageHeight: 3840,
-      exifImageWidth: 2160,
-    } as Exif,
-    duplicateId: null,
-    isOffline: false,
-    status: AssetStatus.Trashed,
-    libraryId: null,
-    stackId: null,
-    updateId: '42',
-    visibility: AssetVisibility.Timeline,
-    width: null,
-    height: null,
-    edits: [],
-    isEdited: false,
-  }),
-
-  trashedOffline: Object.freeze({
-    id: 'asset-id',
-    status: AssetStatus.Active,
-    deviceAssetId: 'device-asset-id',
-    fileModifiedAt: new Date('2023-02-23T05:06:29.716Z'),
-    fileCreatedAt: new Date('2023-02-23T05:06:29.716Z'),
-    owner: userStub.user1,
-    ownerId: 'user-id',
-    deviceId: 'device-id',
-    originalPath: '/original/path.jpg',
-    checksum: Buffer.from('file hash', 'utf8'),
-    type: AssetType.Image,
-    files,
-    thumbhash: Buffer.from('blablabla', 'base64'),
-    encodedVideoPath: null,
-    createdAt: new Date('2023-02-23T05:06:29.716Z'),
-    updatedAt: new Date('2023-02-23T05:06:29.716Z'),
-    deletedAt: new Date('2023-02-24T05:06:29.716Z'),
-    localDateTime: new Date('2023-02-23T05:06:29.716Z'),
-    isFavorite: false,
-    duration: null,
-    libraryId: 'library-id',
-    isExternal: false,
-    livePhotoVideo: null,
-    livePhotoVideoId: null,
-    sharedLinks: [],
-    originalFileName: 'asset-id.jpg',
-    faces: [],
-    exifInfo: {
-      fileSizeInByte: 5000,
-      exifImageHeight: 3840,
-      exifImageWidth: 2160,
-    } as Exif,
-    duplicateId: null,
-    isOffline: true,
-    stackId: null,
-    updateId: '42',
-    visibility: AssetVisibility.Timeline,
-    width: null,
-    height: null,
-    edits: [],
-    isEdited: false,
-  }),
-  archived: Object.freeze({
-    id: 'asset-id',
-    status: AssetStatus.Active,
-    deviceAssetId: 'device-asset-id',
-    fileModifiedAt: new Date('2023-02-23T05:06:29.716Z'),
-    fileCreatedAt: new Date('2023-02-23T05:06:29.716Z'),
-    owner: userStub.user1,
-    ownerId: 'user-id',
-    deviceId: 'device-id',
-    originalPath: '/original/path.jpg',
-    checksum: Buffer.from('file hash', 'utf8'),
-    type: AssetType.Image,
-    files,
-    thumbhash: Buffer.from('blablabla', 'base64'),
-    encodedVideoPath: null,
-    createdAt: new Date('2023-02-23T05:06:29.716Z'),
-    updatedAt: new Date('2023-02-23T05:06:29.716Z'),
-    localDateTime: new Date('2023-02-23T05:06:29.716Z'),
-    isFavorite: true,
-    duration: null,
-    isExternal: false,
-    livePhotoVideo: null,
-    livePhotoVideoId: null,
-    sharedLinks: [],
-    originalFileName: 'asset-id.jpg',
-    faces: [],
-    deletedAt: null,
-    exifInfo: {
-      fileSizeInByte: 5000,
-      exifImageHeight: 3840,
-      exifImageWidth: 2160,
-    } as Exif,
-    duplicateId: null,
-    isOffline: false,
-    libraryId: null,
-    stackId: null,
-    updateId: '42',
-    visibility: AssetVisibility.Timeline,
-    width: null,
-    height: null,
-    edits: [],
-    isEdited: false,
-  }),
-
-  external: Object.freeze({
-    id: 'asset-id',
-    status: AssetStatus.Active,
-    deviceAssetId: 'device-asset-id',
-    fileModifiedAt: new Date('2023-02-23T05:06:29.716Z'),
-    fileCreatedAt: new Date('2023-02-23T05:06:29.716Z'),
-    owner: userStub.user1,
-    ownerId: 'user-id',
-    deviceId: 'device-id',
-    originalPath: '/data/user1/photo.jpg',
-    checksum: Buffer.from('path hash', 'utf8'),
-    type: AssetType.Image,
-    files,
-    thumbhash: Buffer.from('blablabla', 'base64'),
-    encodedVideoPath: null,
-    createdAt: new Date('2023-02-23T05:06:29.716Z'),
-    updatedAt: new Date('2023-02-23T05:06:29.716Z'),
-    localDateTime: new Date('2023-02-23T05:06:29.716Z'),
-    isFavorite: true,
-    isExternal: true,
-    duration: null,
-    livePhotoVideo: null,
-    livePhotoVideoId: null,
-    libraryId: 'library-id',
-    sharedLinks: [],
-    originalFileName: 'asset-id.jpg',
-    faces: [],
-    deletedAt: null,
-    exifInfo: {
-      fileSizeInByte: 5000,
-    } as Exif,
-    duplicateId: null,
-    isOffline: false,
-    updateId: '42',
-    stackId: null,
-    stack: null,
-    visibility: AssetVisibility.Timeline,
-    width: null,
-    height: null,
-    edits: [],
-    isEdited: false,
-  }),
-
-  image1: Object.freeze({
-    id: 'asset-id-1',
-    status: AssetStatus.Active,
-    deviceAssetId: 'device-asset-id',
-    fileModifiedAt: new Date('2023-02-23T05:06:29.716Z'),
-    fileCreatedAt: new Date('2023-02-23T05:06:29.716Z'),
-    owner: userStub.user1,
-    ownerId: 'user-id',
-    deviceId: 'device-id',
-    originalPath: '/original/path.ext',
-    checksum: Buffer.from('file hash', 'utf8'),
-    type: AssetType.Image,
-    files,
-    thumbhash: Buffer.from('blablabla', 'base64'),
-    encodedVideoPath: null,
-    createdAt: new Date('2023-02-23T05:06:29.716Z'),
-    updatedAt: new Date('2023-02-23T05:06:29.716Z'),
-    deletedAt: null,
-    localDateTime: new Date('2023-02-23T05:06:29.716Z'),
-    isFavorite: true,
-    duration: null,
-    livePhotoVideo: null,
-    livePhotoVideoId: null,
-    isExternal: false,
-    sharedLinks: [],
-    originalFileName: 'asset-id.ext',
-    faces: [],
-    exifInfo: {
-      fileSizeInByte: 5000,
-    } as Exif,
-    duplicateId: null,
-    isOffline: false,
-    updateId: '42',
-    stackId: null,
-    libraryId: null,
-    stack: null,
-    visibility: AssetVisibility.Timeline,
-    width: null,
-    height: null,
-    edits: [],
-    isEdited: false,
-  }),
-
-  video: Object.freeze({
-    id: 'asset-id',
-    status: AssetStatus.Active,
-    originalFileName: 'asset-id.ext',
-    deviceAssetId: 'device-asset-id',
-    fileModifiedAt: new Date('2023-02-23T05:06:29.716Z'),
-    fileCreatedAt: new Date('2023-02-23T05:06:29.716Z'),
-    owner: userStub.user1,
-    ownerId: 'user-id',
-    deviceId: 'device-id',
-    originalPath: '/original/path.ext',
-    checksum: Buffer.from('file hash', 'utf8'),
-    type: AssetType.Video,
-    files: [previewFile],
-    thumbhash: null,
-    encodedVideoPath: null,
-    createdAt: new Date('2023-02-23T05:06:29.716Z'),
-    updatedAt: new Date('2023-02-23T05:06:29.716Z'),
-    localDateTime: new Date('2023-02-23T05:06:29.716Z'),
-    isFavorite: true,
-    isExternal: false,
-    duration: null,
-    livePhotoVideo: null,
-    livePhotoVideoId: null,
-    sharedLinks: [],
-    faces: [],
-    exifInfo: {
-      fileSizeInByte: 100_000,
-      exifImageHeight: 2160,
-      exifImageWidth: 3840,
-    } as Exif,
-    deletedAt: null,
-    duplicateId: null,
-    isOffline: false,
-    updateId: '42',
-    libraryId: null,
-    stackId: null,
-    visibility: AssetVisibility.Timeline,
-    width: null,
-    height: null,
-    edits: [],
-    isEdited: false,
-  }),
-
-  livePhotoMotionAsset: Object.freeze({
-    status: AssetStatus.Active,
-    id: fileStub.livePhotoMotion.uuid,
-    originalPath: fileStub.livePhotoMotion.originalPath,
-    ownerId: authStub.user1.user.id,
-    type: AssetType.Video,
-    fileModifiedAt: new Date('2022-06-19T23:41:36.910Z'),
-    fileCreatedAt: new Date('2022-06-19T23:41:36.910Z'),
-    exifInfo: {
-      fileSizeInByte: 100_000,
-      timeZone: `America/New_York`,
-    },
-    files: [],
-    libraryId: null,
-    visibility: AssetVisibility.Hidden,
-    width: null,
-    height: null,
-    edits: [] as AssetEditActionItem[],
-    isEdited: false,
-  } as unknown as MapAsset & {
-    faces: AssetFace[];
-    files: (AssetFile & { isProgressive: boolean })[];
-    exifInfo: Exif;
-    edits: AssetEditActionItem[];
-  }),
-
-  livePhotoStillAsset: Object.freeze({
-    id: 'live-photo-still-asset',
-    status: AssetStatus.Active,
-    originalPath: fileStub.livePhotoStill.originalPath,
-    ownerId: authStub.user1.user.id,
-    type: AssetType.Image,
-    livePhotoVideoId: 'live-photo-motion-asset',
-    fileModifiedAt: new Date('2022-06-19T23:41:36.910Z'),
-    fileCreatedAt: new Date('2022-06-19T23:41:36.910Z'),
-    exifInfo: {
-      fileSizeInByte: 25_000,
-      timeZone: `America/New_York`,
-    },
-    files,
-    faces: [] as AssetFace[],
-    visibility: AssetVisibility.Timeline,
-    width: null,
-    height: null,
-    edits: [] as AssetEditActionItem[],
-    isEdited: false,
-  } as unknown as MapAsset & {
-    faces: AssetFace[];
-    files: (AssetFile & { isProgressive: boolean })[];
-    edits: AssetEditActionItem[];
-  }),
-
-  livePhotoWithOriginalFileName: Object.freeze({
-    id: 'live-photo-still-asset',
-    status: AssetStatus.Active,
-    originalPath: fileStub.livePhotoStill.originalPath,
-    originalFileName: fileStub.livePhotoStill.originalName,
-    ownerId: authStub.user1.user.id,
-    type: AssetType.Image,
-    livePhotoVideoId: 'live-photo-motion-asset',
-    fileModifiedAt: new Date('2022-06-19T23:41:36.910Z'),
-    fileCreatedAt: new Date('2022-06-19T23:41:36.910Z'),
-    exifInfo: {
-      fileSizeInByte: 25_000,
-      timeZone: `America/New_York`,
-    },
-    files: [] as AssetFile[],
-    libraryId: null,
-    faces: [] as AssetFace[],
-    visibility: AssetVisibility.Timeline,
-    width: null,
-    height: null,
-    edits: [] as AssetEditActionItem[],
-    isEdited: false,
-  } as MapAsset & { faces: AssetFace[]; files: AssetFile[]; edits: AssetEditActionItem[] }),
-
-  withLocation: Object.freeze({
-    id: 'asset-with-favorite-id',
-    status: AssetStatus.Active,
-    deviceAssetId: 'device-asset-id',
-    fileModifiedAt: new Date('2023-02-22T05:06:29.716Z'),
-    fileCreatedAt: new Date('2023-02-22T05:06:29.716Z'),
-    owner: userStub.user1,
-    ownerId: 'user-id',
-    deviceId: 'device-id',
-    checksum: Buffer.from('file hash', 'utf8'),
-    originalPath: '/original/path.ext',
-    type: AssetType.Image,
-    files: [previewFile],
-    thumbhash: null,
-    encodedVideoPath: null,
-    createdAt: new Date('2023-02-22T05:06:29.716Z'),
-    updatedAt: new Date('2023-02-22T05:06:29.716Z'),
-    localDateTime: new Date('2020-12-31T23:59:00.000Z'),
-    isFavorite: false,
-    isExternal: false,
-    duration: null,
-    livePhotoVideo: null,
-    livePhotoVideoId: null,
-    updateId: 'foo',
-    libraryId: null,
-    stackId: null,
-    sharedLinks: [],
-    originalFileName: 'asset-id.ext',
-    faces: [],
-    exifInfo: {
-      latitude: 100,
-      longitude: 100,
-      fileSizeInByte: 23_456,
-      city: 'test-city',
-      state: 'test-state',
-      country: 'test-country',
-    } as Exif,
-    deletedAt: null,
-    duplicateId: null,
-    isOffline: false,
-    tags: [],
-    visibility: AssetVisibility.Timeline,
-    width: null,
-    height: null,
-    edits: [],
-    isEdited: false,
-  }),
-
-  hasEncodedVideo: Object.freeze({
-    id: 'asset-id',
-    status: AssetStatus.Active,
-    originalFileName: 'asset-id.ext',
-    deviceAssetId: 'device-asset-id',
-    fileModifiedAt: new Date('2023-02-23T05:06:29.716Z'),
-    fileCreatedAt: new Date('2023-02-23T05:06:29.716Z'),
-    owner: userStub.user1,
-    ownerId: 'user-id',
-    deviceId: 'device-id',
-    originalPath: '/original/path.ext',
-    checksum: Buffer.from('file hash', 'utf8'),
-    type: AssetType.Video,
-    files: [previewFile],
-    thumbhash: null,
-    encodedVideoPath: '/encoded/video/path.mp4',
-    createdAt: new Date('2023-02-23T05:06:29.716Z'),
-    updatedAt: new Date('2023-02-23T05:06:29.716Z'),
-    localDateTime: new Date('2023-02-23T05:06:29.716Z'),
-    isFavorite: true,
-    isExternal: false,
-    duration: null,
-    livePhotoVideo: null,
-    livePhotoVideoId: null,
-    sharedLinks: [],
-    faces: [],
-    exifInfo: {
-      fileSizeInByte: 100_000,
-    } as Exif,
-    deletedAt: null,
-    duplicateId: null,
-    isOffline: false,
-    updateId: '42',
-    libraryId: null,
-    stackId: null,
-    stack: null,
-    visibility: AssetVisibility.Timeline,
-    width: null,
-    height: null,
-    edits: [],
-    isEdited: false,
-  }),
-
-  imageDng: Object.freeze({
-    id: 'asset-id',
-    status: AssetStatus.Active,
-    deviceAssetId: 'device-asset-id',
-    fileModifiedAt: new Date('2023-02-23T05:06:29.716Z'),
-    fileCreatedAt: new Date('2023-02-23T05:06:29.716Z'),
-    owner: userStub.user1,
-    ownerId: 'user-id',
-    deviceId: 'device-id',
-    originalPath: '/original/path.dng',
-    checksum: Buffer.from('file hash', 'utf8'),
-    type: AssetType.Image,
-    files,
-    thumbhash: Buffer.from('blablabla', 'base64'),
-    encodedVideoPath: null,
-    createdAt: new Date('2023-02-23T05:06:29.716Z'),
-    updatedAt: new Date('2023-02-23T05:06:29.716Z'),
-    localDateTime: new Date('2023-02-23T05:06:29.716Z'),
-    isFavorite: true,
-    duration: null,
-    isExternal: false,
-    livePhotoVideo: null,
-    livePhotoVideoId: null,
-    sharedLinks: [],
-    originalFileName: 'asset-id.dng',
-    faces: [],
-    deletedAt: null,
-    exifInfo: {
-      fileSizeInByte: 5000,
-      profileDescription: 'Adobe RGB',
-      bitsPerSample: 14,
-    } as Exif,
-    duplicateId: null,
-    isOffline: false,
-    updateId: '42',
-    libraryId: null,
-    stackId: null,
-    visibility: AssetVisibility.Timeline,
-    width: null,
-    height: null,
-    edits: [],
-    isEdited: false,
-  }),
-
-  withCropEdit: Object.freeze({
-    id: 'asset-id',
-    status: AssetStatus.Active,
-    deviceAssetId: 'device-asset-id',
-    fileModifiedAt: new Date('2023-02-23T05:06:29.716Z'),
-    fileCreatedAt: new Date('2023-02-23T05:06:29.716Z'),
-    owner: userStub.user1,
-    ownerId: 'user-id',
-    deviceId: 'device-id',
-    originalPath: '/original/path.jpg',
-    files,
-    checksum: Buffer.from('file hash', 'utf8'),
-    type: AssetType.Image,
-    thumbhash: Buffer.from('blablabla', 'base64'),
-    encodedVideoPath: null,
-    createdAt: new Date('2023-02-23T05:06:29.716Z'),
-    updatedAt: new Date('2023-02-23T05:06:29.716Z'),
-    localDateTime: new Date('2025-01-01T01:02:03.456Z'),
-    isFavorite: true,
-    duration: null,
-    isExternal: false,
-    livePhotoVideo: null,
-    livePhotoVideoId: null,
-    updateId: 'foo',
-    libraryId: null,
-    stackId: null,
-    sharedLinks: [],
-    originalFileName: 'asset-id.jpg',
-    faces: [],
-    deletedAt: null,
-    sidecarPath: null,
-    exifInfo: {
-      fileSizeInByte: 5000,
-      exifImageHeight: 3840,
-      exifImageWidth: 2160,
-    } as Exif,
-    duplicateId: null,
-    isOffline: false,
-    stack: null,
-    orientation: '',
-    projectionType: null,
-    height: 3840,
-    width: 2160,
-    visibility: AssetVisibility.Timeline,
-    edits: [
-      {
-        action: AssetEditAction.Crop,
-        parameters: {
-          width: 1512,
-          height: 1152,
-          x: 216,
-          y: 1512,
-        },
-      },
-    ] as AssetEditActionItem[],
-    isEdited: true,
-  }),
-};
@@ -1,160 +0,0 @@
-import { SourceType } from 'src/enum';
-import { assetStub } from 'test/fixtures/asset.stub';
-import { personStub } from 'test/fixtures/person.stub';
-
-export const faceStub = {
-  face1: Object.freeze({
-    id: 'assetFaceId1',
-    assetId: assetStub.image.id,
-    asset: {
-      ...assetStub.image,
-      libraryId: null,
-      updateId: '0d1173e3-4d80-4d76-b41e-57d56de21125',
-      stackId: null,
-    },
-    personId: personStub.withName.id,
-    person: personStub.withName,
-    boundingBoxX1: 0,
-    boundingBoxY1: 0,
-    boundingBoxX2: 1,
-    boundingBoxY2: 1,
-    imageHeight: 1024,
-    imageWidth: 1024,
-    sourceType: SourceType.MachineLearning,
-    faceSearch: { faceId: 'assetFaceId1', embedding: '[1, 2, 3, 4]' },
-    deletedAt: new Date(),
-    updatedAt: new Date('2023-01-01T00:00:00Z'),
-    updateId: '0d1173e3-4d80-4d76-b41e-57d56de21125',
-    isVisible: true,
-  }),
-  primaryFace1: Object.freeze({
-    id: 'assetFaceId2',
-    assetId: assetStub.image.id,
-    asset: assetStub.image,
-    personId: personStub.primaryPerson.id,
-    person: personStub.primaryPerson,
-    boundingBoxX1: 0,
-    boundingBoxY1: 0,
-    boundingBoxX2: 1,
-    boundingBoxY2: 1,
-    imageHeight: 1024,
-    imageWidth: 1024,
-    sourceType: SourceType.MachineLearning,
-    faceSearch: { faceId: 'assetFaceId2', embedding: '[1, 2, 3, 4]' },
-    deletedAt: null,
-    updatedAt: new Date('2023-01-01T00:00:00Z'),
-    updateId: '0d1173e3-4d80-4d76-b41e-57d56de21125',
-    isVisible: true,
-  }),
-  mergeFace1: Object.freeze({
-    id: 'assetFaceId3',
-    assetId: assetStub.image.id,
-    asset: assetStub.image,
-    personId: personStub.mergePerson.id,
-    person: personStub.mergePerson,
-    boundingBoxX1: 0,
-    boundingBoxY1: 0,
-    boundingBoxX2: 1,
-    boundingBoxY2: 1,
-    imageHeight: 1024,
-    imageWidth: 1024,
-    sourceType: SourceType.MachineLearning,
-    faceSearch: { faceId: 'assetFaceId3', embedding: '[1, 2, 3, 4]' },
-    deletedAt: null,
-    updatedAt: new Date('2023-01-01T00:00:00Z'),
-    updateId: '0d1173e3-4d80-4d76-b41e-57d56de21125',
-    isVisible: true,
-  }),
-  noPerson1: Object.freeze({
-    id: 'assetFaceId8',
-    assetId: assetStub.image.id,
-    asset: assetStub.image,
-    personId: null,
-    person: null,
-    boundingBoxX1: 0,
-    boundingBoxY1: 0,
-    boundingBoxX2: 1,
-    boundingBoxY2: 1,
-    imageHeight: 1024,
-    imageWidth: 1024,
-    sourceType: SourceType.MachineLearning,
-    faceSearch: { faceId: 'assetFaceId8', embedding: '[1, 2, 3, 4]' },
-    deletedAt: null,
-    updatedAt: new Date('2023-01-01T00:00:00Z'),
-    updateId: '0d1173e3-4d80-4d76-b41e-57d56de21125',
-    isVisible: true,
-  }),
-  noPerson2: Object.freeze({
-    id: 'assetFaceId9',
-    assetId: assetStub.image.id,
-    asset: assetStub.image,
-    personId: null,
-    person: null,
-    boundingBoxX1: 0,
-    boundingBoxY1: 0,
-    boundingBoxX2: 1,
-    boundingBoxY2: 1,
-    imageHeight: 1024,
-    imageWidth: 1024,
-    sourceType: SourceType.MachineLearning,
-    faceSearch: { faceId: 'assetFaceId9', embedding: '[1, 2, 3, 4]' },
-    deletedAt: null,
-    updatedAt: new Date('2023-01-01T00:00:00Z'),
-    updateId: '0d1173e3-4d80-4d76-b41e-57d56de21125',
-    isVisible: true,
-  }),
-  fromExif1: Object.freeze({
-    id: 'assetFaceId9',
-    assetId: assetStub.image.id,
-    asset: assetStub.image,
-    personId: personStub.randomPerson.id,
-    person: personStub.randomPerson,
-    boundingBoxX1: 100,
-    boundingBoxY1: 100,
-    boundingBoxX2: 200,
-    boundingBoxY2: 200,
-    imageHeight: 500,
-    imageWidth: 400,
-    sourceType: SourceType.Exif,
-    deletedAt: null,
-    updatedAt: new Date('2023-01-01T00:00:00Z'),
-    updateId: '0d1173e3-4d80-4d76-b41e-57d56de21125',
-    isVisible: true,
-  }),
-  fromExif2: Object.freeze({
-    id: 'assetFaceId9',
-    assetId: assetStub.image.id,
-    asset: assetStub.image,
-    personId: personStub.randomPerson.id,
-    person: personStub.randomPerson,
-    boundingBoxX1: 0,
-    boundingBoxY1: 0,
-    boundingBoxX2: 1,
-    boundingBoxY2: 1,
-    imageHeight: 1024,
-    imageWidth: 1024,
-    sourceType: SourceType.Exif,
-    deletedAt: null,
-    updatedAt: new Date('2023-01-01T00:00:00Z'),
-    updateId: '0d1173e3-4d80-4d76-b41e-57d56de21125',
-    isVisible: true,
-  }),
-  withBirthDate: Object.freeze({
-    id: 'assetFaceId10',
-    assetId: assetStub.image.id,
-    asset: assetStub.image,
-    personId: personStub.withBirthDate.id,
-    person: personStub.withBirthDate,
-    boundingBoxX1: 0,
-    boundingBoxY1: 0,
-    boundingBoxX2: 1,
-    boundingBoxY2: 1,
-    imageHeight: 1024,
-    imageWidth: 1024,
-    sourceType: SourceType.MachineLearning,
-    deletedAt: null,
-    updatedAt: new Date('2023-01-01T00:00:00Z'),
-    updateId: '0d1173e3-4d80-4d76-b41e-57d56de21125',
-    isVisible: true,
-  }),
-};
@@ -1,5 +1,5 @@
-import { AssetType } from 'src/enum';
-import { previewFile } from 'test/fixtures/asset.stub';
+import { AssetFileType, AssetType } from 'src/enum';
+import { AssetFileFactory } from 'test/factories/asset-file.factory';
 import { userStub } from 'test/fixtures/user.stub';

 const updateId = '0d1173e3-4d80-4d76-b41e-57d56de21125';
@@ -179,7 +179,7 @@ export const personThumbnailStub = {
    type: AssetType.Image,
    originalPath: '/original/path.jpg',
    exifOrientation: '1',
-    previewPath: previewFile.path,
+    previewPath: AssetFileFactory.create({ type: AssetFileType.Preview }).path,
  }),
  newThumbnailMiddle: Object.freeze({
    ownerId: userStub.admin.id,
@@ -192,7 +192,7 @@ export const personThumbnailStub = {
    type: AssetType.Image,
    originalPath: '/original/path.jpg',
    exifOrientation: '1',
-    previewPath: previewFile.path,
+    previewPath: AssetFileFactory.create({ type: AssetFileType.Preview }).path,
  }),
  newThumbnailEnd: Object.freeze({
    ownerId: userStub.admin.id,
@@ -205,7 +205,7 @@ export const personThumbnailStub = {
    type: AssetType.Image,
    originalPath: '/original/path.jpg',
    exifOrientation: '1',
-    previewPath: previewFile.path,
+    previewPath: AssetFileFactory.create({ type: AssetFileType.Preview }).path,
  }),
  rawEmbeddedThumbnail: Object.freeze({
    ownerId: userStub.admin.id,
@@ -218,7 +218,7 @@ export const personThumbnailStub = {
    type: AssetType.Image,
    originalPath: '/original/path.dng',
    exifOrientation: '1',
-    previewPath: previewFile.path,
+    previewPath: AssetFileFactory.create({ type: AssetFileType.Preview }).path,
  }),
  negativeCoordinate: Object.freeze({
    ownerId: userStub.admin.id,
@@ -231,7 +231,7 @@ export const personThumbnailStub = {
    type: AssetType.Image,
    originalPath: '/original/path.jpg',
    exifOrientation: '1',
-    previewPath: previewFile.path,
+    previewPath: AssetFileFactory.create({ type: AssetFileType.Preview }).path,
  }),
  overflowingCoordinate: Object.freeze({
    ownerId: userStub.admin.id,
@@ -244,7 +244,7 @@ export const personThumbnailStub = {
    type: AssetType.Image,
    originalPath: '/original/path.jpg',
    exifOrientation: '1',
-    previewPath: previewFile.path,
+    previewPath: AssetFileFactory.create({ type: AssetFileType.Preview }).path,
  }),
  videoThumbnail: Object.freeze({
    ownerId: userStub.admin.id,
@@ -257,6 +257,6 @@ export const personThumbnailStub = {
    type: AssetType.Video,
    originalPath: '/original/path.mp4',
    exifOrientation: '1',
-    previewPath: previewFile.path,
+    previewPath: AssetFileFactory.create({ type: AssetFileType.Preview }).path,
  }),
 };
@@ -2,7 +2,7 @@ import { UserAdmin } from 'src/database';
 import { MapAsset } from 'src/dtos/asset-response.dto';
 import { SharedLinkResponseDto } from 'src/dtos/shared-link.dto';
 import { AssetStatus, AssetType, AssetVisibility, SharedLinkType } from 'src/enum';
-import { assetStub } from 'test/fixtures/asset.stub';
+import { AssetFactory } from 'test/factories/asset.factory';
 import { authStub } from 'test/fixtures/auth.stub';
 import { userStub } from 'test/fixtures/user.stub';

@@ -31,7 +31,7 @@ export const sharedLinkStub = {
    albumId: null,
    album: null,
    description: null,
-    assets: [assetStub.image],
+    assets: [AssetFactory.create()],
    password: 'password',
    slug: null,
  }),
@@ -0,0 +1,51 @@
+import { Selectable } from 'kysely';
+import { AssetTable } from 'src/schema/tables/asset.table';
+import { AssetFaceFactory } from 'test/factories/asset-face.factory';
+import { AssetFactory } from 'test/factories/asset.factory';
+
+export const getForStorageTemplate = (asset: ReturnType<AssetFactory['build']>) => {
+  return {
+    id: asset.id,
+    ownerId: asset.ownerId,
+    livePhotoVideoId: asset.livePhotoVideoId,
+    type: asset.type,
+    isExternal: asset.isExternal,
+    checksum: asset.checksum,
+    timeZone: asset.exifInfo.timeZone,
+    fileCreatedAt: asset.fileCreatedAt,
+    originalPath: asset.originalPath,
+    originalFileName: asset.originalFileName,
+    fileSizeInByte: asset.exifInfo.fileSizeInByte,
+    files: asset.files,
+    make: asset.exifInfo.make,
+    model: asset.exifInfo.model,
+    lensModel: asset.exifInfo.lensModel,
+    isEdited: asset.isEdited,
+  };
+};
+
+export const getAsDetectedFace = (face: ReturnType<AssetFaceFactory['build']>) => ({
+  faces: [
+    {
+      boundingBox: {
+        x1: face.boundingBoxX1,
+        y1: face.boundingBoxY1,
+        x2: face.boundingBoxX2,
+        y2: face.boundingBoxY2,
+      },
+      embedding: '[1, 2, 3, 4]',
+      score: 0.2,
+    },
+  ],
+  imageHeight: face.imageHeight,
+  imageWidth: face.imageWidth,
+});
+
+export const getForFacialRecognitionJob = (
+  face: ReturnType<AssetFaceFactory['build']>,
+  asset: Pick<Selectable<AssetTable>, 'ownerId' | 'visibility' | 'fileCreatedAt'> | null,
+) => ({
+  ...face,
+  asset,
+  faceSearch: { faceId: face.id, embedding: '[1, 2, 3, 4]' },
+});
@@ -1,12 +1,15 @@
 import { Kysely } from 'kysely';
+import { AssetEditAction } from 'src/dtos/editing.dto';
 import { AssetFileType, AssetMetadataKey, AssetStatus, JobName, SharedLinkType } from 'src/enum';
 import { AccessRepository } from 'src/repositories/access.repository';
 import { AlbumRepository } from 'src/repositories/album.repository';
+import { AssetEditRepository } from 'src/repositories/asset-edit.repository';
 import { AssetJobRepository } from 'src/repositories/asset-job.repository';
 import { AssetRepository } from 'src/repositories/asset.repository';
 import { EventRepository } from 'src/repositories/event.repository';
 import { JobRepository } from 'src/repositories/job.repository';
 import { LoggingRepository } from 'src/repositories/logging.repository';
+import { OcrRepository } from 'src/repositories/ocr.repository';
 import { SharedLinkAssetRepository } from 'src/repositories/shared-link-asset.repository';
 import { SharedLinkRepository } from 'src/repositories/shared-link.repository';
 import { StackRepository } from 'src/repositories/stack.repository';
@@ -25,6 +28,7 @@ const setup = (db?: Kysely<DB>) => {
    database: db || defaultDatabase,
    real: [
      AssetRepository,
+      AssetEditRepository,
      AssetJobRepository,
      AlbumRepository,
      AccessRepository,
@@ -32,7 +36,7 @@ const setup = (db?: Kysely<DB>) => {
      StackRepository,
      UserRepository,
    ],
-    mock: [EventRepository, LoggingRepository, JobRepository, StorageRepository],
+    mock: [EventRepository, LoggingRepository, JobRepository, StorageRepository, OcrRepository],
  });
 };

@@ -398,6 +402,23 @@ describe(AssetService.name, () => {
        }),
      );
    });
+
+    it('should update dateTimeOriginal with time zone UTC+0', async () => {
+      const { sut, ctx } = setup();
+      ctx.getMock(JobRepository).queue.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, description: 'test', timeZone: 'UTC-7' });
+
+      await sut.update(auth, asset.id, { dateTimeOriginal: '2023-11-19T18:11:00.000Z' });
+
+      await expect(ctx.get(AssetRepository).getById(asset.id, { exifInfo: true })).resolves.toEqual(
+        expect.objectContaining({
+          exifInfo: expect.objectContaining({ dateTimeOriginal: '2023-11-19T18:11:00+00:00', timeZone: 'UTC' }),
+        }),
+      );
+    });
  });

  describe('updateAll', () => {
@@ -456,7 +477,7 @@ describe(AssetService.name, () => {
      );
    });

-    it('should relatively update an assets with timezone', async () => {
+    it('should relatively update assets with timezone', async () => {
      const { sut, ctx } = setup();
      ctx.getMock(JobRepository).queueAll.mockResolvedValue();
      const { user } = await ctx.newUser();
@@ -477,7 +498,7 @@ describe(AssetService.name, () => {
      );
    });

-    it('should relatively update an assets and set a timezone', async () => {
+    it('should relatively update assets and set a timezone', async () => {
      const { sut, ctx } = setup();
      ctx.getMock(JobRepository).queueAll.mockResolvedValue();
      const { user } = await ctx.newUser();
@@ -497,6 +518,26 @@ describe(AssetService.name, () => {
      );
    });

+    it('should set asset time zones to UTC', 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-7' });
+
+      await sut.updateAll(auth, { ids: [asset.id], timeZone: 'UTC' });
+
+      await expect(ctx.get(AssetRepository).getById(asset.id, { exifInfo: true })).resolves.toEqual(
+        expect.objectContaining({
+          exifInfo: expect.objectContaining({
+            dateTimeOriginal: '2023-11-19T18:11:00+00:00',
+            timeZone: 'UTC',
+          }),
+        }),
+      );
+    });
+
    it('should update dateTimeOriginal', async () => {
      const { sut, ctx } = setup();
      ctx.getMock(JobRepository).queueAll.mockResolvedValue();
@@ -530,6 +571,125 @@ describe(AssetService.name, () => {
        }),
      );
    });
+
+    it('should update dateTimeOriginal with UTC time zone', 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, description: 'test', timeZone: 'UTC-7' });
+
+      await sut.updateAll(auth, { ids: [asset.id], dateTimeOriginal: '2023-11-19T18:11:00.000Z' });
+
+      await expect(ctx.get(AssetRepository).getById(asset.id, { exifInfo: true })).resolves.toEqual(
+        expect.objectContaining({
+          exifInfo: expect.objectContaining({ dateTimeOriginal: '2023-11-19T18:11:00+00:00', timeZone: 'UTC' }),
+        }),
+      );
+    });
+  });
+
+  describe('getOcr', () => {
+    it('should require access', async () => {
+      const { sut, ctx } = setup();
+      const { user } = await ctx.newUser();
+      const { user: user2 } = await ctx.newUser();
+      const auth = factory.auth({ user });
+      const { asset } = await ctx.newAsset({ ownerId: user2.id });
+
+      await expect(sut.getOcr(auth, asset.id)).rejects.toThrow('Not found or no asset.read access');
+    });
+
+    it('should work', async () => {
+      const { sut, ctx } = setup();
+      const { user } = await ctx.newUser();
+      const auth = factory.auth({ user });
+      const { asset } = await ctx.newAsset({ ownerId: user.id });
+      await ctx.newExif({ assetId: asset.id, exifImageHeight: 42, exifImageWidth: 69, orientation: '1' });
+      ctx.getMock(OcrRepository).getByAssetId.mockResolvedValue([factory.assetOcr()]);
+
+      await expect(sut.getOcr(auth, asset.id)).resolves.toEqual([
+        expect.objectContaining({ x1: 0.1, x2: 0.3, x3: 0.3, x4: 0.1, y1: 0.2, y2: 0.2, y3: 0.4, y4: 0.4 }),
+      ]);
+    });
+
+    it('should apply rotation', async () => {
+      const { sut, ctx } = setup();
+      const { user } = await ctx.newUser();
+      const auth = factory.auth({ user });
+      const { asset } = await ctx.newAsset({ ownerId: user.id });
+      await ctx.newExif({ assetId: asset.id, exifImageHeight: 42, exifImageWidth: 69, orientation: '1' });
+      await ctx.database
+        .insertInto('asset_edit')
+        .values({ assetId: asset.id, action: AssetEditAction.Rotate, parameters: { angle: 90 }, sequence: 1 })
+        .execute();
+      ctx.getMock(OcrRepository).getByAssetId.mockResolvedValue([factory.assetOcr()]);
+
+      await expect(sut.getOcr(auth, asset.id)).resolves.toEqual([
+        expect.objectContaining({
+          x1: 0.6,
+          x2: 0.8,
+          x3: 0.8,
+          x4: 0.6,
+          y1: expect.any(Number),
+          y2: expect.any(Number),
+          y3: 0.3,
+          y4: 0.3,
+        }),
+      ]);
+    });
+  });
+
+  describe('getOcr', () => {
+    it('should require access', async () => {
+      const { sut, ctx } = setup();
+      const { user } = await ctx.newUser();
+      const { user: user2 } = await ctx.newUser();
+      const auth = factory.auth({ user });
+      const { asset } = await ctx.newAsset({ ownerId: user2.id });
+
+      await expect(sut.getOcr(auth, asset.id)).rejects.toThrow('Not found or no asset.read access');
+    });
+
+    it('should work', async () => {
+      const { sut, ctx } = setup();
+      const { user } = await ctx.newUser();
+      const auth = factory.auth({ user });
+      const { asset } = await ctx.newAsset({ ownerId: user.id });
+      await ctx.newExif({ assetId: asset.id, exifImageHeight: 42, exifImageWidth: 69, orientation: '1' });
+      ctx.getMock(OcrRepository).getByAssetId.mockResolvedValue([factory.assetOcr()]);
+
+      await expect(sut.getOcr(auth, asset.id)).resolves.toEqual([
+        expect.objectContaining({ x1: 0.1, x2: 0.3, x3: 0.3, x4: 0.1, y1: 0.2, y2: 0.2, y3: 0.4, y4: 0.4 }),
+      ]);
+    });
+
+    it('should apply rotation', async () => {
+      const { sut, ctx } = setup();
+      const { user } = await ctx.newUser();
+      const auth = factory.auth({ user });
+      const { asset } = await ctx.newAsset({ ownerId: user.id });
+      await ctx.newExif({ assetId: asset.id, exifImageHeight: 42, exifImageWidth: 69, orientation: '1' });
+      await ctx.database
+        .insertInto('asset_edit')
+        .values({ assetId: asset.id, action: AssetEditAction.Rotate, parameters: { angle: 90 }, sequence: 1 })
+        .execute();
+      ctx.getMock(OcrRepository).getByAssetId.mockResolvedValue([factory.assetOcr()]);
+
+      await expect(sut.getOcr(auth, asset.id)).resolves.toEqual([
+        expect.objectContaining({
+          x1: 0.6,
+          x2: 0.8,
+          x3: 0.8,
+          x4: 0.6,
+          y1: expect.any(Number),
+          y2: expect.any(Number),
+          y3: 0.3,
+          y4: 0.3,
+        }),
+      ]);
+    });
  });

  describe('upsertBulkMetadata', () => {
@@ -704,4 +864,38 @@ describe(AssetService.name, () => {
      expect(metadata).toEqual([expect.objectContaining({ key: 'some-other-key', value: { foo: 'bar' } })]);
    });
  });
+
+  describe('editAsset', () => {
+    it('should require access', async () => {
+      const { sut, ctx } = setup();
+      const { user } = await ctx.newUser();
+      const { user: user2 } = await ctx.newUser();
+      const auth = factory.auth({ user });
+      const { asset } = await ctx.newAsset({ ownerId: user2.id });
+
+      await expect(
+        sut.editAsset(auth, asset.id, { edits: [{ action: AssetEditAction.Rotate, parameters: { angle: 90 } }] }),
+      ).rejects.toThrow('Not found or no asset.edit.create access');
+    });
+
+    it('should work', async () => {
+      const { sut, ctx } = setup();
+      ctx.getMock(JobRepository).queue.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, exifImageHeight: 42, exifImageWidth: 69, orientation: '1' });
+
+      const editAction = { action: AssetEditAction.Rotate, parameters: { angle: 90 } } as const;
+      await expect(sut.editAsset(auth, asset.id, { edits: [editAction] })).resolves.toEqual({
+        assetId: asset.id,
+        edits: [editAction],
+      });
+
+      await expect(ctx.get(AssetRepository).getById(asset.id)).resolves.toEqual(
+        expect.objectContaining({ isEdited: true }),
+      );
+      await expect(ctx.get(AssetEditRepository).getAll(asset.id)).resolves.toEqual([editAction]);
+    });
+  });
 });
@@ -90,7 +90,7 @@ describe(SharedLinkService.name, () => {
      assetIds: assets.map(({ asset }) => asset.id),
    });

-    await expect(sut.getMine({ user, sharedLink }, {})).resolves.toMatchObject({
+    await expect(sut.getMine({ user, sharedLink }, [])).resolves.toMatchObject({
      assets: assets.map(({ asset }) => expect.objectContaining({ id: asset.id })),
    });
  });
@@ -114,7 +114,7 @@ describe(SharedLinkService.name, () => {
      assetIds: [asset.id],
    });

-    await expect(sut.getMine({ user, sharedLink }, {})).resolves.toMatchObject({
+    await expect(sut.getMine({ user, sharedLink }, [])).resolves.toMatchObject({
      assets: [expect.objectContaining({ id: asset.id })],
    });

@@ -122,6 +122,6 @@ describe(SharedLinkService.name, () => {
      assetIds: [asset.id],
    });

-    await expect(sut.getMine({ user, sharedLink }, {})).resolves.toHaveProperty('assets', []);
+    await expect(sut.getMine({ user, sharedLink }, [])).resolves.toHaveProperty('assets', []);
  });
 });
@@ -51,7 +51,13 @@ export const newAssetRepositoryMock = (): Mocked<RepositoryInterface<AssetReposi
    deleteMetadataByKey: vitest.fn(),
    deleteBulkMetadata: vitest.fn(),
    getForOriginal: vitest.fn(),
+    getForOriginals: vitest.fn(),
    getForThumbnail: vitest.fn(),
    getForVideo: vitest.fn(),
+    getForEdit: vitest.fn(),
+    getForOcr: vitest.fn(),
+    getForMetadataExtractionTags: vitest.fn(),
+    getForFaces: vitest.fn(),
+    getForUpdateTags: vitest.fn(),
  };
 };
@@ -1,29 +0,0 @@
-import { DatabaseRepository } from 'src/repositories/database.repository';
-import { RepositoryInterface } from 'src/types';
-import { Mocked, vitest } from 'vitest';
-
-export const newDatabaseRepositoryMock = (): Mocked<RepositoryInterface<DatabaseRepository>> => {
-  return {
-    shutdown: vitest.fn(),
-    getExtensionVersions: vitest.fn(),
-    getVectorExtension: vitest.fn(),
-    getExtensionVersionRange: vitest.fn(),
-    getPostgresVersion: vitest.fn().mockResolvedValue('14.10 (Debian 14.10-1.pgdg120+1)'),
-    getPostgresVersionRange: vitest.fn().mockReturnValue('>=14.0.0'),
-    createExtension: vitest.fn().mockResolvedValue(void 0),
-    dropExtension: vitest.fn(),
-    updateVectorExtension: vitest.fn(),
-    reindexVectorsIfNeeded: vitest.fn(),
-    getDimensionSize: vitest.fn(),
-    setDimensionSize: vitest.fn(),
-    deleteAllSearchEmbeddings: vitest.fn(),
-    prewarm: vitest.fn(),
-    runMigrations: vitest.fn(),
-    revertLastMigration: vitest.fn(),
-    withLock: vitest.fn().mockImplementation((_, function_: <R>() => Promise<R>) => function_()),
-    tryLock: vitest.fn(),
-    isBusy: vitest.fn(),
-    wait: vitest.fn(),
-    migrateFilePaths: vitest.fn(),
-  };
-};
@@ -76,7 +76,6 @@ import { IAccessRepositoryMock, newAccessRepositoryMock } from 'test/repositorie
 import { newAssetRepositoryMock } from 'test/repositories/asset.repository.mock';
 import { newConfigRepositoryMock } from 'test/repositories/config.repository.mock';
 import { newCryptoRepositoryMock } from 'test/repositories/crypto.repository.mock';
-import { newDatabaseRepositoryMock } from 'test/repositories/database.repository.mock';
 import { newJobRepositoryMock } from 'test/repositories/job.repository.mock';
 import { newMediaRepositoryMock } from 'test/repositories/media.repository.mock';
 import { newMetadataRepositoryMock } from 'test/repositories/metadata.repository.mock';
@@ -281,6 +280,14 @@ export const getMocks = () => {
  const loggerMock = { setContext: () => {} };
  const configMock = { getEnv: () => ({}) };

+  // eslint-disable-next-line no-sparse-arrays
+  const databaseMock = automock(DatabaseRepository, { args: [, loggerMock], strict: false });
+
+  databaseMock.withLock.mockImplementation((_type, fn) => fn());
+  databaseMock.getPostgresVersion = vitest.fn().mockResolvedValue('14.10 (Debian 14.10-1.pgdg120+1)');
+  databaseMock.getPostgresVersionRange = vitest.fn().mockReturnValue('>=14.0.0');
+  databaseMock.createExtension = vitest.fn().mockResolvedValue(void 0);
+
  const mocks: ServiceMocks = {
    access: newAccessRepositoryMock(),
    // eslint-disable-next-line no-sparse-arrays
@@ -297,7 +304,7 @@ export const getMocks = () => {
    assetJob: automock(AssetJobRepository),
    app: automock(AppRepository, { strict: false }),
    config: newConfigRepositoryMock(),
-    database: newDatabaseRepositoryMock(),
+    database: databaseMock,
    downloadRepository: automock(DownloadRepository, { strict: false }),
    duplicateRepository: automock(DuplicateRepository),
    email: automock(EmailRepository, { args: [loggerMock] }),