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

Merge branch 'master' of github.com:redis/node-redis into COMMAND_DOCS

Browse Source
This commit is contained in:
Avital-Fine
2022-04-03 14:08:19 +03:00
parent ba3dfde74c a5d06937db
commit 7f3a35c309
117 changed files with 2861 additions and 1054 deletions
Download Patch File Download Diff File Expand all files Collapse all files

2
.github/workflows/tests.yml vendored
View File

@@ -17,7 +17,7 @@ jobs:
fail-fast: false
matrix:
node-version: ['12', '14', '16']
redis-version: ['5', '6.0', '6.2']
redis-version: ['5', '6.0', '6.2', '7.0-rc2']
steps:
- uses: actions/checkout@v2.3.4
with:

1361
package-lock.json generated
View File

File diff suppressed because it is too large Load Diff

10
package.json
View File

@@ -1,7 +1,7 @@
{
"name": "redis",
"description": "A modern, high performance Redis client",
"version": "4.0.4",
"version": "4.0.6",
"license": "MIT",
"main": "./dist/index.js",
"types": "./dist/index.d.ts",
@@ -24,17 +24,17 @@
},
"dependencies": {
"@node-redis/bloom": "1.0.1",
"@node-redis/client": "1.0.4",
"@node-redis/client": "1.0.5",
"@node-redis/graph": "1.0.0",
"@node-redis/json": "1.0.2",
"@node-redis/search": "1.0.3",
"@node-redis/search": "1.0.5",
"@node-redis/time-series": "1.0.2"
},
"devDependencies": {
"@tsconfig/node12": "^1.0.9",
"gh-pages": "^3.2.3",
"release-it": "^14.12.1",
"typescript": "^4.5.4"
"release-it": "^14.13.1",
"typescript": "^4.6.3"
},
"repository": {
"type": "git",

10
packages/bloom/package.json
View File

@@ -18,12 +18,12 @@
"devDependencies": {
"@istanbuljs/nyc-config-typescript": "^1.0.2",
"@node-redis/test-utils": "*",
"@types/node": "^17.0.13",
"@types/node": "^17.0.23",
"nyc": "^15.1.0",
"release-it": "^14.12.4",
"release-it": "^14.13.1",
"source-map-support": "^0.5.21",
"ts-node": "^10.4.0",
"typedoc": "^0.22.11",
"typescript": "^4.5.5"
"ts-node": "^10.7.0",
"typedoc": "^0.22.13",
"typescript": "^4.6.3"
}
}

60
packages/client/lib/client/commands.ts
View File

