add album permission repository

server/src/interfaces/album-permission.interface.ts

@@ -0,0 +1,13 @@
+import { AlbumPermissionEntity } from 'src/entities/album-permission.entity';
+
+export const IAlbumPermissionRepository = 'IAlbumPermissionRepository';
+
+export interface IAlbumPermissionRepository {
+  create(albumPermission: Partial<AlbumPermissionEntity>): Promise<AlbumPermissionEntity>;
+  update(
+    userId: string,
+    albumId: string,
+    albumPermission: Partial<AlbumPermissionEntity>,
+  ): Promise<AlbumPermissionEntity>;
+  delete(userId: string, albumId: string): Promise<void>;
+}

server/src/repositories/album-permission.repository.ts

@@ -0,0 +1,30 @@
+import { Injectable } from '@nestjs/common';
+import { InjectRepository } from '@nestjs/typeorm';
+import { DummyValue, GenerateSql } from 'src/decorators';
+import { AlbumPermissionEntity } from 'src/entities/album-permission.entity';
+import { IAlbumPermissionRepository } from 'src/interfaces/album-permission.interface';
+import { Instrumentation } from 'src/utils/instrumentation';
+import { Repository } from 'typeorm';
+
+@Instrumentation()
+@Injectable()
+export class AlbumPermissionRepository implements IAlbumPermissionRepository {
+  constructor(@InjectRepository(AlbumPermissionEntity) private repository: Repository<AlbumPermissionEntity>) {}
+
+  async create(dto: Partial<AlbumPermissionEntity>): Promise<AlbumPermissionEntity> {
+    const { users, albums } = await this.repository.save(dto);
+    return this.repository.findOneOrFail({ where: { users, albums }, relations: { users: true } });
+  }
+
+  async update(userId: string, albumId: string, dto: Partial<AlbumPermissionEntity>): Promise<AlbumPermissionEntity> {
+    await this.repository.update({ users: { id: userId }, albums: { id: albumId } }, dto);
+    return this.repository.findOneOrFail({
+      where: { users: { id: userId }, albums: { id: albumId } },
+      relations: { users: true },
+    });
+  }
+
+  async delete(userId: string, albumId: string): Promise<void> {
+    await this.repository.delete({ users: { id: userId }, albums: { id: albumId } });
+  }
+}

server/src/repositories/index.ts

@@ -1,5 +1,6 @@
 import { IAccessRepository } from 'src/interfaces/access.interface';
 import { IActivityRepository } from 'src/interfaces/activity.interface';
+import { IAlbumPermissionRepository } from 'src/interfaces/album-permission.interface';
 import { IAlbumRepository } from 'src/interfaces/album.interface';
 import { IKeyRepository } from 'src/interfaces/api-key.interface';
 import { IAssetStackRepository } from 'src/interfaces/asset-stack.interface';
@@ -30,6 +31,7 @@ import { IUserTokenRepository } from 'src/interfaces/user-token.interface';
 import { IUserRepository } from 'src/interfaces/user.interface';
 import { AccessRepository } from 'src/repositories/access.repository';
 import { ActivityRepository } from 'src/repositories/activity.repository';
+import { AlbumPermissionRepository } from 'src/repositories/album-permission.repository';
 import { AlbumRepository } from 'src/repositories/album.repository';
 import { ApiKeyRepository } from 'src/repositories/api-key.repository';
 import { AssetStackRepository } from 'src/repositories/asset-stack.repository';
@@ -63,6 +65,7 @@ export const repositories = [
   { provide: IActivityRepository, useClass: ActivityRepository },
   { provide: IAccessRepository, useClass: AccessRepository },
   { provide: IAlbumRepository, useClass: AlbumRepository },
+  { provide: IAlbumPermissionRepository, useClass: AlbumPermissionRepository },
   { provide: IAssetRepository, useClass: AssetRepository },
   { provide: IAssetRepositoryV1, useClass: AssetRepositoryV1 },
   { provide: IAssetStackRepository, useClass: AssetStackRepository },

server/src/services/album.service.ts

@@ -18,6 +18,7 @@ import { AlbumPermissionEntity } from 'src/entities/album-permission.entity';
 import { AlbumEntity } from 'src/entities/album.entity';
 import { AssetEntity } from 'src/entities/asset.entity';
 import { IAccessRepository } from 'src/interfaces/access.interface';
+import { IAlbumPermissionRepository } from 'src/interfaces/album-permission.interface';
 import { AlbumAssetCount, AlbumInfoOptions, IAlbumRepository } from 'src/interfaces/album.interface';
 import { IAssetRepository } from 'src/interfaces/asset.interface';
 import { IUserRepository } from 'src/interfaces/user.interface';
@@ -31,6 +32,7 @@ export class AlbumService {
     @Inject(IAlbumRepository) private albumRepository: IAlbumRepository,
     @Inject(IAssetRepository) private assetRepository: IAssetRepository,
     @Inject(IUserRepository) private userRepository: IUserRepository,
+    @Inject(IAlbumPermissionRepository) private albumPermissionRepository: IAlbumPermissionRepository,
   ) {
     this.access = AccessCore.create(accessRepository);
   }
@@ -227,16 +229,12 @@ export class AlbumService {
         throw new BadRequestException('User not found');
       }
 
-      album.albumPermissions.push({ users: { id: userId } } as AlbumPermissionEntity);
+      album.albumPermissions.push(
+        await this.albumPermissionRepository.create({ users: { id: userId }, albums: { id } } as AlbumPermissionEntity),
+      );
     }
 
-    return this.albumRepository
-      .update({
-        id: album.id,
-        updatedAt: new Date(),
-        albumPermissions: album.albumPermissions,
-      })
-      .then(mapAlbumWithoutAssets);
+    return mapAlbumWithoutAssets(album);
   }
 
   async removeUser(auth: AuthDto, id: string, userId: string | 'me'): Promise<void> {
@@ -260,11 +258,7 @@ export class AlbumService {
       await this.access.requirePermission(auth, Permission.ALBUM_SHARE, id);
     }
 
-    await this.albumRepository.update({
-      id: album.id,
-      updatedAt: new Date(),
-      albumPermissions: album.albumPermissions.filter(({ users: { id } }) => id !== userId),
-    });
+    await this.albumPermissionRepository.delete(userId, id);
   }
 
   private async findOrFail(id: string, options: AlbumInfoOptions) {