chore(deps): update typeorm

src/music-library/album.repository.ts

@@ -1,4 +1,5 @@
-import { EntityRepository, Repository } from "typeorm";
+import { Repository } from "typeorm";
+import { EntityRepository } from "../database/entity-repository";
 import { Album } from "./album.entity";
 
 @EntityRepository(Album)

src/music-library/artist.repository.ts

@@ -1,4 +1,5 @@
-import { EntityRepository, Repository } from "typeorm";
+import { Repository } from "typeorm";
+import { EntityRepository } from "../database/entity-repository";
 import { Artist } from "./artist.entity";
 
 @EntityRepository(Artist)

src/music-library/genre.repository.ts

@@ -1,4 +1,5 @@
-import { EntityRepository, Repository } from "typeorm";
+import { Repository } from "typeorm";
+import { EntityRepository } from "../database/entity-repository";
 import { Genre } from "./genre.entity";
 
 @EntityRepository(Genre)

src/music-library/music-library.module.ts

@@ -1,5 +1,5 @@
 import { Module } from "@nestjs/common";
-import { TypeOrmModule } from "@nestjs/typeorm";
+import { TypeOrmRepositoryModule } from "../database/entity-repository/typeorm-repository.module";
 import { AlbumRepository } from "./album.repository";
 import { ArtistRepository } from "./artist.repository";
 import { GenreRepository } from "./genre.repository";
@@ -8,7 +8,7 @@ import { TrackRepository } from "./track.repository";
 
 @Module({
   imports: [
-    TypeOrmModule.forFeature([
+    TypeOrmRepositoryModule.for([
       AlbumRepository,
       ArtistRepository,
       GenreRepository,

src/music-library/music-library.service.spec.ts

@@ -54,15 +54,15 @@ describe("MusicLibraryService", () => {
         const artist = {
           id: "ARTIST",
         };
-        artistRepository.findOne = jest.fn().mockResolvedValue(artist);
+        artistRepository.findOneBy = jest.fn().mockResolvedValue(artist);
 
         await expect(
           service.findArtist({ spotify: { id: "spotify_artist" } })
         ).resolves.toEqual(artist);
 
-        expect(artistRepository.findOne).toHaveBeenCalledTimes(1);
-        expect(artistRepository.findOne).toHaveBeenCalledWith({
-          where: { spotify: { id: "spotify_artist" } },
+        expect(artistRepository.findOneBy).toHaveBeenCalledTimes(1);
+        expect(artistRepository.findOneBy).toHaveBeenCalledWith({
+          spotify: { id: "spotify_artist" },
         });
       });
     });
@@ -195,15 +195,15 @@ describe("MusicLibraryService", () => {
         const album = {
           id: "ALBUM",
         };
-        albumRepository.findOne = jest.fn().mockResolvedValue(album);
+        albumRepository.findOneBy = jest.fn().mockResolvedValue(album);
 
         await expect(
           service.findAlbum({ spotify: { id: "spotify_album" } })
         ).resolves.toEqual(album);
 
-        expect(albumRepository.findOne).toHaveBeenCalledTimes(1);
-        expect(albumRepository.findOne).toHaveBeenCalledWith({
-          where: { spotify: { id: "spotify_album" } },
+        expect(albumRepository.findOneBy).toHaveBeenCalledTimes(1);
+        expect(albumRepository.findOneBy).toHaveBeenCalledWith({
+          spotify: { id: "spotify_album" },
         });
       });
     });
@@ -284,15 +284,15 @@ describe("MusicLibraryService", () => {
           id: "GENRE",
           name: "Foo",
         };
-        genreRepository.findOne = jest.fn().mockResolvedValue(genre);
+        genreRepository.findOneBy = jest.fn().mockResolvedValue(genre);
 
         await expect(service.findGenre({ name: "Foo" })).resolves.toEqual(
           genre
         );
 
-        expect(genreRepository.findOne).toHaveBeenCalledTimes(1);
-        expect(genreRepository.findOne).toHaveBeenCalledWith({
-          where: { name: "Foo" },
+        expect(genreRepository.findOneBy).toHaveBeenCalledTimes(1);
+        expect(genreRepository.findOneBy).toHaveBeenCalledWith({
+          name: "Foo",
         });
       });
     });
@@ -369,15 +369,15 @@ describe("MusicLibraryService", () => {
         const track = {
           id: "TRACK",
         };
-        trackRepository.findOne = jest.fn().mockResolvedValue(track);
+        trackRepository.findOneBy = jest.fn().mockResolvedValue(track);
 
         await expect(
           service.findTrack({ spotify: { id: "spotify_track" } })
         ).resolves.toEqual(track);
 
-        expect(trackRepository.findOne).toHaveBeenCalledTimes(1);
-        expect(trackRepository.findOne).toHaveBeenCalledWith({
-          where: { spotify: { id: "spotify_track" } },
+        expect(trackRepository.findOneBy).toHaveBeenCalledTimes(1);
+        expect(trackRepository.findOneBy).toHaveBeenCalledWith({
+          spotify: { id: "spotify_track" },
         });
       });
     });

src/music-library/music-library.service.ts

@@ -28,8 +28,8 @@ export class MusicLibraryService {
   ) {}
 
   async findArtist(query: FindArtistDto): Promise<Artist | undefined> {
-    return this.artistRepository.findOne({
-      where: { spotify: { id: query.spotify.id } },
+    return this.artistRepository.findOneBy({
+      spotify: { id: query.spotify.id },
     });
   }
 
@@ -81,8 +81,8 @@ export class MusicLibraryService {
   }
 
   async findAlbum(query: FindAlbumDto): Promise<Album | undefined> {
-    return this.albumRepository.findOne({
-      where: { spotify: { id: query.spotify.id } },
+    return this.albumRepository.findOneBy({
+      spotify: { id: query.spotify.id },
     });
   }
 
@@ -112,8 +112,8 @@ export class MusicLibraryService {
   }
 
   async findGenre(query: FindGenreDto): Promise<Genre | undefined> {
-    return this.genreRepository.findOne({
-      where: { name: query.name },
+    return this.genreRepository.findOneBy({
+      name: query.name,
     });
   }
 
@@ -141,8 +141,8 @@ export class MusicLibraryService {
   }
 
   async findTrack(query: FindTrackDto): Promise<Track | undefined> {
-    return this.trackRepository.findOne({
-      where: { spotify: { id: query.spotify.id } },
+    return this.trackRepository.findOneBy({
+      spotify: { id: query.spotify.id },
     });
   }
 

src/music-library/track.repository.ts

@@ -1,4 +1,5 @@
-import { EntityRepository, Repository } from "typeorm";
+import { Repository } from "typeorm";
+import { EntityRepository } from "../database/entity-repository";
 import { Track } from "./track.entity";
 
 @EntityRepository(Track)