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

buffers, buffers everywhere...

Browse Source
This commit is contained in:
leibale
2021-12-20 14:47:51 -05:00
parent 2733e225ae
commit a0de7967f9
237 changed files with 2322 additions and 1951 deletions
Download Patch File Download Diff File Expand all files Collapse all files

10
README.md
View File

@@ -75,6 +75,16 @@ await client.hGetAll('key'); // { field1: 'value1', field2: 'value2' }
await client.hVals('key'); // ['value1', 'value2'] await client.hVals('key'); // ['value1', 'value2']
``` ```
`Buffer`s are supported as well:
```typescript
await client.hSet('key', 'field', Buffer.from('value')); // 'OK'
await client.hGetAll(
commandOptions({ returnBuffers: true }),
'key'
); // { field: <Buffer 76 61 6c 75 65> }
```
### Unsupported Redis Commands ### Unsupported Redis Commands
If you want to run commands and/or use arguments that Node Redis doesn't know about (yet!) use `.sendCommand()`: If you want to run commands and/or use arguments that Node Redis doesn't know about (yet!) use `.sendCommand()`:

1847
package-lock.json generated
View File

File diff suppressed because it is too large Load Diff

12
package.json
View File

@@ -5,6 +5,9 @@
"license": "MIT", "license": "MIT",
"main": "./dist/index.js", "main": "./dist/index.js",
"types": "./dist/index.d.ts", "types": "./dist/index.d.ts",
"files": [
"dist/"
],
"workspaces": [ "workspaces": [
"./packages/*" "./packages/*"
], ],
@@ -29,8 +32,7 @@
"@tsconfig/node12": "^1.0.9", "@tsconfig/node12": "^1.0.9",
"gh-pages": "^3.2.3", "gh-pages": "^3.2.3",
"release-it": "^14.11.8", "release-it": "^14.11.8",
"typedoc": "^0.22.10", "typescript": "^4.5.4"
"typescript": "^4.5.3"
}, },
"repository": { "repository": {
"type": "git", "type": "git",
@@ -40,10 +42,8 @@
"url": "https://github.com/redis/node-redis/issues" "url": "https://github.com/redis/node-redis/issues"
}, },
"homepage": "https://github.com/redis/node-redis", "homepage": "https://github.com/redis/node-redis",
"files": [
"dist/"
],
"engines": { "engines": {
"npm": ">=7" "npm": ">=7",
"typescript": ">=4"
} }
} }

25
packages/client/lib/client/commands-queue.ts
View File

