All files redis-client-wrapper.ts

100% Statements 38/38
100% Branches 9/9
100% Functions 20/20
100% Lines 38/38

Press n or j to go to the next uncovered block, b, p or k for the previous block.

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113      1x                 1x     9x       2x 2x 2x 1x     1x           2x 2x 2x 1x     1x           2x 2x 2x 1x     1x           2x 2x 2x 1x     1x         1x     5x       1x       1x       1x       1x           1x       16x 1x     15x 9x 6x 5x   1x         14x      
import IORedis from 'ioredis';
import Redis from 'redis';
 
import { REDIS_PACKAGE } from './constans';
 
export interface RedisClient {
  del(...keys: string[]): Promise<number>;
  get(key: string): Promise<string | null>;
  keys(key: string): Promise<string[]>;
  set(key: string, value: string, opts?: { EX: number }): Promise<void>;
}
 
export class RedisWrapper implements RedisClient {
  private client: Redis.RedisClient;
  constructor(client: Redis.RedisClient) {
    this.client = client;
  }
 
  del(...keys: string[]): Promise<number> {
    return new Promise((resolve, reject) => {
      this.client.del(keys, (err, data) => {
        if (err) {
          return reject(err);
        }
 
        return resolve(data);
      });
    });
  }
 
  get(key: string): Promise<string | null> {
    return new Promise((resolve, reject) => {
      this.client.get(key, (err, data) => {
        if (err) {
          return reject(err);
        }
 
        return resolve(data);
      });
    });
  }
 
  keys(key: string): Promise<string[]> {
    return new Promise((resolve, reject) => {
      this.client.keys(key, (err, data) => {
        if (err) {
          return reject(err);
        }
 
        return resolve(data);
      });
    });
  }
 
  set(key: string, value: string, opts: { EX: number }): Promise<void> {
    return new Promise((resolve, reject) => {
      this.client.set(key, value, 'EX', opts.EX, (err) => {
        if (err) {
          return reject(err);
        }
 
        return resolve();
      });
    });
  }
}
export class IORedisWrapper implements RedisClient {
  private client: IORedis.Redis;
  constructor(client: IORedis.Redis) {
    this.client = client;
  }
 
  async del(...keys: string[]): Promise<number> {
    return await this.client.del(...keys);
  }
 
  async get(key: string): Promise<string | null> {
    return await this.client.get(key);
  }
 
  async keys(key: string): Promise<string[]> {
    return await this.client.keys(key);
  }
 
  async set(key: string, value: string, opts: { EX: number }): Promise<void> {
    await this.client.set(key, value, 'EX', opts.EX);
  }
}
 
// add other wrapper
 
export class RedisClientWrapper {
  private clientWrapper: RedisClient;
 
  constructor(packageName: REDIS_PACKAGE, client: any) {
    if (!client) {
      throw new Error('redis client is required');
    }
 
    if (packageName === REDIS_PACKAGE.REDIS) {
      this.clientWrapper = new RedisWrapper(client);
    } else if (packageName === REDIS_PACKAGE.IOREDIS) {
      this.clientWrapper = new IORedisWrapper(client);
    } else {
      throw new Error('redis client only support from packages: redis, ioredis');
    }
  }
 
  getWrapper() {
    return this.clientWrapper;
  }
}