RedisRepository.ts

import ioredis from 'ioredis';
import { DateTime } from 'luxon';

interface IRedisOption {
  expire: number | false;
}

type IRedisResponse<T> = IRedisHaveDataSuccessResponse<T> | IRedisNotHaveDataSuccessResponse | IRedisFailureResponse;

interface IRedisCommonResponse {
  duration: number;
  key: string;
}

interface IRedisHaveDataSuccessResponse<T> extends IRedisCommonResponse {
  success: true;
  data: T;
}

interface IRedisNotHaveDataSuccessResponse extends IRedisCommonResponse {
  success: true;
  data: null;
}

interface IRedisFailureResponse extends IRedisCommonResponse {
  success: false;
  error: Error | null;
}

const defaultRedisOption: IRedisOption = {
  expire: false,
};

export namespace RedisRepository {
  export function get<T>(client: ioredis.Redis, key: string, _option: IRedisOption = defaultRedisOption) {
    return async (): Promise<IRedisResponse<T>> => {
      const start = DateTime.local();
      try {
        const result = await client.get(key);

        if (result === null) {
          const nullResponse: IRedisNotHaveDataSuccessResponse = {
            key,
            success: true,
            data: null,
            duration: start.diffNow().milliseconds * -1,
          };
          return nullResponse;
        }

        const redefined: T = (() => {
          try {
            return JSON.parse(result);
          } catch {
            return result;
          }
        })();

        const response: IRedisHaveDataSuccessResponse<T> = {
          key,
          success: true,
          data: redefined as T,
          duration: start.diffNow().milliseconds * -1,
        };
        return response;
      } catch (error) {
        const response: IRedisFailureResponse = {
          key,
          error,
          success: false,
          duration: start.diffNow().milliseconds * -1,
        };
        return response;
      }
    };
  }
}