Please use version greater than 2.5.0, the clustering and redlock will be supported at v3.0.0 😄 ✨

Methods Nav

• about redis

  • redis

• about baseRedis methods

  • onLock
  • freedLock

• about typescript decorator

  • lock
  • cache
  • hashCache

• about javascript decorator function

  • toLock
  • getCache
  • getHashCache

Installation

npm install @acheetahk/redis

cnpm install @acheetahk/redis

yarn add @acheetahk/redis

Dependencies

{
  "@types/ioredis": "4.17.7",
  "ioredis": "^4.17.3"
}

Usage

redis

import { BaseRedis } from '@acheetahk/redis';

const base = new BaseRedis(`<YOUR OPTIONS>`);

const redis = base.redis;

baseRedis - options

| Param | Type | Default | Description | | --- | --- | --- | --- | | [port] | number | string | Object | 6379 | Port of the Redis server, or a URL string(see the examples below), or the options object(see the third argument). | | [host] | string | Object | "localhost" | Host of the Redis server, when the first argument is a URL string, this argument is an object represents the options. | | [options] | Object | | Other options. | | [options.port] | number | 6379 | Port of the Redis server. | | [options.host] | string | "localhost" | Host of the Redis server. | | [options.family] | string | 4 | Version of IP stack. Defaults to 4. | | [options.path] | string | null | Local domain socket path. If set the port, host and family will be ignored. | | [options.keepAlive] | number | 0 | TCP KeepAlive on the socket with a X ms delay before start. Set to a non-number value to disable keepAlive. | | [options.noDelay] | boolean | true | Whether to disable the Nagle's Algorithm. By default we disable it to reduce the latency. | | [options.connectionName] | string | null | Connection name. | | [options.db] | number | 0 | Database index to use. | | [options.password] | string | null | If set, client will send AUTH command with the value of this option when connected. | | [options.dropBufferSupport] | boolean | false | Drop the buffer support for better performance. This option is recommended to be enabled when handling large array response and you don't need the buffer support. | | [options.enableReadyCheck] | boolean | true | When a connection is established to the Redis server, the server might still be loading the database from disk. While loading, the server not respond to any commands. To work around this, when this option is true, ioredis will check the status of the Redis server, and when the Redis server is able to process commands, a ready event will be emitted. | | [options.enableOfflineQueue] | boolean | true | By default, if there is no active connection to the Redis server, commands are added to a queue and are executed once the connection is "ready" (when enableReadyCheck is true, "ready" means the Redis server has loaded the database from disk, otherwise means the connection to the Redis server has been established). If this option is false, when execute the command when the connection isn't ready, an error will be returned. | | [options.connectTimeout] | number | 10000 | The milliseconds before a timeout occurs during the initial connection to the Redis server. | | [options.autoResubscribe] | boolean | true | After reconnected, if the previous connection was in the subscriber mode, client will auto re-subscribe these channels. | | [options.autoResendUnfulfilledCommands] | boolean | true | If true, client will resend unfulfilled commands(e.g. block commands) in the previous connection when reconnected. | | [options.lazyConnect] | boolean | false | By default, When a new Redis instance is created, it will connect to Redis server automatically. If you want to keep the instance disconnected until a command is called, you can pass the lazyConnect option to the constructor: javascript var redis = new Redis({ lazyConnect: true }); // No attempting to connect to the Redis server here. // Now let's connect to the Redis server redis.get('foo', function () { }); | | [options.tls] | Object | | TLS connection support. See https://github.com/luin/ioredis#tls-options | | [options.keyPrefix] | string | "''" | The prefix to prepend to all keys in a command. | | [options.retryStrategy] | function | | See "Quick Start" section | | [options.maxRetriesPerRequest] | number | | See "Quick Start" section | | [options.reconnectOnError] | function | | See "Quick Start" section | | [options.readOnly] | boolean | false | Enable READONLY mode for the connection. Only available for cluster mode. | | [options.stringNumbers] | boolean | false | Force numbers to be always returned as JavaScript strings. This option is necessary when dealing with big numbers (exceed the [-2^53, +2^53] range). | | [options.enableAutoPipelining] | boolean | false | When enabled, all commands issued during an event loop iteration are automatically wrapped in a pipeline and sent to the server at the same time. This can improve performance by 30-50%. | | [options.autoPipeliningIgnoredCommands] | string[] | [] | The list of commands which must not be automatically wrapped in pipelines. | | [options.maxScriptsCachingTime] | number | 60000 | Default script definition caching time. |

onLock

import { BaseRedis } from '@acheetahk/redis';

const base = new BaseRedis(`<YOUR OPTIONS>`);

const [test, result] = await Promise.all([
  base.onLock('onLockTest', 5),
  base.onLock('onLockTest'),
]);

// result = false

onLock - args

| Param | Type | Description | | --- | --- | --- | |key | string| string mutex lock key | |ttl | number| mutex lock expiration time, units are seconds |

freedLock

import { BaseRedis } from '@acheetahk/redis';

const base = new BaseRedis(`<YOUR OPTIONS>`);

