feat(server): improve and refactor get all albums (#2048)

Co-authored-by: Alex Tran <alex.tran1502@gmail.com>

server/libs/domain/src/album/album.repository.ts

@@ -2,8 +2,19 @@ import { AlbumEntity } from '@app/infra/db/entities';
 
 export const IAlbumRepository = 'IAlbumRepository';
 
+export interface AlbumAssetCount {
+  albumId: string;
+  assetCount: number;
+}
+
 export interface IAlbumRepository {
   getByIds(ids: string[]): Promise<AlbumEntity[]>;
+  getByAssetId(ownerId: string, assetId: string): Promise<AlbumEntity[]>;
+  getAssetCountForIds(ids: string[]): Promise<AlbumAssetCount[]>;
+  getInvalidThumbnail(): Promise<string[]>;
+  getOwned(ownerId: string): Promise<AlbumEntity[]>;
+  getShared(ownerId: string): Promise<AlbumEntity[]>;
+  getNotShared(ownerId: string): Promise<AlbumEntity[]>;
   deleteAll(userId: string): Promise<void>;
   getAll(): Promise<AlbumEntity[]>;
   save(album: Partial<AlbumEntity>): Promise<AlbumEntity>;

server/libs/domain/src/album/album.service.spec.ts

@@ -0,0 +1,114 @@
+import { albumStub, authStub, newAlbumRepositoryMock, newAssetRepositoryMock } from '../../test';
+import { IAssetRepository } from '../asset';
+import { IAlbumRepository } from './album.repository';
+import { AlbumService } from './album.service';
+
+describe(AlbumService.name, () => {
+  let sut: AlbumService;
+  let albumMock: jest.Mocked<IAlbumRepository>;
+  let assetMock: jest.Mocked<IAssetRepository>;
+
+  beforeEach(async () => {
+    albumMock = newAlbumRepositoryMock();
+    assetMock = newAssetRepositoryMock();
+
+    sut = new AlbumService(albumMock, assetMock);
+  });
+
+  it('should work', () => {
+    expect(sut).toBeDefined();
+  });
+
+  describe('get list of albums', () => {
+    it('gets list of albums for auth user', async () => {
+      albumMock.getOwned.mockResolvedValue([albumStub.empty, albumStub.sharedWithUser]);
+      albumMock.getAssetCountForIds.mockResolvedValue([
+        { albumId: albumStub.empty.id, assetCount: 0 },
+        { albumId: albumStub.sharedWithUser.id, assetCount: 0 },
+      ]);
+      albumMock.getInvalidThumbnail.mockResolvedValue([]);
+
+      const result = await sut.getAllAlbums(authStub.admin, {});
+      expect(result).toHaveLength(2);
+      expect(result[0].id).toEqual(albumStub.empty.id);
+      expect(result[1].id).toEqual(albumStub.sharedWithUser.id);
+    });
+
+    it('gets list of albums that have a specific asset', async () => {
+      albumMock.getByAssetId.mockResolvedValue([albumStub.oneAsset]);
+      albumMock.getAssetCountForIds.mockResolvedValue([{ albumId: albumStub.oneAsset.id, assetCount: 1 }]);
+      albumMock.getInvalidThumbnail.mockResolvedValue([]);
+
+      const result = await sut.getAllAlbums(authStub.admin, { assetId: albumStub.oneAsset.id });
+      expect(result).toHaveLength(1);
+      expect(result[0].id).toEqual(albumStub.oneAsset.id);
+      expect(albumMock.getByAssetId).toHaveBeenCalledTimes(1);
+    });
+
+    it('gets list of albums that are shared', async () => {
+      albumMock.getShared.mockResolvedValue([albumStub.sharedWithUser]);
+      albumMock.getAssetCountForIds.mockResolvedValue([{ albumId: albumStub.sharedWithUser.id, assetCount: 0 }]);
+      albumMock.getInvalidThumbnail.mockResolvedValue([]);
+
+      const result = await sut.getAllAlbums(authStub.admin, { shared: true });
+      expect(result).toHaveLength(1);
+      expect(result[0].id).toEqual(albumStub.sharedWithUser.id);
+      expect(albumMock.getShared).toHaveBeenCalledTimes(1);
+    });
+
+    it('gets list of albums that are NOT shared', async () => {
+      albumMock.getNotShared.mockResolvedValue([albumStub.empty]);
+      albumMock.getAssetCountForIds.mockResolvedValue([{ albumId: albumStub.empty.id, assetCount: 0 }]);
+      albumMock.getInvalidThumbnail.mockResolvedValue([]);
+
+      const result = await sut.getAllAlbums(authStub.admin, { shared: false });
+      expect(result).toHaveLength(1);
+      expect(result[0].id).toEqual(albumStub.empty.id);
+      expect(albumMock.getNotShared).toHaveBeenCalledTimes(1);
+    });
+  });
+
+  it('counts assets correctly', async () => {
+    albumMock.getOwned.mockResolvedValue([albumStub.oneAsset]);
+    albumMock.getAssetCountForIds.mockResolvedValue([{ albumId: albumStub.oneAsset.id, assetCount: 1 }]);
+    albumMock.getInvalidThumbnail.mockResolvedValue([]);
+
+    const result = await sut.getAllAlbums(authStub.admin, {});
+
+    expect(result).toHaveLength(1);
+    expect(result[0].assetCount).toEqual(1);
+    expect(albumMock.getOwned).toHaveBeenCalledTimes(1);
+  });
+
+  it('updates the album thumbnail by listing all albums', async () => {
+    albumMock.getOwned.mockResolvedValue([albumStub.oneAssetInvalidThumbnail]);
+    albumMock.getAssetCountForIds.mockResolvedValue([
+      { albumId: albumStub.oneAssetInvalidThumbnail.id, assetCount: 1 },
+    ]);
+    albumMock.getInvalidThumbnail.mockResolvedValue([albumStub.oneAssetInvalidThumbnail.id]);
+    albumMock.save.mockResolvedValue(albumStub.oneAssetValidThumbnail);
+    assetMock.getFirstAssetForAlbumId.mockResolvedValue(albumStub.oneAssetInvalidThumbnail.assets[0]);
+
+    const result = await sut.getAllAlbums(authStub.admin, {});
+
+    expect(result).toHaveLength(1);
+    expect(albumMock.getInvalidThumbnail).toHaveBeenCalledTimes(1);
+    expect(albumMock.save).toHaveBeenCalledTimes(1);
+  });
+
+  it('removes the thumbnail for an empty album', async () => {
+    albumMock.getOwned.mockResolvedValue([albumStub.emptyWithInvalidThumbnail]);
+    albumMock.getAssetCountForIds.mockResolvedValue([
+      { albumId: albumStub.emptyWithInvalidThumbnail.id, assetCount: 1 },
+    ]);
+    albumMock.getInvalidThumbnail.mockResolvedValue([albumStub.emptyWithInvalidThumbnail.id]);
+    albumMock.save.mockResolvedValue(albumStub.emptyWithValidThumbnail);
+    assetMock.getFirstAssetForAlbumId.mockResolvedValue(null);
+
+    const result = await sut.getAllAlbums(authStub.admin, {});
+
+    expect(result).toHaveLength(1);
+    expect(albumMock.getInvalidThumbnail).toHaveBeenCalledTimes(1);
+    expect(albumMock.save).toHaveBeenCalledTimes(1);
+  });
+});

server/libs/domain/src/album/album.service.ts

@@ -0,0 +1,58 @@
+import { AlbumEntity } from '@app/infra';
+import { Inject, Injectable } from '@nestjs/common';
+import { IAssetRepository } from '../asset';
+import { AuthUserDto } from '../auth';
+import { IAlbumRepository } from './album.repository';
+import { GetAlbumsDto } from './dto/get-albums.dto';
+import { AlbumResponseDto } from './response-dto';
+
+@Injectable()
+export class AlbumService {
+  constructor(
+    @Inject(IAlbumRepository) private albumRepository: IAlbumRepository,
+    @Inject(IAssetRepository) private assetRepository: IAssetRepository,
+  ) {}
+
+  async getAllAlbums({ id: ownerId }: AuthUserDto, { assetId, shared }: GetAlbumsDto): Promise<AlbumResponseDto[]> {
+    await this.updateInvalidThumbnails();
+
+    let albums: AlbumEntity[];
+    if (assetId) {
+      albums = await this.albumRepository.getByAssetId(ownerId, assetId);
+    } else if (shared === true) {
+      albums = await this.albumRepository.getShared(ownerId);
+    } else if (shared === false) {
+      albums = await this.albumRepository.getNotShared(ownerId);
+    } else {
+      albums = await this.albumRepository.getOwned(ownerId);
+    }
+
+    // Get asset count for each album. Then map the result to an object:
+    // { [albumId]: assetCount }
+    const albumsAssetCount = await this.albumRepository.getAssetCountForIds(albums.map((album) => album.id));
+    const albumsAssetCountObj = albumsAssetCount.reduce((obj: Record<string, number>, { albumId, assetCount }) => {
+      obj[albumId] = assetCount;
+      return obj;
+    }, {});
+
+    return albums.map((album) => {
+      return {
+        ...album,
+        sharedLinks: undefined, // Don't return shared links
+        shared: album.sharedLinks?.length > 0 || album.sharedUsers?.length > 0,
+        assetCount: albumsAssetCountObj[album.id],
+      } as AlbumResponseDto;
+    });
+  }
+
+  async updateInvalidThumbnails(): Promise<number> {
+    const invalidAlbumIds = await this.albumRepository.getInvalidThumbnail();
+
+    for (const albumId of invalidAlbumIds) {
+      const newThumbnail = await this.assetRepository.getFirstAssetForAlbumId(albumId);
+      await this.albumRepository.save({ id: albumId, albumThumbnailAsset: newThumbnail });
+    }
+
+    return invalidAlbumIds.length;
+  }
+}

server/libs/domain/src/album/dto/get-albums.dto.ts

@@ -0,0 +1,27 @@
+import { Transform } from 'class-transformer';
+import { IsBoolean, IsOptional, IsUUID } from 'class-validator';
+import { toBoolean } from 'apps/immich/src/utils/transform.util';
+import { ApiProperty } from '@nestjs/swagger';
+
+export class GetAlbumsDto {
+  @IsOptional()
+  @IsBoolean()
+  @Transform(toBoolean)
+  @ApiProperty()
+  /**
+   * true: only shared albums
+   * false: only non-shared own albums
+   * undefined: shared and owned albums
+   */
+  shared?: boolean;
+
+  /**
+   * Only returns albums that contain the asset
+   * Ignores the shared parameter
+   * undefined: get all albums
+   */
+  @IsOptional()
+  @IsUUID(4)
+  @ApiProperty({ format: 'uuid' })
+  assetId?: string;
+}

server/libs/domain/src/album/index.ts

@@ -1,2 +1,3 @@
 export * from './album.repository';
+export * from './album.service';
 export * from './response-dto';