@@ -23,16 +23,33 @@ import * as CLIENT_KILL from '../commands/CLIENT_KILL';
import * as CLIENT_SETNAME from '../commands/CLIENT_SETNAME';
import * as CLIENT_INFO from '../commands/CLIENT_INFO';
import * as CLUSTER_ADDSLOTS from '../commands/CLUSTER_ADDSLOTS';
import * as CLUSTER_ADDSLOTSRANGE from '../commands/CLUSTER_ADDSLOTSRANGE';
import * as CLUSTER_BUMPEPOCH from '../commands/CLUSTER_BUMPEPOCH';
import * as CLUSTER_COUNT_FAILURE_REPORTS from '../commands/CLUSTER_COUNT-FAILURE-REPORTS';
import * as CLUSTER_COUNTKEYSINSLOT from '../commands/CLUSTER_COUNTKEYSINSLOT';
import * as CLUSTER_DELSLOTS from '../commands/CLUSTER_DELSLOTS';
import * as CLUSTER_DELSLOTSRANGE from '../commands/CLUSTER_DELSLOTSRANGE';
import * as CLUSTER_FAILOVER from '../commands/CLUSTER_FAILOVER';
import * as CLUSTER_FLUSHSLOTS from '../commands/CLUSTER_FLUSHSLOTS';
import * as CLUSTER_FORGET from '../commands/CLUSTER_FORGET';
import * as CLUSTER_GETKEYSINSLOT from '../commands/CLUSTER_GETKEYSINSLOT';
import * as CLUSTER_INFO from '../commands/CLUSTER_INFO';
import * as CLUSTER_NODES from '../commands/CLUSTER_NODES';
import * as CLUSTER_KEYSLOT from '../commands/CLUSTER_KEYSLOT';
import * as CLUSTER_LINKS from '../commands/CLUSTER_LINKS';
import * as CLUSTER_MEET from '../commands/CLUSTER_MEET';
import * as CLUSTER_MYID from '../commands/CLUSTER_MYID';
import * as CLUSTER_NODES from '../commands/CLUSTER_NODES';
import * as CLUSTER_REPLICAS from '../commands/CLUSTER_REPLICAS';
import * as CLUSTER_REPLICATE from '../commands/CLUSTER_REPLICATE';
import * as CLUSTER_RESET from '../commands/CLUSTER_RESET';
import * as CLUSTER_SAVECONFIG from '../commands/CLUSTER_SAVECONFIG';
import * as CLUSTER_SET_CONFIG_EPOCH from '../commands/CLUSTER_SET-CONFIG-EPOCH';
import * as CLUSTER_SETSLOT from '../commands/CLUSTER_SETSLOT';
import * as CLUSTER_SLOTS from '../commands/CLUSTER_SLOTS';
import * as COMMAND_COUNT from '../commands/COMMAND_COUNT';
import * as COMMAND_DOCS from '../commands/COMMAND_DOCS';
import * as COMMAND_GETKEYS from '../commands/COMMAND_GETKEYS';
import * as COMMAND_GETKEYSANDFLAGS from '../commands/COMMAND_GETKEYSANDFLAGS';
import * as COMMAND_INFO from '../commands/COMMAND_INFO';
import * as COMMAND_LIST from '../commands/COMMAND_LIST';
import * as COMMAND from '../commands/COMMAND';
@@ -82,6 +99,7 @@ import * as SWAPDB from '../commands/SWAPDB';
import * as TIME from '../commands/TIME';
import * as UNWATCH from '../commands/UNWATCH';
import * as WAIT from '../commands/WAIT';
import * as LATENCY_DOCTOR from '../commands/LATENCY_DOCTOR';
export default {
...CLUSTER_COMMANDS,
@@ -133,16 +151,48 @@ export default {
clientInfo: CLIENT_INFO,
CLUSTER_ADDSLOTS,
clusterAddSlots: CLUSTER_ADDSLOTS,
CLUSTER_ADDSLOTSRANGE,
clusterAddSlotsRange: CLUSTER_ADDSLOTSRANGE,
CLUSTER_BUMPEPOCH,
clusterBumpEpoch: CLUSTER_BUMPEPOCH,
CLUSTER_COUNT_FAILURE_REPORTS,
clusterCountFailureReports: CLUSTER_COUNT_FAILURE_REPORTS,
CLUSTER_COUNTKEYSINSLOT,
clusterCountKeysInSlot: CLUSTER_COUNTKEYSINSLOT,
CLUSTER_DELSLOTS,
clusterDelSlots: CLUSTER_DELSLOTS,
CLUSTER_DELSLOTSRANGE,
clusterDelSlotsRange: CLUSTER_DELSLOTSRANGE,
CLUSTER_FAILOVER,
clusterFailover: CLUSTER_FAILOVER,
CLUSTER_FLUSHSLOTS,
clusterFlushSlots: CLUSTER_FLUSHSLOTS,
CLUSTER_FORGET,
clusterForget: CLUSTER_FORGET,
CLUSTER_GETKEYSINSLOT,
clusterGetKeysInSlot: CLUSTER_GETKEYSINSLOT,
CLUSTER_INFO,
clusterInfo: CLUSTER_INFO,
CLUSTER_NODES,
clusterNodes: CLUSTER_NODES,
CLUSTER_KEYSLOT,
clusterKeySlot: CLUSTER_KEYSLOT,
CLUSTER_LINKS,
clusterLinks: CLUSTER_LINKS,
CLUSTER_MEET,
clusterMeet: CLUSTER_MEET,
CLUSTER_MYID,
clusterMyId: CLUSTER_MYID,
CLUSTER_NODES,
clusterNodes: CLUSTER_NODES,
CLUSTER_REPLICAS,
clusterReplicas: CLUSTER_REPLICAS,
CLUSTER_REPLICATE,
clusterReplicate: CLUSTER_REPLICATE,
CLUSTER_RESET,
clusterReset: CLUSTER_RESET,
CLUSTER_SAVECONFIG,
clusterSaveConfig: CLUSTER_SAVECONFIG,
CLUSTER_SET_CONFIG_EPOCH,
clusterSetConfigEpoch: CLUSTER_SET_CONFIG_EPOCH,
CLUSTER_SETSLOT,
clusterSetSlot: CLUSTER_SETSLOT,
CLUSTER_SLOTS,
@@ -153,6 +203,8 @@ export default {
commandDocs: COMMAND_DOCS,
COMMAND_GETKEYS,
commandGetKeys: COMMAND_GETKEYS,
COMMAND_GETKEYSANDFLAGS,
commandGetKeysAndFlags: COMMAND_GETKEYSANDFLAGS,
COMMAND_INFO,
commandInfo: COMMAND_INFO,
COMMAND_LIST,
@@ -187,6 +239,8 @@ export default {
keys: KEYS,
LASTSAVE,
lastSave: LASTSAVE,
LATENCY_DOCTOR,
latencyDoctor: LATENCY_DOCTOR,
LOLWUT,
lolwut: LOLWUT,
MEMOERY_DOCTOR,

11
packages/client/lib/client/index.spec.ts
View File

@@ -477,8 +477,11 @@ describe('Client', () => {
assert.ok(id !== isolatedId);
}, GLOBAL.SERVERS.OPEN);
async function killClient<M extends RedisModules, S extends RedisScripts>(client: RedisClientType<M, S>): Promise<void> {
const onceErrorPromise = once(client, 'error');
async function killClient<M extends RedisModules, S extends RedisScripts>(
client: RedisClientType<M, S>,
errorClient: RedisClientType<M, S> = client
): Promise<void> {
const onceErrorPromise = once(errorClient, 'error');
await client.sendCommand(['QUIT']);
await Promise.all([
onceErrorPromise,
@@ -503,6 +506,10 @@ describe('Client', () => {
minimumDockerVersion: [6, 2] // CLIENT INFO
});
testUtils.testWithClient('should propagated errors from "isolated" clients', client => {
return client.executeIsolated(isolated => killClient(isolated, client));
}, GLOBAL.SERVERS.OPEN);
testUtils.testWithClient('scanIterator', async client => {
const promises = [],
keys = new Set();

2
packages/client/lib/client/index.ts
View File

@@ -189,7 +189,7 @@ export default class RedisClient<M extends RedisModules, S extends RedisScripts>
create: async () => {
const duplicate = this.duplicate({
isolationPoolOptions: undefined
});
}).on('error', err => this.emit('error', err));
await duplicate.connect();
return duplicate;
},

2
packages/client/lib/client/socket.spec.ts
View File

@@ -6,7 +6,7 @@ describe('Socket', () => {
describe('reconnectStrategy', () => {
let clock: SinonFakeTimers;
beforeEach(() => clock = useFakeTimers());
afterEach(() => clock.uninstall());
afterEach(() => clock.restore());
it('custom strategy', () => {
const reconnectStrategy = spy((retries: number): number | Error => {

30
packages/client/lib/cluster/commands.ts
View File

@@ -21,6 +21,7 @@ import * as EVALSHA from '../commands/EVALSHA';
import * as EXISTS from '../commands/EXISTS';
import * as EXPIRE from '../commands/EXPIRE';
import * as EXPIREAT from '../commands/EXPIREAT';
import * as EXPIRETIME from '../commands/EXPIRETIME';
import * as GEOADD from '../commands/GEOADD';
import * as GEODIST from '../commands/GEODIST';
import * as GEOHASH from '../commands/GEOHASH';
@@ -72,9 +73,14 @@ import * as MGET from '../commands/MGET';
import * as MIGRATE from '../commands/MIGRATE';
import * as MSET from '../commands/MSET';
import * as MSETNX from '../commands/MSETNX';
import * as OBJECT_ENCODING from '../commands/OBJECT_ENCODING';
import * as OBJECT_FREQ from '../commands/OBJECT_FREQ';
import * as OBJECT_IDLETIME from '../commands/OBJECT_IDLETIME';
import * as OBJECT_REFCOUNT from '../commands/OBJECT_REFCOUNT';
import * as PERSIST from '../commands/PERSIST';
import * as PEXPIRE from '../commands/PEXPIRE';
import * as PEXPIREAT from '../commands/PEXPIREAT';
import * as PEXPIRETIME from '../commands/PEXPIRETIME';
import * as PFADD from '../commands/PFADD';
import * as PFCOUNT from '../commands/PFCOUNT';
import * as PFMERGE from '../commands/PFMERGE';
@@ -98,11 +104,14 @@ import * as SETEX from '../commands/SETEX';
import * as SETNX from '../commands/SETNX';
import * as SETRANGE from '../commands/SETRANGE';
import * as SINTER from '../commands/SINTER';
import * as SINTERCARD from '../commands/SINTERCARD';
import * as SINTERSTORE from '../commands/SINTERSTORE';
import * as SISMEMBER from '../commands/SISMEMBER';
import * as SMEMBERS from '../commands/SMEMBERS';
import * as SMISMEMBER from '../commands/SMISMEMBER';
import * as SMOVE from '../commands/SMOVE';
import * as SORT_RO from '../commands/SORT_RO';
import * as SORT_STORE from '../commands/SORT_STORE';
import * as SORT from '../commands/SORT';
import * as SPOP from '../commands/SPOP';
import * as SRANDMEMBER_COUNT from '../commands/SRANDMEMBER_COUNT';
@@ -149,6 +158,7 @@ import * as ZDIFFSTORE from '../commands/ZDIFFSTORE';
import * as ZINCRBY from '../commands/ZINCRBY';
import * as ZINTER_WITHSCORES from '../commands/ZINTER_WITHSCORES';
import * as ZINTER from '../commands/ZINTER';
import * as ZINTERCARD from '../commands/ZINTERCARD';
import * as ZINTERSTORE from '../commands/ZINTERSTORE';
import * as ZLEXCOUNT from '../commands/ZLEXCOUNT';
import * as ZMSCORE from '../commands/ZMSCORE';
@@ -222,6 +232,8 @@ export default {
expire: EXPIRE,
EXPIREAT,
expireAt: EXPIREAT,
EXPIRETIME,
expireTime: EXPIRETIME,
GEOADD,
geoAdd: GEOADD,
GEODIST,
@@ -324,12 +336,22 @@ export default {
mSet: MSET,
MSETNX,
mSetNX: MSETNX,
OBJECT_ENCODING,
objectEncoding: OBJECT_ENCODING,
OBJECT_FREQ,
objectFreq: OBJECT_FREQ,
OBJECT_IDLETIME,
objectIdleTime: OBJECT_IDLETIME,
OBJECT_REFCOUNT,
objectRefCount: OBJECT_REFCOUNT,
PERSIST,
persist: PERSIST,
PEXPIRE,
pExpire: PEXPIRE,
PEXPIREAT,
pExpireAt: PEXPIREAT,
PEXPIRETIME,
pExpireTime: PEXPIRETIME,
PFADD,
pfAdd: PFADD,
PFCOUNT,
@@ -366,6 +388,8 @@ export default {
sDiffStore: SDIFFSTORE,
SINTER,
sInter: SINTER,
SINTERCARD,
sInterCard: SINTERCARD,
SINTERSTORE,
sInterStore: SINTERSTORE,
SET,
@@ -386,6 +410,10 @@ export default {
smIsMember: SMISMEMBER,
SMOVE,
sMove: SMOVE,
SORT_RO,
sortRo: SORT_RO,
SORT_STORE,
sortStore: SORT_STORE,
SORT,
sort: SORT,
SPOP,
@@ -478,6 +506,8 @@ export default {
zInterWithScores: ZINTER_WITHSCORES,
ZINTER,
zInter: ZINTER,
ZINTERCARD,
zInterCard: ZINTERCARD,
ZINTERSTORE,
zInterStore: ZINTERSTORE,
ZLEXCOUNT,

34
packages/client/lib/commands/ACL_GETUSER.spec.ts
View File

@@ -13,20 +13,32 @@ describe('ACL GETUSER', () => {
});
testUtils.testWithClient('client.aclGetUser', async client => {
assert.deepEqual(
await client.aclGetUser('default'),
{
const expectedReply: any = {
passwords: [],
commands: '+@all',
keys: ['*'],
...(testUtils.isVersionGreaterThan([6, 2]) ? {
flags: ['on', 'allkeys', 'allchannels', 'allcommands', 'nopass'],
channels: ['*']
} : {
flags: ['on', 'allkeys', 'allcommands', 'nopass'],
channels: undefined
})
};
if (testUtils.isVersionGreaterThan([7])) {
expectedReply.flags = ['on', 'nopass'];
expectedReply.keys = '~*';
expectedReply.channels = '&*';
expectedReply.selectors = [];
} else {
expectedReply.keys = ['*'];
expectedReply.selectors = undefined;
if (testUtils.isVersionGreaterThan([6, 2])) {
expectedReply.flags = ['on', 'allkeys', 'allchannels', 'allcommands', 'nopass'];
expectedReply.channels = ['*'];
} else {
expectedReply.flags = ['on', 'allkeys', 'allcommands', 'nopass'];
expectedReply.channels = undefined;
}
}
assert.deepEqual(
await client.aclGetUser('default'),
expectedReply
);
}, GLOBAL.SERVERS.OPEN);
});

30
packages/client/lib/commands/ACL_GETUSER.ts
View File

@@ -5,24 +5,27 @@ export function transformArguments(username: RedisCommandArgument): RedisCommand
}
type AclGetUserRawReply = [
_: RedisCommandArgument,
flags: Array<RedisCommandArgument>,
_: RedisCommandArgument,
passwords: Array<RedisCommandArgument>,
_: RedisCommandArgument,
commands: RedisCommandArgument,
_: RedisCommandArgument,
keys: Array<RedisCommandArgument>,
_: RedisCommandArgument,
channels: Array<RedisCommandArgument>
'flags',
Array<RedisCommandArgument>,
'passwords',
Array<RedisCommandArgument>,
'commands',
RedisCommandArgument,
'keys',
Array<RedisCommandArgument> | RedisCommandArgument,
'channels',
Array<RedisCommandArgument> | RedisCommandArgument,
'selectors' | undefined,
Array<Array<string>> | undefined
];
interface AclUser {
flags: Array<RedisCommandArgument>;
passwords: Array<RedisCommandArgument>;
commands: RedisCommandArgument;
keys: Array<RedisCommandArgument>;
channels: Array<RedisCommandArgument>
keys: Array<RedisCommandArgument> | RedisCommandArgument;
channels: Array<RedisCommandArgument> | RedisCommandArgument;
selectors?: Array<Array<string>>;
}
export function transformReply(reply: AclGetUserRawReply): AclUser {
@@ -31,6 +34,7 @@ export function transformReply(reply: AclGetUserRawReply): AclUser {
passwords: reply[3],
commands: reply[5],
keys: reply[7],
channels: reply[9]
channels: reply[9],
selectors: reply[11]
};
}

15
packages/client/lib/commands/BITCOUNT.spec.ts
View File

@@ -11,7 +11,8 @@ describe('BITCOUNT', () => {
);
});
it('with range', () => {
describe('with range', () => {
it('simple', () => {
assert.deepEqual(
transformArguments('key', {
start: 0,
@@ -20,6 +21,18 @@ describe('BITCOUNT', () => {
['BITCOUNT', 'key', '0', '1']
);
});
it('with mode', () => {
assert.deepEqual(
transformArguments('key', {
start: 0,
end: 1,
mode: 'BIT'
}),
['BITCOUNT', 'key', '0', '1', 'BIT']
);
});
});
});
testUtils.testWithClient('client.bitCount', async client => {

5
packages/client/lib/commands/BITCOUNT.ts
View File

@@ -7,6 +7,7 @@ export const IS_READ_ONLY = true;
interface BitCountRange {
start: number;
end: number;
mode?: 'BYTE' | 'BIT';
}
export function transformArguments(
@@ -20,6 +21,10 @@ export function transformArguments(
range.start.toString(),
range.end.toString()
);
if (range.mode) {
args.push(range.mode);
}
}
return args;

9
packages/client/lib/commands/BITPOS.spec.ts
View File

@@ -18,12 +18,19 @@ describe('BITPOS', () => {
);
});
it('with start, end', () => {
it('with start and end', () => {
assert.deepEqual(
transformArguments('key', 1, 1, -1),
['BITPOS', 'key', '1', '1', '-1']
);
});
it('with start, end and mode', () => {
assert.deepEqual(
transformArguments('key', 1, 1, -1, 'BIT'),
['BITPOS', 'key', '1', '1', '-1', 'BIT']
);
});
});
testUtils.testWithClient('client.bitPos', async client => {

7
packages/client/lib/commands/BITPOS.ts
View File

@@ -9,7 +9,8 @@ export function transformArguments(
key: RedisCommandArgument,
bit: BitValue,
start?: number,
end?: number
end?: number,
mode?: 'BYTE' | 'BIT'
): RedisCommandArguments {
const args = ['BITPOS', key, bit.toString()];
@@ -21,6 +22,10 @@ export function transformArguments(
args.push(end.toString());
}
if (mode) {
args.push(mode);
}
return args;
}

16
packages/client/lib/commands/CLUSTER_ADDSLOTS.ts
View File

@@ -1,13 +1,11 @@
export function transformArguments(slots: number | Array<number>): Array<string> {
const args = ['CLUSTER', 'ADDSLOTS'];
import { RedisCommandArguments } from '.';
import { pushVerdictNumberArguments } from './generic-transformers';
if (typeof slots === 'number') {
args.push(slots.toString());
} else {
args.push(...slots.map(String));
}
return args;
export function transformArguments(slots: number | Array<number>): RedisCommandArguments {
return pushVerdictNumberArguments(
['CLUSTER', 'ADDSLOTS'],
slots
);
}
export declare function transformReply(): string;

29
packages/client/lib/commands/CLUSTER_ADDSLOTSRANGE.spec.ts Normal file
View File

@@ -0,0 +1,29 @@
import { strict as assert } from 'assert';
import { transformArguments } from './CLUSTER_ADDSLOTSRANGE';
describe('CLUSTER ADDSLOTSRANGE', () => {
describe('transformArguments', () => {
it('single', () => {
assert.deepEqual(
transformArguments({
start: 0,
end: 1
}),
['CLUSTER', 'ADDSLOTSRANGE', '0', '1']
);
});
it('multiple', () => {
assert.deepEqual(
transformArguments([{
start: 0,
end: 1
}, {
start: 2,
end: 3
}]),
['CLUSTER', 'ADDSLOTSRANGE', '0', '1', '2', '3']
);
});
});
});

13
packages/client/lib/commands/CLUSTER_ADDSLOTSRANGE.ts Normal file
View File

@@ -0,0 +1,13 @@
import { RedisCommandArguments } from '.';
import { pushSlotRangesArguments, SlotRange } from './generic-transformers';
export function transformArguments(
ranges: SlotRange | Array<SlotRange>
): RedisCommandArguments {
return pushSlotRangesArguments(
['CLUSTER', 'ADDSLOTSRANGE'],
ranges
);
}
export declare function transformReply(): 'OK';

19
packages/client/lib/commands/CLUSTER_BUMPEPOCH.spec.ts Normal file
View File

@@ -0,0 +1,19 @@
import { strict as assert } from 'assert';
import testUtils, { GLOBAL } from '../test-utils';
import { transformArguments } from './CLUSTER_BUMPEPOCH';
describe('CLUSTER BUMPEPOCH', () => {
it('transformArguments', () => {
assert.deepEqual(
transformArguments(),
['CLUSTER', 'BUMPEPOCH']
);
});
testUtils.testWithCluster('clusterNode.clusterBumpEpoch', async cluster => {
assert.equal(
typeof await cluster.getSlotMaster(0).client.clusterBumpEpoch(),
'string'
);
}, GLOBAL.SERVERS.OPEN);
});

5
packages/client/lib/commands/CLUSTER_BUMPEPOCH.ts Normal file
View File

@@ -0,0 +1,5 @@
export function transformArguments(): Array<string> {
return ['CLUSTER', 'BUMPEPOCH'];
}
export declare function transformReply(): 'BUMPED' | 'STILL';

22
packages/client/lib/commands/CLUSTER_COUNT-FAILURE-REPORTS.spec.ts Normal file
View File

@@ -0,0 +1,22 @@
import { strict as assert } from 'assert';
import testUtils, { GLOBAL } from '../test-utils';
import { transformArguments } from './CLUSTER_COUNT-FAILURE-REPORTS';
describe('CLUSTER COUNT-FAILURE-REPORTS', () => {
it('transformArguments', () => {
assert.deepEqual(
transformArguments('0'),
['CLUSTER', 'COUNT-FAILURE-REPORTS', '0']
);
});
testUtils.testWithCluster('clusterNode.clusterCountFailureReports', async cluster => {
const { client } = cluster.getSlotMaster(0);
assert.equal(
typeof await client.clusterCountFailureReports(
await client.clusterMyId()
),
'number'
);
}, GLOBAL.CLUSTERS.OPEN);
});

5
packages/client/lib/commands/CLUSTER_COUNT-FAILURE-REPORTS.ts Normal file
View File

@@ -0,0 +1,5 @@
export function transformArguments(nodeId: string): Array<string> {
return ['CLUSTER', 'COUNT-FAILURE-REPORTS', nodeId];
}
export declare function transformReply(): number;

19
packages/client/lib/commands/CLUSTER_COUNTKEYSINSLOT.spec.ts Normal file
View File

@@ -0,0 +1,19 @@
import { strict as assert } from 'assert';
import testUtils, { GLOBAL } from '../test-utils';
import { transformArguments } from './CLUSTER_COUNTKEYSINSLOT';
describe('CLUSTER COUNTKEYSINSLOT', () => {
it('transformArguments', () => {
assert.deepEqual(
transformArguments(0),
['CLUSTER', 'COUNTKEYSINSLOT', '0']
);
});
testUtils.testWithCluster('clusterNode.clusterCountKeysInSlot', async cluster => {
assert.equal(
typeof await cluster.getSlotMaster(0).client.clusterCountKeysInSlot(0),
'number'
);
}, GLOBAL.CLUSTERS.OPEN);
});

5
packages/client/lib/commands/CLUSTER_COUNTKEYSINSLOT.ts Normal file
View File

@@ -0,0 +1,5 @@
export function transformArguments(slot: number): Array<string> {
return ['CLUSTER', 'COUNTKEYSINSLOT', slot.toString()];
}
export declare function transformReply(): number;

20
packages/client/lib/commands/CLUSTER_DELSLOTS.spec.ts Normal file
View File

@@ -0,0 +1,20 @@
import { strict as assert } from 'assert';
import { transformArguments } from './CLUSTER_DELSLOTS';
describe('CLUSTER DELSLOTS', () => {
describe('transformArguments', () => {
it('single', () => {
assert.deepEqual(
transformArguments(0),
['CLUSTER', 'DELSLOTS', '0']
);
});
it('multiple', () => {
assert.deepEqual(
transformArguments([0, 1]),
['CLUSTER', 'DELSLOTS', '0', '1']
);
});
});
});

11
packages/client/lib/commands/CLUSTER_DELSLOTS.ts Normal file
View File

@@ -0,0 +1,11 @@
import { RedisCommandArguments } from '.';
import { pushVerdictNumberArguments } from './generic-transformers';
export function transformArguments(slots: number | Array<number>): RedisCommandArguments {
return pushVerdictNumberArguments(
['CLUSTER', 'DELSLOTS'],
slots
);
}
export declare function transformReply(): 'OK';

29
packages/client/lib/commands/CLUSTER_DELSLOTSRANGE.spec.ts Normal file
View File

@@ -0,0 +1,29 @@
import { strict as assert } from 'assert';
import { transformArguments } from './CLUSTER_DELSLOTSRANGE';
describe('CLUSTER DELSLOTSRANGE', () => {
describe('transformArguments', () => {
it('single', () => {
assert.deepEqual(
transformArguments({
start: 0,
end: 1
}),
['CLUSTER', 'DELSLOTSRANGE', '0', '1']
);
});
it('multiple', () => {
assert.deepEqual(
transformArguments([{
start: 0,
end: 1
}, {
start: 2,
end: 3
}]),
['CLUSTER', 'DELSLOTSRANGE', '0', '1', '2', '3']
);
});
});
});

13
packages/client/lib/commands/CLUSTER_DELSLOTSRANGE.ts Normal file
View File

@@ -0,0 +1,13 @@
import { RedisCommandArguments } from '.';
import { pushSlotRangesArguments, SlotRange } from './generic-transformers';
export function transformArguments(
ranges: SlotRange | Array<SlotRange>
): RedisCommandArguments {
return pushSlotRangesArguments(
['CLUSTER', 'DELSLOTSRANGE'],
ranges
);
}
export declare function transformReply(): 'OK';

20
packages/client/lib/commands/CLUSTER_FAILOVER.spec.ts Normal file
View File

@@ -0,0 +1,20 @@
import { strict as assert } from 'assert';
import { FailoverModes, transformArguments } from './CLUSTER_FAILOVER';
describe('CLUSTER FAILOVER', () => {
describe('transformArguments', () => {
it('simple', () => {
assert.deepEqual(
transformArguments(),
['CLUSTER', 'FAILOVER']
);
});
it('with mode', () => {
assert.deepEqual(
transformArguments(FailoverModes.FORCE),
['CLUSTER', 'FAILOVER', 'FORCE']
);
});
});
});

16
packages/client/lib/commands/CLUSTER_FAILOVER.ts Normal file
View File

@@ -0,0 +1,16 @@
export enum FailoverModes {
FORCE = 'FORCE',
TAKEOVER = 'TAKEOVER'
}
export function transformArguments(mode?: FailoverModes): Array<string> {
const args = ['CLUSTER', 'FAILOVER'];
if (mode) {
args.push(mode);
}
return args;
}
export declare function transformReply(): 'OK';

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

@@ -2,4 +2,4 @@ export function transformArguments(): Array<string> {
return ['CLUSTER', 'FLUSHSLOTS'];
}
export declare function transformReply(): string;
export declare function transformReply(): 'OK';

11
packages/client/lib/commands/CLUSTER_FORGET.spec.ts Normal file
View File

@@ -0,0 +1,11 @@
import { strict as assert } from 'assert';
import { transformArguments } from './CLUSTER_FORGET';
describe('CLUSTER FORGET', () => {
it('transformArguments', () => {
assert.deepEqual(
transformArguments('0'),
['CLUSTER', 'FORGET', '0']
);
});
});

5
packages/client/lib/commands/CLUSTER_FORGET.ts Normal file
View File

@@ -0,0 +1,5 @@
export function transformArguments(nodeId: string): Array<string> {
return ['CLUSTER', 'FORGET', nodeId];
}
export declare function transformReply(): 'OK';

9
packages/client/lib/commands/CLUSTER_GETKEYSINSLOT.spec.ts
View File

@@ -1,4 +1,5 @@
import { strict as assert } from 'assert';
import testUtils, { GLOBAL } from '../test-utils';
import { transformArguments } from './CLUSTER_GETKEYSINSLOT';
describe('CLUSTER GETKEYSINSLOT', () => {
@@ -8,4 +9,12 @@ describe('CLUSTER GETKEYSINSLOT', () => {
['CLUSTER', 'GETKEYSINSLOT', '0', '10']
);
});
testUtils.testWithCluster('clusterNode.clusterGetKeysInSlot', async cluster => {
const reply = await cluster.getSlotMaster(0).client.clusterGetKeysInSlot(0, 1);
assert.ok(Array.isArray(reply));
for (const item of reply) {
assert.equal(typeof item, 'string');
}
}, GLOBAL.CLUSTERS.OPEN);
});

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

@@ -2,4 +2,4 @@ export function transformArguments(slot: number, count: number): Array<string> {
return ['CLUSTER', 'GETKEYSINSLOT', slot.toString(), count.toString()];
}
export declare function transformReply(): string;
export declare function transformReply(): Array<string>;

8
packages/client/lib/commands/CLUSTER_INFO.spec.ts
View File

@@ -1,4 +1,5 @@
import { strict as assert } from 'assert';
import testUtils, { GLOBAL } from '../test-utils';
import { transformArguments, transformReply } from './CLUSTER_INFO';
describe('CLUSTER INFO', () => {
@@ -43,4 +44,11 @@ describe('CLUSTER INFO', () => {
}
);
});
testUtils.testWithCluster('clusterNode.clusterInfo', async cluster => {
assert.notEqual(
await cluster.getSlotMaster(0).client.clusterInfo(),
null
);
}, GLOBAL.CLUSTERS.OPEN);
});

19
packages/client/lib/commands/CLUSTER_KEYSLOT.spec.ts Normal file
View File

@@ -0,0 +1,19 @@
import { strict as assert } from 'assert';
import testUtils, { GLOBAL } from '../test-utils';
import { transformArguments } from './CLUSTER_KEYSLOT';
describe('CLUSTER KEYSLOT', () => {
it('transformArguments', () => {
assert.deepEqual(
transformArguments('key'),
['CLUSTER', 'KEYSLOT', 'key']
);
});
testUtils.testWithCluster('clusterNode.clusterKeySlot', async cluster => {
assert.equal(
typeof await cluster.getSlotMaster(0).client.clusterKeySlot('key'),
'number'
);
}, GLOBAL.CLUSTERS.OPEN);
});

5
packages/client/lib/commands/CLUSTER_KEYSLOT.ts Normal file
View File

@@ -0,0 +1,5 @@
export function transformArguments(key: string): Array<string> {
return ['CLUSTER', 'KEYSLOT', key];
}
export declare function transformReply(): number;

27
packages/client/lib/commands/CLUSTER_LINKS.spec.ts Normal file
View File

@@ -0,0 +1,27 @@
import { strict as assert } from 'assert';
import testUtils, { GLOBAL } from '../test-utils';
import { transformArguments } from './CLUSTER_LINKS';
describe('CLUSTER LINKS', () => {
testUtils.isVersionGreaterThanHook([7, 0]);
it('transformArguments', () => {
assert.deepEqual(
transformArguments(),
['CLUSTER', 'LINKS']
);
});
testUtils.testWithCluster('clusterNode.clusterLinks', async cluster => {
const links = await cluster.getSlotMaster(0).client.clusterLinks();
assert.ok(Array.isArray(links));
for (const link of links) {
assert.equal(typeof link.direction, 'string');
assert.equal(typeof link.node, 'string');
assert.equal(typeof link.createTime, 'number');
assert.equal(typeof link.events, 'string');
assert.equal(typeof link.sendBufferAllocated, 'number');
assert.equal(typeof link.sendBufferUsed, 'number');
}
}, GLOBAL.CLUSTERS.OPEN);
});

38
packages/client/lib/commands/CLUSTER_LINKS.ts Normal file
View File

@@ -0,0 +1,38 @@
export function transformArguments(): Array<string> {
return ['CLUSTER', 'LINKS'];
}
type ClusterLinksRawReply = Array<[
'direction',
string,
'node',
string,
'createTime',
number,
'events',
string,
'send-buffer-allocated',
number,
'send-buffer-used',
number
]>;
type ClusterLinksReply = Array<{
direction: string;
node: string;
createTime: number;
events: string;
sendBufferAllocated: number;
sendBufferUsed: number;
}>;
export function transformReply(reply: ClusterLinksRawReply): ClusterLinksReply {
return reply.map(peerLink => ({
direction: peerLink[1],
node: peerLink[3],
createTime: Number(peerLink[5]),
events: peerLink[7],
sendBufferAllocated: Number(peerLink[9]),
sendBufferUsed: Number(peerLink[11])
}));
}

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

@@ -2,4 +2,4 @@ export function transformArguments(ip: string, port: number): Array<string> {
return ['CLUSTER', 'MEET', ip, port.toString()];
}
export declare function transformReply(): string;
export declare function transformReply(): 'OK';

19
packages/client/lib/commands/CLUSTER_MYID.spec.ts Normal file
View File

@@ -0,0 +1,19 @@
import { strict as assert } from 'assert';
import testUtils, { GLOBAL } from '../test-utils';
import { transformArguments } from './CLUSTER_MYID';
describe('CLUSTER MYID', () => {
it('transformArguments', () => {
assert.deepEqual(
transformArguments(),
['CLUSTER', 'MYID']
);
});
testUtils.testWithCluster('clusterNode.clusterMyId', async cluster => {
assert.equal(
typeof await cluster.getSlotMaster(0).client.clusterMyId(),
'string'
);
}, GLOBAL.CLUSTERS.OPEN);
});

5
packages/client/lib/commands/CLUSTER_MYID.ts Normal file
View File

@@ -0,0 +1,5 @@
export function transformArguments(): Array<string> {
return ['CLUSTER', 'MYID'];
}
export declare function transformReply(): string;

11
packages/client/lib/commands/CLUSTER_REPLICAS.spec.ts Normal file
View File

@@ -0,0 +1,11 @@
import { strict as assert } from 'assert';
import { transformArguments } from './CLUSTER_REPLICAS';
describe('CLUSTER REPLICAS', () => {
it('transformArguments', () => {
assert.deepEqual(
transformArguments('0'),
['CLUSTER', 'REPLICAS', '0']
);
});
});

5
packages/client/lib/commands/CLUSTER_REPLICAS.ts Normal file
View File

@@ -0,0 +1,5 @@
export function transformArguments(nodeId: string): Array<string> {
return ['CLUSTER', 'REPLICAS', nodeId];
}
export { transformReply } from './CLUSTER_NODES';

11
packages/client/lib/commands/CLUSTER_REPLICATE.spec.ts Normal file
View File

@@ -0,0 +1,11 @@
import { strict as assert } from 'assert';
import { transformArguments } from './CLUSTER_REPLICATE';
describe('CLUSTER REPLICATE', () => {
it('transformArguments', () => {
assert.deepEqual(
transformArguments('0'),
['CLUSTER', 'REPLICATE', '0']
);
});
});

5
packages/client/lib/commands/CLUSTER_REPLICATE.ts Normal file
View File

@@ -0,0 +1,5 @@
export function transformArguments(nodeId: string): Array<string> {
return ['CLUSTER', 'REPLICATE', nodeId];
}
export declare function transformReply(): 'OK';

9
packages/client/lib/commands/CLUSTER_RESET.spec.ts
View File

@@ -10,18 +10,11 @@ describe('CLUSTER RESET', () => {
);
});
it('HARD', () => {
it('with mode', () => {
assert.deepEqual(
transformArguments('HARD'),
['CLUSTER', 'RESET', 'HARD']
);
});
it('SOFT', () => {
assert.deepEqual(
transformArguments('SOFT'),
['CLUSTER', 'RESET', 'SOFT']
);
});
});
});

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

@@ -1,6 +1,4 @@
export type ClusterResetModes = 'HARD' | 'SOFT';
export function transformArguments(mode?: ClusterResetModes): Array<string> {
export function transformArguments(mode?: 'HARD' | 'SOFT'): Array<string> {
const args = ['CLUSTER', 'RESET'];
if (mode) {

19
packages/client/lib/commands/CLUSTER_SAVECONFIG.spec.ts Normal file
View File

@@ -0,0 +1,19 @@
import { strict as assert } from 'assert';
import testUtils, { GLOBAL } from '../test-utils';
import { transformArguments } from './CLUSTER_SAVECONFIG';
describe('CLUSTER SAVECONFIG', () => {
it('transformArguments', () => {
assert.deepEqual(
transformArguments(),
['CLUSTER', 'SAVECONFIG']
);
});
testUtils.testWithCluster('clusterNode.clusterSaveConfig', async cluster => {
assert.equal(
await cluster.getSlotMaster(0).client.clusterSaveConfig(),
'OK'
);
}, GLOBAL.CLUSTERS.OPEN);
});

5
packages/client/lib/commands/CLUSTER_SAVECONFIG.ts Normal file
View File

@@ -0,0 +1,5 @@
export function transformArguments(): Array<string> {
return ['CLUSTER', 'SAVECONFIG'];
}
export declare function transformReply(): 'OK';

11
packages/client/lib/commands/CLUSTER_SET-CONFIG-EPOCH.spec.ts Normal file
View File

@@ -0,0 +1,11 @@
import { strict as assert } from 'assert';
import { transformArguments } from './CLUSTER_SET-CONFIG-EPOCH';
describe('CLUSTER SET-CONFIG-EPOCH', () => {
it('transformArguments', () => {
assert.deepEqual(
transformArguments(0),
['CLUSTER', 'SET-CONFIG-EPOCH', '0']
);
});
});

5
packages/client/lib/commands/CLUSTER_SET-CONFIG-EPOCH.ts Normal file
View File

@@ -0,0 +1,5 @@
export function transformArguments(configEpoch: number): Array<string> {
return ['CLUSTER', 'SET-CONFIG-EPOCH', configEpoch.toString()];
}
export declare function transformReply(): 'OK';

8
packages/client/lib/commands/CLUSTER_SETSLOT.ts
View File

@@ -5,7 +5,11 @@ export enum ClusterSlotStates {
NODE = 'NODE'
}
export function transformArguments(slot: number, state: ClusterSlotStates, nodeId?: string): Array<string> {
export function transformArguments(
slot: number,
state: ClusterSlotStates,
nodeId?: string
): Array<string> {
const args = ['CLUSTER', 'SETSLOT', slot.toString(), state];
if (nodeId) {
@@ -15,4 +19,4 @@ export function transformArguments(slot: number, state: ClusterSlotStates, nodeI
return args;
}
export declare function transformReply(): string;
export declare function transformReply(): 'OK';

7
packages/client/lib/commands/CLUSTER_SLOTS.ts
View File

@@ -6,7 +6,12 @@ export function transformArguments(): RedisCommandArguments {
type ClusterSlotsRawNode = [ip: string, port: number, id: string];
type ClusterSlotsRawReply = Array<[from: number, to: number, master: ClusterSlotsRawNode, ...replicas: Array<ClusterSlotsRawNode>]>;
type ClusterSlotsRawReply = Array<[
from: number,
to: number,
master: ClusterSlotsRawNode,
...replicas: Array<ClusterSlotsRawNode>
]>;
type ClusterSlotsNode = {
ip: string;

24
packages/client/lib/commands/COMMAND_GETKEYSANDFLAGS.spec.ts Normal file
View File

@@ -0,0 +1,24 @@
import { strict as assert } from 'assert';
import testUtils, { GLOBAL } from '../test-utils';
import { transformArguments } from './COMMAND_GETKEYSANDFLAGS';
describe('COMMAND GETKEYSANDFLAGS', () => {
testUtils.isVersionGreaterThanHook([7, 0]);
it('transformArguments', () => {
assert.deepEqual(
transformArguments(['GET', 'key']),
['COMMAND', 'GETKEYSANDFLAGS', 'GET', 'key']
);
});
testUtils.testWithClient('client.commandGetKeysAndFlags', async client => {
assert.deepEqual(
await client.commandGetKeysAndFlags(['GET', 'key']),
[{
key: 'key',
flags: ['RO', 'access']
}]
);
}, GLOBAL.SERVERS.OPEN);
});

24
packages/client/lib/commands/COMMAND_GETKEYSANDFLAGS.ts Normal file
View File

@@ -0,0 +1,24 @@
import { RedisCommandArgument, RedisCommandArguments } from '.';
export const IS_READ_ONLY = true;
export function transformArguments(args: Array<RedisCommandArgument>): RedisCommandArguments {
return ['COMMAND', 'GETKEYSANDFLAGS', ...args];
}
type KeysAndFlagsRawReply = Array<[
RedisCommandArgument,
RedisCommandArguments
]>;
type KeysAndFlagsReply = Array<{
key: RedisCommandArgument;
flags: RedisCommandArguments;
}>;
export function transformReply(reply: KeysAndFlagsRawReply): KeysAndFlagsReply {
return reply.map(([key, flags]) => ({
key,
flags
}));
}

6
packages/client/lib/commands/COMMAND_INFO.spec.ts
View File

@@ -9,7 +9,11 @@ export function assertPingCommand(commandInfo: CommandReply | null | undefined):
{
name: 'ping',
arity: -1,
flags: new Set([CommandFlags.STALE, CommandFlags.FAST]),
flags: new Set(
testUtils.isVersionGreaterThan([7]) ?
[CommandFlags.FAST] :
[CommandFlags.STALE, CommandFlags.FAST]
),
firstKeyIndex: 0,
lastKeyIndex: 0,
step: 0,

15
packages/client/lib/commands/CONFIG_SET.spec.ts
View File

@@ -2,10 +2,23 @@ import { strict as assert } from 'assert';
import { transformArguments } from './CONFIG_SET';
describe('CONFIG SET', () => {
it('transformArguments', () => {
describe('transformArguments', () => {
it('set one parameter (old version)', () => {
assert.deepEqual(
transformArguments('parameter', 'value'),
['CONFIG', 'SET', 'parameter', 'value']
);
});
it('set muiltiple parameters', () => {
assert.deepEqual(
transformArguments({
1: 'a',
2: 'b',
3: 'c'
}),
['CONFIG', 'SET', '1', 'a', '2', 'b', '3', 'c']
);
});
});
});

22
packages/client/lib/commands/CONFIG_SET.ts
View File

@@ -1,5 +1,23 @@
export function transformArguments(parameter: string, value: string): Array<string> {
return ['CONFIG', 'SET', parameter, value];
import { RedisCommandArgument, RedisCommandArguments } from '.';
type SingleParameter = [parameter: RedisCommandArgument, value: RedisCommandArgument];
type MultipleParameters = [config: Record<string, RedisCommandArgument>];
export function transformArguments(
...[parameterOrConfig, value]: SingleParameter | MultipleParameters
): RedisCommandArguments {
const args: RedisCommandArguments = ['CONFIG', 'SET'];
if (typeof parameterOrConfig === 'string') {
args.push(parameterOrConfig, value!);
} else {
for (const [key, value] of Object.entries(parameterOrConfig)) {
args.push(key, value);
}
}
return args;
}
export declare function transformReply(): string;

11
packages/client/lib/commands/EXPIRE.spec.ts
View File

@@ -3,13 +3,22 @@ import testUtils, { GLOBAL } from '../test-utils';
import { transformArguments } from './EXPIRE';
describe('EXPIRE', () => {
it('transformArguments', () => {
describe('transformArguments', () => {
it('simple', () => {
assert.deepEqual(
transformArguments('key', 1),
['EXPIRE', 'key', '1']
);
});
it('with set option', () => {
assert.deepEqual(
transformArguments('key', 1, 'NX'),
['EXPIRE', 'key', '1', 'NX']
);
});
});
testUtils.testWithClient('client.expire', async client => {
assert.equal(
await client.expire('key', 0),

11
packages/client/lib/commands/EXPIRE.ts
View File

@@ -4,9 +4,16 @@ export const FIRST_KEY_INDEX = 1;
export function transformArguments(
key: RedisCommandArgument,
seconds: number
seconds: number,
mode?: 'NX' | 'XX' | 'GT' | 'LT'
): RedisCommandArguments {
return ['EXPIRE', key, seconds.toString()];
const args = ['EXPIRE', key, seconds.toString()];
if (mode) {
args.push(mode);
}
return args;
}
export { transformBooleanReply as transformReply } from './generic-transformers';

7
packages/client/lib/commands/EXPIREAT.spec.ts
View File

@@ -18,6 +18,13 @@ describe('EXPIREAT', () => {
['EXPIREAT', 'key', Math.floor(d.getTime() / 1000).toString()]
);
});
it('with set option', () => {
assert.deepEqual(
transformArguments('key', 1, 'GT'),
['EXPIREAT', 'key', '1', 'GT']
);
});
});
testUtils.testWithClient('client.expireAt', async client => {

11
packages/client/lib/commands/EXPIREAT.ts
View File

@@ -5,13 +5,20 @@ export const FIRST_KEY_INDEX = 1;
export function transformArguments(
key: RedisCommandArgument,
timestamp: number | Date
timestamp: number | Date,
mode?: 'NX' | 'XX' | 'GT' | 'LT'
): RedisCommandArguments {
return [
const args = [
'EXPIREAT',
key,
transformEXAT(timestamp)
];
if (mode) {
args.push(mode);
}
return args;
}
export { transformBooleanReply as transformReply } from './generic-transformers';

21
packages/client/lib/commands/EXPIRETIME.spec.ts Normal file
View File

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

9
packages/client/lib/commands/EXPIRETIME.ts Normal file
View File

@@ -0,0 +1,9 @@
import { RedisCommandArgument, RedisCommandArguments } from '.';
export const FIRST_KEY_INDEX = 1;
export function transformArguments(key: RedisCommandArgument): RedisCommandArguments {
return ['EXPIRETIME', key];
}
export declare function transformReply(): number;

19
packages/client/lib/commands/LATENCY_DOCTOR.spec.ts Normal file
View File

@@ -0,0 +1,19 @@
import {strict as assert} from 'assert';
import testUtils, {GLOBAL} from '../test-utils';
import { transformArguments } from './LATENCY_DOCTOR';
describe('LATENCY DOCTOR', () => {
it('transformArguments', () => {
assert.deepEqual(
transformArguments(),
['LATENCY', 'DOCTOR']
);
});
testUtils.testWithClient('client.latencyDoctor', async client => {
assert.equal(
typeof (await client.latencyDoctor()),
'string'
);
}, GLOBAL.SERVERS.OPEN);
});

5
packages/client/lib/commands/LATENCY_DOCTOR.ts Normal file
View File

@@ -0,0 +1,5 @@
export function transformArguments(): Array<string> {
return ['LATENCY', 'DOCTOR'];
}
export declare function transformReply(): string;

19
packages/client/lib/commands/OBJECT_ENCODING.spec.ts Normal file
View File

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

11
packages/client/lib/commands/OBJECT_ENCODING.ts Normal file
View File

@@ -0,0 +1,11 @@
import { RedisCommandArgument, RedisCommandArguments } from '.';
export const FIRST_KEY_INDEX = 2;
export const IS_READ_ONLY = true;
export function transformArguments(key: RedisCommandArgument): RedisCommandArguments {
return ['OBJECT', 'ENCODING', key];
}
export declare function transformReply(): string | null;

19
packages/client/lib/commands/OBJECT_FREQ.spec.ts Normal file
View File

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

11
packages/client/lib/commands/OBJECT_FREQ.ts Normal file
View File

@@ -0,0 +1,11 @@
import { RedisCommandArgument, RedisCommandArguments } from '.';
export const FIRST_KEY_INDEX = 2;
export const IS_READ_ONLY = true;
export function transformArguments(key: RedisCommandArgument): RedisCommandArguments {
return ['OBJECT', 'FREQ', key];
}
export declare function transformReply(): number | null;

19
packages/client/lib/commands/OBJECT_IDLETIME.spec.ts Normal file
View File

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

11
packages/client/lib/commands/OBJECT_IDLETIME.ts Normal file
View File

@@ -0,0 +1,11 @@
import { RedisCommandArgument, RedisCommandArguments } from '.';
export const FIRST_KEY_INDEX = 2;
export const IS_READ_ONLY = true;
export function transformArguments(key: RedisCommandArgument): RedisCommandArguments {
return ['OBJECT', 'IDLETIME', key];
}
export declare function transformReply(): number | null;

19
packages/client/lib/commands/OBJECT_REFCOUNT.spec.ts Normal file
View File

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

11
packages/client/lib/commands/OBJECT_REFCOUNT.ts Normal file
View File

@@ -0,0 +1,11 @@
import { RedisCommandArgument, RedisCommandArguments } from '.';
export const FIRST_KEY_INDEX = 2;
export const IS_READ_ONLY = true;
export function transformArguments(key: RedisCommandArgument): RedisCommandArguments {
return ['OBJECT', 'REFCOUNT', key];
}
export declare function transformReply(): number | null;

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

@@ -3,13 +3,22 @@ import testUtils, { GLOBAL } from '../test-utils';
import { transformArguments } from './PEXPIRE';
describe('PEXPIRE', () => {
it('transformArguments', () => {
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']
);
});
});
testUtils.testWithClient('client.pExpire', async client => {
assert.equal(
await client.pExpire('key', 1),

11
packages/client/lib/commands/PEXPIRE.ts
View File

@@ -4,9 +4,16 @@ export const FIRST_KEY_INDEX = 1;
export function transformArguments(
key: RedisCommandArgument,
milliseconds: number
milliseconds: number,
mode?: 'NX' | 'XX' | 'GT' | 'LT'
): RedisCommandArguments {
return ['PEXPIRE', key, milliseconds.toString()];
const args = ['PEXPIRE', key, milliseconds.toString()];
if (mode) {
args.push(mode);
}
return args;
}
export { transformBooleanReply as transformReply } from './generic-transformers';

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

@@ -18,6 +18,13 @@ describe('PEXPIREAT', () => {
['PEXPIREAT', 'key', d.getTime().toString()]
);
});
it('with set option', () => {
assert.deepEqual(
transformArguments('key', 1, 'XX'),
['PEXPIREAT', 'key', '1', 'XX']
);
});
});
testUtils.testWithClient('client.pExpireAt', async client => {

11
packages/client/lib/commands/PEXPIREAT.ts
View File

@@ -5,13 +5,20 @@ export const FIRST_KEY_INDEX = 1;
export function transformArguments(
key: RedisCommandArgument,
millisecondsTimestamp: number | Date
millisecondsTimestamp: number | Date,
mode?: 'NX' | 'XX' | 'GT' | 'LT'
): RedisCommandArguments {
return [
const args = [
'PEXPIREAT',
key,
transformPXAT(millisecondsTimestamp)
];
if (mode) {
args.push(mode);
}
return args;
}
export { transformBooleanReply as transformReply } from './generic-transformers';

21
packages/client/lib/commands/PEXPIRETIME.spec.ts Normal file
View File

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

9
packages/client/lib/commands/PEXPIRETIME.ts Normal file
View File

@@ -0,0 +1,9 @@
import { RedisCommandArgument, RedisCommandArguments } from '.';
export const FIRST_KEY_INDEX = 1;
export function transformArguments(key: RedisCommandArgument): RedisCommandArguments {
return ['PEXPIRETIME', key];
}
export declare function transformReply(): number;

30
packages/client/lib/commands/SINTERCARD.spec.ts Normal file
View File

@@ -0,0 +1,30 @@
import { strict as assert } from 'assert';
import testUtils, { GLOBAL } from '../test-utils';
import { transformArguments } from './SINTERCARD';
describe('SINTERCARD', () => {
testUtils.isVersionGreaterThanHook([7, 0]);
describe('transformArguments', () => {
it('simple', () => {
assert.deepEqual(
transformArguments(['1', '2']),
['SINTERCARD', '2', '1', '2']
);
});
it('with limit', () => {
assert.deepEqual(
transformArguments(['1', '2'], 1),
['SINTERCARD', '2', '1', '2', 'LIMIT', '1']
);
});
});
testUtils.testWithClient('client.sInterCard', async client => {
assert.deepEqual(
await client.sInterCard('key'),
0
);
}, GLOBAL.SERVERS.OPEN);
});

21
packages/client/lib/commands/SINTERCARD.ts Normal file
View File

@@ -0,0 +1,21 @@
import { RedisCommandArgument, RedisCommandArguments } from '.';
import { pushVerdictArgument } from './generic-transformers';
export const FIRST_KEY_INDEX = 2;
export const IS_READ_ONLY = true;
export function transformArguments(
keys: Array<RedisCommandArgument> | RedisCommandArgument,
limit?: number
): RedisCommandArguments {
const args = pushVerdictArgument(['SINTERCARD'], keys);
if (limit) {
args.push('LIMIT', limit.toString());
}
return args;
}
export declare function transformReply(): number;

16
packages/client/lib/commands/SORT.spec.ts
View File

@@ -70,16 +70,7 @@ describe('SORT', () => {
);
});
it('with STORE', () => {
assert.deepEqual(
transformArguments('key', {
STORE: 'destination'
}),
['SORT', 'key', 'STORE', 'destination']
);
});
it('with BY, LIMIT, GET, DIRECTION, ALPHA, STORE', () => {
it('with BY, LIMIT, GET, DIRECTION, ALPHA', () => {
assert.deepEqual(
transformArguments('key', {
BY: 'pattern',
@@ -89,10 +80,9 @@ describe('SORT', () => {
},
GET: 'pattern',
DIRECTION: 'ASC',
ALPHA: true,
STORE: 'destination'
ALPHA: true
}),
['SORT', 'key', 'BY', 'pattern', 'LIMIT', '0', '1', 'GET', 'pattern', 'ASC', 'ALPHA', 'STORE', 'destination']
['SORT', 'key', 'BY', 'pattern', 'LIMIT', '0', '1', 'GET', 'pattern', 'ASC', 'ALPHA']
);
});
});

61
packages/client/lib/commands/SORT.ts
View File

@@ -1,56 +1,13 @@
import { RedisCommandArguments } from '.';
import { pushSortArguments, SortOptions } from './generic-transformers';
export const FIRST_KEY_INDEX = 1;
export const IS_READ_ONLY = true;
interface SortOptions {
BY?: string;
LIMIT?: {
offset: number;
count: number;
},
GET?: string | Array<string>;
DIRECTION?: 'ASC' | 'DESC';
ALPHA?: true;
STORE?: string;
export function transformArguments(
key: string,
options?: SortOptions
): RedisCommandArguments {
return pushSortArguments(['SORT', key], options);
}
export function transformArguments(key: string, options?: SortOptions): Array<string> {
const args = ['SORT', key];
if (options?.BY) {
args.push('BY', options.BY);
}
if (options?.LIMIT) {
args.push(
'LIMIT',
options.LIMIT.offset.toString(),
options.LIMIT.count.toString()
);
}
if (options?.GET) {
for (const pattern of (typeof options.GET === 'string' ? [options.GET] : options.GET)) {
args.push('GET', pattern);
}
}
if (options?.DIRECTION) {
args.push(options.DIRECTION);
}
if (options?.ALPHA) {
args.push('ALPHA');
}
if (options?.STORE) {
args.push('STORE', options.STORE);
}
return args;
}
// integer when using `STORE`
export function transformReply(reply: Array<string> | number): Array<string> | number {
return reply;
}
export declare function transformReply(): Array<string>;

98
packages/client/lib/commands/SORT_RO.spec.ts Normal file
View File

@@ -0,0 +1,98 @@
import { strict as assert } from 'assert';
import testUtils, { GLOBAL } from '../test-utils';
import { transformArguments } from './SORT_RO';
describe('SORT_RO', () => {
testUtils.isVersionGreaterThanHook([7, 0]);
describe('transformArguments', () => {
it('simple', () => {
assert.deepEqual(
transformArguments('key'),
['SORT_RO', 'key']
);
});
it('with BY', () => {
assert.deepEqual(
transformArguments('key', {
BY: 'pattern'
}),
['SORT_RO', 'key', 'BY', 'pattern']
);
});
it('with LIMIT', () => {
assert.deepEqual(
transformArguments('key', {
LIMIT: {
offset: 0,
count: 1
}
}),
['SORT_RO', 'key', 'LIMIT', '0', '1']
);
});
describe('with GET', () => {
it('string', () => {
assert.deepEqual(
transformArguments('key', {
GET: 'pattern'
}),
['SORT_RO', 'key', 'GET', 'pattern']
);
});
it('array', () => {
assert.deepEqual(
transformArguments('key', {
GET: ['1', '2']
}),
['SORT_RO', 'key', 'GET', '1', 'GET', '2']
);
});
});
it('with DIRECTION', () => {
assert.deepEqual(
transformArguments('key', {
DIRECTION: 'ASC'
}),
['SORT_RO', 'key', 'ASC']
);
});
it('with ALPHA', () => {
assert.deepEqual(
transformArguments('key', {
ALPHA: true
}),
['SORT_RO', 'key', 'ALPHA']
);
});
it('with BY, LIMIT, GET, DIRECTION, ALPHA', () => {
assert.deepEqual(
transformArguments('key', {
BY: 'pattern',
LIMIT: {
offset: 0,
count: 1
},
GET: 'pattern',
DIRECTION: 'ASC',
ALPHA: true,
}),
['SORT_RO', 'key', 'BY', 'pattern', 'LIMIT', '0', '1', 'GET', 'pattern', 'ASC', 'ALPHA']
);
});
});
testUtils.testWithClient('client.sortRo', async client => {
assert.deepEqual(
await client.sortRo('key'),
[]
);
}, GLOBAL.SERVERS.OPEN);
});

15
packages/client/lib/commands/SORT_RO.ts Normal file
View File

@@ -0,0 +1,15 @@
import { RedisCommandArguments } from '.';
import { pushSortArguments, SortOptions } from "./generic-transformers";
export const FIRST_KEY_INDEX = 1;
export const IS_READ_ONLY = true;
export function transformArguments(
key: string,
options?: SortOptions
): RedisCommandArguments {
return pushSortArguments(['SORT_RO', key], options);
}
export declare function transformReply(): Array<string>;

96
packages/client/lib/commands/SORT_STORE.spec.ts Normal file
View File

@@ -0,0 +1,96 @@
import { strict as assert } from 'assert';
import testUtils, { GLOBAL } from '../test-utils';
import { transformArguments } from './SORT_STORE';
describe('SORT STORE', () => {
describe('transformArguments', () => {
it('simple', () => {
assert.deepEqual(
transformArguments('source', 'destination'),
['SORT', 'source', 'STORE', 'destination']
);
});
it('with BY', () => {
assert.deepEqual(
transformArguments('source', 'destination', {
BY: 'pattern'
}),
['SORT', 'source', 'BY', 'pattern', 'STORE', 'destination']
);
});
it('with LIMIT', () => {
assert.deepEqual(
transformArguments('source', 'destination', {
LIMIT: {
offset: 0,
count: 1
}
}),
['SORT', 'source', 'LIMIT', '0', '1', 'STORE', 'destination']
);
});
describe('with GET', () => {
it('string', () => {
assert.deepEqual(
transformArguments('source', 'destination', {
GET: 'pattern'
}),
['SORT', 'source', 'GET', 'pattern', 'STORE', 'destination']
);
});
it('array', () => {
assert.deepEqual(
transformArguments('source', 'destination', {
GET: ['1', '2']
}),
['SORT', 'source', 'GET', '1', 'GET', '2', 'STORE', 'destination']
);
});
});
it('with DIRECTION', () => {
assert.deepEqual(
transformArguments('source', 'destination', {
DIRECTION: 'ASC'
}),
['SORT', 'source', 'ASC', 'STORE', 'destination']
);
});
it('with ALPHA', () => {
assert.deepEqual(
transformArguments('source', 'destination', {
ALPHA: true
}),
['SORT', 'source', 'ALPHA', 'STORE', 'destination']
);
});
it('with BY, LIMIT, GET, DIRECTION, ALPHA', () => {
assert.deepEqual(
transformArguments('source', 'destination', {
BY: 'pattern',
LIMIT: {
offset: 0,
count: 1
},
GET: 'pattern',
DIRECTION: 'ASC',
ALPHA: true
}),
['SORT', 'source', 'BY', 'pattern', 'LIMIT', '0', '1', 'GET', 'pattern', 'ASC', 'ALPHA', 'STORE', 'destination']
);
});
});
testUtils.testWithClient('client.sortStore', async client => {
assert.equal(
await client.sortStore('source', 'destination'),
0
);
}, GLOBAL.SERVERS.OPEN);
});

17
packages/client/lib/commands/SORT_STORE.ts Normal file
View File

@@ -0,0 +1,17 @@
import { RedisCommandArguments } from '.';
import { SortOptions } from './generic-transformers';
import { transformArguments as transformSortArguments } from './SORT';
export const FIRST_KEY_INDEX = 1;
export function transformArguments(
source: string,
destination: string,
options?: SortOptions
): RedisCommandArguments {
const args = transformSortArguments(source, options);
args.push('STORE', destination);
return args;
}
export declare function transformReply(): number;

30
packages/client/lib/commands/ZINTERCARD.spec.ts Normal file
View File

@@ -0,0 +1,30 @@
import { strict as assert } from 'assert';
import testUtils, { GLOBAL } from '../test-utils';
import { transformArguments } from './ZINTERCARD';
describe('ZINTERCARD', () => {
testUtils.isVersionGreaterThanHook([7, 0]);
describe('transformArguments', () => {
it('simple', () => {
assert.deepEqual(
transformArguments(['1', '2']),
['ZINTERCARD', '2', '1', '2']
);
});
it('with limit', () => {
assert.deepEqual(
transformArguments(['1', '2'], 1),
['ZINTERCARD', '2', '1', '2', 'LIMIT', '1']
);
});
});
testUtils.testWithClient('client.zInterCard', async client => {
assert.deepEqual(
await client.zInterCard('key'),
0
);
}, GLOBAL.SERVERS.OPEN);
});

21
packages/client/lib/commands/ZINTERCARD.ts Normal file
View File

@@ -0,0 +1,21 @@
import { RedisCommandArgument, RedisCommandArguments } from '.';
import { pushVerdictArgument } from './generic-transformers';
export const FIRST_KEY_INDEX = 2;
export const IS_READ_ONLY = true;
export function transformArguments(
keys: Array<RedisCommandArgument> | RedisCommandArgument,
limit?: number
): RedisCommandArguments {
const args = pushVerdictArgument(['ZINTERCARD'], keys);
if (limit) {
args.push('LIMIT', limit.toString());
}
return args;
}
export declare function transformReply(): number;

45
packages/client/lib/commands/generic-transformers.spec.ts
View File

@@ -19,11 +19,13 @@ import {
transformPXAT,
pushEvalArguments,
pushVerdictArguments,
pushVerdictNumberArguments,
pushVerdictArgument,
pushOptionalVerdictArgument,
transformCommandReply,
CommandFlags,
CommandCategories
CommandCategories,
pushSlotRangesArguments
} from './generic-transformers';
describe('Generic Transformers', () => {
@@ -578,6 +580,22 @@ describe('Generic Transformers', () => {
});
});
describe('pushVerdictNumberArguments', () => {
it('number', () => {
assert.deepEqual(
pushVerdictNumberArguments([], 0),
['0']
);
});
it('array', () => {
assert.deepEqual(
pushVerdictNumberArguments([], [0, 1]),
['0', '1']
);
});
});
describe('pushVerdictArgument', () => {
it('string', () => {
assert.deepEqual(
@@ -639,4 +657,29 @@ describe('Generic Transformers', () => {
}
);
});
describe('pushSlotRangesArguments', () => {
it('single range', () => {
assert.deepEqual(
pushSlotRangesArguments([], {
start: 0,
end: 1
}),
['0', '1']
);
});
it('multiple ranges', () => {
assert.deepEqual(
pushSlotRangesArguments([], [{
start: 0,
end: 1
}, {
start: 2,
end: 3
}]),
['0', '1', '2', '3']
);
});
});
});

89
packages/client/lib/commands/generic-transformers.ts
View File

@@ -322,6 +322,21 @@ export function pushVerdictArguments(args: RedisCommandArguments, value: RedisCo
return args;
}
export function pushVerdictNumberArguments(
args: RedisCommandArguments,
value: number | Array<number>
): RedisCommandArguments {
if (Array.isArray(value)) {
for (const item of value) {
args.push(item.toString());
}
} else {
args.push(value.toString());
}
return args;
}
export function pushVerdictArgument(
args: RedisCommandArguments,
value: RedisCommandArgument | Array<RedisCommandArgument>
@@ -422,3 +437,77 @@ export function transformCommandReply(
categories: new Set(categories)
};
}
export interface SortOptions {
BY?: string;
LIMIT?: {
offset: number;
count: number;
},
GET?: string | Array<string>;
DIRECTION?: 'ASC' | 'DESC';
ALPHA?: true;
}
export function pushSortArguments(
args: RedisCommandArguments,
options?: SortOptions
): RedisCommandArguments {
if (options?.BY) {
args.push('BY', options.BY);
}
if (options?.LIMIT) {
args.push(
'LIMIT',
options.LIMIT.offset.toString(),
options.LIMIT.count.toString()
);
}
if (options?.GET) {
for (const pattern of (typeof options.GET === 'string' ? [options.GET] : options.GET)) {
args.push('GET', pattern);
}
}
if (options?.DIRECTION) {
args.push(options.DIRECTION);
}
if (options?.ALPHA) {
args.push('ALPHA');
}
return args;
}
export interface SlotRange {
start: number;
end: number;
}
function pushSlotRangeArguments(
args: RedisCommandArguments,
range: SlotRange
): void {
args.push(
range.start.toString(),
range.end.toString()
);
}
export function pushSlotRangesArguments(
args: RedisCommandArguments,
ranges: SlotRange | Array<SlotRange>
): RedisCommandArguments {
if (Array.isArray(ranges)) {
for (const range of ranges) {
pushSlotRangeArguments(args, range);
}
} else {
pushSlotRangeArguments(args, ranges);
}
return args;
}

22
packages/client/package.json
View File

@@ -1,6 +1,6 @@
{
"name": "@node-redis/client",
"version": "1.0.4",
"version": "1.0.5",
"license": "MIT",
"main": "./dist/index.js",
"types": "./dist/index.d.ts",
@@ -22,20 +22,20 @@
"devDependencies": {
"@istanbuljs/nyc-config-typescript": "^1.0.2",
"@node-redis/test-utils": "*",
"@types/node": "^17.0.13",
"@types/node": "^17.0.23",
"@types/redis-parser": "^3.0.0",
"@types/sinon": "^10.0.9",
"@types/sinon": "^10.0.11",
"@types/yallist": "^4.0.1",
"@typescript-eslint/eslint-plugin": "^5.10.1",
"@typescript-eslint/parser": "^5.10.1",
"eslint": "^8.8.0",
"@typescript-eslint/eslint-plugin": "^5.16.0",
"@typescript-eslint/parser": "^5.16.0",
"eslint": "^8.12.0",
"nyc": "^15.1.0",
"release-it": "^14.12.4",
"sinon": "^13.0.0",
"release-it": "^14.13.1",
"sinon": "^13.0.1",
"source-map-support": "^0.5.21",
"ts-node": "^10.4.0",
"typedoc": "^0.22.11",
"typescript": "^4.5.5"
"ts-node": "^10.7.0",
"typedoc": "^0.22.13",
"typescript": "^4.6.3"
},
"engines": {
"node": ">=12"

10
packages/graph/package.json
View File

@@ -18,12 +18,12 @@
"devDependencies": {
"@istanbuljs/nyc-config-typescript": "^1.0.2",
"@node-redis/test-utils": "*",
"@types/node": "^17.0.13",
"@types/node": "^17.0.23",
"nyc": "^15.1.0",
"release-it": "^14.12.4",
"release-it": "^14.13.1",
"source-map-support": "^0.5.21",
"ts-node": "^10.4.0",
"typedoc": "^0.22.11",
"typescript": "^4.5.5"
"ts-node": "^10.7.0",
"typedoc": "^0.22.13",
"typescript": "^4.6.3"
}
}

10
packages/json/package.json
View File

@@ -18,12 +18,12 @@
"devDependencies": {
"@istanbuljs/nyc-config-typescript": "^1.0.2",
"@node-redis/test-utils": "*",
"@types/node": "^17.0.13",
"@types/node": "^17.0.23",
"nyc": "^15.1.0",
"release-it": "^14.12.4",
"release-it": "^14.13.1",
"source-map-support": "^0.5.21",
"ts-node": "^10.4.0",
"typedoc": "^0.22.11",
"typescript": "^4.5.5"
"ts-node": "^10.7.0",
"typedoc": "^0.22.13",
"typescript": "^4.6.3"
}
}

20
packages/search/lib/commands/AGGREGATE.spec.ts
View File

@@ -434,6 +434,26 @@ describe('AGGREGATE', () => {
);
});
});
it('with PARAMS', () => {
assert.deepEqual(
transformArguments('index', '*', {
PARAMS: {
param: 'value'
}
}),
['FT.AGGREGATE', 'index', '*', 'PARAMS', '2', 'param', 'value']
);
});
it('with DIALECT', () => {
assert.deepEqual(
transformArguments('index', '*', {
DIALECT: 1
}),
['FT.AGGREGATE', 'index', '*', 'DIALECT', '1']
);
});
});
testUtils.testWithClient('client.ft.aggregate', async client => {

20
packages/search/lib/commands/AGGREGATE.ts
View File

@@ -1,6 +1,6 @@
import { RedisCommandArgument, RedisCommandArguments } from '@node-redis/client/dist/lib/commands';
import { pushVerdictArgument, transformTuplesReply } from '@node-redis/client/dist/lib/commands/generic-transformers';
import { PropertyName, pushArgumentsWithLength, pushSortByArguments, SortByProperty } from '.';
import { Params, PropertyName, pushArgumentsWithLength, pushParamsArgs, pushSortByArguments, SortByProperty } from '.';
export enum AggregateSteps {
GROUPBY = 'GROUPBY',
@@ -122,6 +122,8 @@ export interface AggregateOptions {
VERBATIM?: true;
LOAD?: LoadField | Array<LoadField>;
STEPS?: Array<GroupByStep | SortStep | ApplyStep | LimitStep | FilterStep>;
PARAMS?: Params;
DIALECT?: number;
}
export function transformArguments(
@@ -129,17 +131,16 @@ export function transformArguments(
query: string,
options?: AggregateOptions
): RedisCommandArguments {
const args = ['FT.AGGREGATE', index, query];
pushAggregatehOptions(args, options);
return args;
return pushAggregatehOptions(
['FT.AGGREGATE', index, query],
options
);
}
export function pushAggregatehOptions(
args: RedisCommandArguments,
options?: AggregateOptions
): RedisCommandArguments {
if (options?.VERBATIM) {
args.push('VERBATIM');
}
@@ -202,6 +203,12 @@ export function pushAggregatehOptions(
}
}
pushParamsArgs(args, options?.PARAMS);
if (options?.DIALECT) {
args.push('DIALECT', options.DIALECT.toString());
}
return args;
}
@@ -257,7 +264,6 @@ function pushGroupByReducer(args: RedisCommandArguments, reducer: GroupByReducer
}
}
});
break;
}

48
packages/search/lib/commands/CREATE.spec.ts
View File

@@ -1,7 +1,7 @@
import { strict as assert } from 'assert';
import testUtils, { GLOBAL } from '../test-utils';
import { transformArguments } from './CREATE';
import { SchemaFieldTypes, SchemaTextFieldPhonetics, RedisSearchLanguages } from '.';
import { SchemaFieldTypes, SchemaTextFieldPhonetics, RedisSearchLanguages, VectorAlgorithms } from '.';
describe('CREATE', () => {
describe('transformArguments', () => {
@@ -126,6 +126,52 @@ describe('CREATE', () => {
});
});
describe('VECTOR', () => {
it('Flat algorithm', () => {
assert.deepEqual(
transformArguments('index', {
field: {
type: SchemaFieldTypes.VECTOR,
ALGORITHM: VectorAlgorithms.FLAT,
TYPE: 'FLOAT32',
DIM: 2,
DISTANCE_METRIC: 'L2',
INITIAL_CAP: 1000000,
BLOCK_SIZE: 1000
}
}),
[
'FT.CREATE', 'index', 'SCHEMA', 'field', 'VECTOR', 'FLAT', '10', 'TYPE',
'FLOAT32', 'DIM', '2', 'DISTANCE_METRIC', 'L2', 'INITIAL_CAP', '1000000',
'BLOCK_SIZE', '1000'
]
);
});
it('HNSW algorithm', () => {
assert.deepEqual(
transformArguments('index', {
field: {
type: SchemaFieldTypes.VECTOR,
ALGORITHM: VectorAlgorithms.HNSW,
TYPE: 'FLOAT32',
DIM: 2,
DISTANCE_METRIC: 'L2',
INITIAL_CAP: 1000000,
M: 40,
EF_CONSTRUCTION: 250,
EF_RUNTIME: 20
}
}),
[
'FT.CREATE', 'index', 'SCHEMA', 'field', 'VECTOR', 'HNSW', '14', 'TYPE',
'FLOAT32', 'DIM', '2', 'DISTANCE_METRIC', 'L2', 'INITIAL_CAP', '1000000',
'M', '40', 'EF_CONSTRUCTION', '250', 'EF_RUNTIME', '20'
]
);
});
});
describe('with generic options', () => {
it('with AS', () => {
assert.deepEqual(

Some files were not shown because too many files have changed in this diff Show More