refactor: migrate library repository to kysely (#15271)

server/src/repositories/library.repository.ts

@@ -1,84 +1,122 @@
 import { Injectable } from '@nestjs/common';
-import { InjectRepository } from '@nestjs/typeorm';
+import { ExpressionBuilder, Insertable, Kysely, Updateable } from 'kysely';
+import { jsonObjectFrom } from 'kysely/helpers/postgres';
+import { InjectKysely } from 'nestjs-kysely';
+import { DB, Libraries } from 'src/db';
 import { DummyValue, GenerateSql } from 'src/decorators';
 import { LibraryStatsResponseDto } from 'src/dtos/library.dto';
 import { LibraryEntity } from 'src/entities/library.entity';
+import { AssetType } from 'src/enum';
 import { ILibraryRepository } from 'src/interfaces/library.interface';
-import { IsNull, Not } from 'typeorm';
-import { Repository } from 'typeorm/repository/Repository.js';
+
+const userColumns = [
+  'users.id',
+  'users.email',
+  'users.createdAt',
+  'users.profileImagePath',
+  'users.isAdmin',
+  'users.shouldChangePassword',
+  'users.deletedAt',
+  'users.oauthId',
+  'users.updatedAt',
+  'users.storageLabel',
+  'users.name',
+  'users.quotaSizeInBytes',
+  'users.quotaUsageInBytes',
+  'users.status',
+  'users.profileChangedAt',
+] as const;
+
+const withOwner = (eb: ExpressionBuilder<DB, 'libraries'>) => {
+  return jsonObjectFrom(eb.selectFrom('users').whereRef('users.id', '=', 'libraries.ownerId').select(userColumns)).as(
+    'owner',
+  );
+};
 
 @Injectable()
 export class LibraryRepository implements ILibraryRepository {
-  constructor(@InjectRepository(LibraryEntity) private repository: Repository<LibraryEntity>) {}
+  constructor(@InjectKysely() private db: Kysely<DB>) {}
 
   @GenerateSql({ params: [DummyValue.UUID] })
-  get(id: string, withDeleted = false): Promise<LibraryEntity | null> {
-    return this.repository.findOneOrFail({
-      where: {
-        id,
-      },
-      relations: { owner: true },
-      withDeleted,
-    });
+  get(id: string, withDeleted = false): Promise<LibraryEntity | undefined> {
+    return this.db
+      .selectFrom('libraries')
+      .selectAll('libraries')
+      .select(withOwner)
+      .where('libraries.id', '=', id)
+      .$if(!withDeleted, (qb) => qb.where('libraries.deletedAt', 'is', null))
+      .executeTakeFirst() as Promise<LibraryEntity | undefined>;
   }
 
   @GenerateSql({ params: [] })
   getAll(withDeleted = false): Promise<LibraryEntity[]> {
-    return this.repository.find({
-      relations: {
-        owner: true,
-      },
-      order: {
-        createdAt: 'ASC',
-      },
-      withDeleted,
-    });
+    return this.db
+      .selectFrom('libraries')
+      .selectAll('libraries')
+      .select(withOwner)
+      .orderBy('createdAt', 'asc')
+      .$if(!withDeleted, (qb) => qb.where('libraries.deletedAt', 'is', null))
+      .execute() as unknown as Promise<LibraryEntity[]>;
   }
 
   @GenerateSql()
   getAllDeleted(): Promise<LibraryEntity[]> {
-    return this.repository.find({
-      where: {
-        deletedAt: Not(IsNull()),
-      },
-      relations: {
-        owner: true,
-      },
-      order: {
-        createdAt: 'ASC',
-      },
-      withDeleted: true,
-    });
+    return this.db
+      .selectFrom('libraries')
+      .selectAll('libraries')
+      .select(withOwner)
+      .where('libraries.deletedAt', 'is not', null)
+      .orderBy('createdAt', 'asc')
+      .execute() as unknown as Promise<LibraryEntity[]>;
   }
 
-  create(library: Omit<LibraryEntity, 'id' | 'createdAt' | 'updatedAt' | 'ownerId'>): Promise<LibraryEntity> {
-    return this.repository.save(library);
+  create(library: Insertable<Libraries>): Promise<LibraryEntity> {
+    return this.db
+      .insertInto('libraries')
+      .values(library)
+      .returningAll()
+      .executeTakeFirstOrThrow() as Promise<LibraryEntity>;
   }
 
   async delete(id: string): Promise<void> {
-    await this.repository.delete({ id });
+    await this.db.deleteFrom('libraries').where('libraries.id', '=', id).execute();
   }
 
   async softDelete(id: string): Promise<void> {
-    await this.repository.softDelete({ id });
+    await this.db.updateTable('libraries').set({ deletedAt: new Date() }).where('libraries.id', '=', id).execute();
   }
 
-  async update(library: Partial<LibraryEntity>): Promise<LibraryEntity> {
-    return this.save(library);
+  update(id: string, library: Updateable<Libraries>): Promise<LibraryEntity> {
+    return this.db
+      .updateTable('libraries')
+      .set(library)
+      .where('libraries.id', '=', id)
+      .returningAll()
+      .executeTakeFirstOrThrow() as Promise<LibraryEntity>;
   }
 
   @GenerateSql({ params: [DummyValue.UUID] })
   async getStatistics(id: string): Promise<LibraryStatsResponseDto | undefined> {
-    const stats = await this.repository
-      .createQueryBuilder('libraries')
-      .addSelect(`COUNT(assets.id) FILTER (WHERE assets.type = 'IMAGE' AND assets.isVisible)`, 'photos')
-      .addSelect(`COUNT(assets.id) FILTER (WHERE assets.type = 'VIDEO' AND assets.isVisible)`, 'videos')
-      .addSelect('COALESCE(SUM(exif.fileSizeInByte), 0)', 'usage')
-      .leftJoin('libraries.assets', 'assets')
-      .leftJoin('assets.exifInfo', 'exif')
+    const stats = await this.db
+      .selectFrom('libraries')
+      .innerJoin('assets', 'assets.libraryId', 'libraries.id')
+      .innerJoin('exif', 'exif.assetId', 'assets.id')
+      .select((eb) =>
+        eb.fn
+          .count('assets.id')
+          .filterWhere((eb) => eb.and([eb('assets.type', '=', AssetType.IMAGE), eb('assets.isVisible', '=', true)]))
+          .as('photos'),
+      )
+      .select((eb) =>
+        eb.fn
+          .countAll()
+          .filterWhere((eb) => eb.and([eb('assets.type', '=', AssetType.VIDEO), eb('assets.isVisible', '=', true)]))
+          .as('videos'),
+      )
+      .select((eb) => eb.fn.coalesce((eb) => eb.fn.sum('exif.fileSizeInByte'), eb.val(0)).as('usage'))
       .groupBy('libraries.id')
-      .where('libraries.id = :id', { id })
-      .getRawOne();
+      .where('libraries.id', '=', id)
+      .executeTakeFirst();
 
     if (!stats) {
       return;
@@ -91,9 +129,4 @@ export class LibraryRepository implements ILibraryRepository {
       total: Number(stats.photos) + Number(stats.videos),
     };
   }
-
-  private async save(library: Partial<LibraryEntity>) {
-    const { id } = await this.repository.save(library);
-    return this.repository.findOneByOrFail({ id });
-  }
 }