@tomei/sso/src/session/session.service.ts

Tomei SSO Package

import { RedisService } from '../redis-client/redis.service';
import { ISessionService } from './interfaces/session-service.interface';
import { IUserSession } from '../interfaces/user-session.interface';

export class SessionService implements ISessionService {
  private static _RedisService: RedisService;
  private environment: string = '';

  private constructor() {}

  static async init(redisClient?: any): Promise<SessionService> {
    const sessionService = new SessionService();
    SessionService._RedisService = await RedisService.init(redisClient);
    if (process.env.NODE_ENV == 'test') {
      sessionService.environment = 'test:';
    } else if (process.env.NODE_ENV == 'staging') {
      sessionService.environment = 'staging:';
    }
    return sessionService;
  }

  async setUserSession(
    userId: string,
    sessionData: IUserSession,
    sessionName: string = 'tomei-sid',
    duration: number = 60 * 60, //1 hour
  ): Promise<void> {
    try {
      const key = `${this.environment}${sessionName}:${userId}`;
      await SessionService._RedisService.set(key, sessionData, duration);
    } catch (error) {
      throw error;
    }
  }

  async retrieveUserSession(
    userId: string,
    sessionName: string = 'tomei-sid',
  ): Promise<IUserSession> {
    try {
      const key = `${this.environment}${sessionName}:${userId}`;
      const stringData = await SessionService._RedisService.get(key);
      if (!stringData)
        return {
          systemLogins: [],
        };
      return JSON.parse(stringData);
    } catch (error) {
      throw error;
    }
  }

  async refreshDuration(
    userid: string,
    sessionName: string = 'tomei-sid',
    duration: number = 60 * 60,
  ): Promise<void> {
    try {
      const userSession = await this.retrieveUserSession(userid, sessionName);
      await this.setUserSession(userid, userSession, sessionName, duration);
    } catch (error) {
      throw error;
    }
  }

  async setAuthorizationCode(
    token: string,
    value: string,
    expire: number,
  ): Promise<void> {
    try {
      const key = `${this.environment}tomei-auth-code:${token}`;
      await SessionService._RedisService.set(key, value, expire);
    } catch (error) {
      throw error;
    }
  }

  async retrieveAuthorizationCode(token: string): Promise<string> {
    try {
      const key = `${this.environment}tomei-auth-code:${token}`;
      return await SessionService._RedisService.get(key);
    } catch (error) {
      throw error;
    }
  }

  async deleteAuthorizationCode(token: string): Promise<void> {
    try {
      const key = `${this.environment}tomei-auth-code:${token}`;
      await SessionService._RedisService.del(key);
    } catch (error) {
      throw error;
    }
  }
}