refactor: remove user entity (#17498)

server/src/repositories/user.repository.ts

@@ -1,11 +1,11 @@
 import { Injectable } from '@nestjs/common';
-import { Insertable, Kysely, sql, Updateable } from 'kysely';
+import { ExpressionBuilder, Insertable, Kysely, sql, Updateable } from 'kysely';
+import { jsonArrayFrom } from 'kysely/helpers/postgres';
 import { DateTime } from 'luxon';
 import { InjectKysely } from 'nestjs-kysely';
-import { columns, UserAdmin } from 'src/database';
+import { columns } from 'src/database';
 import { DB, UserMetadata as DbUserMetadata } from 'src/db';
 import { DummyValue, GenerateSql } from 'src/decorators';
-import { UserEntity, withMetadata } from 'src/entities/user.entity';
 import { AssetType, UserStatus } from 'src/enum';
 import { UserTable } from 'src/schema/tables/user.table';
 import { UserMetadata, UserMetadataItem } from 'src/types';
@@ -32,12 +32,21 @@ export interface UserFindOptions {
   withDeleted?: boolean;
 }
 
+const withMetadata = (eb: ExpressionBuilder<DB, 'users'>) => {
+  return jsonArrayFrom(
+    eb
+      .selectFrom('user_metadata')
+      .select(['user_metadata.key', 'user_metadata.value'])
+      .whereRef('users.id', '=', 'user_metadata.userId'),
+  ).as('metadata');
+};
+
 @Injectable()
 export class UserRepository {
   constructor(@InjectKysely() private db: Kysely<DB>) {}
 
   @GenerateSql({ params: [DummyValue.UUID, DummyValue.BOOLEAN] })
-  get(userId: string, options: UserFindOptions): Promise<UserEntity | undefined> {
+  get(userId: string, options: UserFindOptions) {
     options = options || {};
 
     return this.db
@@ -46,7 +55,7 @@ export class UserRepository {
       .select(withMetadata)
       .where('users.id', '=', userId)
       .$if(!options.withDeleted, (eb) => eb.where('users.deletedAt', 'is', null))
-      .executeTakeFirst() as Promise<UserEntity | undefined>;
+      .executeTakeFirst();
   }
 
   getMetadata(userId: string) {
@@ -58,13 +67,14 @@ export class UserRepository {
   }
 
   @GenerateSql()
-  getAdmin(): Promise<UserEntity | undefined> {
+  getAdmin() {
     return this.db
       .selectFrom('users')
       .select(columns.userAdmin)
+      .select(withMetadata)
       .where('users.isAdmin', '=', true)
       .where('users.deletedAt', 'is', null)
-      .executeTakeFirst() as Promise<UserEntity | undefined>;
+      .executeTakeFirst();
   }
 
   @GenerateSql()
@@ -80,34 +90,36 @@ export class UserRepository {
   }
 
   @GenerateSql({ params: [DummyValue.EMAIL] })
-  getByEmail(email: string, withPassword?: boolean): Promise<UserEntity | undefined> {
+  getByEmail(email: string, withPassword?: boolean) {
     return this.db
       .selectFrom('users')
       .select(columns.userAdmin)
+      .select(withMetadata)
       .$if(!!withPassword, (eb) => eb.select('password'))
       .where('email', '=', email)
       .where('users.deletedAt', 'is', null)
-      .executeTakeFirst() as Promise<UserEntity | undefined>;
+      .executeTakeFirst();
   }
 
   @GenerateSql({ params: [DummyValue.STRING] })
-  getByStorageLabel(storageLabel: string): Promise<UserEntity | undefined> {
+  getByStorageLabel(storageLabel: string) {
     return this.db
       .selectFrom('users')
       .select(columns.userAdmin)
       .where('users.storageLabel', '=', storageLabel)
       .where('users.deletedAt', 'is', null)
-      .executeTakeFirst() as Promise<UserEntity | undefined>;
+      .executeTakeFirst();
   }
 
   @GenerateSql({ params: [DummyValue.STRING] })
-  getByOAuthId(oauthId: string): Promise<UserEntity | undefined> {
+  getByOAuthId(oauthId: string) {
     return this.db
       .selectFrom('users')
       .select(columns.userAdmin)
+      .select(withMetadata)
       .where('users.oauthId', '=', oauthId)
       .where('users.deletedAt', 'is', null)
-      .executeTakeFirst() as Promise<UserEntity | undefined>;
+      .executeTakeFirst();
   }
 
   @GenerateSql({ params: [DateTime.now().minus({ years: 1 })] })
@@ -126,18 +138,19 @@ export class UserRepository {
       .select(withMetadata)
       .$if(!withDeleted, (eb) => eb.where('users.deletedAt', 'is', null))
       .orderBy('createdAt', 'desc')
-      .execute() as Promise<UserAdmin[]>;
+      .execute();
   }
 
-  async create(dto: Insertable<UserTable>): Promise<UserEntity> {
+  async create(dto: Insertable<UserTable>) {
     return this.db
       .insertInto('users')
       .values(dto)
       .returning(columns.userAdmin)
-      .executeTakeFirst() as unknown as Promise<UserEntity>;
+      .returning(withMetadata)
+      .executeTakeFirstOrThrow();
   }
 
-  update(id: string, dto: Updateable<UserTable>): Promise<UserEntity> {
+  update(id: string, dto: Updateable<UserTable>) {
     return this.db
       .updateTable('users')
       .set(dto)
@@ -145,17 +158,17 @@ export class UserRepository {
       .where('users.deletedAt', 'is', null)
       .returning(columns.userAdmin)
       .returning(withMetadata)
-      .executeTakeFirst() as unknown as Promise<UserEntity>;
+      .executeTakeFirstOrThrow();
   }
 
-  restore(id: string): Promise<UserEntity> {
+  restore(id: string) {
     return this.db
       .updateTable('users')
       .set({ status: UserStatus.ACTIVE, deletedAt: null })
       .where('users.id', '=', asUuid(id))
       .returning(columns.userAdmin)
       .returning(withMetadata)
-      .executeTakeFirst() as unknown as Promise<UserEntity>;
+      .executeTakeFirstOrThrow();
   }
 
   async upsertMetadata<T extends keyof UserMetadata>(id: string, { key, value }: { key: T; value: UserMetadata[T] }) {
@@ -175,14 +188,10 @@ export class UserRepository {
     await this.db.deleteFrom('user_metadata').where('userId', '=', id).where('key', '=', key).execute();
   }
 
-  delete(user: { id: string }, hard?: boolean): Promise<UserEntity> {
+  delete(user: { id: string }, hard?: boolean) {
     return hard
-      ? (this.db.deleteFrom('users').where('id', '=', user.id).execute() as unknown as Promise<UserEntity>)
-      : (this.db
-          .updateTable('users')
-          .set({ deletedAt: new Date() })
-          .where('id', '=', user.id)
-          .execute() as unknown as Promise<UserEntity>);
+      ? this.db.deleteFrom('users').where('id', '=', user.id).execute()
+      : this.db.updateTable('users').set({ deletedAt: new Date() }).where('id', '=', user.id).execute();
   }
 
   @GenerateSql()