refactor: session repository (#15957)

server/src/repositories/index.ts

@@ -10,7 +10,6 @@ import { IMoveRepository } from 'src/interfaces/move.interface';
 import { IPartnerRepository } from 'src/interfaces/partner.interface';
 import { IPersonRepository } from 'src/interfaces/person.interface';
 import { ISearchRepository } from 'src/interfaces/search.interface';
-import { ISessionRepository } from 'src/interfaces/session.interface';
 import { ISharedLinkRepository } from 'src/interfaces/shared-link.interface';
 import { IStackRepository } from 'src/interfaces/stack.interface';
 import { IStorageRepository } from 'src/interfaces/storage.interface';
@@ -72,6 +71,7 @@ export const repositories = [
   NotificationRepository,
   OAuthRepository,
   ProcessRepository,
+  SessionRepository,
   ServerInfoRepository,
   SystemMetadataRepository,
   TelemetryRepository,
@@ -93,7 +93,6 @@ export const providers = [
   { provide: IPartnerRepository, useClass: PartnerRepository },
   { provide: IPersonRepository, useClass: PersonRepository },
   { provide: ISearchRepository, useClass: SearchRepository },
-  { provide: ISessionRepository, useClass: SessionRepository },
   { provide: ISharedLinkRepository, useClass: SharedLinkRepository },
   { provide: IStackRepository, useClass: StackRepository },
   { provide: IStorageRepository, useClass: StorageRepository },

server/src/repositories/session.repository.ts

@@ -3,36 +3,37 @@ import { Insertable, Kysely, Updateable } from 'kysely';
 import { InjectKysely } from 'nestjs-kysely';
 import { DB, Sessions } from 'src/db';
 import { DummyValue, GenerateSql } from 'src/decorators';
-import { SessionEntity, withUser } from 'src/entities/session.entity';
-import { ISessionRepository, SessionSearchOptions } from 'src/interfaces/session.interface';
+import { withUser } from 'src/entities/session.entity';
 import { asUuid } from 'src/utils/database';
 
+export type SessionSearchOptions = { updatedBefore: Date };
+
 @Injectable()
-export class SessionRepository implements ISessionRepository {
+export class SessionRepository {
   constructor(@InjectKysely() private db: Kysely<DB>) {}
 
   @GenerateSql({ params: [{ updatedBefore: DummyValue.DATE }] })
-  search(options: SessionSearchOptions): Promise<SessionEntity[]> {
+  search(options: SessionSearchOptions) {
     return this.db
       .selectFrom('sessions')
       .selectAll()
       .where('sessions.updatedAt', '<=', options.updatedBefore)
-      .execute() as Promise<SessionEntity[]>;
+      .execute();
   }
 
   @GenerateSql({ params: [DummyValue.STRING] })
-  getByToken(token: string): Promise<SessionEntity | undefined> {
+  getByToken(token: string) {
     return this.db
       .selectFrom('sessions')
       .innerJoinLateral(withUser, (join) => join.onTrue())
       .selectAll('sessions')
       .select((eb) => eb.fn.toJson('user').as('user'))
       .where('sessions.token', '=', token)
-      .executeTakeFirst() as Promise<SessionEntity | undefined>;
+      .executeTakeFirst();
   }
 
   @GenerateSql({ params: [DummyValue.UUID] })
-  getByUserId(userId: string): Promise<SessionEntity[]> {
+  getByUserId(userId: string) {
     return this.db
       .selectFrom('sessions')
       .innerJoinLateral(withUser, (join) => join.onTrue())
@@ -41,30 +42,24 @@ export class SessionRepository implements ISessionRepository {
       .where('sessions.userId', '=', userId)
       .orderBy('sessions.updatedAt', 'desc')
       .orderBy('sessions.createdAt', 'desc')
-      .execute() as unknown as Promise<SessionEntity[]>;
+      .execute();
   }
 
-  async create(dto: Insertable<Sessions>): Promise<SessionEntity> {
-    const { id, token, userId, createdAt, updatedAt, deviceType, deviceOS } = await this.db
-      .insertInto('sessions')
-      .values(dto)
-      .returningAll()
-      .executeTakeFirstOrThrow();
-
-    return { id, token, userId, createdAt, updatedAt, deviceType, deviceOS } as SessionEntity;
+  create(dto: Insertable<Sessions>) {
+    return this.db.insertInto('sessions').values(dto).returningAll().executeTakeFirstOrThrow();
   }
 
-  update(id: string, dto: Updateable<Sessions>): Promise<SessionEntity> {
+  update(id: string, dto: Updateable<Sessions>) {
     return this.db
       .updateTable('sessions')
       .set(dto)
       .where('sessions.id', '=', asUuid(id))
       .returningAll()
-      .executeTakeFirstOrThrow() as Promise<SessionEntity>;
+      .executeTakeFirstOrThrow();
   }
 
   @GenerateSql({ params: [DummyValue.UUID] })
-  async delete(id: string): Promise<void> {
+  async delete(id: string) {
     await this.db.deleteFrom('sessions').where('id', '=', asUuid(id)).execute();
   }
 }