feat (server, web): Share with partner (#2388)

* feat(server, web): implement share with partner

* chore: regenerate api

* chore: regenerate api

* Pass userId to getAssetCountByTimeBucket and getAssetByTimeBucket

* chore: regenerate api

* Use AssetGrid to view partner's assets

* Remove disableNavBarActions flag

* Check access to buckets

* Apply suggestions from code review

Co-authored-by: Jason Rasmussen <jrasm91@gmail.com>

* Remove exception rethrowing

* Simplify partner access check

* Create new PartnerController

* chore api:generate

* Use partnerApi

* Remove id from PartnerResponseDto

* Refactor PartnerEntity

* Rename args

* Remove duplicate code in getAll

* Create composite primary keys for partners table

* Move asset access check into PartnerCore

* Remove redundant getUserAssets call

* Remove unused getUserAssets method

* chore: regenerate api

* Simplify getAll

* Replace ?? with ||

* Simplify PartnerRepository.create

* Introduce PartnerIds interface

* Replace two database migrations with one

* Simplify getAll

* Change PartnerResponseDto to include UserResponseDto

* Move partner sharing endpoints to PartnerController

* Rename ShareController to SharedLinkController

* chore: regenerate api after rebase

* refactor: shared link remove return type

* refactor: return user response dto

* chore: regenerate open api

* refactor: partner getAll

* refactor: partner settings event typing

* chore: remove unused code

* refactor: add partners modal trigger

* refactor: update url for viewing partner photos

* feat: update partner sharing title

* refactor: rename service method names

* refactor: http exception logic to service, PartnerIds interface

* chore: regenerate open api

* test: coverage for domain code

* fix: addPartner => createPartner

* fix: missed rename

* refactor: more code cleanup

* chore: alphabetize settings order

* feat: stop sharing confirmation modal

* Enhance contrast of the email in dark mode

* Replace button with CircleIconButton

* Fix linter warning

* Fix date types for PartnerEntity

* Fix PartnerEntity creation

* Reset assetStore state

* Change layout of the partner's assets page

* Add bulk download action for partner's assets

---------

Co-authored-by: Jason Rasmussen <jrasm91@gmail.com>

server/libs/domain/src/domain.module.ts

@@ -6,31 +6,33 @@ import { AuthService } from './auth';
 import { JobService } from './job';
 import { MediaService } from './media';
 import { OAuthService } from './oauth';
+import { PartnerService } from './partner';
 import { SearchService } from './search';
 import { ServerInfoService } from './server-info';
 import { ShareService } from './share';
 import { SmartInfoService } from './smart-info';
 import { StorageService } from './storage';
 import { StorageTemplateService } from './storage-template';
-import { INITIAL_SYSTEM_CONFIG, SystemConfigService } from './system-config';
 import { UserService } from './user';
+import { INITIAL_SYSTEM_CONFIG, SystemConfigService } from './system-config';
 
 const providers: Provider[] = [
   AlbumService,
-  AssetService,
   APIKeyService,
+  AssetService,
   AuthService,
   JobService,
   MediaService,
   OAuthService,
+  PartnerService,
+  SearchService,
   ServerInfoService,
+  ShareService,
   SmartInfoService,
   StorageService,
   StorageTemplateService,
   SystemConfigService,
   UserService,
-  ShareService,
-  SearchService,
   {
     provide: INITIAL_SYSTEM_CONFIG,
     inject: [SystemConfigService],

server/libs/domain/src/index.ts

@@ -14,6 +14,7 @@ export * from './metadata';
 export * from './oauth';
 export * from './search';
 export * from './server-info';
+export * from './partner';
 export * from './share';
 export * from './smart-info';
 export * from './storage';

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

@@ -0,0 +1,3 @@
+export * from './partner.core';
+export * from './partner.repository';
+export * from './partner.service';

server/libs/domain/src/partner/partner.core.ts

@@ -0,0 +1,33 @@
+import { PartnerEntity } from '@app/infra/entities';
+import { IPartnerRepository, PartnerIds } from './partner.repository';
+
+export enum PartnerDirection {
+  SharedBy = 'shared-by',
+  SharedWith = 'shared-with',
+}
+
+export class PartnerCore {
+  constructor(private repository: IPartnerRepository) {}
+
+  async getAll(userId: string, direction: PartnerDirection): Promise<PartnerEntity[]> {
+    const partners = await this.repository.getAll(userId);
+    const key = direction === PartnerDirection.SharedBy ? 'sharedById' : 'sharedWithId';
+    return partners.filter((partner) => partner[key] === userId);
+  }
+
+  get(ids: PartnerIds): Promise<PartnerEntity | null> {
+    return this.repository.get(ids);
+  }
+
+  async create(ids: PartnerIds): Promise<PartnerEntity> {
+    return this.repository.create(ids);
+  }
+
+  async remove(ids: PartnerIds): Promise<void> {
+    await this.repository.remove(ids as PartnerEntity);
+  }
+
+  hasAssetAccess(assetId: string, userId: string): Promise<boolean> {
+    return this.repository.hasAssetAccess(assetId, userId);
+  }
+}

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

@@ -0,0 +1,16 @@
+import { PartnerEntity } from '@app/infra/entities';
+
+export interface PartnerIds {
+  sharedById: string;
+  sharedWithId: string;
+}
+
+export const IPartnerRepository = 'IPartnerRepository';
+
+export interface IPartnerRepository {
+  getAll(userId: string): Promise<PartnerEntity[]>;
+  get(partner: PartnerIds): Promise<PartnerEntity | null>;
+  create(partner: PartnerIds): Promise<PartnerEntity>;
+  remove(entity: PartnerEntity): Promise<void>;
+  hasAssetAccess(assetId: string, userId: string): Promise<boolean>;
+}

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

@@ -0,0 +1,102 @@
+import { BadRequestException } from '@nestjs/common';
+import { authStub, newPartnerRepositoryMock, partnerStub } from '../../test';
+import { PartnerDirection } from './partner.core';
+import { IPartnerRepository } from './partner.repository';
+import { PartnerService } from './partner.service';
+
+const responseDto = {
+  admin: {
+    createdAt: '2021-01-01',
+    deletedAt: undefined,
+    email: 'admin@test.com',
+    firstName: 'admin_first_name',
+    id: 'admin_id',
+    isAdmin: true,
+    lastName: 'admin_last_name',
+    oauthId: '',
+    profileImagePath: '',
+    shouldChangePassword: false,
+    updatedAt: '2021-01-01',
+  },
+  user1: {
+    createdAt: '2021-01-01',
+    deletedAt: undefined,
+    email: 'immich@test.com',
+    firstName: 'immich_first_name',
+    id: 'immich_id',
+    isAdmin: false,
+    lastName: 'immich_last_name',
+    oauthId: '',
+    profileImagePath: '',
+    shouldChangePassword: false,
+    updatedAt: '2021-01-01',
+  },
+};
+
+describe(PartnerService.name, () => {
+  let sut: PartnerService;
+  let partnerMock: jest.Mocked<IPartnerRepository>;
+
+  beforeEach(async () => {
+    partnerMock = newPartnerRepositoryMock();
+    sut = new PartnerService(partnerMock);
+  });
+
+  it('should work', () => {
+    expect(sut).toBeDefined();
+  });
+
+  describe('getAll', () => {
+    it("should return a list of partners with whom I've shared my library", async () => {
+      partnerMock.getAll.mockResolvedValue([partnerStub.adminToUser1, partnerStub.user1ToAdmin1]);
+      await expect(sut.getAll(authStub.user1, PartnerDirection.SharedBy)).resolves.toEqual([responseDto.admin]);
+      expect(partnerMock.getAll).toHaveBeenCalledWith(authStub.user1.id);
+    });
+
+    it('should return a list of partners who have shared their libraries with me', async () => {
+      partnerMock.getAll.mockResolvedValue([partnerStub.adminToUser1, partnerStub.user1ToAdmin1]);
+      await expect(sut.getAll(authStub.user1, PartnerDirection.SharedWith)).resolves.toEqual([responseDto.admin]);
+      expect(partnerMock.getAll).toHaveBeenCalledWith(authStub.user1.id);
+    });
+  });
+
+  describe('create', () => {
+    it('should create a new partner', async () => {
+      partnerMock.get.mockResolvedValue(null);
+      partnerMock.create.mockResolvedValue(partnerStub.adminToUser1);
+
+      await expect(sut.create(authStub.admin, authStub.user1.id)).resolves.toEqual(responseDto.user1);
+
+      expect(partnerMock.create).toHaveBeenCalledWith({
+        sharedById: authStub.admin.id,
+        sharedWithId: authStub.user1.id,
+      });
+    });
+
+    it('should throw an error when the partner already exists', async () => {
+      partnerMock.get.mockResolvedValue(partnerStub.adminToUser1);
+
+      await expect(sut.create(authStub.admin, authStub.user1.id)).rejects.toBeInstanceOf(BadRequestException);
+
+      expect(partnerMock.create).not.toHaveBeenCalled();
+    });
+  });
+
+  describe('remove', () => {
+    it('should remove a partner', async () => {
+      partnerMock.get.mockResolvedValue(partnerStub.adminToUser1);
+
+      await sut.remove(authStub.admin, authStub.user1.id);
+
+      expect(partnerMock.remove).toHaveBeenCalledWith(partnerStub.adminToUser1);
+    });
+
+    it('should throw an error when the partner does not exist', async () => {
+      partnerMock.get.mockResolvedValue(null);
+
+      await expect(sut.remove(authStub.admin, authStub.user1.id)).rejects.toBeInstanceOf(BadRequestException);
+
+      expect(partnerMock.remove).not.toHaveBeenCalled();
+    });
+  });
+});

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

@@ -0,0 +1,45 @@
+import { PartnerEntity } from '@app/infra/entities';
+import { BadRequestException, Inject, Injectable } from '@nestjs/common';
+import { AuthUserDto } from '../auth';
+import { IPartnerRepository, PartnerCore, PartnerDirection, PartnerIds } from '../partner';
+import { mapUser, UserResponseDto } from '../user';
+
+@Injectable()
+export class PartnerService {
+  private partnerCore: PartnerCore;
+
+  constructor(@Inject(IPartnerRepository) partnerRepository: IPartnerRepository) {
+    this.partnerCore = new PartnerCore(partnerRepository);
+  }
+
+  async create(authUser: AuthUserDto, sharedWithId: string): Promise<UserResponseDto> {
+    const partnerId: PartnerIds = { sharedById: authUser.id, sharedWithId };
+    const exists = await this.partnerCore.get(partnerId);
+    if (exists) {
+      throw new BadRequestException(`Partner already exists`);
+    }
+
+    const partner = await this.partnerCore.create(partnerId);
+    return this.map(partner, PartnerDirection.SharedBy);
+  }
+
+  async remove(authUser: AuthUserDto, sharedWithId: string): Promise<void> {
+    const partnerId: PartnerIds = { sharedById: authUser.id, sharedWithId };
+    const partner = await this.partnerCore.get(partnerId);
+    if (!partner) {
+      throw new BadRequestException('Partner not found');
+    }
+
+    await this.partnerCore.remove(partner);
+  }
+
+  async getAll(authUser: AuthUserDto, direction: PartnerDirection): Promise<UserResponseDto[]> {
+    const partners = await this.partnerCore.getAll(authUser.id, direction);
+    return partners.map((partner) => this.map(partner, direction));
+  }
+
+  private map(partner: PartnerEntity, direction: PartnerDirection): UserResponseDto {
+    // this is opposite to return the non-me user of the "partner"
+    return mapUser(direction === PartnerDirection.SharedBy ? partner.sharedWith : partner.sharedBy);
+  }
+}

server/libs/domain/src/share/share.core.ts

@@ -1,11 +1,5 @@
 import { AssetEntity, SharedLinkEntity } from '@app/infra/entities';
-import {
-  BadRequestException,
-  ForbiddenException,
-  InternalServerErrorException,
-  Logger,
-  UnauthorizedException,
-} from '@nestjs/common';
+import { BadRequestException, ForbiddenException, Logger, UnauthorizedException } from '@nestjs/common';
 import { AuthUserDto } from '../auth';
 import { ICryptoRepository } from '../crypto';
 import { CreateSharedLinkDto } from './dto';
@@ -25,24 +19,19 @@ export class ShareCore {
   }
 
   create(userId: string, dto: CreateSharedLinkDto): Promise<SharedLinkEntity> {
-    try {
-      return this.repository.create({
-        key: Buffer.from(this.cryptoRepository.randomBytes(50)),
-        description: dto.description,
-        userId,
-        createdAt: new Date().toISOString(),
-        expiresAt: dto.expiresAt ?? null,
-        type: dto.type,
-        assets: dto.assets,
-        album: dto.album,
-        allowUpload: dto.allowUpload ?? false,
-        allowDownload: dto.allowDownload ?? true,
-        showExif: dto.showExif ?? true,
-      });
-    } catch (error: any) {
-      this.logger.error(error, error.stack);
-      throw new InternalServerErrorException('failed to create shared link');
-    }
+    return this.repository.create({
+      key: Buffer.from(this.cryptoRepository.randomBytes(50)),
+      description: dto.description,
+      userId,
+      createdAt: new Date().toISOString(),
+      expiresAt: dto.expiresAt ?? null,
+      type: dto.type,
+      assets: dto.assets,
+      album: dto.album,
+      allowUpload: dto.allowUpload ?? false,
+      allowDownload: dto.allowDownload ?? true,
+      showExif: dto.showExif ?? true,
+    });
   }
 
   async save(userId: string, id: string, entity: Partial<SharedLinkEntity>): Promise<SharedLinkEntity> {
@@ -54,13 +43,13 @@ export class ShareCore {
     return this.repository.save({ ...entity, userId, id });
   }
 
-  async remove(userId: string, id: string): Promise<SharedLinkEntity> {
+  async remove(userId: string, id: string): Promise<void> {
     const link = await this.get(userId, id);
     if (!link) {
       throw new BadRequestException('Shared link not found');
     }
 
-    return this.repository.remove(link);
+    await this.repository.remove(link);
   }
 
   async addAssets(userId: string, id: string, assets: AssetEntity[]) {

server/libs/domain/src/share/shared-link.repository.ts

@@ -7,7 +7,7 @@ export interface ISharedLinkRepository {
   get(userId: string, id: string): Promise<SharedLinkEntity | null>;
   getByKey(key: string): Promise<SharedLinkEntity | null>;
   create(entity: Omit<SharedLinkEntity, 'id' | 'user'>): Promise<SharedLinkEntity>;
-  remove(entity: SharedLinkEntity): Promise<SharedLinkEntity>;
+  remove(entity: SharedLinkEntity): Promise<void>;
   save(entity: Partial<SharedLinkEntity>): Promise<SharedLinkEntity>;
   hasAssetAccess(id: string, assetId: string): Promise<boolean>;
 }

server/libs/domain/test/fixtures.ts

@@ -3,6 +3,7 @@ import {
   APIKeyEntity,
   AssetEntity,
   AssetType,
+  PartnerEntity,
   SharedLinkEntity,
   SharedLinkType,
   SystemConfig,
@@ -824,3 +825,22 @@ export const probeStub = {
     },
   }),
 };
+
+export const partnerStub = {
+  adminToUser1: Object.freeze<PartnerEntity>({
+    createdAt: new Date('2023-02-23T05:06:29.716Z'),
+    updatedAt: new Date('2023-02-23T05:06:29.716Z'),
+    sharedById: userEntityStub.admin.id,
+    sharedBy: userEntityStub.admin,
+    sharedWith: userEntityStub.user1,
+    sharedWithId: userEntityStub.user1.id,
+  }),
+  user1ToAdmin1: Object.freeze<PartnerEntity>({
+    createdAt: new Date('2023-02-23T05:06:29.716Z'),
+    updatedAt: new Date('2023-02-23T05:06:29.716Z'),
+    sharedBy: userEntityStub.user1,
+    sharedById: userEntityStub.user1.id,
+    sharedWithId: userEntityStub.admin.id,
+    sharedWith: userEntityStub.admin,
+  }),
+};

server/libs/domain/test/index.ts

@@ -7,6 +7,7 @@ export * from './fixtures';
 export * from './job.repository.mock';
 export * from './machine-learning.repository.mock';
 export * from './media.repository.mock';
+export * from './partner.repository.mock';
 export * from './search.repository.mock';
 export * from './shared-link.repository.mock';
 export * from './smart-info.repository.mock';

server/libs/domain/test/partner.repository.mock.ts

@@ -0,0 +1,11 @@
+import { IPartnerRepository } from '../src';
+
+export const newPartnerRepositoryMock = (): jest.Mocked<IPartnerRepository> => {
+  return {
+    create: jest.fn(),
+    remove: jest.fn(),
+    getAll: jest.fn(),
+    get: jest.fn(),
+    hasAssetAccess: jest.fn(),
+  };
+};

server/libs/infra/src/entities/index.ts

@@ -1,16 +1,18 @@
 import { AlbumEntity } from './album.entity';
 import { APIKeyEntity } from './api-key.entity';
 import { AssetEntity } from './asset.entity';
+import { PartnerEntity } from './partner.entity';
 import { SharedLinkEntity } from './shared-link.entity';
 import { SmartInfoEntity } from './smart-info.entity';
 import { SystemConfigEntity } from './system-config.entity';
-import { UserTokenEntity } from './user-token.entity';
 import { UserEntity } from './user.entity';
+import { UserTokenEntity } from './user-token.entity';
 
 export * from './album.entity';
 export * from './api-key.entity';
 export * from './asset.entity';
 export * from './exif.entity';
+export * from './partner.entity';
 export * from './shared-link.entity';
 export * from './smart-info.entity';
 export * from './system-config.entity';
@@ -19,12 +21,13 @@ export * from './user-token.entity';
 export * from './user.entity';
 
 export const databaseEntities = [
-  AssetEntity,
   AlbumEntity,
   APIKeyEntity,
-  UserEntity,
+  AssetEntity,
+  PartnerEntity,
   SharedLinkEntity,
   SmartInfoEntity,
   SystemConfigEntity,
+  UserEntity,
   UserTokenEntity,
 ];

server/libs/infra/src/entities/partner.entity.ts

@@ -0,0 +1,26 @@
+import { CreateDateColumn, Entity, ManyToOne, PrimaryColumn, JoinColumn, UpdateDateColumn } from 'typeorm';
+
+import { UserEntity } from './user.entity';
+
+@Entity('partners')
+export class PartnerEntity {
+  @PrimaryColumn('uuid')
+  sharedById!: string;
+
+  @PrimaryColumn('uuid')
+  sharedWithId!: string;
+
+  @ManyToOne(() => UserEntity, { onDelete: 'CASCADE', eager: true })
+  @JoinColumn({ name: 'sharedById' })
+  sharedBy!: UserEntity;
+
+  @ManyToOne(() => UserEntity, { onDelete: 'CASCADE', eager: true })
+  @JoinColumn({ name: 'sharedWithId' })
+  sharedWith!: UserEntity;
+
+  @CreateDateColumn({ type: 'timestamptz' })
+  createdAt!: Date;
+
+  @UpdateDateColumn({ type: 'timestamptz' })
+  updatedAt!: Date;
+}

server/libs/infra/src/infra.module.ts

@@ -9,6 +9,7 @@ import {
   IMachineLearningRepository,
   IMediaRepository,
   immichAppConfig,
+  IPartnerRepository,
   ISearchRepository,
   ISharedLinkRepository,
   ISmartInfoRepository,
@@ -36,6 +37,7 @@ import {
   JobRepository,
   MachineLearningRepository,
   MediaRepository,
+  PartnerRepository,
   SharedLinkRepository,
   SmartInfoRepository,
   SystemConfigRepository,
@@ -54,6 +56,7 @@ const providers: Provider[] = [
   { provide: IKeyRepository, useClass: APIKeyRepository },
   { provide: IMachineLearningRepository, useClass: MachineLearningRepository },
   { provide: IMediaRepository, useClass: MediaRepository },
+  { provide: IPartnerRepository, useClass: PartnerRepository },
   { provide: ISearchRepository, useClass: TypesenseRepository },
   { provide: ISharedLinkRepository, useClass: SharedLinkRepository },
   { provide: ISmartInfoRepository, useClass: SmartInfoRepository },

server/libs/infra/src/migrations/1683808254676-AddPartnersTable.ts

@@ -0,0 +1,18 @@
+import { MigrationInterface, QueryRunner } from "typeorm";
+
+export class AddPartnersTable1683808254676 implements MigrationInterface {
+    name = 'AddPartnersTable1683808254676'
+
+    public async up(queryRunner: QueryRunner): Promise<void> {
+        await queryRunner.query(`CREATE TABLE "partners" ("sharedById" uuid NOT NULL, "sharedWithId" uuid NOT NULL, "createdAt" TIMESTAMP WITH TIME ZONE NOT NULL DEFAULT now(), "updatedAt" TIMESTAMP WITH TIME ZONE NOT NULL DEFAULT now(), CONSTRAINT "PK_f1cc8f73d16b367f426261a8736" PRIMARY KEY ("sharedById", "sharedWithId"))`);
+        await queryRunner.query(`ALTER TABLE "partners" ADD CONSTRAINT "FK_7e077a8b70b3530138610ff5e04" FOREIGN KEY ("sharedById") REFERENCES "users"("id") ON DELETE CASCADE ON UPDATE NO ACTION`);
+        await queryRunner.query(`ALTER TABLE "partners" ADD CONSTRAINT "FK_d7e875c6c60e661723dbf372fd3" FOREIGN KEY ("sharedWithId") REFERENCES "users"("id") ON DELETE CASCADE ON UPDATE NO ACTION`);
+    }
+
+    public async down(queryRunner: QueryRunner): Promise<void> {
+        await queryRunner.query(`ALTER TABLE "partners" DROP CONSTRAINT "FK_d7e875c6c60e661723dbf372fd3"`);
+        await queryRunner.query(`ALTER TABLE "partners" DROP CONSTRAINT "FK_7e077a8b70b3530138610ff5e04"`);
+        await queryRunner.query(`DROP TABLE "partners"`);
+    }
+
+}

server/libs/infra/src/repositories/index.ts

@@ -8,6 +8,7 @@ export * from './geocoding.repository';
 export * from './job.repository';
 export * from './machine-learning.repository';
 export * from './media.repository';
+export * from './partner.repository';
 export * from './shared-link.repository';
 export * from './smart-info.repository';
 export * from './system-config.repository';

server/libs/infra/src/repositories/partner.repository.ts

@@ -0,0 +1,50 @@
+import { IPartnerRepository, PartnerIds } from '@app/domain';
+import { Injectable } from '@nestjs/common';
+import { InjectRepository } from '@nestjs/typeorm';
+import { Repository } from 'typeorm';
+import { PartnerEntity } from '../entities';
+
+@Injectable()
+export class PartnerRepository implements IPartnerRepository {
+  constructor(@InjectRepository(PartnerEntity) private readonly repository: Repository<PartnerEntity>) {}
+
+  getAll(userId: string): Promise<PartnerEntity[]> {
+    return this.repository.find({ where: [{ sharedWithId: userId }, { sharedById: userId }] });
+  }
+
+  get({ sharedWithId, sharedById }: PartnerIds): Promise<PartnerEntity | null> {
+    return this.repository.findOne({ where: { sharedById, sharedWithId } });
+  }
+
+  async create({ sharedById, sharedWithId }: PartnerIds): Promise<PartnerEntity> {
+    await this.repository.save({ sharedBy: { id: sharedById }, sharedWith: { id: sharedWithId } });
+    return this.repository.findOneOrFail({ where: { sharedById, sharedWithId } });
+  }
+
+  async remove(entity: PartnerEntity): Promise<void> {
+    await this.repository.remove(entity);
+  }
+
+  async hasAssetAccess(assetId: string, userId: string): Promise<boolean> {
+    const count = await this.repository.count({
+      where: {
+        sharedWith: {
+          id: userId,
+        },
+        sharedBy: {
+          assets: {
+            id: assetId,
+          },
+        },
+      },
+      relations: {
+        sharedWith: true,
+        sharedBy: {
+          assets: true,
+        },
+      },
+    });
+
+    return count == 1;
+  }
+}

server/libs/infra/src/repositories/shared-link.repository.ts

@@ -82,8 +82,8 @@ export class SharedLinkRepository implements ISharedLinkRepository {
     return this.repository.save(entity);
   }
 
-  remove(entity: SharedLinkEntity): Promise<SharedLinkEntity> {
-    return this.repository.remove(entity);
+  async remove(entity: SharedLinkEntity): Promise<void> {
+    await this.repository.remove(entity);
   }
 
   async save(entity: SharedLinkEntity): Promise<SharedLinkEntity> {