Server: Album Service: allow getting many by slug or id + allow delet…

…ing many

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

@@ -289,24 +289,19 @@ describe("Album Service", () => {
 	});
 
 	describe("Delete Album", () => {
-		it("should throw, as the album does not exist (by id)", () => {
-			const test = async () => albumService.delete({ id: -1 });
-			return expect(test()).rejects.toThrow(AlbumNotFoundException);
-		});
-
 		it("should not delete the album, as it has releases", async () => {
 			const albumQueryParameters = {
 				id: dummyRepository.compilationAlbumA.id,
 			};
 
 			const test = async () =>
-				await albumService.delete(albumQueryParameters);
+				await albumService.delete([albumQueryParameters]);
 			return expect(test()).rejects.toThrow(AlbumNotEmptyException);
 		});
 
 		it("should delete the album", async () => {
 			const tmpAlbum = await albumService.create({ name: "1234" });
-			await albumService.delete({ id: tmpAlbum.id });
+			await albumService.delete([{ id: tmpAlbum.id }]);
 			const test = async () => albumService.get({ id: tmpAlbum.id });
 			return expect(test()).rejects.toThrow(AlbumNotFoundException);
 		});

server/src/album/album.service.ts

@@ -210,7 +210,7 @@ export default class AlbumService extends SearchableRepositoryService {
 	) {
 		const matchingIds = await this.getMatchingIds(token, pagination);
 		const artists = await this.getMany(
-			{ ...where, id: { in: matchingIds } },
+			{ ...where, albums: matchingIds.map((id) => ({ id })) },
 			{},
 			{},
 			include,
@@ -232,7 +232,7 @@ export default class AlbumService extends SearchableRepositoryService {
 				pagination,
 			);
 			return this.getMany(
-				{ ...where, id: { in: randomIds } },
+				{ ...where, albums: randomIds.map((id) => ({ id })) },
 				undefined,
 				undefined,
 				include,
@@ -278,8 +278,12 @@ export default class AlbumService extends SearchableRepositoryService {
 			name: buildStringSearchParameters(where.name),
 		};
 
-		if (where.id) {
-			query = deepmerge(query, { id: where.id });
+		if (where.albums) {
+			query = deepmerge(query, {
+				OR: where.albums.map((album) =>
+					AlbumService.formatWhereInput(album),
+				),
+			});
 		}
 		if (where.related) {
 			// Related albums have at least one song group in common
@@ -510,42 +514,49 @@ export default class AlbumService extends SearchableRepositoryService {
 	 * Deletes an album
 	 * @param where the query parameter
 	 */
-	async delete(where: AlbumQueryParameters.DeleteInput): Promise<AlbumModel> {
-		try {
-			const album = await this.prismaService.album.delete({
-				where: AlbumService.formatWhereInput(where),
-			});
+	async delete(where: AlbumQueryParameters.DeleteInput[]): Promise<number> {
+		const albums = await this.getMany(
+			{ albums: where },
+			undefined,
+			undefined,
+			{ releases: true },
+		);
 
-			this.meiliSearch.index(this.indexName).deleteDocument(album.id);
-			this.logger.warn(`Album '${album.slug}' deleted`);
-			return album;
-		} catch (error) {
-			if (
-				error instanceof Prisma.PrismaClientKnownRequestError &&
-				error.code == PrismaError.ForeignConstraintViolation
-			) {
-				throw new AlbumNotEmptyException(where.id);
+		for (const album of albums) {
+			if (album.releases!.length) {
+				throw new AlbumNotEmptyException(album.id);
 			}
-			throw await this.onNotFound(error, where);
 		}
+		const deletedAlbum = await this.prismaService.album
+			.deleteMany({
+				where: AlbumService.formatManyWhereInput({ albums: where }),
+			})
+			.catch((error) => {
+				throw new UnhandledORMErrorException(error, where);
+			});
+		this.meiliSearch
+			.index(this.indexName)
+			.deleteDocuments(albums.map(({ id }) => id));
+		return deletedAlbum.count;
 	}
 
 	/**
 	 * Delete all albums that do not have relaed releases
 	 */
 	async housekeeping(): Promise<void> {
-		const emptyAlbums = await this.prismaService.album
-			.findMany({
-				select: {
-					id: true,
-					_count: {
-						select: { releases: true },
-					},
-				},
-			})
-			.then((albums) => albums.filter((album) => !album._count.releases));
+		const emptyAlbums = await this.prismaService.album.findMany({
+			select: {
+				id: true,
+			},
+			where: { releases: { none: {} } },
+		});
+		const deletedAlbumCount = await this.delete(
+			emptyAlbums.map(({ id }) => ({ id })),
+		);
 
-		await Promise.all(emptyAlbums.map(({ id }) => this.delete({ id })));
+		if (deletedAlbumCount) {
+			this.logger.warn(`Deleted ${deletedAlbumCount} albums`);
+		}
 		await this.resolveMasterReleases();
 	}
 

server/src/album/models/album.model.ts

@@ -31,4 +31,5 @@ export type AlbumModel = {
 	type: AlbumType;
 	artistId: number | null;
 	artist?: ArtistModel | null;
+	releases?: Release[];
 };

server/src/album/models/album.query-parameters.ts

@@ -70,7 +70,7 @@ namespace AlbumQueryParameters {
 			releaseDate: SearchDateInput;
 			genre: GenreQueryParameters.WhereInput;
 			type: AlbumType;
-			id: { in: number[] };
+			albums: AlbumQueryParameters.WhereInput[];
 			// Get albums with a song in common. Does not include the given album
 			related: AlbumQueryParameters.WhereInput;
 		}>

server/src/search/search-history.service.ts

@@ -128,11 +128,9 @@ export class SearchHistoryService {
 		);
 		const albums = await this.albumService.getMany(
 			{
-				id: {
-					in: history
-						.filter((item) => item.albumId !== null)
-						.map(({ albumId }) => albumId!),
-				},
+				albums: history
+					.filter((item) => item.albumId !== null)
+					.map(({ albumId }) => ({ id: albumId! })),
 			},
 			undefined,
 			undefined,

server/src/search/search.service.ts

@@ -94,7 +94,7 @@ export class SearchService {
 				[
 					(ids: number[]) =>
 						this.albumService.getMany(
-							{ id: { in: ids } },
+							{ albums: ids.map((id) => ({ id })) },
 							undefined,
 							undefined,
 							{