refactor(server)*: tsconfigs (#2689)

* refactor(server): tsconfigs

* chore: dummy commit

* fix: start.sh

* chore: restore original entry scripts

server/src/domain/person/dto/index.ts

@@ -0,0 +1 @@
+export * from './person-update.dto';

server/src/domain/person/dto/person-update.dto.ts

@@ -0,0 +1,7 @@
+import { IsNotEmpty, IsString } from 'class-validator';
+
+export class PersonUpdateDto {
+  @IsNotEmpty()
+  @IsString()
+  name!: string;
+}

server/src/domain/person/index.ts

@@ -0,0 +1,4 @@
+export * from './dto';
+export * from './person.repository';
+export * from './person.service';
+export * from './response-dto';

server/src/domain/person/person.repository.ts

@@ -0,0 +1,19 @@
+import { AssetEntity, PersonEntity } from '@app/infra/entities';
+
+export const IPersonRepository = 'IPersonRepository';
+
+export interface PersonSearchOptions {
+  minimumFaceCount: number;
+}
+
+export interface IPersonRepository {
+  getAll(userId: string, options: PersonSearchOptions): Promise<PersonEntity[]>;
+  getAllWithoutFaces(): Promise<PersonEntity[]>;
+  getById(userId: string, personId: string): Promise<PersonEntity | null>;
+  getAssets(userId: string, id: string): Promise<AssetEntity[]>;
+
+  create(entity: Partial<PersonEntity>): Promise<PersonEntity>;
+  update(entity: Partial<PersonEntity>): Promise<PersonEntity>;
+  delete(entity: PersonEntity): Promise<PersonEntity | null>;
+  deleteAll(): Promise<number>;
+}

server/src/domain/person/person.service.spec.ts

@@ -0,0 +1,126 @@
+import { BadRequestException, NotFoundException } from '@nestjs/common';
+import { IJobRepository, JobName } from '..';
+import {
+  assetEntityStub,
+  authStub,
+  newJobRepositoryMock,
+  newPersonRepositoryMock,
+  newStorageRepositoryMock,
+  personStub,
+} from '@test';
+import { IStorageRepository } from '../storage';
+import { IPersonRepository } from './person.repository';
+import { PersonService } from './person.service';
+import { PersonResponseDto } from './response-dto';
+
+const responseDto: PersonResponseDto = {
+  id: 'person-1',
+  name: 'Person 1',
+  thumbnailPath: '/path/to/thumbnail',
+};
+
+describe(PersonService.name, () => {
+  let sut: PersonService;
+  let personMock: jest.Mocked<IPersonRepository>;
+  let storageMock: jest.Mocked<IStorageRepository>;
+  let jobMock: jest.Mocked<IJobRepository>;
+
+  beforeEach(async () => {
+    personMock = newPersonRepositoryMock();
+    storageMock = newStorageRepositoryMock();
+    jobMock = newJobRepositoryMock();
+    sut = new PersonService(personMock, storageMock, jobMock);
+  });
+
+  it('should be defined', () => {
+    expect(sut).toBeDefined();
+  });
+
+  describe('getAll', () => {
+    it('should get all people with thumbnails', async () => {
+      personMock.getAll.mockResolvedValue([personStub.withName, personStub.noThumbnail]);
+      await expect(sut.getAll(authStub.admin)).resolves.toEqual([responseDto]);
+      expect(personMock.getAll).toHaveBeenCalledWith(authStub.admin.id, { minimumFaceCount: 1 });
+    });
+  });
+
+  describe('getById', () => {
+    it('should throw a bad request when person is not found', async () => {
+      personMock.getById.mockResolvedValue(null);
+      await expect(sut.getById(authStub.admin, 'person-1')).rejects.toBeInstanceOf(BadRequestException);
+    });
+
+    it('should get a person by id', async () => {
+      personMock.getById.mockResolvedValue(personStub.withName);
+      await expect(sut.getById(authStub.admin, 'person-1')).resolves.toEqual(responseDto);
+      expect(personMock.getById).toHaveBeenCalledWith(authStub.admin.id, 'person-1');
+    });
+  });
+
+  describe('getThumbnail', () => {
+    it('should throw an error when personId is invalid', async () => {
+      personMock.getById.mockResolvedValue(null);
+      await expect(sut.getThumbnail(authStub.admin, 'person-1')).rejects.toBeInstanceOf(NotFoundException);
+      expect(storageMock.createReadStream).not.toHaveBeenCalled();
+    });
+
+    it('should throw an error when person has no thumbnail', async () => {
+      personMock.getById.mockResolvedValue(personStub.noThumbnail);
+      await expect(sut.getThumbnail(authStub.admin, 'person-1')).rejects.toBeInstanceOf(NotFoundException);
+      expect(storageMock.createReadStream).not.toHaveBeenCalled();
+    });
+
+    it('should serve the thumbnail', async () => {
+      personMock.getById.mockResolvedValue(personStub.noName);
+      await sut.getThumbnail(authStub.admin, 'person-1');
+      expect(storageMock.createReadStream).toHaveBeenCalledWith('/path/to/thumbnail', 'image/jpeg');
+    });
+  });
+
+  describe('getAssets', () => {
+    it("should return a person's assets", async () => {
+      personMock.getAssets.mockResolvedValue([assetEntityStub.image, assetEntityStub.video]);
+      await sut.getAssets(authStub.admin, 'person-1');
+      expect(personMock.getAssets).toHaveBeenCalledWith('admin_id', 'person-1');
+    });
+  });
+
+  describe('update', () => {
+    it('should throw an error when personId is invalid', async () => {
+      personMock.getById.mockResolvedValue(null);
+      await expect(sut.update(authStub.admin, 'person-1', { name: 'Person 1' })).rejects.toBeInstanceOf(
+        BadRequestException,
+      );
+      expect(personMock.update).not.toHaveBeenCalled();
+    });
+
+    it("should update a person's name", async () => {
+      personMock.getById.mockResolvedValue(personStub.noName);
+      personMock.update.mockResolvedValue(personStub.withName);
+      personMock.getAssets.mockResolvedValue([assetEntityStub.image]);
+
+      await expect(sut.update(authStub.admin, 'person-1', { name: 'Person 1' })).resolves.toEqual(responseDto);
+
+      expect(personMock.getById).toHaveBeenCalledWith('admin_id', 'person-1');
+      expect(personMock.update).toHaveBeenCalledWith({ id: 'person-1', name: 'Person 1' });
+      expect(jobMock.queue).toHaveBeenCalledWith({
+        name: JobName.SEARCH_INDEX_ASSET,
+        data: { ids: [assetEntityStub.image.id] },
+      });
+    });
+  });
+
+  describe('handlePersonCleanup', () => {
+    it('should delete people without faces', async () => {
+      personMock.getAllWithoutFaces.mockResolvedValue([personStub.noName]);
+
+      await sut.handlePersonCleanup();
+
+      expect(personMock.delete).toHaveBeenCalledWith(personStub.noName);
+      expect(jobMock.queue).toHaveBeenCalledWith({
+        name: JobName.DELETE_FILES,
+        data: { files: ['/path/to/thumbnail'] },
+      });
+    });
+  });
+});

server/src/domain/person/person.service.ts

@@ -0,0 +1,84 @@
+import { BadRequestException, Inject, Injectable, Logger, NotFoundException } from '@nestjs/common';
+import { AssetResponseDto, mapAsset } from '../asset';
+import { AuthUserDto } from '../auth';
+import { IJobRepository, JobName } from '../job';
+import { ImmichReadStream, IStorageRepository } from '../storage';
+import { PersonUpdateDto } from './dto';
+import { IPersonRepository } from './person.repository';
+import { mapPerson, PersonResponseDto } from './response-dto';
+
+@Injectable()
+export class PersonService {
+  readonly logger = new Logger(PersonService.name);
+
+  constructor(
+    @Inject(IPersonRepository) private repository: IPersonRepository,
+    @Inject(IStorageRepository) private storageRepository: IStorageRepository,
+    @Inject(IJobRepository) private jobRepository: IJobRepository,
+  ) {}
+
+  async getAll(authUser: AuthUserDto): Promise<PersonResponseDto[]> {
+    const people = await this.repository.getAll(authUser.id, { minimumFaceCount: 1 });
+    const named = people.filter((person) => !!person.name);
+    const unnamed = people.filter((person) => !person.name);
+    return (
+      [...named, ...unnamed]
+        // with thumbnails
+        .filter((person) => !!person.thumbnailPath)
+        .map((person) => mapPerson(person))
+    );
+  }
+
+  async getById(authUser: AuthUserDto, personId: string): Promise<PersonResponseDto> {
+    const person = await this.repository.getById(authUser.id, personId);
+    if (!person) {
+      throw new BadRequestException();
+    }
+
+    return mapPerson(person);
+  }
+
+  async getThumbnail(authUser: AuthUserDto, personId: string): Promise<ImmichReadStream> {
+    const person = await this.repository.getById(authUser.id, personId);
+    if (!person || !person.thumbnailPath) {
+      throw new NotFoundException();
+    }
+
+    return this.storageRepository.createReadStream(person.thumbnailPath, 'image/jpeg');
+  }
+
+  async getAssets(authUser: AuthUserDto, personId: string): Promise<AssetResponseDto[]> {
+    const assets = await this.repository.getAssets(authUser.id, personId);
+    return assets.map(mapAsset);
+  }
+
+  async update(authUser: AuthUserDto, personId: string, dto: PersonUpdateDto): Promise<PersonResponseDto> {
+    const exists = await this.repository.getById(authUser.id, personId);
+    if (!exists) {
+      throw new BadRequestException();
+    }
+
+    const person = await this.repository.update({ id: personId, name: dto.name });
+
+    const relatedAsset = await this.getAssets(authUser, personId);
+    const assetIds = relatedAsset.map((asset) => asset.id);
+    await this.jobRepository.queue({ name: JobName.SEARCH_INDEX_ASSET, data: { ids: assetIds } });
+
+    return mapPerson(person);
+  }
+
+  async handlePersonCleanup() {
+    const people = await this.repository.getAllWithoutFaces();
+    for (const person of people) {
+      this.logger.debug(`Person ${person.name || person.id} no longer has any faces, deleting.`);
+      try {
+        await this.repository.delete(person);
+        await this.jobRepository.queue({ name: JobName.DELETE_FILES, data: { files: [person.thumbnailPath] } });
+      } catch (error: Error | any) {
+        this.logger.error(`Unable to delete person: ${error}`, error?.stack);
+      }
+    }
+
+    return true;
+  }
+}

server/src/domain/person/response-dto/index.ts

@@ -0,0 +1 @@
+export * from './person-response.dto';

server/src/domain/person/response-dto/person-response.dto.ts

@@ -0,0 +1,19 @@
+import { AssetFaceEntity, PersonEntity } from '@app/infra/entities';
+
+export class PersonResponseDto {
+  id!: string;
+  name!: string;
+  thumbnailPath!: string;
+}
+
+export function mapPerson(person: PersonEntity): PersonResponseDto {
+  return {
+    id: person.id,
+    name: person.name,
+    thumbnailPath: person.thumbnailPath,
+  };
+}
+
+export function mapFace(face: AssetFaceEntity): PersonResponseDto {
+  return mapPerson(face.person);
+}