ff-admin-server/src/command/refreshCommandHandler.ts

import { dataSource } from "../data-source";
import { refresh } from "../entity/refresh";
import { PWA_REFRESH_EXPIRATION, REFRESH_EXPIRATION } from "../env.defaults";
import DatabaseActionException from "../exceptions/databaseActionException";
import InternalException from "../exceptions/internalException";
import { StringHelper } from "../helpers/stringHelper";
import UserService from "../service/management/userService";
import { CreateRefreshCommand, DeleteRefreshCommand } from "./refreshCommand";
import ms from "ms";

export default abstract class RefreshCommandHandler {
  /**
   * @description create and save refreshToken to user
   * @param {CreateRefreshCommand} createRefresh
   * @returns {Promise<string>}
   */
  static async create(createRefresh: CreateRefreshCommand): Promise<string> {
    const refreshToken = StringHelper.random(32);

    return await dataSource
      .createQueryBuilder()
      .insert()
      .into(refresh)
      .values({
        token: refreshToken,
        userId: createRefresh.userId,
        expiry: createRefresh.isFromPwa
          ? new Date(Date.now() + ms(PWA_REFRESH_EXPIRATION))
          : new Date(Date.now() + ms(REFRESH_EXPIRATION)),
      })
      .execute()
      .then((result) => {
        return refreshToken;
      })
      .catch((err) => {
        throw new DatabaseActionException("CREATE", "refresh", err);
      });
  }

  /**
   * @description delete refresh by user and token
   * @param {DeleteRefreshCommand} deleteRefresh
   * @returns {Promise<any>}
   */
  static async deleteByToken(deleteRefresh: DeleteRefreshCommand): Promise<any> {
    return await dataSource
      .createQueryBuilder()
      .delete()
      .from(refresh)
      .where({ token: deleteRefresh.token, userId: deleteRefresh.userId })
      .execute()
      .then((res) => {})
      .catch((err) => {
        throw new DatabaseActionException("DELETE", "refresh", err);
      });
  }

  /**
   * @description delete expired
   * @returns {Promise<any>}
   */
  static async deleteExpired(): Promise<any> {
    return await dataSource
      .createQueryBuilder()
      .delete()
      .from(refresh)
      .where("refresh.expiry < :expiry", { expiry: new Date() })
      .execute()
      .then((res) => {})
      .catch((err) => {
        throw new DatabaseActionException("DELETE", "refresh", err);
      });
  }
}