feat(server): person delete (#19511)

feat(api): person delete

server/test/medium.factory.ts

@@ -7,6 +7,7 @@ import { AssetFace } from 'src/database';
 import { Albums, AssetJobStatus, Assets, DB, FaceSearch, Person, Sessions } from 'src/db';
 import { AuthDto } from 'src/dtos/auth.dto';
 import { AssetType, AssetVisibility, SourceType, SyncRequestType } from 'src/enum';
+import { AccessRepository } from 'src/repositories/access.repository';
 import { ActivityRepository } from 'src/repositories/activity.repository';
 import { AlbumUserRepository } from 'src/repositories/album-user.repository';
 import { AlbumRepository } from 'src/repositories/album.repository';
@@ -24,6 +25,7 @@ import { PartnerRepository } from 'src/repositories/partner.repository';
 import { PersonRepository } from 'src/repositories/person.repository';
 import { SearchRepository } from 'src/repositories/search.repository';
 import { SessionRepository } from 'src/repositories/session.repository';
+import { StorageRepository } from 'src/repositories/storage.repository';
 import { SyncRepository } from 'src/repositories/sync.repository';
 import { SystemMetadataRepository } from 'src/repositories/system-metadata.repository';
 import { UserRepository } from 'src/repositories/user.repository';
@@ -40,6 +42,7 @@ const sha256 = (value: string) => createHash('sha256').update(value).digest('bas
 
 // type Repositories = Omit<ServiceOverrides, 'access' | 'telemetry'>;
 type RepositoriesTypes = {
+  access: AccessRepository;
   activity: ActivityRepository;
   album: AlbumRepository;
   albumUser: AlbumUserRepository;
@@ -58,6 +61,7 @@ type RepositoriesTypes = {
   person: PersonRepository;
   search: SearchRepository;
   session: SessionRepository;
+  storage: StorageRepository;
   sync: SyncRepository;
   systemMetadata: SystemMetadataRepository;
   versionHistory: VersionHistoryRepository;
@@ -180,6 +184,10 @@ export const newMediumService = <R extends RepositoryOptions, S extends BaseServ
 
 export const getRepository = <K extends keyof RepositoriesTypes>(key: K, db: Kysely<DB>) => {
   switch (key) {
+    case 'access': {
+      return new AccessRepository(db);
+    }
+
     case 'activity': {
       return new ActivityRepository(db);
     }
@@ -352,6 +360,10 @@ const getRepositoryMock = <K extends keyof RepositoryMocks>(key: K) => {
       return automock(SessionRepository);
     }
 
+    case 'storage': {
+      return automock(StorageRepository, { args: [{ setContext: () => {} }] });
+    }
+
     case 'sync': {
       return automock(SyncRepository);
     }
@@ -411,7 +423,7 @@ export const asDeps = (repositories: ServiceOverrides) => {
     repositories.session || getRepositoryMock('session'),
     repositories.sharedLink,
     repositories.stack,
-    repositories.storage,
+    repositories.storage || getRepositoryMock('storage'),
     repositories.sync || getRepositoryMock('sync'),
     repositories.systemMetadata || getRepositoryMock('systemMetadata'),
     repositories.tag,

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

@@ -0,0 +1,90 @@
+import { Kysely } from 'kysely';
+import { DB } from 'src/db';
+import { PersonService } from 'src/services/person.service';
+import { mediumFactory, newMediumService } from 'test/medium.factory';
+import { factory } from 'test/small.factory';
+import { getKyselyDB } from 'test/utils';
+
+describe.concurrent(PersonService.name, () => {
+  let defaultDatabase: Kysely<DB>;
+
+  const createSut = (db?: Kysely<DB>) => {
+    return newMediumService(PersonService, {
+      database: db || defaultDatabase,
+      repos: {
+        access: 'real',
+        database: 'real',
+        person: 'real',
+        storage: 'mock',
+      },
+    });
+  };
+
+  beforeEach(async () => {
+    defaultDatabase = await getKyselyDB();
+  });
+
+  describe('delete', () => {
+    it('should throw an error when there is no access', async () => {
+      const { sut } = createSut();
+      const auth = factory.auth();
+      const personId = factory.uuid();
+      await expect(sut.delete(auth, personId)).rejects.toThrow('Not found or no person.delete access');
+    });
+
+    it('should delete the person', async () => {
+      const { sut, getRepository, mocks } = createSut();
+
+      const user = mediumFactory.userInsert();
+      const auth = factory.auth({ user });
+      const person = mediumFactory.personInsert({ ownerId: auth.user.id });
+      mocks.storage.unlink.mockResolvedValue();
+
+      const userRepo = getRepository('user');
+      await userRepo.create(user);
+
+      const personRepo = getRepository('person');
+      await personRepo.create(person);
+
+      await expect(personRepo.getById(person.id)).resolves.toEqual(expect.objectContaining({ id: person.id }));
+      await expect(sut.delete(auth, person.id)).resolves.toBeUndefined();
+      await expect(personRepo.getById(person.id)).resolves.toBeUndefined();
+
+      expect(mocks.storage.unlink).toHaveBeenCalledWith(person.thumbnailPath);
+    });
+  });
+
+  describe('deleteAll', () => {
+    it('should throw an error when there is no access', async () => {
+      const { sut } = createSut();
+      const auth = factory.auth();
+      const personId = factory.uuid();
+      await expect(sut.deleteAll(auth, { ids: [personId] })).rejects.toThrow('Not found or no person.delete access');
+    });
+
+    it('should delete the person', async () => {
+      const { sut, getRepository, mocks } = createSut();
+
+      const user = mediumFactory.userInsert();
+      const auth = factory.auth({ user });
+      const person1 = mediumFactory.personInsert({ ownerId: auth.user.id });
+      const person2 = mediumFactory.personInsert({ ownerId: auth.user.id });
+      mocks.storage.unlink.mockResolvedValue();
+
+      const userRepo = getRepository('user');
+      await userRepo.create(user);
+
+      const personRepo = getRepository('person');
+      await personRepo.create(person1);
+      await personRepo.create(person2);
+
+      await expect(sut.deleteAll(auth, { ids: [person1.id, person2.id] })).resolves.toBeUndefined();
+      await expect(personRepo.getById(person1.id)).resolves.toBeUndefined();
+      await expect(personRepo.getById(person2.id)).resolves.toBeUndefined();
+
+      expect(mocks.storage.unlink).toHaveBeenCalledTimes(2);
+      expect(mocks.storage.unlink).toHaveBeenCalledWith(person1.thumbnailPath);
+      expect(mocks.storage.unlink).toHaveBeenCalledWith(person2.thumbnailPath);
+    });
+  });
+});

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

@@ -1,38 +0,0 @@
-import { PersonRepository } from 'src/repositories/person.repository';
-import { RepositoryInterface } from 'src/types';
-import { Mocked, vitest } from 'vitest';
-
-export const newPersonRepositoryMock = (): Mocked<RepositoryInterface<PersonRepository>> => {
-  return {
-    reassignFaces: vitest.fn(),
-    unassignFaces: vitest.fn(),
-    delete: vitest.fn(),
-    deleteFaces: vitest.fn(),
-    getAllFaces: vitest.fn(),
-    getAll: vitest.fn(),
-    getAllForUser: vitest.fn(),
-    getAllWithoutFaces: vitest.fn(),
-    getFaces: vitest.fn(),
-    getFaceById: vitest.fn(),
-    getFaceForFacialRecognitionJob: vitest.fn(),
-    getDataForThumbnailGenerationJob: vitest.fn(),
-    reassignFace: vitest.fn(),
-    getById: vitest.fn(),
-    getByName: vitest.fn(),
-    getDistinctNames: vitest.fn(),
-    getStatistics: vitest.fn(),
-    getNumberOfPeople: vitest.fn(),
-    create: vitest.fn(),
-    createAll: vitest.fn(),
-    refreshFaces: vitest.fn(),
-    update: vitest.fn(),
-    updateAll: vitest.fn(),
-    getFacesByIds: vitest.fn(),
-    getRandomFace: vitest.fn(),
-    getLatestFaceDate: vitest.fn(),
-    createAssetFace: vitest.fn(),
-    deleteAssetFace: vitest.fn(),
-    softDeleteAssetFaces: vitest.fn(),
-    vacuum: vitest.fn(),
-  };
-};

server/test/utils.ts

@@ -67,7 +67,6 @@ import { newDatabaseRepositoryMock } from 'test/repositories/database.repository
 import { newJobRepositoryMock } from 'test/repositories/job.repository.mock';
 import { newMediaRepositoryMock } from 'test/repositories/media.repository.mock';
 import { newMetadataRepositoryMock } from 'test/repositories/metadata.repository.mock';
-import { newPersonRepositoryMock } from 'test/repositories/person.repository.mock';
 import { newStorageRepositoryMock } from 'test/repositories/storage.repository.mock';
 import { newSystemMetadataRepositoryMock } from 'test/repositories/system-metadata.repository.mock';
 import { ITelemetryRepositoryMock, newTelemetryRepositoryMock } from 'test/repositories/telemetry.repository.mock';
@@ -278,7 +277,7 @@ export const newTestService = <T extends BaseService>(
     notification: automock(NotificationRepository),
     oauth: automock(OAuthRepository, { args: [loggerMock] }),
     partner: automock(PartnerRepository, { strict: false }),
-    person: newPersonRepositoryMock(),
+    person: automock(PersonRepository, { strict: false }),
     process: automock(ProcessRepository),
     search: automock(SearchRepository, { strict: false }),
     // eslint-disable-next-line no-sparse-arrays