@@ -11,6 +11,7 @@ export interface QueueCommandOptions {
asap?: boolean; asap?: boolean;
chainId?: symbol; chainId?: symbol;
signal?: AbortSignal; signal?: AbortSignal;
returnBuffers?: boolean;
ignorePubSubMode?: boolean; ignorePubSubMode?: boolean;
} }
@@ -27,7 +28,7 @@ interface CommandWaitingForReply {
resolve(reply?: unknown): void; resolve(reply?: unknown): void;
reject(err: Error): void; reject(err: Error): void;
channelsCounter?: number; channelsCounter?: number;
bufferMode?: boolean; returnBuffers?: boolean;
} }
export enum PubSubSubscribeCommands { export enum PubSubSubscribeCommands {
@@ -41,8 +42,8 @@ export enum PubSubUnsubscribeCommands {
} }
export type PubSubListener< export type PubSubListener<
BUFFER_MODE extends boolean = false, RETURN_BUFFERS extends boolean = false,
T = BUFFER_MODE extends true ? Buffer : string T = RETURN_BUFFERS extends true ? Buffer : string
> = (message: T, channel: T) => unknown; > = (message: T, channel: T) => unknown;
interface PubSubListeners { interface PubSubListeners {
@@ -142,7 +143,7 @@ export default class RedisCommandsQueue {
this.#maxLength = maxLength; this.#maxLength = maxLength;
} }
addCommand<T = RedisCommandRawReply>(args: RedisCommandArguments, options?: QueueCommandOptions, bufferMode?: boolean): Promise<T> { addCommand<T = RedisCommandRawReply>(args: RedisCommandArguments, options?: QueueCommandOptions): Promise<T> {
if (this.#pubSubState && !options?.ignorePubSubMode) { if (this.#pubSubState && !options?.ignorePubSubMode) {
return Promise.reject(new Error('Cannot send commands in PubSub mode')); return Promise.reject(new Error('Cannot send commands in PubSub mode'));
} else if (this.#maxLength && this.#waitingToBeSent.length + this.#waitingForReply.length >= this.#maxLength) { } else if (this.#maxLength && this.#waitingToBeSent.length + this.#waitingForReply.length >= this.#maxLength) {
@@ -154,7 +155,7 @@ export default class RedisCommandsQueue {
const node = new LinkedList.Node<CommandWaitingToBeSent>({ const node = new LinkedList.Node<CommandWaitingToBeSent>({
args, args,
chainId: options?.chainId, chainId: options?.chainId,
bufferMode, returnBuffers: options?.returnBuffers,
resolve, resolve,
reject reject
}); });
@@ -197,7 +198,7 @@ export default class RedisCommandsQueue {
command: PubSubSubscribeCommands, command: PubSubSubscribeCommands,
channels: RedisCommandArgument | Array<RedisCommandArgument>, channels: RedisCommandArgument | Array<RedisCommandArgument>,
listener: PubSubListener<T>, listener: PubSubListener<T>,
bufferMode?: T returnBuffers?: T
): Promise<void> { ): Promise<void> {
const pubSubState = this.#initiatePubSubState(), const pubSubState = this.#initiatePubSubState(),
channelsToSubscribe: Array<RedisCommandArgument> = [], channelsToSubscribe: Array<RedisCommandArgument> = [],
@@ -215,7 +216,7 @@ export default class RedisCommandsQueue {
} }
// https://github.com/microsoft/TypeScript/issues/23132 // https://github.com/microsoft/TypeScript/issues/23132
(bufferMode ? listeners.buffers : listeners.strings).add(listener as any); (returnBuffers ? listeners.buffers : listeners.strings).add(listener as any);
} }
if (!channelsToSubscribe.length) { if (!channelsToSubscribe.length) {
@@ -228,7 +229,7 @@ export default class RedisCommandsQueue {
command: PubSubUnsubscribeCommands, command: PubSubUnsubscribeCommands,
channels?: string | Array<string>, channels?: string | Array<string>,
listener?: PubSubListener<T>, listener?: PubSubListener<T>,
bufferMode?: T returnBuffers?: T
): Promise<void> { ): Promise<void> {
if (!this.#pubSubState) { if (!this.#pubSubState) {
return Promise.resolve(); return Promise.resolve();
@@ -252,7 +253,7 @@ export default class RedisCommandsQueue {
let shouldUnsubscribe; let shouldUnsubscribe;
if (listener) { if (listener) {
// https://github.com/microsoft/TypeScript/issues/23132 // https://github.com/microsoft/TypeScript/issues/23132
(bufferMode ? sets.buffers : sets.strings).delete(listener as any); (returnBuffers ? sets.buffers : sets.strings).delete(listener as any);
shouldUnsubscribe = !sets.buffers.size && !sets.strings.size; shouldUnsubscribe = !sets.buffers.size && !sets.strings.size;
} else { } else {
shouldUnsubscribe = true; shouldUnsubscribe = true;
@@ -289,7 +290,7 @@ export default class RedisCommandsQueue {
this.#waitingToBeSent.push({ this.#waitingToBeSent.push({
args: commandArgs, args: commandArgs,
channelsCounter, channelsCounter,
bufferMode: true, returnBuffers: true,
resolve: () => { resolve: () => {
pubSubState[inProgressKey] -= channelsCounter; pubSubState[inProgressKey] -= channelsCounter;
if (isSubscribe) { if (isSubscribe) {
@@ -350,7 +351,7 @@ export default class RedisCommandsQueue {
resolve: toSend.resolve, resolve: toSend.resolve,
reject: toSend.reject, reject: toSend.reject,
channelsCounter: toSend.channelsCounter, channelsCounter: toSend.channelsCounter,
bufferMode: toSend.bufferMode returnBuffers: toSend.returnBuffers
}); });
} }
this.#chainInExecution = toSend?.chainId; this.#chainInExecution = toSend?.chainId;
@@ -359,7 +360,7 @@ export default class RedisCommandsQueue {
parseResponse(data: Buffer): void { parseResponse(data: Buffer): void {
this.#parser.setReturnBuffers( this.#parser.setReturnBuffers(
!!this.#waitingForReply.head?.value.bufferMode || !!this.#waitingForReply.head?.value.returnBuffers ||
!!this.#pubSubState?.subscribed !!this.#pubSubState?.subscribed
); );
this.#parser.execute(data); this.#parser.execute(data);

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

@@ -319,9 +319,11 @@ describe('Client', () => {
assert.equal(await client.sendCommand(['PING']), 'PONG'); assert.equal(await client.sendCommand(['PING']), 'PONG');
}, GLOBAL.SERVERS.OPEN); }, GLOBAL.SERVERS.OPEN);
testUtils.testWithClient('bufferMode', async client => { testUtils.testWithClient('returnBuffers', async client => {
assert.deepEqual( assert.deepEqual(
await client.sendCommand(['PING'], undefined, true), await client.sendCommand(['PING'], RedisClient.commandOptions({
returnBuffers: true
}),),
Buffer.from('PONG') Buffer.from('PONG')
); );
}, GLOBAL.SERVERS.OPEN); }, GLOBAL.SERVERS.OPEN);
@@ -435,10 +437,10 @@ describe('Client', () => {
}); });
testUtils.testWithClient('modules', async client => { testUtils.testWithClient('modules', async client => {
assert.equal( // assert.equal(
await client.module.echo('message'), // await client.module.echo('message'),
'message' // 'message'
); // );
}, { }, {
...GLOBAL.SERVERS.OPEN, ...GLOBAL.SERVERS.OPEN,
clientOptions: { clientOptions: {
@@ -551,7 +553,7 @@ describe('Client', () => {
await client.zAdd('key', members); await client.zAdd('key', members);
const map = new Map(); const map = new Map<string, number>();
for await (const member of client.zScanIterator('key')) { for await (const member of client.zScanIterator('key')) {
map.set(member.value, member.score); map.set(member.value, member.score);
} }

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

@@ -1,5 +1,5 @@
import COMMANDS from './commands'; import COMMANDS from './commands';
import { RedisCommand, RedisCommandArguments, RedisCommandRawReply, RedisCommandReply, RedisModules, RedisPlugins, RedisScript, RedisScripts } from '../commands'; import { RedisCommand, RedisCommandArgument, RedisCommandArguments, RedisCommandRawReply, RedisCommandReply, RedisModules, RedisPlugins, RedisScript, RedisScripts } from '../commands';
import RedisSocket, { RedisSocketOptions, RedisTlsSocketOptions } from './socket'; import RedisSocket, { RedisSocketOptions, RedisTlsSocketOptions } from './socket';
import RedisCommandsQueue, { PubSubListener, PubSubSubscribeCommands, PubSubUnsubscribeCommands, QueueCommandOptions } from './commands-queue'; import RedisCommandsQueue, { PubSubListener, PubSubSubscribeCommands, PubSubUnsubscribeCommands, QueueCommandOptions } from './commands-queue';
import RedisClientMultiCommand, { RedisClientMultiCommandType } from './multi-command'; import RedisClientMultiCommand, { RedisClientMultiCommandType } from './multi-command';
@@ -28,8 +28,30 @@ export interface RedisClientOptions<M extends RedisModules, S extends RedisScrip
isolationPoolOptions?: PoolOptions; isolationPoolOptions?: PoolOptions;
} }
export type RedisClientCommandSignature<C extends RedisCommand> = type ConvertArgumentType<Type, ToType> =
(...args: Parameters<C['transformArguments']> | [options: CommandOptions<ClientCommandOptions>, ...rest: Parameters<C['transformArguments']>]) => Promise<RedisCommandReply<C>>; Type extends RedisCommandArgument ? (
Type extends (string & ToType) ? Type : ToType
) : (
Type extends Set<infer Member> ? Set<ConvertArgumentType<Member, ToType>> : (
Type extends Map<infer Key, infer Value> ? Map<Key, ConvertArgumentType<Value, ToType>> : (
Type extends Record<keyof any, any> ? {
[Property in keyof Type]: ConvertArgumentType<Type[Property], ToType>
} : Type
)
)
);
export type RedisClientCommandSignature<
Command extends RedisCommand,
Params extends Array<unknown> = Parameters<Command['transformArguments']>
> = <Options extends CommandOptions<ClientCommandOptions>>(
...args: Params | [options: Options, ...rest: Params]
) => Promise<
ConvertArgumentType<
RedisCommandReply<Command>,
Options['returnBuffers'] extends true ? Buffer : string
>
>;
type WithCommands = { type WithCommands = {
[P in keyof typeof COMMANDS]: RedisClientCommandSignature<(typeof COMMANDS)[P]>; [P in keyof typeof COMMANDS]: RedisClientCommandSignature<(typeof COMMANDS)[P]>;
@@ -59,7 +81,7 @@ type ClientLegacyCallback = (err: Error | null, reply?: RedisCommandRawReply) =>
export type ClientLegacyCommandArguments = LegacyCommandArguments | [...LegacyCommandArguments, ClientLegacyCallback]; export type ClientLegacyCommandArguments = LegacyCommandArguments | [...LegacyCommandArguments, ClientLegacyCallback];
export default class RedisClient<M extends RedisModules, S extends RedisScripts> extends EventEmitter { export default class RedisClient<M extends RedisModules, S extends RedisScripts> extends EventEmitter {
static commandOptions(options: ClientCommandOptions): CommandOptions<ClientCommandOptions> { static commandOptions<T extends ClientCommandOptions>(options: T): CommandOptions<T> {
return commandOptions(options); return commandOptions(options);
} }
@@ -325,17 +347,17 @@ export default class RedisClient<M extends RedisModules, S extends RedisScripts>
return transformCommandReply( return transformCommandReply(
command, command,
await this.#sendCommand(redisArgs, options, command.BUFFER_MODE), await this.#sendCommand(redisArgs, options),
redisArgs.preserve redisArgs.preserve
); );
} }
sendCommand<T = RedisCommandRawReply>(args: RedisCommandArguments, options?: ClientCommandOptions, bufferMode?: boolean): Promise<T> { sendCommand<T = RedisCommandRawReply>(args: RedisCommandArguments, options?: ClientCommandOptions): Promise<T> {
return this.#sendCommand(args, options, bufferMode); return this.#sendCommand(args, options);
} }
// using `#sendCommand` cause `sendCommand` is overwritten in legacy mode // using `#sendCommand` cause `sendCommand` is overwritten in legacy mode
#sendCommand<T = RedisCommandRawReply>(args: RedisCommandArguments, options?: ClientCommandOptions, bufferMode?: boolean): Promise<T> { #sendCommand<T = RedisCommandRawReply>(args: RedisCommandArguments, options?: ClientCommandOptions): Promise<T> {
if (!this.#socket.isOpen) { if (!this.#socket.isOpen) {
return Promise.reject(new ClientClosedError()); return Promise.reject(new ClientClosedError());
} }
@@ -349,7 +371,7 @@ export default class RedisClient<M extends RedisModules, S extends RedisScripts>
); );
} }
const promise = this.#queue.addCommand<T>(args, options, bufferMode); const promise = this.#queue.addCommand<T>(args, options);
this.#tick(); this.#tick();
return promise; return promise;
} }
@@ -359,19 +381,19 @@ export default class RedisClient<M extends RedisModules, S extends RedisScripts>
return transformCommandReply( return transformCommandReply(
script, script,
await this.executeScript(script, redisArgs, options, script.BUFFER_MODE), await this.executeScript(script, redisArgs, options),
redisArgs.preserve redisArgs.preserve
); );
} }
async executeScript(script: RedisScript, args: RedisCommandArguments, options?: ClientCommandOptions, bufferMode?: boolean): Promise<RedisCommandReply<typeof script>> { async executeScript(script: RedisScript, args: RedisCommandArguments, options?: ClientCommandOptions): Promise<RedisCommandReply<typeof script>> {
try { try {
return await this.#sendCommand([ return await this.#sendCommand([
'EVALSHA', 'EVALSHA',
script.SHA1, script.SHA1,
script.NUMBER_OF_KEYS.toString(), script.NUMBER_OF_KEYS.toString(),
...args ...args
], options, bufferMode); ], options);
} catch (err: any) { } catch (err: any) {
if (!err?.message?.startsWith?.('NOSCRIPT')) { if (!err?.message?.startsWith?.('NOSCRIPT')) {
throw err; throw err;
@@ -382,7 +404,7 @@ export default class RedisClient<M extends RedisModules, S extends RedisScripts>
script.SCRIPT, script.SCRIPT,
script.NUMBER_OF_KEYS.toString(), script.NUMBER_OF_KEYS.toString(),
...args ...args
], options, bufferMode); ], options);
} }
} }
@@ -553,7 +575,7 @@ export default class RedisClient<M extends RedisModules, S extends RedisScripts>
} while (cursor !== 0); } while (cursor !== 0);
} }
async* hScanIterator(key: string, options?: ScanOptions): AsyncIterable<HScanTuple> { async* hScanIterator(key: string, options?: ScanOptions): AsyncIterable<ConvertArgumentType<HScanTuple, string>> {
let cursor = 0; let cursor = 0;
do { do {
const reply = await (this as any).hScan(key, cursor, options); const reply = await (this as any).hScan(key, cursor, options);
@@ -575,7 +597,7 @@ export default class RedisClient<M extends RedisModules, S extends RedisScripts>
} while (cursor !== 0); } while (cursor !== 0);
} }
async* zScanIterator(key: string, options?: ScanOptions): AsyncIterable<ZMember<string>> { async* zScanIterator(key: string, options?: ScanOptions): AsyncIterable<ConvertArgumentType<ZMember, string>> {
let cursor = 0; let cursor = 0;
do { do {
const reply = await (this as any).zScan(key, cursor, options); const reply = await (this as any).zScan(key, cursor, options);

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

@@ -4,13 +4,9 @@ import * as BITCOUNT from '../commands/BITCOUNT';
import * as BITFIELD from '../commands/BITFIELD'; import * as BITFIELD from '../commands/BITFIELD';
import * as BITOP from '../commands/BITOP'; import * as BITOP from '../commands/BITOP';
import * as BITPOS from '../commands/BITPOS'; import * as BITPOS from '../commands/BITPOS';
import * as BLMOVE_BUFFER from '../commands/BLMOVE_BUFFER';
import * as BLMOVE from '../commands/BLMOVE'; import * as BLMOVE from '../commands/BLMOVE';
import * as BLPOP_BUFFER from '../commands/BLPOP_BUFFER';
import * as BLPOP from '../commands/BLPOP'; import * as BLPOP from '../commands/BLPOP';
import * as BRPOP_BUFFER from '../commands/BRPOP_BUFFER';
import * as BRPOP from '../commands/BRPOP'; import * as BRPOP from '../commands/BRPOP';
import * as BRPOPLPUSH_BUFFER from '../commands/BRPOPLPUSH_BUFFER';
import * as BRPOPLPUSH from '../commands/BRPOPLPUSH'; import * as BRPOPLPUSH from '../commands/BRPOPLPUSH';
import * as BZPOPMAX from '../commands/BZPOPMAX'; import * as BZPOPMAX from '../commands/BZPOPMAX';
import * as BZPOPMIN from '../commands/BZPOPMIN'; import * as BZPOPMIN from '../commands/BZPOPMIN';
@@ -31,7 +27,6 @@ import * as GEOPOS from '../commands/GEOPOS';
import * as GEOSEARCH_WITH from '../commands/GEOSEARCH_WITH'; import * as GEOSEARCH_WITH from '../commands/GEOSEARCH_WITH';
import * as GEOSEARCH from '../commands/GEOSEARCH'; import * as GEOSEARCH from '../commands/GEOSEARCH';
import * as GEOSEARCHSTORE from '../commands/GEOSEARCHSTORE'; import * as GEOSEARCHSTORE from '../commands/GEOSEARCHSTORE';
import * as GET_BUFFER from '../commands/GET_BUFFER';
import * as GET from '../commands/GET'; import * as GET from '../commands/GET';
import * as GETBIT from '../commands/GETBIT'; import * as GETBIT from '../commands/GETBIT';
import * as GETDEL from '../commands/GETDEL'; import * as GETDEL from '../commands/GETDEL';
@@ -40,16 +35,13 @@ import * as GETRANGE from '../commands/GETRANGE';
import * as GETSET from '../commands/GETSET'; import * as GETSET from '../commands/GETSET';
import * as HDEL from '../commands/HDEL'; import * as HDEL from '../commands/HDEL';
import * as HEXISTS from '../commands/HEXISTS'; import * as HEXISTS from '../commands/HEXISTS';
import * as HGET_BUFFER from '../commands/HGET_BUFFER';
import * as HGET from '../commands/HGET'; import * as HGET from '../commands/HGET';
import * as HGETALL_BUFFER from '../commands/HGETALL_BUFFER';
import * as HGETALL from '../commands/HGETALL'; import * as HGETALL from '../commands/HGETALL';
import * as HINCRBY from '../commands/HINCRBY'; import * as HINCRBY from '../commands/HINCRBY';
import * as HINCRBYFLOAT from '../commands/HINCRBYFLOAT'; import * as HINCRBYFLOAT from '../commands/HINCRBYFLOAT';
import * as HKEYS from '../commands/HKEYS'; import * as HKEYS from '../commands/HKEYS';
import * as HLEN from '../commands/HLEN'; import * as HLEN from '../commands/HLEN';
import * as HMGET from '../commands/HMGET'; import * as HMGET from '../commands/HMGET';
import * as HRANDFIELD_COUNT_WITHVALUES_BUFFER from '../commands/HRANDFIELD_COUNT_WITHVALUES_BUFFER';
import * as HRANDFIELD_COUNT_WITHVALUES from '../commands/HRANDFIELD_COUNT_WITHVALUES'; import * as HRANDFIELD_COUNT_WITHVALUES from '../commands/HRANDFIELD_COUNT_WITHVALUES';
import * as HRANDFIELD_COUNT from '../commands/HRANDFIELD_COUNT'; import * as HRANDFIELD_COUNT from '../commands/HRANDFIELD_COUNT';
import * as HRANDFIELD from '../commands/HRANDFIELD'; import * as HRANDFIELD from '../commands/HRANDFIELD';
@@ -126,12 +118,8 @@ import * as UNLINK from '../commands/UNLINK';
import * as WATCH from '../commands/WATCH'; import * as WATCH from '../commands/WATCH';
import * as XACK from '../commands/XACK'; import * as XACK from '../commands/XACK';
import * as XADD from '../commands/XADD'; import * as XADD from '../commands/XADD';
import * as XAUTOCLAIM_JUSTID_BUFFER from '../commands/XAUTOCLAIM_JUSTID_BUFFER';
import * as XAUTOCLAIM_BUFFER from '../commands/XAUTOCLAIM_BUFFER';
import * as XAUTOCLAIM_JUSTID from '../commands/XAUTOCLAIM_JUSTID'; import * as XAUTOCLAIM_JUSTID from '../commands/XAUTOCLAIM_JUSTID';
import * as XAUTOCLAIM from '../commands/XAUTOCLAIM'; import * as XAUTOCLAIM from '../commands/XAUTOCLAIM';
import * as XCLAIM_JUSTID_BUFFER from '../commands/XCLAIM_JUSTID_BUFFER';
import * as XCLAIM_BUFFER from '../commands/XCLAIM_BUFFER';
import * as XCLAIM_JUSTID from '../commands/XCLAIM_JUSTID'; import * as XCLAIM_JUSTID from '../commands/XCLAIM_JUSTID';
import * as XCLAIM from '../commands/XCLAIM'; import * as XCLAIM from '../commands/XCLAIM';
import * as XDEL from '../commands/XDEL'; import * as XDEL from '../commands/XDEL';
@@ -146,13 +134,9 @@ import * as XINFO_STREAM from '../commands/XINFO_STREAM';
import * as XLEN from '../commands/XLEN'; import * as XLEN from '../commands/XLEN';
import * as XPENDING_RANGE from '../commands/XPENDING_RANGE'; import * as XPENDING_RANGE from '../commands/XPENDING_RANGE';
import * as XPENDING from '../commands/XPENDING'; import * as XPENDING from '../commands/XPENDING';
import * as XRANGE_BUFFER from '../commands/XRANGE_BUFFER';
import * as XRANGE from '../commands/XRANGE'; import * as XRANGE from '../commands/XRANGE';
import * as XREAD_BUFFER from '../commands/XREAD_BUFFER';
import * as XREAD from '../commands/XREAD'; import * as XREAD from '../commands/XREAD';
import * as XREADGROUP_BUFFER from '../commands/XREADGROUP_BUFFER';
import * as XREADGROUP from '../commands/XREADGROUP'; import * as XREADGROUP from '../commands/XREADGROUP';
import * as XREVRANGE_BUFFER from '../commands/XREVRANGE_BUFFER';
import * as XREVRANGE from '../commands/XREVRANGE'; import * as XREVRANGE from '../commands/XREVRANGE';
import * as XTRIM from '../commands/XTRIM'; import * as XTRIM from '../commands/XTRIM';
import * as ZADD from '../commands/ZADD'; import * as ZADD from '../commands/ZADD';
@@ -203,20 +187,12 @@ export default {
bitOp: BITOP, bitOp: BITOP,
BITPOS, BITPOS,
bitPos: BITPOS, bitPos: BITPOS,
BLMOVE_BUFFER,
blMoveBuffer: BLMOVE_BUFFER,
BLMOVE, BLMOVE,
blMove: BLMOVE, blMove: BLMOVE,
BLPOP_BUFFER,
blPopBuffer: BLPOP_BUFFER,
BLPOP, BLPOP,
blPop: BLPOP, blPop: BLPOP,
BRPOP_BUFFER,
brPopBuffer: BRPOP_BUFFER,
BRPOP, BRPOP,
brPop: BRPOP, brPop: BRPOP,
BRPOPLPUSH_BUFFER,
brPopLPushBuffer: BRPOPLPUSH_BUFFER,
BRPOPLPUSH, BRPOPLPUSH,
brPopLPush: BRPOPLPUSH, brPopLPush: BRPOPLPUSH,
BZPOPMAX, BZPOPMAX,
@@ -257,8 +233,6 @@ export default {
geoSearch: GEOSEARCH, geoSearch: GEOSEARCH,
GEOSEARCHSTORE, GEOSEARCHSTORE,
geoSearchStore: GEOSEARCHSTORE, geoSearchStore: GEOSEARCHSTORE,
GET_BUFFER,
getBuffer: GET_BUFFER,
GET, GET,
get: GET, get: GET,
GETBIT, GETBIT,
@@ -275,12 +249,8 @@ export default {
hDel: HDEL, hDel: HDEL,
HEXISTS, HEXISTS,
hExists: HEXISTS, hExists: HEXISTS,
HGET_BUFFER,
hGetBuffer: HGET_BUFFER,
HGET, HGET,
hGet: HGET, hGet: HGET,
HGETALL_BUFFER,
hGetAllBuffer: HGETALL_BUFFER,
HGETALL, HGETALL,
hGetAll: HGETALL, hGetAll: HGETALL,
HINCRBY, HINCRBY,
@@ -293,8 +263,6 @@ export default {
hLen: HLEN, hLen: HLEN,
HMGET, HMGET,
hmGet: HMGET, hmGet: HMGET,
HRANDFIELD_COUNT_WITHVALUES_BUFFER,
hRandFieldCountWithValuesBuffer: HRANDFIELD_COUNT_WITHVALUES_BUFFER,
HRANDFIELD_COUNT_WITHVALUES, HRANDFIELD_COUNT_WITHVALUES,
hRandFieldCountWithValues: HRANDFIELD_COUNT_WITHVALUES, hRandFieldCountWithValues: HRANDFIELD_COUNT_WITHVALUES,
HRANDFIELD_COUNT, HRANDFIELD_COUNT,
@@ -447,20 +415,12 @@ export default {
xAck: XACK, xAck: XACK,
XADD, XADD,
xAdd: XADD, xAdd: XADD,
XAUTOCLAIM_JUSTID_BUFFER,
xAutoClaimJustIdBuffer: XAUTOCLAIM_JUSTID_BUFFER,
XAUTOCLAIM_BUFFER,
xAutoClaimBuffer: XAUTOCLAIM_BUFFER,
XAUTOCLAIM_JUSTID, XAUTOCLAIM_JUSTID,
xAutoClaimJustId: XAUTOCLAIM_JUSTID, xAutoClaimJustId: XAUTOCLAIM_JUSTID,
XAUTOCLAIM, XAUTOCLAIM,
xAutoClaim: XAUTOCLAIM, xAutoClaim: XAUTOCLAIM,
XCLAIM, XCLAIM,
xClaim: XCLAIM, xClaim: XCLAIM,
XCLAIM_JUSTID_BUFFER,
xClaimJustIdBuffer: XCLAIM_JUSTID_BUFFER,
XCLAIM_BUFFER,
xClaimBuffer: XCLAIM_BUFFER,
XCLAIM_JUSTID, XCLAIM_JUSTID,
xClaimJustId: XCLAIM_JUSTID, xClaimJustId: XCLAIM_JUSTID,
XDEL, XDEL,
@@ -487,20 +447,12 @@ export default {
xPendingRange: XPENDING_RANGE, xPendingRange: XPENDING_RANGE,
XPENDING, XPENDING,
xPending: XPENDING, xPending: XPENDING,
XRANGE_BUFFER,
xRangeBuffer: XRANGE_BUFFER,
XRANGE, XRANGE,
xRange: XRANGE, xRange: XRANGE,
XREAD_BUFFER,
xReadBuffer: XREAD_BUFFER,
XREAD, XREAD,
xRead: XREAD, xRead: XREAD,
XREADGROUP_BUFFER,
xReadGroupBuffer: XREADGROUP_BUFFER,
XREADGROUP, XREADGROUP,
xReadGroup: XREADGROUP, xReadGroup: XREADGROUP,
XREVRANGE_BUFFER,
xRevRangeBuffer: XREVRANGE_BUFFER,
XREVRANGE, XREVRANGE,
xRevRange: XREVRANGE, xRevRange: XREVRANGE,
XTRIM, XTRIM,

14
packages/client/lib/cluster/index.ts
View File

@@ -76,8 +76,7 @@ export default class RedisCluster<M extends RedisModules = Record<string, never>
RedisCluster.extractFirstKey(command, args, redisArgs), RedisCluster.extractFirstKey(command, args, redisArgs),
command.IS_READ_ONLY, command.IS_READ_ONLY,
redisArgs, redisArgs,
options, options
command.BUFFER_MODE
), ),
redisArgs.preserve redisArgs.preserve
); );
@@ -88,19 +87,18 @@ export default class RedisCluster<M extends RedisModules = Record<string, never>
isReadonly: boolean | undefined, isReadonly: boolean | undefined,
args: RedisCommandArguments, args: RedisCommandArguments,
options?: ClientCommandOptions, options?: ClientCommandOptions,
bufferMode?: boolean,
redirections = 0 redirections = 0
): Promise<RedisCommandReply<C>> { ): Promise<RedisCommandReply<C>> {
const client = this.#slots.getClient(firstKey, isReadonly); const client = this.#slots.getClient(firstKey, isReadonly);
try { try {
return await client.sendCommand(args, options, bufferMode); return await client.sendCommand(args, options);
} catch (err: any) { } catch (err: any) {
const shouldRetry = await this.#handleCommandError(err, client, redirections); const shouldRetry = await this.#handleCommandError(err, client, redirections);
if (shouldRetry === true) { if (shouldRetry === true) {
return this.sendCommand(firstKey, isReadonly, args, options, bufferMode, redirections + 1); return this.sendCommand(firstKey, isReadonly, args, options, redirections + 1);
} else if (shouldRetry) { } else if (shouldRetry) {
return shouldRetry.sendCommand(args, options, bufferMode); return shouldRetry.sendCommand(args, options);
} }
throw err; throw err;
@@ -135,13 +133,13 @@ export default class RedisCluster<M extends RedisModules = Record<string, never>
); );
try { try {
return await client.executeScript(script, redisArgs, options, script.BUFFER_MODE); return await client.executeScript(script, redisArgs, options);
} catch (err: any) { } catch (err: any) {
const shouldRetry = await this.#handleCommandError(err, client, redirections); const shouldRetry = await this.#handleCommandError(err, client, redirections);
if (shouldRetry === true) { if (shouldRetry === true) {
return this.executeScript(script, originalArgs, redisArgs, options, redirections + 1); return this.executeScript(script, originalArgs, redisArgs, options, redirections + 1);
} else if (shouldRetry) { } else if (shouldRetry) {
return shouldRetry.executeScript(script, redisArgs, options, script.BUFFER_MODE); return shouldRetry.executeScript(script, redisArgs, options);
} }
throw err; throw err;

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

@@ -1,5 +1,7 @@
export function transformArguments(categoryName?: string): Array<string> { import { RedisCommandArgument, RedisCommandArguments } from '.';
const args = ['ACL', 'CAT'];
export function transformArguments(categoryName?: RedisCommandArgument): RedisCommandArguments {
const args: RedisCommandArguments = ['ACL', 'CAT'];
if (categoryName) { if (categoryName) {
args.push(categoryName); args.push(categoryName);
@@ -8,4 +10,4 @@ export function transformArguments(categoryName?: string): Array<string> {
return args; return args;
} }
export declare function transformReply(): Array<string>; export declare function transformReply(): Array<RedisCommandArgument>;

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

@@ -1,8 +1,10 @@
import { RedisCommandArguments } from '.'; import { RedisCommandArgument, RedisCommandArguments } from '.';
import { pushVerdictArguments } from './generic-transformers'; import { pushVerdictArguments } from './generic-transformers';
export function transformArguments(username: string | Array<string>): RedisCommandArguments { export function transformArguments(
username: RedisCommandArgument | Array<RedisCommandArgument>
): RedisCommandArguments {
return pushVerdictArguments(['ACL', 'DELUSER'], username); return pushVerdictArguments(['ACL', 'DELUSER'], username);
} }
export declare const transformReply: (reply: number) => number; export declare function transformReply(): number;

6
packages/client/lib/commands/ACL_GENPASS.ts
View File

@@ -1,4 +1,6 @@
export function transformArguments(bits?: number): Array<string> { import { RedisCommandArgument, RedisCommandArguments } from '.';
export function transformArguments(bits?: number): RedisCommandArguments {
const args = ['ACL', 'GENPASS']; const args = ['ACL', 'GENPASS'];
if (bits) { if (bits) {
@@ -8,4 +10,4 @@ export function transformArguments(bits?: number): Array<string> {
return args; return args;
} }
export declare function transformReply(): string; export declare function transformReply(): RedisCommandArgument;

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

@@ -1,26 +1,28 @@
export function transformArguments(username: string): Array<string> { import { RedisCommandArgument, RedisCommandArguments } from '.';
export function transformArguments(username: RedisCommandArgument): RedisCommandArguments {
return ['ACL', 'GETUSER', username]; return ['ACL', 'GETUSER', username];
} }
type AclGetUserRawReply = [ type AclGetUserRawReply = [
_: string, _: RedisCommandArgument,
flags: Array<string>, flags: Array<RedisCommandArgument>,
_: string, _: RedisCommandArgument,
passwords: Array<string>, passwords: Array<RedisCommandArgument>,
_: string, _: RedisCommandArgument,
commands: string, commands: RedisCommandArgument,
_: string, _: RedisCommandArgument,
keys: Array<string>, keys: Array<RedisCommandArgument>,
_: string, _: RedisCommandArgument,
channels: Array<string> channels: Array<RedisCommandArgument>
]; ];
interface AclUser { interface AclUser {
flags: Array<string>; flags: Array<RedisCommandArgument>;
passwords: Array<string>; passwords: Array<RedisCommandArgument>;
commands: string; commands: RedisCommandArgument;
keys: Array<string>; keys: Array<RedisCommandArgument>;
channels: Array<string> channels: Array<RedisCommandArgument>
} }
export function transformReply(reply: AclGetUserRawReply): AclUser { export function transformReply(reply: AclGetUserRawReply): AclUser {

6
packages/client/lib/commands/ACL_LIST.ts
View File

@@ -1,5 +1,7 @@
export function transformArguments(): Array<string> { import { RedisCommandArgument, RedisCommandArguments } from '.';
export function transformArguments(): RedisCommandArguments {
return ['ACL', 'LIST']; return ['ACL', 'LIST'];
} }
export declare function transformReply(): Array<string>; export declare function transformReply(): Array<RedisCommandArgument>;

6
packages/client/lib/commands/ACL_LOAD.ts
View File

@@ -1,5 +1,7 @@
export function transformArguments(): Array<string> { import { RedisCommandArgument, RedisCommandArguments } from '.';
export function transformArguments(): RedisCommandArguments {
return ['ACL', 'LOAD']; return ['ACL', 'LOAD'];
} }
export declare function transformReply(): string; export declare function transformReply(): RedisCommandArgument;

40
packages/client/lib/commands/ACL_LOG.ts
View File

@@ -1,4 +1,6 @@
export function transformArguments(count?: number): Array<string> { import { RedisCommandArgument, RedisCommandArguments } from '.';
export function transformArguments(count?: number): RedisCommandArguments {
const args = ['ACL', 'LOG']; const args = ['ACL', 'LOG'];
if (count) { if (count) {
@@ -9,30 +11,30 @@ export function transformArguments(count?: number): Array<string> {
} }
type AclLogRawReply = [ type AclLogRawReply = [
_: string, _: RedisCommandArgument,
count: number, count: number,
_: string, _: RedisCommandArgument,
reason: string, reason: RedisCommandArgument,
_: string, _: RedisCommandArgument,
context: string, context: RedisCommandArgument,
_: string, _: RedisCommandArgument,
object: string, object: RedisCommandArgument,
_: string, _: RedisCommandArgument,
username: string, username: RedisCommandArgument,
_: string, _: RedisCommandArgument,
ageSeconds: string, ageSeconds: RedisCommandArgument,
_: string, _: RedisCommandArgument,
clientInfo: string clientInfo: RedisCommandArgument
]; ];
interface AclLog { interface AclLog {
count: number; count: number;
reason: string; reason: RedisCommandArgument;
context: string; context: RedisCommandArgument;
object: string; object: RedisCommandArgument;
username: string; username: RedisCommandArgument;
ageSeconds: number; ageSeconds: number;
clientInfo: string; clientInfo: RedisCommandArgument;
} }
export function transformReply(reply: Array<AclLogRawReply>): Array<AclLog> { export function transformReply(reply: Array<AclLogRawReply>): Array<AclLog> {

6
packages/client/lib/commands/ACL_LOG_RESET.ts
View File

@@ -1,5 +1,7 @@
export function transformArguments(): Array<string> { import { RedisCommandArgument, RedisCommandArguments } from '.';
export function transformArguments(): RedisCommandArguments {
return ['ACL', 'LOG', 'RESET']; return ['ACL', 'LOG', 'RESET'];
} }
export declare function transformReply(): string; export declare function transformReply(): RedisCommandArgument;

6
packages/client/lib/commands/ACL_SAVE.ts
View File

@@ -1,5 +1,7 @@
export function transformArguments(): Array<string> { import { RedisCommandArgument, RedisCommandArguments } from '.';
export function transformArguments(): RedisCommandArguments {
return ['ACL', 'SAVE']; return ['ACL', 'SAVE'];
} }
export declare function transformReply(): string; export declare function transformReply(): RedisCommandArgument;

9
packages/client/lib/commands/ACL_SETUSER.ts
View File

@@ -1,8 +1,11 @@
import { RedisCommandArguments } from '.'; import { RedisCommandArgument, RedisCommandArguments } from '.';
import { pushVerdictArguments } from './generic-transformers'; import { pushVerdictArguments } from './generic-transformers';
export function transformArguments(username: string, rule: string | Array<string>): RedisCommandArguments { export function transformArguments(
username: RedisCommandArgument,
rule: RedisCommandArgument | Array<RedisCommandArgument>
): RedisCommandArguments {
return pushVerdictArguments(['ACL', 'SETUSER', username], rule); return pushVerdictArguments(['ACL', 'SETUSER', username], rule);
} }
export declare function transformReply(): string; export declare function transformReply(): RedisCommandArgument;

6
packages/client/lib/commands/ACL_USERS.ts
View File

@@ -1,5 +1,7 @@
export function transformArguments(): Array<string> { import { RedisCommandArgument, RedisCommandArguments } from '.';
export function transformArguments(): RedisCommandArguments {
return ['ACL', 'USERS']; return ['ACL', 'USERS'];
} }
export declare function transformReply(): Array<string>; export declare function transformReply(): Array<RedisCommandArgument>;

6
packages/client/lib/commands/ACL_WHOAMI.ts
View File

@@ -1,5 +1,7 @@
export function transformArguments(): Array<string> { import { RedisCommandArgument, RedisCommandArguments } from '.';
export function transformArguments(): RedisCommandArguments {
return ['ACL', 'WHOAMI']; return ['ACL', 'WHOAMI'];
} }
export declare function transformReply(): string; export declare function transformReply(): RedisCommandArgument;

6
packages/client/lib/commands/ASKING.ts
View File

@@ -1,5 +1,7 @@
export function transformArguments(): Array<string> { import { RedisCommandArguments, RedisCommandArgument } from '.';
export function transformArguments(): RedisCommandArguments {
return ['ASKING']; return ['ASKING'];
} }
export declare function transformReply(): string; export declare function transformReply(): RedisCommandArgument;

10
packages/client/lib/commands/AUTH.ts
View File

@@ -1,9 +1,11 @@
import { RedisCommandArgument, RedisCommandArguments } from '.';
export interface AuthOptions { export interface AuthOptions {
username?: string; username?: RedisCommandArgument;
password: string; password: RedisCommandArgument;
} }
export function transformArguments({username, password}: AuthOptions): Array<string> { export function transformArguments({ username, password }: AuthOptions): RedisCommandArguments {
if (!username) { if (!username) {
return ['AUTH', password]; return ['AUTH', password];
} }
@@ -11,4 +13,4 @@ export function transformArguments({username, password}: AuthOptions): Array<str
return ['AUTH', username, password]; return ['AUTH', username, password];
} }
export declare function transformReply(): string; export declare function transformReply(): RedisCommandArgument;

6
packages/client/lib/commands/BGREWRITEAOF.ts
View File

@@ -1,5 +1,7 @@
export function transformArguments(): Array<string> { import { RedisCommandArgument, RedisCommandArguments } from '.';
export function transformArguments(): RedisCommandArguments {
return ['BGREWRITEAOF']; return ['BGREWRITEAOF'];
} }
export declare function transformReply(): string; export declare function transformReply(): RedisCommandArgument;

6
packages/client/lib/commands/BGSAVE.ts
View File

@@ -1,8 +1,10 @@
import { RedisCommandArgument, RedisCommandArguments } from '.';
interface BgSaveOptions { interface BgSaveOptions {
SCHEDULE?: true; SCHEDULE?: true;
} }
export function transformArguments(options?: BgSaveOptions): Array<string> { export function transformArguments(options?: BgSaveOptions): RedisCommandArguments {
const args = ['BGSAVE']; const args = ['BGSAVE'];
if (options?.SCHEDULE) { if (options?.SCHEDULE) {
@@ -12,4 +14,4 @@ export function transformArguments(options?: BgSaveOptions): Array<string> {
return args; return args;
} }
export declare function transformReply(): string; export declare function transformReply(): RedisCommandArgument;

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

@@ -1,3 +1,5 @@
import { RedisCommandArgument, RedisCommandArguments } from '.';
export const FIRST_KEY_INDEX = 1; export const FIRST_KEY_INDEX = 1;
export const IS_READ_ONLY = true; export const IS_READ_ONLY = true;
@@ -7,7 +9,10 @@ interface BitCountRange {
end: number; end: number;
} }
export function transformArguments(key: string, range?: BitCountRange): Array<string> { export function transformArguments(
key: RedisCommandArgument,
range?: BitCountRange
): RedisCommandArguments {
const args = ['BITCOUNT', key]; const args = ['BITCOUNT', key];
if (range) { if (range) {

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

@@ -1,11 +1,15 @@
import { RedisCommandArguments } from '.'; import { RedisCommandArgument, RedisCommandArguments } from '.';
import { pushVerdictArguments } from './generic-transformers'; import { pushVerdictArguments } from './generic-transformers';
export const FIRST_KEY_INDEX = 2; export const FIRST_KEY_INDEX = 2;
type BitOperations = 'AND' | 'OR' | 'XOR' | 'NOT'; type BitOperations = 'AND' | 'OR' | 'XOR' | 'NOT';
export function transformArguments(operation: BitOperations, destKey: string, key: string | Array<string>): RedisCommandArguments { export function transformArguments(
operation: BitOperations,
destKey: RedisCommandArgument,
key: RedisCommandArgument | Array<RedisCommandArgument>
): RedisCommandArguments {
return pushVerdictArguments(['BITOP', operation, destKey], key); return pushVerdictArguments(['BITOP', operation, destKey], key);
} }

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

@@ -1,10 +1,16 @@
import { RedisCommandArgument, RedisCommandArguments } from '.';
import { BitValue } from './generic-transformers'; import { BitValue } from './generic-transformers';
export const FIRST_KEY_INDEX = 1; export const FIRST_KEY_INDEX = 1;
export const IS_READ_ONLY = true; export const IS_READ_ONLY = true;
export function transformArguments(key: string, bit: BitValue, start?: number, end?: number): Array<string> { export function transformArguments(
key: RedisCommandArgument,
bit: BitValue,
start?: number,
end?: number
): RedisCommandArguments {
const args = ['BITPOS', key, bit.toString()]; const args = ['BITPOS', key, bit.toString()];
if (typeof start === 'number') { if (typeof start === 'number') {

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

@@ -20,4 +20,4 @@ export function transformArguments(
]; ];
} }
export declare function transformReply(): string | null; export declare function transformReply(): RedisCommandArgument | null;

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

@@ -1,5 +0,0 @@
export { FIRST_KEY_INDEX, transformArguments } from './BLMOVE';
export const BUFFER_MODE = true;
export declare function transformReply(): Buffer | null;

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

@@ -14,12 +14,14 @@ export function transformArguments(
return args; return args;
} }
type BLPopRawReply = null | [RedisCommandArgument, RedisCommandArgument];
type BLPopReply = null | { type BLPopReply = null | {
key: string; key: RedisCommandArgument;
element: string; element: RedisCommandArgument;
}; };
export function transformReply(reply: null | [string, string]): BLPopReply { export function transformReply(reply: BLPopRawReply): BLPopReply {
if (reply === null) return null; if (reply === null) return null;
return { return {

17
packages/client/lib/commands/BLPOP_BUFFER.ts
View File

@@ -1,17 +0,0 @@
export { FIRST_KEY_INDEX, transformArguments } from './BLPOP';
export const BUFFER_MODE = true;
type BLPopBufferReply = null | {
key: Buffer;
element: Buffer;
};
export function transformReply(reply: null | [Buffer, Buffer]): BLPopBufferReply {
if (reply === null) return null;
return {
key: reply[0],
element: reply[1]
};
}

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

@@ -1,9 +1,12 @@
import { RedisCommandArguments } from '.'; import { RedisCommandArgument, RedisCommandArguments } from '.';
import { pushVerdictArguments } from './generic-transformers'; import { pushVerdictArguments } from './generic-transformers';
export const FIRST_KEY_INDEX = 1; export const FIRST_KEY_INDEX = 1;
export function transformArguments(key: string | Array<string>, timeout: number): RedisCommandArguments { export function transformArguments(
key: RedisCommandArgument | Array<RedisCommandArgument>,
timeout: number
): RedisCommandArguments {
const args = pushVerdictArguments(['BRPOP'], key); const args = pushVerdictArguments(['BRPOP'], key);
args.push(timeout.toString()); args.push(timeout.toString());

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

@@ -10,4 +10,4 @@ export function transformArguments(
return ['BRPOPLPUSH', source, destination, timeout.toString()]; return ['BRPOPLPUSH', source, destination, timeout.toString()];
} }
export declare function transformReply(): string | null; export declare function transformReply(): RedisCommandArgument | null;

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

@@ -1,5 +0,0 @@
export { FIRST_KEY_INDEX, transformArguments } from './BRPOPLPUSH';
export const BUFFER_MODE = true;
export declare function transformReply(): Buffer | null;

3
packages/client/lib/commands/BRPOP_BUFFER.ts
View File

@@ -1,3 +0,0 @@
export { FIRST_KEY_INDEX, transformArguments } from './BRPOP';
export { BUFFER_MODE, transformReply } from './BLPOP_BUFFER';

12
packages/client/lib/commands/BZPOPMAX.ts
View File

@@ -1,5 +1,5 @@
import { RedisCommandArgument, RedisCommandArguments } from '.'; import { RedisCommandArgument, RedisCommandArguments } from '.';
import { pushVerdictArguments, transformReplyNumberInfinity, ZMember } from './generic-transformers'; import { pushVerdictArguments, transformNumberInfinityReply, ZMember } from './generic-transformers';
export const FIRST_KEY_INDEX = 1; export const FIRST_KEY_INDEX = 1;
@@ -14,18 +14,16 @@ export function transformArguments(
return args; return args;
} }
interface ZMemberWithKey extends ZMember<string> { type ZMemberRawReply = [key: RedisCommandArgument, value: RedisCommandArgument, score: RedisCommandArgument] | null;
key: string;
}
type BZPopMaxReply = ZMemberWithKey | null; type BZPopMaxReply = (ZMember & { key: RedisCommandArgument }) | null;
export function transformReply(reply: [key: string, value: string, score: string] | null): BZPopMaxReply | null { export function transformReply(reply: ZMemberRawReply): BZPopMaxReply | null {
if (!reply) return null; if (!reply) return null;
return { return {
key: reply[0], key: reply[0],
value: reply[1], value: reply[1],
score: transformReplyNumberInfinity(reply[2]) score: transformNumberInfinityReply(reply[2])
}; };
} }

25
packages/client/lib/commands/BZPOPMIN.ts
View File

@@ -1,9 +1,12 @@
import { RedisCommandArguments } from '.'; import { RedisCommandArgument, RedisCommandArguments } from '.';
import { pushVerdictArguments, transformReplyNumberInfinity, ZMember } from './generic-transformers'; import { pushVerdictArguments } from './generic-transformers';
export const FIRST_KEY_INDEX = 1; export const FIRST_KEY_INDEX = 1;
export function transformArguments(key: string | Array<string>, timeout: number): RedisCommandArguments { export function transformArguments(
key: RedisCommandArgument | Array<RedisCommandArgument>,
timeout: number
): RedisCommandArguments {
const args = pushVerdictArguments(['BZPOPMIN'], key); const args = pushVerdictArguments(['BZPOPMIN'], key);
args.push(timeout.toString()); args.push(timeout.toString());
@@ -11,18 +14,4 @@ export function transformArguments(key: string | Array<string>, timeout: number)
return args; return args;
} }
interface ZMemberWithKey extends ZMember<string> { export { transformReply } from './BZPOPMAX';
key: string;
}
type BZPopMinReply = ZMemberWithKey | null;
export function transformReply(reply: [key: string, value: string, score: string] | null): BZPopMinReply | null {
if (!reply) return null;
return {
key: reply[0],
value: reply[1],
score: transformReplyNumberInfinity(reply[2])
};
}

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

@@ -8,4 +8,4 @@ export function transformArguments(value: boolean): RedisCommandArguments {
]; ];
} }
export declare function transformReply(): 'OK'; export declare function transformReply(): 'OK' | Buffer;

6
packages/client/lib/commands/CLIENT_SETNAME.ts
View File

@@ -1,7 +1,7 @@
import { RedisCommandArguments } from '.'; import { RedisCommandArgument, RedisCommandArguments } from '.';
export function transformArguments(name: string): RedisCommandArguments { export function transformArguments(name: RedisCommandArgument): RedisCommandArguments {
return ['CLIENT', 'SETNAME', name]; return ['CLIENT', 'SETNAME', name];
} }
export declare function transformReply(): string | null; export declare function transformReply(): RedisCommandArgument;

6
packages/client/lib/commands/COMMAND_GETKEYS.ts
View File

@@ -1,9 +1,9 @@
import { RedisCommandArguments } from '.'; import { RedisCommandArgument, RedisCommandArguments } from '.';
export const IS_READ_ONLY = true; export const IS_READ_ONLY = true;
export function transformArguments(args: Array<string>): RedisCommandArguments { export function transformArguments(args: Array<RedisCommandArgument>): RedisCommandArguments {
return ['COMMAND', 'GETKEYS', ...args]; return ['COMMAND', 'GETKEYS', ...args];
} }
export declare function transformReply(): Array<string>; export declare function transformReply(): Array<RedisCommandArgument>;

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

@@ -2,4 +2,4 @@ export function transformArguments(parameter: string): Array<string> {
return ['CONFIG', 'GET', parameter]; return ['CONFIG', 'GET', parameter];
} }
export { transformReplyStringTuples as transformReply } from './generic-transformers'; export { transformTuplesReply as transformReply } from './generic-transformers';

10
packages/client/lib/commands/COPY.ts
View File

@@ -1,3 +1,5 @@
import { RedisCommandArgument, RedisCommandArguments } from '.';
interface CopyCommandOptions { interface CopyCommandOptions {
destinationDb?: number; destinationDb?: number;
replace?: boolean; replace?: boolean;
@@ -5,7 +7,11 @@ interface CopyCommandOptions {
export const FIRST_KEY_INDEX = 1; export const FIRST_KEY_INDEX = 1;
export function transformArguments(source: string, destination: string, options?: CopyCommandOptions): Array<string> { export function transformArguments(
source: RedisCommandArgument,
destination: RedisCommandArgument,
options?: CopyCommandOptions
): RedisCommandArguments {
const args = ['COPY', source, destination]; const args = ['COPY', source, destination];
if (options?.destinationDb) { if (options?.destinationDb) {
@@ -19,4 +25,4 @@ export function transformArguments(source: string, destination: string, options?
return args; return args;
} }
export { transformReplyBoolean as transformReply } from './generic-transformers'; export { transformBooleanReply as transformReply } from './generic-transformers';

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

@@ -1,6 +1,8 @@
import { RedisCommandArgument, RedisCommandArguments } from '.';
export const FIRST_KEY_INDEX = 1; export const FIRST_KEY_INDEX = 1;
export function transformArguments(key: string): Array<string> { export function transformArguments(key: RedisCommandArgument): RedisCommandArguments {
return ['DECR', key]; return ['DECR', key];
} }

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

@@ -1,6 +1,11 @@
import { RedisCommandArgument, RedisCommandArguments } from '.';
export const FIRST_KEY_INDEX = 1; export const FIRST_KEY_INDEX = 1;
export function transformArguments(key: string, decrement: number): Array<string> { export function transformArguments(
key: RedisCommandArgument,
decrement: number
): RedisCommandArguments {
return ['DECRBY', key, decrement.toString()]; return ['DECRBY', key, decrement.toString()];
} }

6
packages/client/lib/commands/DEL.ts
View File

@@ -1,7 +1,9 @@
import { RedisCommandArguments } from '.'; import { RedisCommandArgument, RedisCommandArguments } from '.';
import { pushVerdictArguments } from './generic-transformers'; import { pushVerdictArguments } from './generic-transformers';
export function transformArguments(keys: string | Array<string>): RedisCommandArguments { export function transformArguments(
keys: RedisCommandArgument | Array<RedisCommandArgument>
): RedisCommandArguments {
return pushVerdictArguments(['DEL'], keys); return pushVerdictArguments(['DEL'], keys);
} }

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

@@ -1,5 +1,7 @@
import { RedisCommandArgument } from '.';
export function transformArguments(): Array<string> { export function transformArguments(): Array<string> {
return ['DISCARD']; return ['DISCARD'];
} }
export declare function transformReply(): string; export declare function transformReply(): RedisCommandArgument;

6
packages/client/lib/commands/DUMP.ts
View File

@@ -1,5 +1,7 @@
export function transformArguments(key: string): Array<string> { import { RedisCommandArgument, RedisCommandArguments } from '.';
export function transformArguments(key: RedisCommandArgument): RedisCommandArguments {
return ['DUMP', key]; return ['DUMP', key];
} }
export declare function transformReply(): string; export declare function transformReply(): RedisCommandArgument;

6
packages/client/lib/commands/ECHO.ts
View File

@@ -1,7 +1,9 @@
import { RedisCommandArgument, RedisCommandArguments } from '.';
export const IS_READ_ONLY = true; export const IS_READ_ONLY = true;
export function transformArguments(message: string): Array<string> { export function transformArguments(message: RedisCommandArgument): RedisCommandArguments {
return ['ECHO', message]; return ['ECHO', message];
} }
export declare function transformReply(): string; export declare function transformReply(): RedisCommandArgument;

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

@@ -1,12 +1,14 @@
import { RedisCommandArguments } from '.'; import { RedisCommandArgument, RedisCommandArguments } from '.';
import { pushVerdictArguments } from './generic-transformers'; import { pushVerdictArguments } from './generic-transformers';
export const FIRST_KEY_INDEX = 1; export const FIRST_KEY_INDEX = 1;
export const IS_READ_ONLY = true; export const IS_READ_ONLY = true;
export function transformArguments(keys: string | Array<string>): RedisCommandArguments { export function transformArguments(
keys: RedisCommandArgument | Array<RedisCommandArgument>
): RedisCommandArguments {
return pushVerdictArguments(['EXISTS'], keys); return pushVerdictArguments(['EXISTS'], keys);
} }
export { transformReplyBoolean as transformReply } from './generic-transformers'; export { transformBooleanReply as transformReply } from './generic-transformers';

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

@@ -1,5 +1,12 @@
export function transformArguments(key: string, seconds: number): Array<string> { import { RedisCommandArgument, RedisCommandArguments } from '.';
export const FIRST_KEY_INDEX = 1;
export function transformArguments(
key: RedisCommandArgument,
seconds: number
): RedisCommandArguments {
return ['EXPIRE', key, seconds.toString()]; return ['EXPIRE', key, seconds.toString()];
} }
export { transformReplyBoolean as transformReply } from './generic-transformers'; export { transformBooleanReply as transformReply } from './generic-transformers';

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

@@ -1,6 +1,12 @@
import { RedisCommandArgument, RedisCommandArguments } from '.';
import { transformEXAT } from './generic-transformers'; import { transformEXAT } from './generic-transformers';
export function transformArguments(key: string, timestamp: number | Date): Array<string> { export const FIRST_KEY_INDEX = 1;
export function transformArguments(
key: RedisCommandArgument,
timestamp: number | Date
): RedisCommandArguments {
return [ return [
'EXPIREAT', 'EXPIREAT',
key, key,
@@ -8,4 +14,4 @@ export function transformArguments(key: string, timestamp: number | Date): Array
]; ];
} }
export { transformReplyBoolean as transformReply } from './generic-transformers'; export { transformBooleanReply as transformReply } from './generic-transformers';

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

@@ -1,7 +1,8 @@
import { RedisCommandArgument, RedisCommandArguments } from '.';
import { GeoCoordinates } from './generic-transformers'; import { GeoCoordinates } from './generic-transformers';
interface GeoMember extends GeoCoordinates { interface GeoMember extends GeoCoordinates {
member: string; member: RedisCommandArgument;
} }
interface NX { interface NX {
@@ -22,7 +23,10 @@ type GeoAddOptions = SetGuards & GeoAddCommonOptions;
export const FIRST_KEY_INDEX = 1; export const FIRST_KEY_INDEX = 1;
export function transformArguments(key: string, toAdd: GeoMember | Array<GeoMember>, options?: GeoAddOptions): Array<string> { export function transformArguments(
key: RedisCommandArgument, toAdd: GeoMember | Array<GeoMember>,
options?: GeoAddOptions
): RedisCommandArguments {
const args = ['GEOADD', key]; const args = ['GEOADD', key];
if ((options as NX)?.NX) { if ((options as NX)?.NX) {

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

@@ -1,3 +1,4 @@
import { RedisCommandArgument, RedisCommandArguments } from '.';
import { GeoUnits } from './generic-transformers'; import { GeoUnits } from './generic-transformers';
export const FIRST_KEY_INDEX = 1; export const FIRST_KEY_INDEX = 1;
@@ -5,11 +6,11 @@ export const FIRST_KEY_INDEX = 1;
export const IS_READ_ONLY = true; export const IS_READ_ONLY = true;
export function transformArguments( export function transformArguments(
key: string, key: RedisCommandArgument,
member1: string, member1: RedisCommandArgument,
member2: string, member2: RedisCommandArgument,
unit?: GeoUnits unit?: GeoUnits
): Array<string> { ): RedisCommandArguments {
const args = ['GEODIST', key, member1, member2]; const args = ['GEODIST', key, member1, member2];
if (unit) { if (unit) {
@@ -19,6 +20,6 @@ export function transformArguments(
return args; return args;
} }
export function transformReply(reply: string | null): number | null { export function transformReply(reply: RedisCommandArgument | null): number | null {
return reply === null ? null : Number(reply); return reply === null ? null : Number(reply);
} }

9
packages/client/lib/commands/GEOHASH.ts
View File

@@ -1,12 +1,15 @@
import { RedisCommandArguments } from '.'; import { RedisCommandArgument, RedisCommandArguments } from '.';
import { pushVerdictArguments } from './generic-transformers'; import { pushVerdictArguments } from './generic-transformers';
export const FIRST_KEY_INDEX = 1; export const FIRST_KEY_INDEX = 1;
export const IS_READ_ONLY = true; export const IS_READ_ONLY = true;
export function transformArguments(key: string, member: string | Array<string>): RedisCommandArguments { export function transformArguments(
key: RedisCommandArgument,
member: RedisCommandArgument | Array<RedisCommandArgument>
): RedisCommandArguments {
return pushVerdictArguments(['GEOHASH', key], member); return pushVerdictArguments(['GEOHASH', key], member);
} }
export declare function transformReply(): Array<string>; export declare function transformReply(): Array<RedisCommandArgument>;

15
packages/client/lib/commands/GEOPOS.ts
View File

@@ -1,20 +1,25 @@
import { RedisCommandArguments } from '.'; import { RedisCommandArgument, RedisCommandArguments } from '.';
import { pushVerdictArguments } from './generic-transformers'; import { pushVerdictArguments } from './generic-transformers';
export const FIRST_KEY_INDEX = 1; export const FIRST_KEY_INDEX = 1;
export const IS_READ_ONLY = true; export const IS_READ_ONLY = true;
export function transformArguments(key: string, member: string | Array<string>): RedisCommandArguments { export function transformArguments(
key: RedisCommandArgument,
member: RedisCommandArgument | Array<RedisCommandArgument>
): RedisCommandArguments {
return pushVerdictArguments(['GEOPOS', key], member); return pushVerdictArguments(['GEOPOS', key], member);
} }
type GeoCoordinatesRawReply = Array<[RedisCommandArgument, RedisCommandArgument] | null>;
interface GeoCoordinates { interface GeoCoordinates {
longitude: string; longitude: RedisCommandArgument;
latitude: string; latitude: RedisCommandArgument;
} }
export function transformReply(reply: Array<[string, string] | null>): Array<GeoCoordinates | null> { export function transformReply(reply: GeoCoordinatesRawReply): Array<GeoCoordinates | null> {
return reply.map(coordinates => coordinates === null ? null : { return reply.map(coordinates => coordinates === null ? null : {
longitude: coordinates[0], longitude: coordinates[0],
latitude: coordinates[1] latitude: coordinates[1]

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

@@ -1,3 +1,4 @@
import { RedisCommandArgument, RedisCommandArguments } from '.';
import { GeoSearchFrom, GeoSearchBy, GeoSearchOptions, pushGeoSearchArguments } from './generic-transformers'; import { GeoSearchFrom, GeoSearchBy, GeoSearchOptions, pushGeoSearchArguments } from './generic-transformers';
export const FIRST_KEY_INDEX = 1; export const FIRST_KEY_INDEX = 1;
@@ -5,12 +6,12 @@ export const FIRST_KEY_INDEX = 1;
export const IS_READ_ONLY = true; export const IS_READ_ONLY = true;
export function transformArguments( export function transformArguments(
key: string, key: RedisCommandArgument,
from: GeoSearchFrom, from: GeoSearchFrom,
by: GeoSearchBy, by: GeoSearchBy,
options?: GeoSearchOptions options?: GeoSearchOptions
): Array<string> { ): RedisCommandArguments {
return pushGeoSearchArguments(['GEOSEARCH'], key, from, by, options); return pushGeoSearchArguments(['GEOSEARCH'], key, from, by, options);
} }
export declare function transformReply(): Array<string>; export declare function transformReply(): Array<RedisCommandArgument>;

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

@@ -1,3 +1,4 @@
import { RedisCommandArgument, RedisCommandArguments } from '.';
import { GeoSearchFrom, GeoSearchBy, GeoSearchOptions, pushGeoSearchArguments } from './generic-transformers'; import { GeoSearchFrom, GeoSearchBy, GeoSearchOptions, pushGeoSearchArguments } from './generic-transformers';
export const FIRST_KEY_INDEX = 1; export const FIRST_KEY_INDEX = 1;
@@ -9,12 +10,12 @@ interface GeoSearchStoreOptions extends GeoSearchOptions {
} }
export function transformArguments( export function transformArguments(
destination: string, destination: RedisCommandArgument,
source: string, source: RedisCommandArgument,
from: GeoSearchFrom, from: GeoSearchFrom,
by: GeoSearchBy, by: GeoSearchBy,
options?: GeoSearchStoreOptions options?: GeoSearchStoreOptions
): Array<string> { ): RedisCommandArguments {
const args = pushGeoSearchArguments( const args = pushGeoSearchArguments(
['GEOSEARCHSTORE', destination], ['GEOSEARCHSTORE', destination],
source, source,

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

@@ -1,11 +1,11 @@
import { RedisCommandArguments } from '.'; import { RedisCommandArgument, RedisCommandArguments } from '.';
import { GeoSearchFrom, GeoSearchBy, GeoReplyWith, GeoSearchOptions } from './generic-transformers'; import { GeoSearchFrom, GeoSearchBy, GeoReplyWith, GeoSearchOptions } from './generic-transformers';
import { transformArguments as geoSearchTransformArguments } from './GEOSEARCH'; import { transformArguments as geoSearchTransformArguments } from './GEOSEARCH';
export { FIRST_KEY_INDEX, IS_READ_ONLY } from './GEOSEARCH'; export { FIRST_KEY_INDEX, IS_READ_ONLY } from './GEOSEARCH';
export function transformArguments( export function transformArguments(
key: string, key: RedisCommandArgument,
from: GeoSearchFrom, from: GeoSearchFrom,
by: GeoSearchBy, by: GeoSearchBy,
replyWith: Array<GeoReplyWith>, replyWith: Array<GeoReplyWith>,

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

@@ -1,4 +1,5 @@
import { strict as assert } from 'assert'; import { strict as assert } from 'assert';
import RedisClient from '../client';
import testUtils, { GLOBAL } from '../test-utils'; import testUtils, { GLOBAL } from '../test-utils';
import { transformArguments } from './GET'; import { transformArguments } from './GET';
@@ -11,6 +12,12 @@ describe('GET', () => {
}); });
testUtils.testWithClient('client.get', async client => { testUtils.testWithClient('client.get', async client => {
const a = await client.get(
'key'
);
assert.equal( assert.equal(
await client.get('key'), await client.get('key'),
null null

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

@@ -8,4 +8,4 @@ export function transformArguments(key: RedisCommandArgument): RedisCommandArgum
return ['GET', key]; return ['GET', key];
} }
export declare function transformReply(): string | null; export declare function transformReply(): RedisCommandArgument | null;

6
packages/client/lib/commands/GETBIT.ts
View File

@@ -1,10 +1,14 @@
import { RedisCommandArgument, RedisCommandArguments } from '.';
import { BitValue } from './generic-transformers'; import { BitValue } from './generic-transformers';
export const FIRST_KEY_INDEX = 1; export const FIRST_KEY_INDEX = 1;
export const IS_READ_ONLY = true; export const IS_READ_ONLY = true;
export function transformArguments(key: string, offset: number): Array<string> { export function transformArguments(
key: RedisCommandArgument,
offset: number
): RedisCommandArguments {
return ['GETBIT', key, offset.toString()]; return ['GETBIT', key, offset.toString()];
} }

6
packages/client/lib/commands/GETDEL.ts
View File

@@ -1,7 +1,9 @@
import { RedisCommandArgument, RedisCommandArguments } from '.';
export const FIRST_KEY_INDEX = 1; export const FIRST_KEY_INDEX = 1;
export function transformArguments(key: string): Array<string> { export function transformArguments(key: RedisCommandArgument): RedisCommandArguments {
return ['GETDEL', key]; return ['GETDEL', key];
} }
export declare function transformReply(): string | null; export declare function transformReply(): RedisCommandArgument | null;

9
packages/client/lib/commands/GETEX.ts
View File

@@ -1,4 +1,4 @@
import { RedisCommandArguments } from '.'; import { RedisCommandArgument, RedisCommandArguments } from '.';
import { transformEXAT, transformPXAT } from './generic-transformers'; import { transformEXAT, transformPXAT } from './generic-transformers';
export const FIRST_KEY_INDEX = 1; export const FIRST_KEY_INDEX = 1;
@@ -15,7 +15,10 @@ type GetExModes = {
PERSIST: true; PERSIST: true;
}; };
export function transformArguments(key: string, mode: GetExModes): RedisCommandArguments { export function transformArguments(
key: RedisCommandArgument,
mode: GetExModes
): RedisCommandArguments {
const args = ['GETEX', key]; const args = ['GETEX', key];
if ('EX' in mode) { if ('EX' in mode) {
@@ -33,4 +36,4 @@ export function transformArguments(key: string, mode: GetExModes): RedisCommandA
return args; return args;
} }
export declare function transformReply(): string | null; export declare function transformReply(): RedisCommandArgument | null;

10
packages/client/lib/commands/GETRANGE.ts
View File

@@ -1,9 +1,15 @@
import { RedisCommandArgument, RedisCommandArguments } from '.';
export const FIRST_KEY_INDEX = 1; export const FIRST_KEY_INDEX = 1;
export const IS_READ_ONLY = true; export const IS_READ_ONLY = true;
export function transformArguments(key: string, start: number, end: number): Array<string> { export function transformArguments(
key: RedisCommandArgument,
start: number,
end: number
): RedisCommandArguments {
return ['GETRANGE', key, start.toString(), end.toString()]; return ['GETRANGE', key, start.toString(), end.toString()];
} }
export declare function transformReply(): string; export declare function transformReply(): RedisCommandArgument;

9
packages/client/lib/commands/GETSET.ts
View File

@@ -1,7 +1,12 @@
import { RedisCommandArgument, RedisCommandArguments } from '.';
export const FIRST_KEY_INDEX = 1; export const FIRST_KEY_INDEX = 1;
export function transformArguments(key: string, value: string): Array<string> { export function transformArguments(
key: RedisCommandArgument,
value: RedisCommandArgument
): RedisCommandArguments {
return ['GETSET', key, value]; return ['GETSET', key, value];
} }
export declare function transformReply(): string | null; export declare function transformReply(): RedisCommandArgument | null;

22
packages/client/lib/commands/GET_BUFFER.spec.ts
View File

@@ -1,22 +0,0 @@
import { strict as assert } from 'assert';
import testUtils, { GLOBAL } from '../test-utils';
describe('GET_BUFFER', () => {
testUtils.testWithClient('client.getBuffer', async client => {
const buffer = Buffer.from('string');
await client.set('key', buffer);
assert.deepEqual(
buffer,
await client.getBuffer('key')
);
}, GLOBAL.SERVERS.OPEN);
testUtils.testWithCluster('cluster.getBuffer', async cluster => {
const buffer = Buffer.from('string');
await cluster.set('key', buffer);
assert.deepEqual(
buffer,
await cluster.getBuffer('key')
);
}, GLOBAL.CLUSTERS.OPEN);
});

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

@@ -1,5 +0,0 @@
export { FIRST_KEY_INDEX, IS_READ_ONLY, transformArguments } from './GET';
export const BUFFER_MODE = true;
export declare function transformReply(): Buffer | null;

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

@@ -1,9 +1,12 @@
import { RedisCommandArguments } from '.'; import { RedisCommandArgument, RedisCommandArguments } from '.';
import { pushVerdictArguments } from './generic-transformers'; import { pushVerdictArguments } from './generic-transformers';
export const FIRST_KEY_INDEX = 1; export const FIRST_KEY_INDEX = 1;
export function transformArguments(key: string, field: string | Array<string>): RedisCommandArguments { export function transformArguments(
key: RedisCommandArgument,
field: RedisCommandArgument | Array<RedisCommandArgument>
): RedisCommandArguments {
return pushVerdictArguments(['HDEL', key], field); return pushVerdictArguments(['HDEL', key], field);
} }

25
packages/client/lib/commands/HELLO.ts
View File

@@ -1,3 +1,4 @@
import { RedisCommandArgument, RedisCommandArguments } from '.';
import { AuthOptions } from './AUTH'; import { AuthOptions } from './AUTH';
interface HelloOptions { interface HelloOptions {
@@ -6,8 +7,8 @@ interface HelloOptions {
clientName?: string; clientName?: string;
} }
export function transformArguments(options?: HelloOptions): Array<string> { export function transformArguments(options?: HelloOptions): RedisCommandArguments {
const args = ['HELLO']; const args: RedisCommandArguments = ['HELLO'];
if (options) { if (options) {
args.push(options.protover.toString()); args.push(options.protover.toString());
@@ -26,29 +27,29 @@ export function transformArguments(options?: HelloOptions): Array<string> {
type HelloRawReply = [ type HelloRawReply = [
_: never, _: never,
server: string, server: RedisCommandArgument,
_: never, _: never,
version: string, version: RedisCommandArgument,
_: never, _: never,
proto: number, proto: number,
_: never, _: never,
id: number, id: number,
_: never, _: never,
mode: string, mode: RedisCommandArgument,
_: never, _: never,
role: string, role: RedisCommandArgument,
_: never, _: never,
modules: Array<string> modules: Array<RedisCommandArgument>
]; ];
interface HelloTransformedReply { interface HelloTransformedReply {
server: string; server: RedisCommandArgument;
version: string; version: RedisCommandArgument;
proto: number; proto: number;
id: number; id: number;
mode: string; mode: RedisCommandArgument;
role: string; role: RedisCommandArgument;
modules: Array<string>; modules: Array<RedisCommandArgument>;
} }
export function transformReply(reply: HelloRawReply): HelloTransformedReply { export function transformReply(reply: HelloRawReply): HelloTransformedReply {

9
packages/client/lib/commands/HEXISTS.ts
View File

@@ -1,7 +1,12 @@
import { RedisCommandArgument, RedisCommandArguments } from '.';
export const FIRST_KEY_INDEX = 1; export const FIRST_KEY_INDEX = 1;
export function transformArguments(key: string, field: string): Array<string> { export function transformArguments(
key: RedisCommandArgument,
field: RedisCommandArgument
): RedisCommandArguments {
return ['HEXISTS', key, field]; return ['HEXISTS', key, field];
} }
export { transformReplyBoolean as transformReply } from './generic-transformers'; export { transformBooleanReply as transformReply } from './generic-transformers';

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

@@ -11,4 +11,4 @@ export function transformArguments(
return ['HGET', key, field]; return ['HGET', key, field];
} }
export declare function transformReply(): string | undefined; export declare function transformReply(): RedisCommandArgument | undefined;

6
packages/client/lib/commands/HGETALL.ts
View File

@@ -1,9 +1,11 @@
import { RedisCommandArgument, RedisCommandArguments } from '.';
export const FIRST_KEY_INDEX = 1; export const FIRST_KEY_INDEX = 1;
export const IS_READ_ONLY = true; export const IS_READ_ONLY = true;
export function transformArguments(key: string): Array<string> { export function transformArguments(key: RedisCommandArgument): RedisCommandArguments {
return ['HGETALL', key]; return ['HGETALL', key];
} }
export { transformReplyStringTuples as transformReply } from './generic-transformers'; export { transformTuplesReply as transformReply } from './generic-transformers';

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

@@ -1,5 +0,0 @@
export { FIRST_KEY_INDEX, IS_READ_ONLY, transformArguments } from './HGETALL';
export const BUFFER_MODE = true;
export { transformReplyBufferTuples as transformReply } from './generic-transformers';

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

@@ -1,5 +0,0 @@
export { FIRST_KEY_INDEX, IS_READ_ONLY, transformArguments } from './HGET';
export const BUFFER_MODE = true;
export declare function transformReply(): Buffer | undefined;

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

@@ -1,6 +1,12 @@
import { RedisCommandArgument, RedisCommandArguments } from '.';
export const FIRST_KEY_INDEX = 1; export const FIRST_KEY_INDEX = 1;
export function transformArguments(key: string, field: string, increment: number): Array<string> { export function transformArguments(
key: RedisCommandArgument,
field: RedisCommandArgument,
increment: number
): RedisCommandArguments {
return ['HINCRBY', key, field, increment.toString()]; return ['HINCRBY', key, field, increment.toString()];
} }

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

@@ -1,6 +1,12 @@
import { RedisCommandArgument, RedisCommandArguments } from '.';
export const FIRST_KEY_INDEX = 1; export const FIRST_KEY_INDEX = 1;
export function transformArguments(key: string, field: string, increment: number): Array<string> { export function transformArguments(
key: RedisCommandArgument,
field: RedisCommandArgument,
increment: number
): RedisCommandArguments {
return ['HINCRBYFLOAT', key, field, increment.toString()]; return ['HINCRBYFLOAT', key, field, increment.toString()];
} }

6
packages/client/lib/commands/HKEYS.ts
View File

@@ -1,7 +1,9 @@
import { RedisCommandArgument, RedisCommandArguments } from '.';
export const FIRST_KEY_INDEX = 1; export const FIRST_KEY_INDEX = 1;
export function transformArguments(key: string): Array<string> { export function transformArguments(key: RedisCommandArgument): RedisCommandArguments {
return ['HKEYS', key]; return ['HKEYS', key];
} }
export declare function transformReply(): Array<string>; export declare function transformReply(): Array<RedisCommandArgument>;

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

@@ -1,6 +1,8 @@
import { RedisCommandArgument, RedisCommandArguments } from '.';
export const FIRST_KEY_INDEX = 1; export const FIRST_KEY_INDEX = 1;
export function transformArguments(key: string): Array<string> { export function transformArguments(key: RedisCommandArgument): RedisCommandArguments {
return ['HLEN', key]; return ['HLEN', key];
} }

9
packages/client/lib/commands/HMGET.ts
View File

@@ -1,12 +1,15 @@
import { RedisCommandArguments } from '.'; import { RedisCommandArgument, RedisCommandArguments } from '.';
import { pushVerdictArguments } from './generic-transformers'; import { pushVerdictArguments } from './generic-transformers';
export const FIRST_KEY_INDEX = 1; export const FIRST_KEY_INDEX = 1;
export const IS_READ_ONLY = true; export const IS_READ_ONLY = true;
export function transformArguments(key: string, fields: string | Array<string>): RedisCommandArguments { export function transformArguments(
key: RedisCommandArgument,
fields: RedisCommandArgument | Array<RedisCommandArgument>
): RedisCommandArguments {
return pushVerdictArguments(['HMGET', key], fields); return pushVerdictArguments(['HMGET', key], fields);
} }
export declare function transformReply(): Array<string>; export declare function transformReply(): Array<RedisCommandArgument>;

6
packages/client/lib/commands/HRANDFIELD.ts
View File

@@ -1,9 +1,11 @@
import { RedisCommandArgument, RedisCommandArguments } from '.';
export const FIRST_KEY_INDEX = 1; export const FIRST_KEY_INDEX = 1;
export const IS_READ_ONLY = true; export const IS_READ_ONLY = true;
export function transformArguments(key: string): Array<string> { export function transformArguments(key: RedisCommandArgument): RedisCommandArguments {
return ['HRANDFIELD', key]; return ['HRANDFIELD', key];
} }
export declare function transformReply(): string | null; export declare function transformReply(): RedisCommandArgument | null;

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

@@ -1,12 +1,16 @@
import { RedisCommandArgument, RedisCommandArguments } from '.';
import { transformArguments as transformHRandFieldArguments } from './HRANDFIELD'; import { transformArguments as transformHRandFieldArguments } from './HRANDFIELD';
export { FIRST_KEY_INDEX, IS_READ_ONLY } from './HRANDFIELD'; export { FIRST_KEY_INDEX, IS_READ_ONLY } from './HRANDFIELD';
export function transformArguments(key: string, count: number): Array<string> { export function transformArguments(
key: RedisCommandArgument,
count: number
): RedisCommandArguments {
return [ return [
...transformHRandFieldArguments(key), ...transformHRandFieldArguments(key),
count.toString() count.toString()
]; ];
} }
export declare function transformReply(): Array<string>; export declare function transformReply(): Array<RedisCommandArgument>;

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

@@ -1,12 +1,16 @@
import { RedisCommandArgument, RedisCommandArguments } from '.';
import { transformArguments as transformHRandFieldCountArguments } from './HRANDFIELD_COUNT'; import { transformArguments as transformHRandFieldCountArguments } from './HRANDFIELD_COUNT';
export { FIRST_KEY_INDEX, IS_READ_ONLY } from './HRANDFIELD_COUNT'; export { FIRST_KEY_INDEX, IS_READ_ONLY } from './HRANDFIELD_COUNT';
export function transformArguments(key: string, count: number): Array<string> { export function transformArguments(
key: RedisCommandArgument,
count: number
): RedisCommandArguments {
return [ return [
...transformHRandFieldCountArguments(key, count), ...transformHRandFieldCountArguments(key, count),
'WITHVALUES' 'WITHVALUES'
]; ];
} }
export { transformReplyStringTuples as transformReply } from './generic-transformers'; export { transformTuplesReply as transformReply } from './generic-transformers';

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

@@ -1,5 +0,0 @@
export { FIRST_KEY_INDEX, IS_READ_ONLY, transformArguments } from './HRANDFIELD_COUNT';
export const BUFFER_MODE = true;
export { transformReplyBufferTuples as transformReply } from './generic-transformers';

15
packages/client/lib/commands/HSCAN.ts
View File

@@ -1,19 +1,26 @@
import { RedisCommandArgument, RedisCommandArguments } from '.';
import { ScanOptions, pushScanArguments } from './generic-transformers'; import { ScanOptions, pushScanArguments } from './generic-transformers';
export const FIRST_KEY_INDEX = 1; export const FIRST_KEY_INDEX = 1;
export const IS_READ_ONLY = true; export const IS_READ_ONLY = true;
export function transformArguments(key: string, cursor: number, options?: ScanOptions): Array<string> { export function transformArguments(
key: RedisCommandArgument,
cursor: number,
options?: ScanOptions
): RedisCommandArguments {
return pushScanArguments([ return pushScanArguments([
'HSCAN', 'HSCAN',
key key
], cursor, options); ], cursor, options);
} }
type HScanRawReply = [RedisCommandArgument, Array<RedisCommandArgument>];
export interface HScanTuple { export interface HScanTuple {
field: string; field: RedisCommandArgument;
value: string; value: RedisCommandArgument;
} }
interface HScanReply { interface HScanReply {
@@ -21,7 +28,7 @@ interface HScanReply {
tuples: Array<HScanTuple>; tuples: Array<HScanTuple>;
} }
export function transformReply([cursor, rawTuples]: [string, Array<string>]): HScanReply { export function transformReply([cursor, rawTuples]: HScanRawReply): HScanReply {
const parsedTuples = []; const parsedTuples = [];
for (let i = 0; i < rawTuples.length; i += 2) { for (let i = 0; i < rawTuples.length; i += 2) {
parsedTuples.push({ parsedTuples.push({

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

@@ -1,6 +1,6 @@
import { RedisCommandArgument, RedisCommandArguments } from '.'; import { RedisCommandArgument, RedisCommandArguments } from '.';
type Types = string | number | Buffer; type Types = RedisCommandArgument | number;
type HSETObject = Record<string | number, Types>; type HSETObject = Record<string | number, Types>;

10
packages/client/lib/commands/HSETNX.ts
View File

@@ -1,7 +1,13 @@
import { RedisCommandArgument, RedisCommandArguments } from '.';
export const FIRST_KEY_INDEX = 1; export const FIRST_KEY_INDEX = 1;
export function transformArguments(key: string, field: string, value: string): Array<string> { export function transformArguments(
key: RedisCommandArgument,
field: RedisCommandArgument,
value: RedisCommandArgument
): RedisCommandArguments {
return ['HSETNX', key, field, value]; return ['HSETNX', key, field, value];
} }
export { transformReplyBoolean as transformReply } from './generic-transformers'; export { transformBooleanReply as transformReply } from './generic-transformers';

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

@@ -1,6 +1,11 @@
import { RedisCommandArgument, RedisCommandArguments } from '.';
export const FIRST_KEY_INDEX = 1; export const FIRST_KEY_INDEX = 1;
export function transformArguments(key: string, field: string): Array<string> { export function transformArguments(
key: RedisCommandArgument,
field: RedisCommandArgument
): RedisCommandArguments {
return ['HSTRLEN', key, field]; return ['HSTRLEN', key, field];
} }

6
packages/client/lib/commands/HVALS.ts
View File

@@ -1,7 +1,9 @@
import { RedisCommandArgument, RedisCommandArguments } from '.';
export const FIRST_KEY_INDEX = 1; export const FIRST_KEY_INDEX = 1;
export function transformArguments(key: string): Array<string> { export function transformArguments(key: RedisCommandArgument): RedisCommandArguments {
return ['HVALS', key]; return ['HVALS', key];
} }
export declare function transformReply(): Array<string>; export declare function transformReply(): Array<RedisCommandArgument>;

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

@@ -1,6 +1,8 @@
import { RedisCommandArgument, RedisCommandArguments } from '.';
export const FIRST_KEY_INDEX = 1; export const FIRST_KEY_INDEX = 1;
export function transformArguments(key: string): Array<string> { export function transformArguments(key: RedisCommandArgument): RedisCommandArguments {
return ['INCR', key]; return ['INCR', key];
} }

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

@@ -1,6 +1,11 @@
import { RedisCommandArgument, RedisCommandArguments } from '.';
export const FIRST_KEY_INDEX = 1; export const FIRST_KEY_INDEX = 1;
export function transformArguments(key: string, increment: number): Array<string> { export function transformArguments(
key: RedisCommandArgument,
increment: number
): RedisCommandArguments {
return ['INCRBY', key, increment.toString()]; return ['INCRBY', key, increment.toString()];
} }

9
packages/client/lib/commands/INCRBYFLOAT.ts
View File

@@ -1,7 +1,12 @@
import { RedisCommandArgument, RedisCommandArguments } from '.';
export const FIRST_KEY_INDEX = 1; export const FIRST_KEY_INDEX = 1;
export function transformArguments(key: string, increment: number): Array<string> { export function transformArguments(
key: RedisCommandArgument,
increment: number
): RedisCommandArguments {
return ['INCRBYFLOAT', key, increment.toString()]; return ['INCRBYFLOAT', key, increment.toString()];
} }
export declare function transformReply(): string; export declare function transformReply(): RedisCommandArgument;

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

@@ -1,7 +1,7 @@
export function transformArguments(pattern: string): Array<string> { import { RedisCommandArgument, RedisCommandArguments } from '.';
export function transformArguments(pattern: RedisCommandArgument): RedisCommandArguments {
return ['KEYS', pattern]; return ['KEYS', pattern];
} }
export function transformReply(keys: Array<string>): Array<string> { export declare function transformReply(): Array<RedisCommandArgument>;
return keys;
}

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

@@ -1,8 +1,12 @@
import { RedisCommandArgument, RedisCommandArguments } from '.';
export const IS_READ_ONLY = true; export const IS_READ_ONLY = true;
export function transformArguments(key: string, index: number): Array<string> { export function transformArguments(
key: RedisCommandArgument,
index: number
): RedisCommandArguments {
return ['LINDEX', key, index.toString()]; return ['LINDEX', key, index.toString()];
} }
export declare function transformReply(): string | null; export declare function transformReply(): RedisCommandArgument | null;

10
packages/client/lib/commands/LINSERT.ts
View File

@@ -1,13 +1,15 @@
import { RedisCommandArgument, RedisCommandArguments } from '.';
export const FIRST_KEY_INDEX = 1; export const FIRST_KEY_INDEX = 1;
type LInsertPosition = 'BEFORE' | 'AFTER'; type LInsertPosition = 'BEFORE' | 'AFTER';
export function transformArguments( export function transformArguments(
key: string, key: RedisCommandArgument,
position: LInsertPosition, position: LInsertPosition,
pivot: string, pivot: RedisCommandArgument,
element: string element: RedisCommandArgument
): Array<string> { ): RedisCommandArguments {
return [ return [
'LINSERT', 'LINSERT',
key, key,

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

@@ -1,8 +1,10 @@
import { RedisCommandArgument, RedisCommandArguments } from '.';
export const FIRST_KEY_INDEX = 1; export const FIRST_KEY_INDEX = 1;
export const IS_READ_ONLY = true; export const IS_READ_ONLY = true;
export function transformArguments(key: string): Array<string> { export function transformArguments(key: RedisCommandArgument): RedisCommandArguments {
return ['LLEN', key]; return ['LLEN', key];
} }

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

@@ -1,13 +1,15 @@
import { RedisCommandArgument, RedisCommandArguments } from '.';
export type LMoveSide = 'LEFT' | 'RIGHT'; export type LMoveSide = 'LEFT' | 'RIGHT';
export const FIRST_KEY_INDEX = 1; export const FIRST_KEY_INDEX = 1;
export function transformArguments( export function transformArguments(
source: string, source: RedisCommandArgument,
destination: string, destination: RedisCommandArgument,
sourceSide: LMoveSide, sourceSide: LMoveSide,
destinationSide: LMoveSide destinationSide: LMoveSide
): Array<string> { ): RedisCommandArguments {
return [ return [
'LMOVE', 'LMOVE',
source, source,
@@ -17,4 +19,4 @@ export function transformArguments(
]; ];
} }
export declare function transformReply(): string | null; export declare function transformReply(): RedisCommandArgument | null;

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

@@ -1,3 +1,5 @@
import { RedisCommandArgument } from '.';
export const IS_READ_ONLY = true; export const IS_READ_ONLY = true;
export function transformArguments(version?: number, ...optionalArguments: Array<number>): Array<string> { export function transformArguments(version?: number, ...optionalArguments: Array<number>): Array<string> {
@@ -14,4 +16,4 @@ export function transformArguments(version?: number, ...optionalArguments: Array
return args; return args;
} }
export declare function transformReply(): string; export declare function transformReply(): RedisCommandArgument;

6
packages/client/lib/commands/LPOP.ts
View File

@@ -1,7 +1,9 @@
import { RedisCommandArgument, RedisCommandArguments } from '.';
export const FIRST_KEY_INDEX = 1; export const FIRST_KEY_INDEX = 1;
export function transformArguments(key: string): Array<string> { export function transformArguments(key: RedisCommandArgument): RedisCommandArguments {
return ['LPOP', key]; return ['LPOP', key];
} }
export declare function transformReply(): string | null; export declare function transformReply(): RedisCommandArgument | null;

9
packages/client/lib/commands/LPOP_COUNT.ts
View File

@@ -1,7 +1,12 @@
import { RedisCommandArgument, RedisCommandArguments } from '.';
export const FIRST_KEY_INDEX = 1; export const FIRST_KEY_INDEX = 1;
export function transformArguments(key: string, count: number): Array<string> { export function transformArguments(
key: RedisCommandArgument,
count: number
): RedisCommandArguments {
return ['LPOP', key, count.toString()]; return ['LPOP', key, count.toString()];
} }
export declare function transformReply(): Array<string> | null; export declare function transformReply(): Array<RedisCommandArgument> | null;

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

@@ -1,3 +1,5 @@
import { RedisCommandArgument, RedisCommandArguments } from '.';
export const FIRST_KEY_INDEX = 1; export const FIRST_KEY_INDEX = 1;
export const IS_READ_ONLY = true; export const IS_READ_ONLY = true;
@@ -7,7 +9,11 @@ export interface LPosOptions {
MAXLEN?: number; MAXLEN?: number;
} }
export function transformArguments(key: string, element: string, options?: LPosOptions): Array<string> { export function transformArguments(
key: RedisCommandArgument,
element: RedisCommandArgument,
options?: LPosOptions
): RedisCommandArguments {
const args = ['LPOS', key, element]; const args = ['LPOS', key, element];
if (typeof options?.RANK === 'number') { if (typeof options?.RANK === 'number') {

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