refactor(server): repositories (#9119)

refactor repos

server/src/repositories/asset.repository.ts

@@ -510,7 +510,7 @@ export class AssetRepository implements IAssetRepository {
   }
 
   async getStatistics(ownerId: string, options: AssetStatsOptions): Promise<AssetStats> {
-    let builder = this.repository
+    const builder = this.repository
       .createQueryBuilder('asset')
       .select(`COUNT(asset.id)`, 'count')
       .addSelect(`asset.type`, 'type')
@@ -520,15 +520,15 @@ export class AssetRepository implements IAssetRepository {
 
     const { isArchived, isFavorite, isTrashed } = options;
     if (isArchived !== undefined) {
-      builder = builder.andWhere(`asset.isArchived = :isArchived`, { isArchived });
+      builder.andWhere(`asset.isArchived = :isArchived`, { isArchived });
     }
 
     if (isFavorite !== undefined) {
-      builder = builder.andWhere(`asset.isFavorite = :isFavorite`, { isFavorite });
+      builder.andWhere(`asset.isFavorite = :isFavorite`, { isFavorite });
     }
 
     if (isTrashed !== undefined) {
-      builder = builder.withDeleted().andWhere(`asset.deletedAt is not null`);
+      builder.withDeleted().andWhere(`asset.deletedAt is not null`);
     }
 
     const items = await builder.getRawMany();
@@ -644,43 +644,43 @@ export class AssetRepository implements IAssetRepository {
   private getBuilder(options: AssetBuilderOptions) {
     const { isArchived, isFavorite, isTrashed, albumId, personId, userIds, withStacked, exifInfo, assetType } = options;
 
-    let builder = this.repository.createQueryBuilder('asset').where('asset.isVisible = true');
+    const builder = this.repository.createQueryBuilder('asset').where('asset.isVisible = true');
     if (assetType !== undefined) {
-      builder = builder.andWhere('asset.type = :assetType', { assetType });
+      builder.andWhere('asset.type = :assetType', { assetType });
     }
 
     let stackJoined = false;
 
     if (exifInfo !== false) {
       stackJoined = true;
-      builder = builder
+      builder
         .leftJoinAndSelect('asset.exifInfo', 'exifInfo')
         .leftJoinAndSelect('asset.stack', 'stack')
         .leftJoinAndSelect('stack.assets', 'stackedAssets');
     }
 
     if (albumId) {
-      builder = builder.leftJoin('asset.albums', 'album').andWhere('album.id = :albumId', { albumId });
+      builder.leftJoin('asset.albums', 'album').andWhere('album.id = :albumId', { albumId });
     }
 
     if (userIds) {
-      builder = builder.andWhere('asset.ownerId IN (:...userIds )', { userIds });
+      builder.andWhere('asset.ownerId IN (:...userIds )', { userIds });
     }
 
     if (isArchived !== undefined) {
-      builder = builder.andWhere('asset.isArchived = :isArchived', { isArchived });
+      builder.andWhere('asset.isArchived = :isArchived', { isArchived });
     }
 
     if (isFavorite !== undefined) {
-      builder = builder.andWhere('asset.isFavorite = :isFavorite', { isFavorite });
+      builder.andWhere('asset.isFavorite = :isFavorite', { isFavorite });
     }
 
     if (isTrashed !== undefined) {
-      builder = builder.andWhere(`asset.deletedAt ${isTrashed ? 'IS NOT NULL' : 'IS NULL'}`).withDeleted();
+      builder.andWhere(`asset.deletedAt ${isTrashed ? 'IS NOT NULL' : 'IS NULL'}`).withDeleted();
     }
 
     if (personId !== undefined) {
-      builder = builder
+      builder
         .innerJoin('asset.faces', 'faces')
         .innerJoin('faces.person', 'person')
         .andWhere('person.id = :personId', { personId });
@@ -688,9 +688,9 @@ export class AssetRepository implements IAssetRepository {
 
     if (withStacked) {
       if (!stackJoined) {
-        builder = builder.leftJoinAndSelect('asset.stack', 'stack').leftJoinAndSelect('stack.assets', 'stackedAssets');
+        builder.leftJoinAndSelect('asset.stack', 'stack').leftJoinAndSelect('stack.assets', 'stackedAssets');
       }
-      builder = builder.andWhere(
+      builder.andWhere(
         new Brackets((qb) => qb.where('stack.primaryAssetId = asset.id').orWhere('asset.stackId IS NULL')),
       );
     }
@@ -711,13 +711,13 @@ export class AssetRepository implements IAssetRepository {
   })
   getAllForUserFullSync(options: AssetFullSyncOptions): Promise<AssetEntity[]> {
     const { ownerId, lastCreationDate, lastId, updatedUntil, limit } = options;
-    let builder = this.repository
+    const builder = this.repository
       .createQueryBuilder('asset')
       .leftJoinAndSelect('asset.exifInfo', 'exifInfo')
       .leftJoinAndSelect('asset.stack', 'stack')
       .where('asset.ownerId = :ownerId', { ownerId });
     if (lastCreationDate !== undefined && lastId !== undefined) {
-      builder = builder.andWhere('(asset.fileCreatedAt, asset.id) < (:lastCreationDate, :lastId)', {
+      builder.andWhere('(asset.fileCreatedAt, asset.id) < (:lastCreationDate, :lastId)', {
         lastCreationDate,
         lastId,
       });

server/src/repositories/library.repository.ts

@@ -173,18 +173,18 @@ export class LibraryRepository implements ILibraryRepository {
 
   @GenerateSql({ params: [DummyValue.UUID] })
   async getAssetIds(libraryId: string, withDeleted = false): Promise<string[]> {
-    let query = this.repository
+    const builder = this.repository
       .createQueryBuilder('library')
       .innerJoinAndSelect('library.assets', 'assets')
       .where('library.id = :id', { id: libraryId })
       .select('assets.id');
 
     if (withDeleted) {
-      query = query.withDeleted();
+      builder.withDeleted();
     }
 
     // Return all asset paths for a given library
-    const rawResults = await query.getRawMany();
+    const rawResults = await builder.getRawMany();
 
     const results: string[] = [];
 

server/src/repositories/memory.repository.ts

@@ -1,7 +1,6 @@
 import { Injectable } from '@nestjs/common';
 import { InjectDataSource, InjectRepository } from '@nestjs/typeorm';
 import { Chunked, ChunkedSet, DummyValue, GenerateSql } from 'src/decorators';
-import { AssetEntity } from 'src/entities/asset.entity';
 import { MemoryEntity } from 'src/entities/memory.entity';
 import { IMemoryRepository } from 'src/interfaces/memory.interface';
 import { Instrumentation } from 'src/utils/instrumentation';
@@ -11,7 +10,6 @@ import { DataSource, In, Repository } from 'typeorm';
 @Injectable()
 export class MemoryRepository implements IMemoryRepository {
   constructor(
-    @InjectRepository(AssetEntity) private assetRepository: Repository<AssetEntity>,
     @InjectRepository(MemoryEntity) private repository: Repository<MemoryEntity>,
     @InjectDataSource() private dataSource: DataSource,
   ) {}

server/src/repositories/tag.repository.ts

@@ -96,7 +96,7 @@ export class TagRepository implements ITagRepository {
   }
 
   hasAsset(userId: string, tagId: string, assetId: string): Promise<boolean> {
-    return this.repository.exist({
+    return this.repository.exists({
       where: {
         id: tagId,
         userId,
@@ -111,7 +111,7 @@ export class TagRepository implements ITagRepository {
   }
 
   hasName(userId: string, name: string): Promise<boolean> {
-    return this.repository.exist({
+    return this.repository.exists({
       where: {
         name,
         userId,

server/src/repositories/user.repository.ts

@@ -36,15 +36,15 @@ export class UserRepository implements IUserRepository {
 
   @GenerateSql()
   async hasAdmin(): Promise<boolean> {
-    return this.userRepository.exist({ where: { isAdmin: true } });
+    return this.userRepository.exists({ where: { isAdmin: true } });
   }
 
   @GenerateSql({ params: [DummyValue.EMAIL] })
   async getByEmail(email: string, withPassword?: boolean): Promise<UserEntity | null> {
-    let builder = this.userRepository.createQueryBuilder('user').where({ email });
+    const builder = this.userRepository.createQueryBuilder('user').where({ email });
 
     if (withPassword) {
-      builder = builder.addSelect('user.password');
+      builder.addSelect('user.password');
     }
 
     return builder.getOne();