feat: more factories for small tests

server/src/config.ts

@@ -15,7 +15,7 @@ import {
 } from 'src/enum';
 import { ConcurrentQueueName, FullsizeImageOptions, ImageOptions } from 'src/types';
 
-export interface SystemConfig {
+export type SystemConfig = {
   backup: {
     database: {
       enabled: boolean;
@@ -187,7 +187,7 @@ export interface SystemConfig {
   user: {
     deleteDelay: number;
   };
-}
+};
 
 export type MachineLearningConfig = SystemConfig['machineLearning'];
 

server/src/services/metadata.service.spec.ts

@@ -387,7 +387,7 @@ describe(MetadataService.name, () => {
 
     it('should extract tags from TagsList', async () => {
       mocks.assetJob.getForMetadataExtraction.mockResolvedValue(removeNonSidecarFiles(assetStub.image));
-      mocks.asset.getById.mockResolvedValue({ exifInfo: { tags: ['Parent'] } } as any);
+      mocks.asset.getById.mockResolvedValue({ ...factory.asset(), exifInfo: factory.exif({ tags: ['Parent'] }) });
       mockReadTags({ TagsList: ['Parent'] });
       mocks.tag.upsertValue.mockResolvedValue(tagStub.parentUpsert);
 
@@ -398,7 +398,7 @@ describe(MetadataService.name, () => {
 
     it('should extract hierarchy from TagsList', async () => {
       mocks.assetJob.getForMetadataExtraction.mockResolvedValue(removeNonSidecarFiles(assetStub.image));
-      mocks.asset.getById.mockResolvedValue({ exifInfo: { tags: ['Parent/Child'] } } as any);
+      mocks.asset.getById.mockResolvedValue({ ...factory.asset(), exifInfo: factory.exif({ tags: ['Parent/Child'] }) });
       mockReadTags({ TagsList: ['Parent/Child'] });
       mocks.tag.upsertValue.mockResolvedValueOnce(tagStub.parentUpsert);
       mocks.tag.upsertValue.mockResolvedValueOnce(tagStub.childUpsert);
@@ -419,7 +419,7 @@ describe(MetadataService.name, () => {
 
     it('should extract tags from Keywords as a string', async () => {
       mocks.assetJob.getForMetadataExtraction.mockResolvedValue(removeNonSidecarFiles(assetStub.image));
-      mocks.asset.getById.mockResolvedValue({ exifInfo: { tags: ['Parent'] } } as any);
+      mocks.asset.getById.mockResolvedValue({ ...factory.asset(), exifInfo: factory.exif({ tags: ['Parent'] }) });
       mockReadTags({ Keywords: 'Parent' });
       mocks.tag.upsertValue.mockResolvedValue(tagStub.parentUpsert);
 
@@ -430,7 +430,7 @@ describe(MetadataService.name, () => {
 
     it('should extract tags from Keywords as a list', async () => {
       mocks.assetJob.getForMetadataExtraction.mockResolvedValue(removeNonSidecarFiles(assetStub.image));
-      mocks.asset.getById.mockResolvedValue({ exifInfo: { tags: ['Parent'] } } as any);
+      mocks.asset.getById.mockResolvedValue({ ...factory.asset(), exifInfo: factory.exif({ tags: ['Parent'] }) });
       mockReadTags({ Keywords: ['Parent'] });
       mocks.tag.upsertValue.mockResolvedValue(tagStub.parentUpsert);
 
@@ -441,7 +441,10 @@ describe(MetadataService.name, () => {
 
     it('should extract tags from Keywords as a list with a number', async () => {
       mocks.assetJob.getForMetadataExtraction.mockResolvedValue(removeNonSidecarFiles(assetStub.image));
-      mocks.asset.getById.mockResolvedValue({ exifInfo: { tags: ['Parent', '2024'] } } as any);
+      mocks.asset.getById.mockResolvedValue({
+        ...factory.asset(),
+        exifInfo: factory.exif({ tags: ['Parent', '2024'] }),
+      });
       mockReadTags({ Keywords: ['Parent', 2024] });
       mocks.tag.upsertValue.mockResolvedValue(tagStub.parentUpsert);
 
@@ -453,7 +456,7 @@ describe(MetadataService.name, () => {
 
     it('should extract hierarchal tags from Keywords', async () => {
       mocks.assetJob.getForMetadataExtraction.mockResolvedValue(removeNonSidecarFiles(assetStub.image));
-      mocks.asset.getById.mockResolvedValue({ exifInfo: { tags: ['Parent/Child'] } } as any);
+      mocks.asset.getById.mockResolvedValue({ ...factory.asset(), exifInfo: factory.exif({ tags: ['Parent/Child'] }) });
       mockReadTags({ Keywords: 'Parent/Child' });
       mocks.tag.upsertValue.mockResolvedValue(tagStub.parentUpsert);
 
@@ -473,7 +476,10 @@ describe(MetadataService.name, () => {
 
     it('should ignore Keywords when TagsList is present', async () => {
       mocks.assetJob.getForMetadataExtraction.mockResolvedValue(removeNonSidecarFiles(assetStub.image));
-      mocks.asset.getById.mockResolvedValue({ exifInfo: { tags: ['Parent/Child', 'Child'] } } as any);
+      mocks.asset.getById.mockResolvedValue({
+        ...factory.asset(),
+        exifInfo: factory.exif({ tags: ['Parent/Child', 'Child'] }),
+      });
       mockReadTags({ Keywords: 'Child', TagsList: ['Parent/Child'] });
       mocks.tag.upsertValue.mockResolvedValue(tagStub.parentUpsert);
 
@@ -493,7 +499,10 @@ describe(MetadataService.name, () => {
 
     it('should extract hierarchy from HierarchicalSubject', async () => {
       mocks.assetJob.getForMetadataExtraction.mockResolvedValue(removeNonSidecarFiles(assetStub.image));
-      mocks.asset.getById.mockResolvedValue({ exifInfo: { tags: ['Parent/Child', 'TagA'] } } as any);
+      mocks.asset.getById.mockResolvedValue({
+        ...factory.asset(),
+        exifInfo: factory.exif({ tags: ['Parent/Child', 'TagA'] }),
+      });
       mockReadTags({ HierarchicalSubject: ['Parent|Child', 'TagA'] });
       mocks.tag.upsertValue.mockResolvedValueOnce(tagStub.parentUpsert);
       mocks.tag.upsertValue.mockResolvedValueOnce(tagStub.childUpsert);
@@ -515,7 +524,10 @@ describe(MetadataService.name, () => {
 
     it('should extract tags from HierarchicalSubject as a list with a number', async () => {
       mocks.assetJob.getForMetadataExtraction.mockResolvedValue(removeNonSidecarFiles(assetStub.image));
-      mocks.asset.getById.mockResolvedValue({ exifInfo: { tags: ['Parent', '2024'] } } as any);
+      mocks.asset.getById.mockResolvedValue({
+        ...factory.asset(),
+        exifInfo: factory.exif({ tags: ['Parent', '2024'] }),
+      });
       mockReadTags({ HierarchicalSubject: ['Parent', 2024] });
       mocks.tag.upsertValue.mockResolvedValue(tagStub.parentUpsert);
 
@@ -527,7 +539,7 @@ describe(MetadataService.name, () => {
 
     it('should extract ignore / characters in a HierarchicalSubject tag', async () => {
       mocks.assetJob.getForMetadataExtraction.mockResolvedValue(assetStub.image);
-      mocks.asset.getById.mockResolvedValue({ exifInfo: { tags: ['Mom|Dad'] } } as any);
+      mocks.asset.getById.mockResolvedValue({ ...factory.asset(), exifInfo: factory.exif({ tags: ['Mom|Dad'] }) });
       mockReadTags({ HierarchicalSubject: ['Mom/Dad'] });
       mocks.tag.upsertValue.mockResolvedValueOnce(tagStub.parentUpsert);
 
@@ -542,7 +554,10 @@ describe(MetadataService.name, () => {
 
     it('should ignore HierarchicalSubject when TagsList is present', async () => {
       mocks.assetJob.getForMetadataExtraction.mockResolvedValue(assetStub.image);
-      mocks.asset.getById.mockResolvedValue({ exifInfo: { tags: ['Parent/Child', 'Parent2/Child2'] } } as any);
+      mocks.asset.getById.mockResolvedValue({
+        ...factory.asset(),
+        exifInfo: factory.exif({ tags: ['Parent/Child', 'Parent2/Child2'] }),
+      });
       mockReadTags({ HierarchicalSubject: ['Parent2|Child2'], TagsList: ['Parent/Child'] });
       mocks.tag.upsertValue.mockResolvedValue(tagStub.parentUpsert);
 

server/src/services/tag.service.spec.ts

@@ -4,6 +4,7 @@ import { JobStatus } from 'src/enum';
 import { TagService } from 'src/services/tag.service';
 import { authStub } from 'test/fixtures/auth.stub';
 import { tagResponseStub, tagStub } from 'test/fixtures/tag.stub';
+import { factory } from 'test/small.factory';
 import { newTestService, ServiceMocks } from 'test/utils';
 
 describe(TagService.name, () => {
@@ -191,7 +192,10 @@ describe(TagService.name, () => {
     it('should upsert records', async () => {
       mocks.access.tag.checkOwnerAccess.mockResolvedValue(new Set(['tag-1', 'tag-2']));
       mocks.access.asset.checkOwnerAccess.mockResolvedValue(new Set(['asset-1', 'asset-2', 'asset-3']));
-      mocks.asset.getById.mockResolvedValue({ tags: [{ value: 'tag-1' }, { value: 'tag-2' }] } as any);
+      mocks.asset.getById.mockResolvedValue({
+        ...factory.asset(),
+        tags: [factory.tag({ value: 'tag-1' }), factory.tag({ value: 'tag-2' })],
+      });
       mocks.tag.upsertAssetIds.mockResolvedValue([
         { tagId: 'tag-1', assetId: 'asset-1' },
         { tagId: 'tag-1', assetId: 'asset-2' },
@@ -206,15 +210,15 @@ describe(TagService.name, () => {
         count: 6,
       });
       expect(mocks.asset.upsertExif).toHaveBeenCalledWith(
-        { assetId: 'asset-1', tags: ['tag-1', 'tag-2'] },
+        { assetId: 'asset-1', lockedProperties: ['tags'], tags: ['tag-1', 'tag-2'] },
         { lockedPropertiesBehavior: 'append' },
       );
       expect(mocks.asset.upsertExif).toHaveBeenCalledWith(
-        { assetId: 'asset-2', tags: ['tag-1', 'tag-2'] },
+        { assetId: 'asset-2', lockedProperties: ['tags'], tags: ['tag-1', 'tag-2'] },
         { lockedPropertiesBehavior: 'append' },
       );
       expect(mocks.asset.upsertExif).toHaveBeenCalledWith(
-        { assetId: 'asset-3', tags: ['tag-1', 'tag-2'] },
+        { assetId: 'asset-3', lockedProperties: ['tags'], tags: ['tag-1', 'tag-2'] },
         { lockedPropertiesBehavior: 'append' },
       );
       expect(mocks.tag.upsertAssetIds).toHaveBeenCalledWith([
@@ -242,7 +246,10 @@ describe(TagService.name, () => {
       mocks.tag.get.mockResolvedValue(tagStub.tag);
       mocks.tag.getAssetIds.mockResolvedValue(new Set(['asset-1']));
       mocks.tag.addAssetIds.mockResolvedValue();
-      mocks.asset.getById.mockResolvedValue({ tags: [{ value: 'tag-1' }] } as any);
+      mocks.asset.getById.mockResolvedValue({
+        ...factory.asset(),
+        tags: [factory.tag({ value: 'tag-1' })],
+      });
       mocks.access.asset.checkOwnerAccess.mockResolvedValue(new Set(['asset-2']));
 
       await expect(
@@ -255,11 +262,11 @@ describe(TagService.name, () => {
       ]);
 
       expect(mocks.asset.upsertExif).not.toHaveBeenCalledWith(
-        { assetId: 'asset-1', tags: ['tag-1'] },
+        { assetId: 'asset-1', lockedProperties: ['tags'], tags: ['tag-1'] },
         { lockedPropertiesBehavior: 'append' },
       );
       expect(mocks.asset.upsertExif).toHaveBeenCalledWith(
-        { assetId: 'asset-2', tags: ['tag-1'] },
+        { assetId: 'asset-2', lockedProperties: ['tags'], tags: ['tag-1'] },
         { lockedPropertiesBehavior: 'append' },
       );
       expect(mocks.tag.getAssetIds).toHaveBeenCalledWith('tag-1', ['asset-1', 'asset-2']);

server/src/services/tag.service.ts

@@ -16,6 +16,7 @@ import { JobName, JobStatus, Permission, QueueName } from 'src/enum';
 import { TagAssetTable } from 'src/schema/tables/tag-asset.table';
 import { BaseService } from 'src/services/base.service';
 import { addAssets, removeAssets } from 'src/utils/asset.util';
+import { updateLockedColumns } from 'src/utils/database';
 import { upsertTags } from 'src/utils/tag';
 
 @Injectable()
@@ -152,7 +153,7 @@ export class TagService extends BaseService {
   private async updateTags(assetId: string) {
     const asset = await this.assetRepository.getById(assetId, { tags: true });
     await this.assetRepository.upsertExif(
-      { assetId, tags: asset?.tags?.map(({ value }) => value) ?? [] },
+      updateLockedColumns({ assetId, tags: asset?.tags?.map(({ value }) => value) ?? [] }),
       { lockedPropertiesBehavior: 'append' },
     );
   }

server/src/types.ts

@@ -23,34 +23,39 @@ import {
   VideoCodec,
 } from 'src/enum';
 
-export type DeepPartial<T> = T extends object ? { [K in keyof T]?: DeepPartial<T[K]> } : T;
+export type DeepPartial<T> =
+  T extends Record<string, unknown>
+    ? { [K in keyof T]?: DeepPartial<T[K]> }
+    : T extends Array<infer R>
+      ? DeepPartial<R>[]
+      : T;
 
 export type RepositoryInterface<T extends object> = Pick<T, keyof T>;
 
-export interface FullsizeImageOptions {
+export type FullsizeImageOptions = {
   format: ImageFormat;
   quality: number;
   enabled: boolean;
-}
+};
 
-export interface ImageOptions {
+export type ImageOptions = {
   format: ImageFormat;
   quality: number;
   size: number;
-}
+};
 
-export interface RawImageInfo {
+export type RawImageInfo = {
   width: number;
   height: number;
   channels: 1 | 2 | 3 | 4;
-}
+};
 
-interface DecodeImageOptions {
+type DecodeImageOptions = {
   colorspace: string;
   processInvalidImages: boolean;
   raw?: RawImageInfo;
   edits?: AssetEditActionItem[];
-}
+};
 
 export interface DecodeToBufferOptions extends DecodeImageOptions {
   size?: number;
@@ -504,7 +509,7 @@ export interface SystemMetadata extends Record<SystemMetadataKey, Record<string,
   [SystemMetadataKey.MemoriesState]: MemoriesState;
 }
 
-export interface UserPreferences {
+export type UserPreferences = {
   albums: {
     defaultAssetOrder: AssetOrder;
   };
@@ -547,7 +552,7 @@ export interface UserPreferences {
   cast: {
     gCastEnabled: boolean;
   };
-}
+};
 
 export type UserMetadataItem<T extends keyof UserMetadata = UserMetadataKey> = {
   key: T;

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

@@ -1,12 +1,15 @@
 import { Kysely } from 'kysely';
 import { JobStatus } from 'src/enum';
 import { AccessRepository } from 'src/repositories/access.repository';
+import { AssetRepository } from 'src/repositories/asset.repository';
+import { EventRepository } from 'src/repositories/event.repository';
 import { LoggingRepository } from 'src/repositories/logging.repository';
 import { TagRepository } from 'src/repositories/tag.repository';
 import { DB } from 'src/schema';
 import { TagService } from 'src/services/tag.service';
 import { upsertTags } from 'src/utils/tag';
 import { newMediumService } from 'test/medium.factory';
+import { factory } from 'test/small.factory';
 import { getKyselyDB } from 'test/utils';
 
 let defaultDatabase: Kysely<DB>;
@@ -14,8 +17,8 @@ let defaultDatabase: Kysely<DB>;
 const setup = (db?: Kysely<DB>) => {
   return newMediumService(TagService, {
     database: db || defaultDatabase,
-    real: [TagRepository, AccessRepository],
-    mock: [LoggingRepository],
+    real: [AssetRepository, TagRepository, AccessRepository],
+    mock: [EventRepository, LoggingRepository],
   });
 };
 
@@ -24,6 +27,32 @@ beforeAll(async () => {
 });
 
 describe(TagService.name, () => {
+  describe('addAssets', () => {
+    it('should lock exif column', async () => {
+      const { sut, ctx } = setup();
+      ctx.getMock(EventRepository).emit.mockResolvedValue();
+      const { user } = await ctx.newUser();
+      const { asset } = await ctx.newAsset({ ownerId: user.id });
+      const [tag] = await upsertTags(ctx.get(TagRepository), { userId: user.id, tags: ['tag-1'] });
+      const authDto = factory.auth({ user });
+
+      await sut.addAssets(authDto, tag.id, { ids: [asset.id] });
+      await expect(
+        ctx.database
+          .selectFrom('asset_exif')
+          .select(['lockedProperties', 'tags'])
+          .where('assetId', '=', asset.id)
+          .executeTakeFirstOrThrow(),
+      ).resolves.toEqual({
+        lockedProperties: ['tags'],
+        tags: ['tag-1'],
+      });
+      await expect(ctx.get(TagRepository).getByValue(user.id, 'tag-1')).resolves.toEqual(
+        expect.objectContaining({ id: tag.id }),
+      );
+      await expect(ctx.get(TagRepository).getAssetIds(tag.id, [asset.id])).resolves.toContain(asset.id);
+    });
+  });
   describe('deleteEmptyTags', () => {
     it('single tag exists, not connected to any assets, and is deleted', async () => {
       const { sut, ctx } = setup();

server/test/small.factory.ts

@@ -1,6 +1,7 @@
 import {
   Activity,
   ApiKey,
+  AssetFace,
   AssetFile,
   AuthApiKey,
   AuthSharedLink,
@@ -9,12 +10,16 @@ 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,
@@ -23,10 +28,11 @@ import {
   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 +166,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 +236,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();
@@ -391,6 +408,102 @@ const assetFileFactory = (file: Partial<AssetFile> = {}): AssetFile => ({
   ...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,
+});
+
 export const factory = {
   activity: activityFactory,
   apiKey: apiKeyFactory,
@@ -412,6 +525,11 @@ export const factory = {
   jobAssets: {
     sidecarWrite: assetSidecarWriteFactory,
   },
+  exif: exifFactory,
+  face: faceFactory,
+  person: personFactory,
+  assetEdit: assetEditFactory,
+  tag: tagFactory,
   uuid: newUuid,
   date: newDate,
   responses: {