redis/node-redis
1
0
Fork 0
mirror of https://github.com/redis/node-redis.git synced 2025-08-06 02:15:48 +03:00
Code Activity

some more commands

Browse Source
This commit is contained in:
Leibale
2023-05-01 06:58:27 -04:00
parent a5d0963fcf
commit 4304f4dba3
22 changed files with 354 additions and 328 deletions
Download Patch File Download Diff File Expand all files Collapse all files

36
packages/client/lib/commands/LLEN.spec.ts
View File

@@ -1,26 +1,22 @@
import { strict as assert } from 'assert';
import testUtils, { GLOBAL } from '../test-utils';
import { transformArguments } from './LLEN';
import LLEN from './LLEN';
describe('LLEN', () => {
it('transformArguments', () => {
assert.deepEqual(
transformArguments('key'),
['LLEN', 'key']
);
});
it('transformArguments', () => {
assert.deepEqual(
LLEN.transformArguments('key'),
['LLEN', 'key']
);
});
testUtils.testWithClient('client.lLen', async client => {
assert.equal(
await client.lLen('key'),
0
);
}, GLOBAL.SERVERS.OPEN);
testUtils.testWithCluster('cluster.lLen', async cluster => {
assert.equal(
await cluster.lLen('key'),
0
);
}, GLOBAL.CLUSTERS.OPEN);
testUtils.testAll('lLen', async client => {
assert.equal(
await client.lLen('key'),
0
);
}, {
client: GLOBAL.SERVERS.OPEN,
cluster: GLOBAL.CLUSTERS.OPEN
});
});

38
packages/client/lib/commands/LMOVE.spec.ts
View File

@@ -1,28 +1,24 @@
import { strict as assert } from 'assert';
import testUtils, { GLOBAL } from '../test-utils';
import { transformArguments } from './LMOVE';
import LMOVE from './LMOVE';
describe('LMOVE', () => {
testUtils.isVersionGreaterThanHook([6, 2]);
testUtils.isVersionGreaterThanHook([6, 2]);
it('transformArguments', () => {
assert.deepEqual(
transformArguments('source', 'destination', 'LEFT', 'RIGHT'),
['LMOVE', 'source', 'destination', 'LEFT', 'RIGHT']
);
});
it('transformArguments', () => {
assert.deepEqual(
LMOVE.transformArguments('source', 'destination', 'LEFT', 'RIGHT'),
['LMOVE', 'source', 'destination', 'LEFT', 'RIGHT']
);
});
testUtils.testWithClient('client.lMove', async client => {
assert.equal(
await client.lMove('source', 'destination', 'LEFT', 'RIGHT'),
null
);
}, GLOBAL.SERVERS.OPEN);
testUtils.testWithCluster('cluster.lMove', async cluster => {
assert.equal(
await cluster.lMove('{tag}source', '{tag}destination', 'LEFT', 'RIGHT'),
null
);
}, GLOBAL.CLUSTERS.OPEN);
testUtils.testAll('lMove', async client => {
assert.equal(
await client.lMove('source', 'destination', 'LEFT', 'RIGHT'),
null
);
}, {
client: GLOBAL.SERVERS.OPEN,
cluster: GLOBAL.CLUSTERS.OPEN
});
});

1
packages/client/lib/commands/LMOVE.ts
View File

