refactor(server)*: tsconfigs (#2689)

* refactor(server): tsconfigs

* chore: dummy commit

* fix: start.sh

* chore: restore original entry scripts

server/src/domain/partner/index.ts

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

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

@@ -0,0 +1,20 @@
+import { PartnerEntity } from '@app/infra/entities';
+
+export interface PartnerIds {
+  sharedById: string;
+  sharedWithId: string;
+}
+
+export enum PartnerDirection {
+  SharedBy = 'shared-by',
+  SharedWith = 'shared-with',
+}
+
+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>;
+}

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

@@ -0,0 +1,103 @@
+import { BadRequestException } from '@nestjs/common';
+import { authStub, newPartnerRepositoryMock, partnerStub } from '@test';
+import { IPartnerRepository, PartnerDirection } from './partner.repository';
+import { PartnerService } from './partner.service';
+
+const responseDto = {
+  admin: {
+    email: 'admin@test.com',
+    firstName: 'admin_first_name',
+    id: 'admin_id',
+    isAdmin: true,
+    lastName: 'admin_last_name',
+    oauthId: '',
+    profileImagePath: '',
+    shouldChangePassword: false,
+    storageLabel: 'admin',
+    createdAt: new Date('2021-01-01'),
+    deletedAt: null,
+    updatedAt: new Date('2021-01-01'),
+  },
+  user1: {
+    email: 'immich@test.com',
+    firstName: 'immich_first_name',
+    id: 'user-id',
+    isAdmin: false,
+    lastName: 'immich_last_name',
+    oauthId: '',
+    profileImagePath: '',
+    shouldChangePassword: false,
+    storageLabel: null,
+    createdAt: new Date('2021-01-01'),
+    deletedAt: null,
+    updatedAt: new Date('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/src/domain/partner/partner.service.ts

@@ -0,0 +1,42 @@
+import { PartnerEntity } from '@app/infra/entities';
+import { BadRequestException, Inject, Injectable } from '@nestjs/common';
+import { AuthUserDto } from '../auth';
+import { IPartnerRepository, PartnerDirection, PartnerIds } from '.';
+import { mapUser, UserResponseDto } from '../user';
+
+@Injectable()
+export class PartnerService {
+  constructor(@Inject(IPartnerRepository) private repository: IPartnerRepository) {}
+
+  async create(authUser: AuthUserDto, sharedWithId: string): Promise<UserResponseDto> {
+    const partnerId: PartnerIds = { sharedById: authUser.id, sharedWithId };
+    const exists = await this.repository.get(partnerId);
+    if (exists) {
+      throw new BadRequestException(`Partner already exists`);
+    }
+
+    const partner = await this.repository.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.repository.get(partnerId);
+    if (!partner) {
+      throw new BadRequestException('Partner not found');
+    }
+
+    await this.repository.remove(partner);
+  }
+
+  async getAll(authUser: AuthUserDto, direction: PartnerDirection): Promise<UserResponseDto[]> {
+    const partners = await this.repository.getAll(authUser.id);
+    const key = direction === PartnerDirection.SharedBy ? 'sharedById' : 'sharedWithId';
+    return partners.filter((partner) => partner[key] === authUser.id).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);
+  }
+}