How to use the ioredis function in ioredis

private setupRedis(): IORedis.Redis {
		return new IORedis({
			port: config.vpdb.redis.port,
			host: config.vpdb.redis.host,
			family: 4,           // 4 (IPv4) or 6 (IPv6)
			db: config.vpdb.redis.db,
		});
	}
}

redisOptions
    })
    subscriber = new Redis.Cluster(redisNodes, {
      slotsRefreshTimeout: 20000,
      redisOptions
    })
  } else {
    redisOptions = {
      host: process.env.REDIS_HOST,
      port: process.env.REDIS_PORT,
      password: process.env.REDIS_PASSWORD,
      keyPrefix: process.env.NODE_ENV
    }

    publisher = new Redis(redisOptions)
    subscriber = new Redis(redisOptions)
  }

  const pubsub = new RedisPubSub({
    publisher,
    subscriber
  })

  const hooksRegistry = new HooksRegistry(serviceRegistry.services, logger)

  hooksRegistry.register()

  const server = await Server.init(
    schema,
    {
      QueryResolvers,
      MutationResolvers,

async function init() {
    if (!config.get('enableDataAnalytics')) {
        return
    }
    if (redis === null) {
        redis = new Redis(config.get('redis'))
    }
}

private async init() {
    const opts = this.opts as RedisOptions;
    if (!this._client) {
      this._client = new IORedis(opts);
    }

    await RedisConnection.waitUntilReady(this._client);

    if (opts && opts.skipVersionCheck !== true) {
      const version = await this.getRedisVersion();
      if (semver.lt(version, RedisConnection.minimumVersion)) {
        throw new Error(
          `Redis version needs to be greater than ${RedisConnection.minimumVersion} Current: ${version}`,
        );
      }
    }
    return this._client;
  }

/**
 * Tell nginx to read the X-Forwarded-For header for logging IP addresses which
 * will contain the real IP.
 */
app.enable('trust proxy');

/**
 * Initialize a cache.
 */
const appCache = new NodeCache({
  stdTTL: 60,
  checkperiod: 120
});
export const cache = appCache;

export const redis = new Redis(settings.REDIS_URI);

/**
 * Support json & urlencoded requests.
 */
app.use(bodyParser.json());
app.use(bodyParser.urlencoded({ extended: false }));

/**
 * Setup logging
 */
winston.configure({
  transports: [
    new (winston.transports.Console)({
      handleExceptions: true,
      humanReadableUnhandledException: true,
      formatter(options) {

function createRedisClient(config: StoreRedisConfig) {
  return new Redis({
    host: config.host,
    port: config.port,
  })
}

const redisOptions = {
  port: conf.get('redis:port'),
  host: conf.get('redis:hostname'),
  password: conf.get('redis:password'),
  retryStrategy: times => Math.min(times * 50, 2000),
  maxRetriesPerRequest: 2
};

export const pubsub = isAppRealTime
  ? new RedisPubSub({
      publisher: new Redis(redisOptions),
      subscriber: new Redis(redisOptions)
    })
  : null;

const client = isAppRealTime && new Redis(redisOptions);
if (client) {
  client.on('error', error => {
    logger.error(error);
  });
}
const isActive = () => client && client.status === 'ready';
/**
 * Delete the user context for a specific edition
 * @param user the user
 * @param instanceId
 * @returns {*}
 */
export const delEditContext = (user, instanceId) =>
  isActive() && client.del(`edit:${instanceId}:${user.id}`);

/**

const initApp = () => {
    diContainer.logger.info('Initializing Redis...');
    diContainer.redis = new Redis({
      host: diContainer.appConfig.REDIS_HOST,
      port: diContainer.appConfig.REDIS_PORT
    });

    diContainer.redis.on('connect', () => {
      diContainer.logger.info(`Redis => Connected to: ${diContainer.appConfig.REDIS_HOST}:${diContainer.appConfig.REDIS_PORT}`);
      diContainer.cache = new Cache(diContainer);

      if (diContainer.appConfig.DB_TYPE === 'cassandra') {
        diContainer.models = cassandraModels(diContainer);
      } else {
        diContainer.models = postgresModels(diContainer);
      }

      diContainer.kafkaUtils = new KafkaUtils(diContainer);

import Redis from 'ioredis';

import logger from './logger';
import * as appMeta from '../package.json';

export const resqueConfig = {
  pkg: 'ioredis',
  namespace: `${appMeta.name}:resque`,
  port: process.env.REDIS_SERVER_PORT || 6379,
  host: process.env.REDIS_SERVER_HOST || '127.0.0.1',
  password: process.env.REDIS_SERVER_PASSWORD || null,
  looping: true,
  database: 0,
};

export const redis = new Redis({
  keyPrefix: `${appMeta.name}:`,
  port: process.env.REDIS_SERVER_PORT || 6379,
  host: process.env.REDIS_SERVER_HOST || '127.0.0.1',
  password: process.env.REDIS_SERVER_PASSWORD || undefined,
}).on('error', (error) => {
  if (error.code === 'ECONNREFUSED') {
    logger('info', 'requirements: redis (v2.0.0 or above) must be running.');
  }

  logger('error', 'redis:', `${error.code}\n`);

  throw error;
});

import config                  from 'config';
import Redis                   from 'ioredis';
import {client as redisClient} from '../../shared-backend/redis';
import log                     from '../../shared-backend/log';
import startSyncStars          from './SyncStars';

const pub = new Redis(config.get('redis'));

export default function (job, done) {
  const data = job.data;
  const {user_id} = data;
  const channel = `sync-stars:user_id:${user_id}`;
  const uniqKey = `{uniq-job:sync-stars}:user_id:${user_id}`;
  let total;
  let i = 0;

  log.info({user_id, job_type: 'sync-stars', job_id: job.id}, 'JOB_STARTED');

  startSyncStars(user_id).subscribe(onNext, onError, onCompleted);

  function onNext(event) {
    switch (event.type) {
    case 'SUMMARY_ITEM':