chore(deps): update typeorm

src/auth/auth-session.repository.ts

@@ -1,5 +1,6 @@
 /* eslint-disable max-classes-per-file */
-import { EntityRepository, Repository, SelectQueryBuilder } from "typeorm";
+import { Repository, SelectQueryBuilder } from "typeorm";
+import { EntityRepository } from "../database/entity-repository";
 import { User } from "../users/user.entity";
 import { AuthSession } from "./auth-session.entity";
 

src/auth/auth.module.ts

@@ -2,8 +2,8 @@ import { MiddlewareConsumer, Module, NestModule } from "@nestjs/common";
 import { ConfigService } from "@nestjs/config";
 import { JwtModule } from "@nestjs/jwt";
 import { PassportModule } from "@nestjs/passport";
-import { TypeOrmModule } from "@nestjs/typeorm";
 import { CookieParserMiddleware } from "../cookie-parser";
+import { TypeOrmRepositoryModule } from "../database/entity-repository/typeorm-repository.module";
 import { UsersModule } from "../users/users.module";
 import { AuthSessionRepository } from "./auth-session.repository";
 import { AuthController } from "./auth.controller";
@@ -14,7 +14,7 @@ import { SpotifyStrategy } from "./strategies/spotify.strategy";
 
 @Module({
   imports: [
-    TypeOrmModule.forFeature([AuthSessionRepository]),
+    TypeOrmRepositoryModule.for([AuthSessionRepository]),
     PassportModule.register({ defaultStrategy: "jwt" }),
     JwtModule.registerAsync({
       useFactory: (config: ConfigService) => ({

src/auth/auth.service.spec.ts

@@ -248,7 +248,7 @@ describe("AuthService", () => {
     beforeEach(() => {
       session = { id: "AUTH_SESSION" } as AuthSession;
 
-      authSessionRepository.findOne = jest.fn().mockResolvedValue(session);
+      authSessionRepository.findOneBy = jest.fn().mockResolvedValue(session);
     });
 
     it("returns the session", async () => {
@@ -256,10 +256,10 @@ describe("AuthService", () => {
         session
       );
 
-      expect(authSessionRepository.findOne).toHaveBeenCalledTimes(1);
-      expect(authSessionRepository.findOne).toHaveBeenLastCalledWith(
-        "AUTH_SESSION"
-      );
+      expect(authSessionRepository.findOneBy).toHaveBeenCalledTimes(1);
+      expect(authSessionRepository.findOneBy).toHaveBeenLastCalledWith({
+        id: "AUTH_SESSION",
+      });
     });
   });
 

src/auth/auth.service.ts

@@ -98,7 +98,7 @@ export class AuthService {
   }
 
   async findSession(id: string): Promise<AuthSession> {
-    return this.authSessionRepository.findOne(id);
+    return this.authSessionRepository.findOneBy({ id });
   }
 
   async findUser(id: string): Promise<User> {

src/database/entity-repository/README.md

@@ -0,0 +1,4 @@
+This module restores the classes-based custom Repository functionality from
+typeorm v0.2.
+
+Directly adapted from anchan828: https://gist.github.com/anchan828/9e569f076e7bc18daf21c652f7c3d012

src/database/entity-repository/entity-repository.decorator.ts

@@ -0,0 +1,7 @@
+import { SetMetadata } from "@nestjs/common";
+
+export const TYPEORM_ENTITY_REPOSITORY = "TYPEORM_ENTITY_REPOSITORY";
+
+export function EntityRepository(entity: Function): ClassDecorator {
+  return SetMetadata(TYPEORM_ENTITY_REPOSITORY, entity);
+}

src/database/entity-repository/index.ts

@@ -0,0 +1,3 @@
+import { EntityRepository } from "./entity-repository.decorator";
+
+export { EntityRepository };

src/database/entity-repository/typeorm-repository.module.ts

@@ -0,0 +1,39 @@
+import { DynamicModule, Provider } from "@nestjs/common";
+import { getDataSourceToken } from "@nestjs/typeorm";
+import { DataSource } from "typeorm";
+import { TYPEORM_ENTITY_REPOSITORY } from "./entity-repository.decorator";
+
+export class TypeOrmRepositoryModule {
+  public static for<T extends new (...args: any[]) => any>(
+    repositories: T[]
+  ): DynamicModule {
+    const providers: Provider[] = [];
+
+    for (const repository of repositories) {
+      const entity = Reflect.getMetadata(TYPEORM_ENTITY_REPOSITORY, repository);
+
+      if (!entity) {
+        continue;
+      }
+
+      providers.push({
+        inject: [getDataSourceToken()],
+        provide: repository,
+        useFactory: (dataSource: DataSource): typeof repository => {
+          const baseRepository = dataSource.getRepository<any>(entity);
+          return new repository(
+            baseRepository.target,
+            baseRepository.manager,
+            baseRepository.queryRunner
+          );
+        },
+      });
+    }
+
+    return {
+      exports: providers,
+      module: TypeOrmRepositoryModule,
+      providers,
+    };
+  }
+}

src/listens/listen.repository.ts

@@ -1,5 +1,6 @@
 /* eslint-disable max-classes-per-file */
-import { EntityRepository, Repository, SelectQueryBuilder } from "typeorm";
+import { Repository, SelectQueryBuilder } from "typeorm";
+import { EntityRepository } from "../database/entity-repository";
 import { Interval } from "../reports/interval";
 import { User } from "../users/user.entity";
 import {
@@ -57,13 +58,13 @@ export class ListenRepository extends Repository<Listen> {
     if (!insertedRowIdentifier) {
       // We did not insert a new listen, it already existed
       return {
-        listen: await this.findOne({ where: { user, track, playedAt } }),
+        listen: await this.findOneBy({ user, track, playedAt }),
         isDuplicate: true,
       };
     }
 
     return {
-      listen: await this.findOne(insertedRowIdentifier.id),
+      listen: await this.findOneBy({ id: insertedRowIdentifier.id }),
       isDuplicate: false,
     };
   }

src/listens/listens.module.ts

@@ -1,11 +1,11 @@
 import { Module } from "@nestjs/common";
-import { TypeOrmModule } from "@nestjs/typeorm";
+import { TypeOrmRepositoryModule } from "../database/entity-repository/typeorm-repository.module";
 import { ListenRepository } from "./listen.repository";
 import { ListensController } from "./listens.controller";
 import { ListensService } from "./listens.service";
 
 @Module({
-  imports: [TypeOrmModule.forFeature([ListenRepository])],
+  imports: [TypeOrmRepositoryModule.for([ListenRepository])],
   providers: [ListensService],
   exports: [ListensService],
   controllers: [ListensController],

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)

src/users/user.repository.ts

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

src/users/users.module.ts

@@ -1,11 +1,11 @@
 import { Module } from "@nestjs/common";
-import { TypeOrmModule } from "@nestjs/typeorm";
 import { UserRepository } from "./user.repository";
 import { UsersService } from "./users.service";
 import { UsersController } from "./users.controller";
+import { TypeOrmRepositoryModule } from "../database/entity-repository/typeorm-repository.module";
 
 @Module({
-  imports: [TypeOrmModule.forFeature([UserRepository])],
+  imports: [TypeOrmRepositoryModule.for([UserRepository])],
   providers: [UsersService],
   exports: [UsersService],
   controllers: [UsersController],

src/users/users.service.ts

@@ -9,7 +9,7 @@ export class UsersService {
   constructor(private readonly userRepository: UserRepository) {}
 
   async findById(id: string): Promise<User> {
-    const user = await this.userRepository.findOne(id);
+    const user = await this.userRepository.findOneBy({ id });
 
     if (!user) {
       throw new NotFoundException("UserNotFound");
@@ -23,8 +23,8 @@ export class UsersService {
   }
 
   async createOrUpdate(data: CreateOrUpdateDto): Promise<User> {
-    let user = await this.userRepository.findOne({
-      where: { spotify: { id: data.spotify.id } },
+    let user = await this.userRepository.findOneBy({
+      spotify: { id: data.spotify.id },
     });
 
     if (!user) {