const result1 = await base.onLock('onLockTest', 1000); // true
const result2 = await base.onLock('onLockTest'); // false
await base1.freedLock('onLockTest');
const result3 = await base1.onLock('onLockTest'); // true

freedLock - args

| Param | Type | Description | | --- | --- | --- | |key | string| string mutex lock key |

lock

import { BaseRedis } from '@acheetahk/redis';

const base = new BaseRedis(`<YOUR OPTIONS>`);

class Demo {
  @base.lock('key', 5, true)
  async doSomeThings(args: any) {
    const result = await `<YOUR PROMISE FUNCTION>`(args);
    return result;
  }
}

const demo = new Demo();

// success
try {
  const result = await demo.doSomeThings({ key: 'value'});
} catch (error) {
  // console.log(error);
}

// error
try {
  await Promise.all([
    demo.doSomeThings({ key: 'value'}),
    demo.doSomeThings({ key: 'value'})
  ]);
} catch (error) {
  // Error: Frequent operation'
}

lock - args

| Param | Type | Description | | --- | --- | --- | |key | string| string mutex lock key | |ttl | number| mutex lock expiration time, units are seconds | |isAuto | boolean| whether to automatically serialization args according to the bound function parameters, the default is false| |message | string| failure information, the default is Frequent operation|

cache

import { BaseRedis } from '@acheetahk/redis';

let count = 0;
const base = new BaseRedis(`<YOUR OPTIONS>`);

class Demo {
  @base.cache('cacheKey', 3600, true) // 1h
  doSomeThings(num: number) {
    return num + count;
  }
}

const demo = new Demo();

const result = await demo.doSomeThings(1); // 1
const result1 = await demo.doSomeThings(2); // 1

await base.redis.del('cacheKey');
const result2 = await demo.doSomeThings(2); // 2

cache - args

| Param | Type | Description | | --- | --- | --- | |key | string| string cache key | |ttl | number| expiration time, units are seconds | |isAuto | boolean| whether to automatically serialization args according to the bound function parameters, the default is false|

hashCache

import { BaseRedis } from '@acheetahk/redis';

let count = 0;

const base = new BaseRedis(`<YOUR OPTIONS>`);

class Demo {
  @base.hashCache('hkey') // 1h
  doSomeThings(num: number) {
    return num + count;
  }
}

const demo = new Demo();

const result = await demo.doSomeThings(1); // 1
const result1 = await demo.doSomeThings(2); // 1

await base.redis.hdel('hkey', autoMd5([1]));
const result2 = await demo.doSomeThings(2); // 2

hashCache - args

| Param | Type | Description | | --- | --- | --- | |hkey | string| hash cache key |

toLock

import { BaseRedis } from '@acheetahk/redis';
const base = new BaseRedis(`<YOUR OPTIONS>`);

const getResult = async () => { return await doSomeThings() };

try {
  await Promise.all([
    toLock(base, 'toLock', getResult, 5).withArgs(),
    toLock(base, 'toLock', getResult, 5).withArgs(),
  ]);
} catch (error) {
  // Error: Frequent operation
}

toLock - args

| Param | Type | Description | | --- | --- | --- | |baseRedis | BaseRedis| instance by BaseRedis| |key | string| string mutex lock key | |next | Function| function to be executed | |ttl | number| mutex lock expiration time, units are seconds | |message | string| failure information, the default is Frequent operation|

getCache

import { BaseRedis } from '@acheetahk/redis';
const base = new BaseRedis(`<YOUR OPTIONS>`);

let info = 'before ';
const getResult = async (num: string, num2: string) => {
  const result = await doSomeThings();
  const value = info + result + num + num2;
  return value;
};

const result1 = await getCache(base, 'getCache', getResult, 10000).withArgs(123, 234); // 'before success123234';

info = 'now ';
const result2 = await getCache(base, 'getCache', getResult, 10000).withArgs(123, 234); // 'before success123234';

await base.redis.del('getCache');
const result3 = await getCache(base, 'getCache', getResult, 10000).withArgs(123, 234); // 'now success123234';

getCache - args

| Param | Type | Description | | --- | --- | --- | |baseRedis | BaseRedis| instance by BaseRedis| |key | string| string mutex lock key | |next | Function| function to be executed | |ttl | number| expiration time, units are seconds |

getHashCache

import { BaseRedis } from '@acheetahk/redis';
const base = new BaseRedis(`<YOUR OPTIONS>`);

let info = 'before ';

const getResult = async (num: string, num2: string) => {
  const result = await doSomeThings();
  const value = info + result + num + num2;
  return value;
};

const result1 = await getHashCache(base, 'getHashCache', 'key', getResult).withArgs(123, 234); // 'before success123234'

info = 'now ';
const result2 = await getHashCache(base, 'getHashCache', 'key', getResult).withArgs(123, 234); // 'before success123234'

await base.redis.hdel('getHashCache', 'key');
const result4 = await getHashCache(base, 'getHashCache', 'key', getResult).withArgs(123, 234); // 'now success123234'

await base.redis.del('getHashCache');

getHashCache - args

| Param | Type | Description | | --- | --- | --- | |baseRedis | BaseRedis| instance by BaseRedis| |hkey | string| hash cache key | |key | string| hash table key | |next | Function| function to be executed |