@@ -3,6 +3,7 @@ import { ListSide } from './generic-transformers';
export default {
FIRST_KEY_INDEX: 1,
IS_READ_ONLY: false,
transformArguments(
source: RedisArgument,
destination: RedisArgument,

51
packages/client/lib/commands/LMPOP.spec.ts
View File

@@ -1,32 +1,35 @@
import { strict as assert } from 'assert';
import testUtils, { GLOBAL } from '../test-utils';
import { transformArguments } from './LMPOP';
import LMPOP from './LMPOP';
describe('LMPOP', () => {
testUtils.isVersionGreaterThanHook([7]);
testUtils.isVersionGreaterThanHook([7]);
describe('transformArguments', () => {
it('simple', () => {
assert.deepEqual(
transformArguments('key', 'LEFT'),
['LMPOP', '1', 'key', 'LEFT']
);
});
it('with COUNT', () => {
assert.deepEqual(
transformArguments('key', 'LEFT', {
COUNT: 2
}),
['LMPOP', '1', 'key', 'LEFT', 'COUNT', '2']
);
});
describe('transformArguments', () => {
it('simple', () => {
assert.deepEqual(
LMPOP.transformArguments('key', 'LEFT'),
['LMPOP', '1', 'key', 'LEFT']
);
});
testUtils.testWithClient('client.lmPop', async client => {
assert.deepEqual(
await client.lmPop('key', 'RIGHT'),
null
);
}, GLOBAL.SERVERS.OPEN);
it('with COUNT', () => {
assert.deepEqual(
LMPOP.transformArguments('key', 'LEFT', {
COUNT: 2
}),
['LMPOP', '1', 'key', 'LEFT', 'COUNT', '2']
);
});
});
testUtils.testAll('client.lmPop', async client => {
assert.deepEqual(
await client.lmPop('key', 'RIGHT'),
null
);
}, {
client: GLOBAL.SERVERS.OPEN,
cluster: GLOBAL.SERVERS.OPEN
});
});

1
packages/client/lib/commands/LMPOP.ts
View File

@@ -3,6 +3,7 @@ import { transformLMPopArguments, LMPopOptions, ListSide, RedisVariadicArgument
export default {
FIRST_KEY_INDEX: 2,
IS_READ_ONLY: false,
transformArguments(
keys: RedisVariadicArgument,
side: ListSide,

4
packages/client/lib/commands/LSET.ts
View File

@@ -9,11 +9,11 @@ export default {
element: RedisArgument
) {
return [
'LREM',
'LSET',
key,
index.toString(),
element
];
},
transformReply: undefined as unknown as () => SimpleStringReply
transformReply: undefined as unknown as () => SimpleStringReply<'OK'>
} as const satisfies Command;

4
packages/client/lib/commands/LTRIM.ts
View File

@@ -8,11 +8,11 @@ export default {
stop: number
) {
return [
'LREM',
'LTRIM',
key,
start.toString(),
stop.toString()
];
},
transformReply: undefined as unknown as () => SimpleStringReply
transformReply: undefined as unknown as () => SimpleStringReply<'OK'>
} as const satisfies Command;

26
packages/client/lib/commands/MOVE.spec.ts
View File

@@ -1,19 +1,19 @@
import { strict as assert } from 'assert';
import testUtils, { GLOBAL } from '../test-utils';
import { transformArguments } from './MOVE';
import MOVE from './MOVE';
describe('MOVE', () => {
it('transformArguments', () => {
assert.deepEqual(
transformArguments('key', 1),
['MOVE', 'key', '1']
);
});
it('transformArguments', () => {
assert.deepEqual(
MOVE.transformArguments('key', 1),
['MOVE', 'key', '1']
);
});
testUtils.testWithClient('client.move', async client => {
assert.equal(
await client.move('key', 1),
false
);
}, GLOBAL.SERVERS.OPEN);
testUtils.testWithClient('client.move', async client => {
assert.equal(
await client.move('key', 1),
1
);
}, GLOBAL.SERVERS.OPEN);
});

64
packages/client/lib/commands/MSET.spec.ts
View File

@@ -1,42 +1,38 @@
import { strict as assert } from 'assert';
import testUtils, { GLOBAL } from '../test-utils';
import { transformArguments } from './MSET';
import MSET from './MSET';
describe('MSET', () => {
describe('transformArguments', () => {
it("['key1', 'value1', 'key2', 'value2']", () => {
assert.deepEqual(
transformArguments(['key1', 'value1', 'key2', 'value2']),
['MSET', 'key1', 'value1', 'key2', 'value2']
);
});
it("[['key1', 'value1'], ['key2', 'value2']]", () => {
assert.deepEqual(
transformArguments([['key1', 'value1'], ['key2', 'value2']]),
['MSET', 'key1', 'value1', 'key2', 'value2']
);
});
it("{key1: 'value1'. key2: 'value2'}", () => {
assert.deepEqual(
transformArguments({ key1: 'value1', key2: 'value2' }),
['MSET', 'key1', 'value1', 'key2', 'value2']
);
});
describe('transformArguments', () => {
it("['key1', 'value1', 'key2', 'value2']", () => {
assert.deepEqual(
MSET.transformArguments(['key1', 'value1', 'key2', 'value2']),
['MSET', 'key1', 'value1', 'key2', 'value2']
);
});
testUtils.testWithClient('client.mSet', async client => {
assert.equal(
await client.mSet(['key1', 'value1', 'key2', 'value2']),
'OK'
);
}, GLOBAL.SERVERS.OPEN);
it("[['key1', 'value1'], ['key2', 'value2']]", () => {
assert.deepEqual(
MSET.transformArguments([['key1', 'value1'], ['key2', 'value2']]),
['MSET', 'key1', 'value1', 'key2', 'value2']
);
});
testUtils.testWithCluster('cluster.mSet', async cluster => {
assert.equal(
await cluster.mSet(['{key}1', 'value1', '{key}2', 'value2']),
'OK'
);
}, GLOBAL.CLUSTERS.OPEN);
it("{key1: 'value1'. key2: 'value2'}", () => {
assert.deepEqual(
MSET.transformArguments({ key1: 'value1', key2: 'value2' }),
['MSET', 'key1', 'value1', 'key2', 'value2']
);
});
});
testUtils.testAll('mSet', async client => {
assert.equal(
await client.mSet(['key1', 'value1', 'key2', 'value2']),
'OK'
);
}, {
client: GLOBAL.SERVERS.OPEN,
cluster: GLOBAL.CLUSTERS.OPEN
});
});

64
packages/client/lib/commands/MSETNX.spec.ts
View File

@@ -1,42 +1,38 @@
import { strict as assert } from 'assert';
import testUtils, { GLOBAL } from '../test-utils';
import { transformArguments } from './MSETNX';
import MSETNX from './MSETNX';
describe('MSETNX', () => {
describe('transformArguments', () => {
it("['key1', 'value1', 'key2', 'value2']", () => {
assert.deepEqual(
transformArguments(['key1', 'value1', 'key2', 'value2']),
['MSETNX', 'key1', 'value1', 'key2', 'value2']
);
});
it("[['key1', 'value1'], ['key2', 'value2']]", () => {
assert.deepEqual(
transformArguments([['key1', 'value1'], ['key2', 'value2']]),
['MSETNX', 'key1', 'value1', 'key2', 'value2']
);
});
it("{key1: 'value1'. key2: 'value2'}", () => {
assert.deepEqual(
transformArguments({ key1: 'value1', key2: 'value2' }),
['MSETNX', 'key1', 'value1', 'key2', 'value2']
);
});
describe('transformArguments', () => {
it("['key1', 'value1', 'key2', 'value2']", () => {
assert.deepEqual(
MSETNX.transformArguments(['key1', 'value1', 'key2', 'value2']),
['MSETNX', 'key1', 'value1', 'key2', 'value2']
);
});
testUtils.testWithClient('client.mSetNX', async client => {
assert.equal(
await client.mSetNX(['key1', 'value1', 'key2', 'value2']),
true
);
}, GLOBAL.SERVERS.OPEN);
it("[['key1', 'value1'], ['key2', 'value2']]", () => {
assert.deepEqual(
MSETNX.transformArguments([['key1', 'value1'], ['key2', 'value2']]),
['MSETNX', 'key1', 'value1', 'key2', 'value2']
);
});
testUtils.testWithCluster('cluster.mSetNX', async cluster => {
assert.equal(
await cluster.mSetNX(['{key}1', 'value1', '{key}2', 'value2']),
true
);
}, GLOBAL.CLUSTERS.OPEN);
it("{key1: 'value1'. key2: 'value2'}", () => {
assert.deepEqual(
MSETNX.transformArguments({ key1: 'value1', key2: 'value2' }),
['MSETNX', 'key1', 'value1', 'key2', 'value2']
);
});
});
testUtils.testAll('mSetNX', async client => {
assert.equal(
await client.mSetNX(['{key}1', 'value1', '{key}2', 'value2']),
1
);
}, {
client: GLOBAL.SERVERS.OPEN,
cluster: GLOBAL.CLUSTERS.OPEN
});
});

29
packages/client/lib/commands/PERSIST.spec.ts
View File

@@ -1,19 +1,22 @@
import { strict as assert } from 'assert';
import testUtils, { GLOBAL } from '../test-utils';
import { transformArguments } from './PERSIST';
import PERSIST from './PERSIST';
describe('PERSIST', () => {
it('transformArguments', () => {
assert.deepEqual(
transformArguments('key'),
['PERSIST', 'key']
);
});
it('transformArguments', () => {
assert.deepEqual(
PERSIST.transformArguments('key'),
['PERSIST', 'key']
);
});
testUtils.testWithClient('client.persist', async client => {
assert.equal(
await client.persist('key'),
false
);
}, GLOBAL.SERVERS.OPEN);
testUtils.testAll('persist', async client => {
assert.equal(
await client.persist('key'),
0
);
}, {
client: GLOBAL.SERVERS.OPEN,
cluster: GLOBAL.CLUSTERS.OPEN
});
});

45
packages/client/lib/commands/PEXPIRE.spec.ts
View File

@@ -1,28 +1,31 @@
import { strict as assert } from 'assert';
import testUtils, { GLOBAL } from '../test-utils';
import { transformArguments } from './PEXPIRE';
import PEXPIRE from './PEXPIRE';
describe('PEXPIRE', () => {
describe('transformArguments', () => {
it('simple', () => {
assert.deepEqual(
transformArguments('key', 1),
['PEXPIRE', 'key', '1']
);
});
it('with set option', () => {
assert.deepEqual(
transformArguments('key', 1, 'GT'),
['PEXPIRE', 'key', '1', 'GT']
);
});
describe('transformArguments', () => {
it('simple', () => {
assert.deepEqual(
PEXPIRE.transformArguments('key', 1),
['PEXPIRE', 'key', '1']
);
});
testUtils.testWithClient('client.pExpire', async client => {
assert.equal(
await client.pExpire('key', 1),
false
);
}, GLOBAL.SERVERS.OPEN);
it('with set option', () => {
assert.deepEqual(
PEXPIRE.transformArguments('key', 1, 'GT'),
['PEXPIRE', 'key', '1', 'GT']
);
});
});
testUtils.testAll('pExpire', async client => {
assert.equal(
await client.pExpire('key', 1),
0
);
}, {
client: GLOBAL.SERVERS.OPEN,
cluster: GLOBAL.CLUSTERS.OPEN
});
});

61
packages/client/lib/commands/PEXPIREAT.spec.ts
View File

@@ -1,36 +1,39 @@
import { strict as assert } from 'assert';
import testUtils, { GLOBAL } from '../test-utils';
import { transformArguments } from './PEXPIREAT';
import PEXPIREAT from './PEXPIREAT';
describe('PEXPIREAT', () => {
describe('transformArguments', () => {
it('number', () => {
assert.deepEqual(
transformArguments('key', 1),
['PEXPIREAT', 'key', '1']
);
});
it('date', () => {
const d = new Date();
assert.deepEqual(
transformArguments('key', d),
['PEXPIREAT', 'key', d.getTime().toString()]
);
});
it('with set option', () => {
assert.deepEqual(
transformArguments('key', 1, 'XX'),
['PEXPIREAT', 'key', '1', 'XX']
);
});
describe('transformArguments', () => {
it('number', () => {
assert.deepEqual(
PEXPIREAT.transformArguments('key', 1),
['PEXPIREAT', 'key', '1']
);
});
testUtils.testWithClient('client.pExpireAt', async client => {
assert.equal(
await client.pExpireAt('key', 1),
false
);
}, GLOBAL.SERVERS.OPEN);
it('date', () => {
const d = new Date();
assert.deepEqual(
PEXPIREAT.transformArguments('key', d),
['PEXPIREAT', 'key', d.getTime().toString()]
);
});
it('with set option', () => {
assert.deepEqual(
PEXPIREAT.transformArguments('key', 1, 'XX'),
['PEXPIREAT', 'key', '1', 'XX']
);
});
});
testUtils.testAll('pExpireAt', async client => {
assert.equal(
await client.pExpireAt('key', 1),
0
);
}, {
client: GLOBAL.SERVERS.OPEN,
cluster: GLOBAL.CLUSTERS.OPEN
});
});

31
packages/client/lib/commands/PEXPIRETIME.spec.ts
View File

@@ -1,21 +1,24 @@
import { strict as assert } from 'assert';
import testUtils, { GLOBAL } from '../test-utils';
import { transformArguments } from './PEXPIRETIME';
import PEXPIRETIME from './PEXPIRETIME';
describe('PEXPIRETIME', () => {
testUtils.isVersionGreaterThanHook([7]);
testUtils.isVersionGreaterThanHook([7]);
it('transformArguments', () => {
assert.deepEqual(
transformArguments('key'),
['PEXPIRETIME', 'key']
);
});
it('transformArguments', () => {
assert.deepEqual(
PEXPIRETIME.transformArguments('key'),
['PEXPIRETIME', 'key']
);
});
testUtils.testWithClient('client.pExpireTime', async client => {
assert.equal(
await client.pExpireTime('key'),
-2
);
}, GLOBAL.SERVERS.OPEN);
testUtils.testAll('pExpireTime', async client => {
assert.equal(
await client.pExpireTime('key'),
-2
);
}, {
client: GLOBAL.SERVERS.OPEN,
cluster: GLOBAL.CLUSTERS.OPEN
});
});

2
packages/client/lib/commands/PEXPIRETIME.ts
View File

@@ -4,7 +4,7 @@ export default {
FIRST_KEY_INDEX: 1,
IS_READ_ONLY: true,
transformArguments(key: RedisArgument) {
return ['PEXPIREAT', key];
return ['PEXPIRETIME', key];
},
transformReply: undefined as unknown as () => NumberReply
} as const satisfies Command;

45
packages/client/lib/commands/PFADD.spec.ts
View File

@@ -1,28 +1,31 @@
import { strict as assert } from 'assert';
import testUtils, { GLOBAL } from '../test-utils';
import { transformArguments } from './PFADD';
import PFADD from './PFADD';
describe('PFADD', () => {
describe('transformArguments', () => {
it('string', () => {
assert.deepEqual(
transformArguments('key', 'element'),
['PFADD', 'key', 'element']
);
});
it('array', () => {
assert.deepEqual(
transformArguments('key', ['1', '2']),
['PFADD', 'key', '1', '2']
);
});
describe('transformArguments', () => {
it('string', () => {
assert.deepEqual(
PFADD.transformArguments('key', 'element'),
['PFADD', 'key', 'element']
);
});
testUtils.testWithClient('client.pfAdd', async client => {
assert.equal(
await client.pfAdd('key', '1'),
true
);
}, GLOBAL.SERVERS.OPEN);
it('array', () => {
assert.deepEqual(
PFADD.transformArguments('key', ['1', '2']),
['PFADD', 'key', '1', '2']
);
});
});
testUtils.testAll('pfAdd', async client => {
assert.equal(
await client.pfAdd('key', '1'),
1
);
}, {
client: GLOBAL.SERVERS.OPEN,
cluster: GLOBAL.CLUSTERS.OPEN
});
});

4
packages/client/lib/commands/PFADD.ts
View File

@@ -1,4 +1,4 @@
import { RedisArgument, ArrayReply, BlobStringReply, Command } from '../RESP/types';
import { RedisArgument, NumberReply, Command } from '../RESP/types';
import { RedisVariadicArgument, pushVariadicArguments } from './generic-transformers';
export default {
@@ -10,5 +10,5 @@ export default {
return pushVariadicArguments(args, element);
},
transformReply: undefined as unknown as () => ArrayReply<BlobStringReply>
transformReply: undefined as unknown as () => NumberReply
} as const satisfies Command;

45
packages/client/lib/commands/PFCOUNT.spec.ts
View File

@@ -1,28 +1,31 @@
import { strict as assert } from 'assert';
import testUtils, { GLOBAL } from '../test-utils';
import { transformArguments } from './PFCOUNT';
import PFCOUNT from './PFCOUNT';
describe('PFCOUNT', () => {
describe('transformArguments', () => {
it('string', () => {
assert.deepEqual(
transformArguments('key'),
['PFCOUNT', 'key']
);
});
it('array', () => {
assert.deepEqual(
transformArguments(['1', '2']),
['PFCOUNT', '1', '2']
);
});
describe('transformArguments', () => {
it('string', () => {
assert.deepEqual(
PFCOUNT.transformArguments('key'),
['PFCOUNT', 'key']
);
});
testUtils.testWithClient('client.pfCount', async client => {
assert.equal(
await client.pfCount('key'),
0
);
}, GLOBAL.SERVERS.OPEN);
it('array', () => {
assert.deepEqual(
PFCOUNT.transformArguments(['1', '2']),
['PFCOUNT', '1', '2']
);
});
});
testUtils.testAll('pfCount', async client => {
assert.equal(
await client.pfCount('key'),
0
);
}, {
client: GLOBAL.SERVERS.OPEN,
cluster: GLOBAL.CLUSTERS.OPEN
});
});

45
packages/client/lib/commands/PFMERGE.spec.ts
View File

@@ -1,28 +1,31 @@
import { strict as assert } from 'assert';
import testUtils, { GLOBAL } from '../test-utils';
import { transformArguments } from './PFMERGE';
import PFMERGE from './PFMERGE';
describe('PFMERGE', () => {
describe('transformArguments', () => {
it('string', () => {
assert.deepEqual(
transformArguments('destination', 'source'),
['PFMERGE', 'destination', 'source']
);
});
it('array', () => {
assert.deepEqual(
transformArguments('destination', ['1', '2']),
['PFMERGE', 'destination', '1', '2']
);
});
describe('transformArguments', () => {
it('string', () => {
assert.deepEqual(
PFMERGE.transformArguments('destination', 'source'),
['PFMERGE', 'destination', 'source']
);
});
testUtils.testWithClient('client.pfMerge', async client => {
assert.equal(
await client.pfMerge('destination', 'source'),
'OK'
);
}, GLOBAL.SERVERS.OPEN);
it('array', () => {
assert.deepEqual(
PFMERGE.transformArguments('destination', ['1', '2']),
['PFMERGE', 'destination', '1', '2']
);
});
});
testUtils.testAll('pfMerge', async client => {
assert.equal(
await client.pfMerge('{tag}destination', '{tag}source'),
'OK'
);
}, {
client: GLOBAL.SERVERS.OPEN,
cluster: GLOBAL.CLUSTERS.OPEN
});
});

37
packages/client/lib/commands/PSETEX.spec.ts
View File

@@ -1,27 +1,22 @@
import { strict as assert } from 'assert';
import testUtils, { GLOBAL } from '../test-utils';
import { transformArguments } from './PSETEX';
import PSETEX from './PSETEX';
describe('PSETEX', () => {
it('transformArguments', () => {
assert.deepEqual(
transformArguments('key', 1, 'value'),
['PSETEX', 'key', '1', 'value']
);
});
it('transformArguments', () => {
assert.deepEqual(
PSETEX.transformArguments('key', 1, 'value'),
['PSETEX', 'key', '1', 'value']
);
});
testUtils.testWithClient('client.pSetEx', async client => {
const a = await client.pSetEx('key', 1, 'value');
assert.equal(
await client.pSetEx('key', 1, 'value'),
'OK'
);
}, GLOBAL.SERVERS.OPEN);
testUtils.testWithCluster('cluster.pSetEx', async cluster => {
assert.equal(
await cluster.pSetEx('key', 1, 'value'),
'OK'
);
}, GLOBAL.CLUSTERS.OPEN);
testUtils.testAll('pSetEx', async client => {
assert.equal(
await client.pSetEx('key', 1, 'value'),
'OK'
);
}, {
client: GLOBAL.SERVERS.OPEN,
cluster: GLOBAL.CLUSTERS.OPEN
});
});

29
packages/client/lib/commands/PTTL.spec.ts
View File

@@ -1,19 +1,22 @@
import { strict as assert } from 'assert';
import testUtils, { GLOBAL } from '../test-utils';
import { transformArguments } from './PTTL';
import PTTL from './PTTL';
describe('PTTL', () => {
it('transformArguments', () => {
assert.deepEqual(
transformArguments('key'),
['PTTL', 'key']
);
});
it('transformArguments', () => {
assert.deepEqual(
PTTL.transformArguments('key'),
['PTTL', 'key']
);
});
testUtils.testWithClient('client.pTTL', async client => {
assert.equal(
await client.pTTL('key'),
-2
);
}, GLOBAL.SERVERS.OPEN);
testUtils.testAll('pTTL', async client => {
assert.equal(
await client.pTTL('key'),
-2
);
}, {
client: GLOBAL.SERVERS.OPEN,
cluster: GLOBAL.CLUSTERS.OPEN
});
});

20
packages/client/lib/commands/index.ts
View File

@@ -91,11 +91,17 @@ import LTRIM from './LTRIM';
import MGET from './MGET';
import MSET from './MSET';
import MSETNX from './MSETNX';
import PERSIST from './PERSIST';
import PEXPIRE from './PEXPIRE';
import PEXPIREAT from './PEXPIREAT';
import PEXPIRETIME from './PEXPIRETIME';
import PFADD from './PFADD';
import PFCOUNT from './PFCOUNT';
import PFMERGE from './PFMERGE';
import PING from './PING';
import PSETEX from './PSETEX';
import PTTL from './PTTL';
import RANDOMKEY from './RANDOMKEY';
import RENAME from './RENAME';
import RENAMENX from './RENAMENX';
import RPOP_COUNT from './RPOP_COUNT';
@@ -344,7 +350,15 @@ export default {
MSET,
mSet: MSET,
MSETNX,
mSetNx: MSETNX,
mSetNX: MSETNX,
PERSIST,
persist: PERSIST,
PEXPIRE,
pExpire: PEXPIRE,
PEXPIREAT,
pExpireAt: PEXPIREAT,
PEXPIRETIME,
pExpireTime: PEXPIRETIME,
PFADD,
pfAdd: PFADD,
PFCOUNT,
@@ -358,6 +372,10 @@ export default {
ping: PING,
PSETEX,
pSetEx: PSETEX,
PTTL,
pTTL: PTTL,
RANDOMKEY,
randomKey: RANDOMKEY,
RENAME,
rename: RENAME,
RENAMENX,