redis/node-redis
1
0
Fork 0
mirror of https://github.com/redis/node-redis.git synced 2025-08-07 13:22:56 +03:00
Code Activity

Merge branch 'v5' of github.com:leibale/node-redis into v5

Browse Source
This commit is contained in:
Leibale
2023-05-03 17:30:19 -04:00
parent 331e390bef 74caece450
commit 083ad023da
5 changed files with 238 additions and 155 deletions
Download Patch File Download Diff File Expand all files Collapse all files

197
packages/client/lib/commands/XADD.spec.ts
View File

@@ -1,118 +1,93 @@
// import { strict as assert } from 'assert'; import { strict as assert } from 'assert';
// import testUtils, { GLOBAL } from '../test-utils'; import testUtils, { GLOBAL } from '../test-utils';
// import { transformArguments } from './XADD'; import XADD from './XADD';
// describe('XADD', () => { describe('XADD', () => {
// describe('transformArguments', () => { describe('transformArguments', () => {
// it('single field', () => { it('single field', () => {
// assert.deepEqual( assert.deepEqual(
// transformArguments('key', '*', { XADD.transformArguments('key', '*', {
// field: 'value' field: 'value'
// }), }),
// ['XADD', 'key', '*', 'field', 'value'] ['XADD', 'key', '*', 'field', 'value']
// ); );
// }); });
// it('multiple fields', () => { it('multiple fields', () => {
// assert.deepEqual( assert.deepEqual(
// transformArguments('key', '*', { XADD.transformArguments('key', '*', {
// '1': 'I', '1': 'I',
// '2': 'II' '2': 'II'
// }), }),
// ['XADD', 'key', '*', '1', 'I', '2', 'II'] ['XADD', 'key', '*', '1', 'I', '2', 'II']
// ); );
// }); });
// it('with NOMKSTREAM', () => { it('with TRIM', () => {
// assert.deepEqual( assert.deepEqual(
// transformArguments('key', '*', { XADD.transformArguments('key', '*', {
// field: 'value' field: 'value'
// }, { }, {
// NOMKSTREAM: true TRIM: {
// }), threshold: 1000
// ['XADD', 'key', 'NOMKSTREAM', '*', 'field', 'value'] }
// ); }),
// }); ['XADD', 'key', '1000', '*', 'field', 'value']
);
});
// it('with TRIM', () => { it('with TRIM.strategy', () => {
// assert.deepEqual( assert.deepEqual(
// transformArguments('key', '*', { XADD.transformArguments('key', '*', {
// field: 'value' field: 'value'
// }, { }, {
// TRIM: { TRIM: {
// threshold: 1000 strategy: 'MAXLEN',
// } threshold: 1000
// }), }
// ['XADD', 'key', '1000', '*', 'field', 'value'] }),
// ); ['XADD', 'key', 'MAXLEN', '1000', '*', 'field', 'value']
// }); );
});
// it('with TRIM.strategy', () => { it('with TRIM.strategyModifier', () => {
// assert.deepEqual( assert.deepEqual(
// transformArguments('key', '*', { XADD.transformArguments('key', '*', {
// field: 'value' field: 'value'
// }, { }, {
// TRIM: { TRIM: {
// strategy: 'MAXLEN', strategyModifier: '=',
// threshold: 1000 threshold: 1000
// } }
// }), }),
// ['XADD', 'key', 'MAXLEN', '1000', '*','field', 'value'] ['XADD', 'key', '=', '1000', '*', 'field', 'value']
// ); );
// }); });
// it('with TRIM.strategyModifier', () => { it('with TRIM.limit', () => {
// assert.deepEqual( assert.deepEqual(
// transformArguments('key', '*', { XADD.transformArguments('key', '*', {
// field: 'value' field: 'value'
// }, { }, {
// TRIM: { TRIM: {
// strategyModifier: '=', threshold: 1000,
// threshold: 1000 limit: 1
// } }
// }), }),
// ['XADD', 'key', '=', '1000', '*', 'field', 'value'] ['XADD', 'key', '1000', 'LIMIT', '1', '*', 'field', 'value']
// ); );
// }); });
});
// it('with TRIM.limit', () => { testUtils.testAll('xAdd', async client => {
// assert.deepEqual( assert.equal(
// transformArguments('key', '*', { typeof await client.xAdd('key', '*', {
// field: 'value' field: 'value'
// }, { }),
// TRIM: { 'string'
// threshold: 1000, );
// limit: 1 }, {
// } client: GLOBAL.SERVERS.OPEN,
// }), cluster: GLOBAL.CLUSTERS.OPEN
// ['XADD', 'key', '1000', 'LIMIT', '1', '*', 'field', 'value'] });
// ); });
// });
// it('with NOMKSTREAM, TRIM, TRIM.*', () => {
// assert.deepEqual(
// transformArguments('key', '*', {
// field: 'value'
// }, {
// NOMKSTREAM: true,
// TRIM: {
// strategy: 'MAXLEN',
// strategyModifier: '=',
// threshold: 1000,
// limit: 1
// }
// }),
// ['XADD', 'key', 'NOMKSTREAM', 'MAXLEN', '=', '1000', 'LIMIT', '1', '*', 'field', 'value']
// );
// });
// });
// testUtils.testWithClient('client.xAdd', async client => {
// assert.equal(
// typeof await client.xAdd('key', '*', {
// field: 'value'
// }),
// 'string'
// );
// }, GLOBAL.SERVERS.OPEN);
// });

82
packages/client/lib/commands/XADD.ts
View File

@@ -1,52 +1,48 @@
// import { RedisCommandArgument, RedisCommandArguments } from '.'; import { RedisArgument, BlobStringReply, Command } from '../RESP/types';
// export const FIRST_KEY_INDEX = 1; export interface XAddOptions {
TRIM?: {
strategy?: 'MAXLEN' | 'MINID';
strategyModifier?: '=' | '~';
threshold: number;
limit?: number;
};
}
// interface XAddOptions { export default {
// NOMKSTREAM?: true; FIRST_KEY_INDEX: 1,
// TRIM?: { IS_READ_ONLY: false,
// strategy?: 'MAXLEN' | 'MINID'; transformArguments(
// strategyModifier?: '=' | '~'; key: RedisArgument,
// threshold: number; id: RedisArgument,
// limit?: number; message: Record<string, RedisArgument>,
// }; options?: XAddOptions
// } ) {
const args = ['XADD', key];
// export function transformArguments( if (options?.TRIM) {
// key: RedisCommandArgument, if (options.TRIM.strategy) {
// id: RedisCommandArgument, args.push(options.TRIM.strategy);
// message: Record<string, RedisCommandArgument>, }
// options?: XAddOptions
// ): RedisCommandArguments {
// const args = ['XADD', key];
// if (options?.NOMKSTREAM) { if (options.TRIM.strategyModifier) {
// args.push('NOMKSTREAM'); args.push(options.TRIM.strategyModifier);
// } }
// if (options?.TRIM) { args.push(options.TRIM.threshold.toString());
// if (options.TRIM.strategy) {
// args.push(options.TRIM.strategy);
// }
// if (options.TRIM.strategyModifier) { if (options.TRIM.limit) {
// args.push(options.TRIM.strategyModifier); args.push('LIMIT', options.TRIM.limit.toString());
// } }
}
// args.push(options.TRIM.threshold.toString()); args.push(id);
// if (options.TRIM.limit) { for (const [key, value] of Object.entries(message)) {
// args.push('LIMIT', options.TRIM.limit.toString()); args.push(key, value);
// } }
// }
// args.push(id); return args;
},
// for (const [key, value] of Object.entries(message)) { transformReply: undefined as unknown as () => BlobStringReply
// args.push(key, value); } as const satisfies Command;
// }
// return args;
// }
// export declare function transformReply(): string;

93
packages/client/lib/commands/XADD_NOMKSTREAM.spec.ts Normal file
View File

@@ -0,0 +1,93 @@
import { strict as assert } from 'assert';
import testUtils, { GLOBAL } from '../test-utils';
import XADD_NOMKSTREAM from './XADD_NOMKSTREAM';
describe('XADD NOMKSTREAM', () => {
describe('transformArguments', () => {
it('single field', () => {
assert.deepEqual(
XADD_NOMKSTREAM.transformArguments('key', '*', {
field: 'value'
}),
['XADD', 'key', '*', 'field', 'value', 'NOMKSTREAM']
);
});
it('multiple fields', () => {
assert.deepEqual(
XADD_NOMKSTREAM.transformArguments('key', '*', {
'1': 'I',
'2': 'II'
}),
['XADD', 'key', '*', '1', 'I', '2', 'II', 'NOMKSTREAM']
);
});
it('with TRIM', () => {
assert.deepEqual(
XADD_NOMKSTREAM.transformArguments('key', '*', {
field: 'value'
}, {
TRIM: {
threshold: 1000
}
}),
['XADD', 'key', '1000', '*', 'field', 'value', 'NOMKSTREAM']
);
});
it('with TRIM.strategy', () => {
assert.deepEqual(
XADD_NOMKSTREAM.transformArguments('key', '*', {
field: 'value'
}, {
TRIM: {
strategy: 'MAXLEN',
threshold: 1000
}
}),
['XADD', 'key', 'MAXLEN', '1000', '*', 'field', 'value', 'NOMKSTREAM']
);
});
it('with TRIM.strategyModifier', () => {
assert.deepEqual(
XADD_NOMKSTREAM.transformArguments('key', '*', {
field: 'value'
}, {
TRIM: {
strategyModifier: '=',
threshold: 1000
}
}),
['XADD', 'key', '=', '1000', '*', 'field', 'value', 'NOMKSTREAM']
);
});
it('with TRIM.limit', () => {
assert.deepEqual(
XADD_NOMKSTREAM.transformArguments('key', '*', {
field: 'value'
}, {
TRIM: {
threshold: 1000,
limit: 1
}
}),
['XADD', 'key', '1000', 'LIMIT', '1', '*', 'field', 'value', 'NOMKSTREAM']
);
});
});
testUtils.testAll('xAddNoMkStream', async client => {
assert.equal(
typeof await client.xAddNoMkStream('key', '*', {
field: 'value'
}),
'string'
);
}, {
client: GLOBAL.SERVERS.OPEN,
cluster: GLOBAL.CLUSTERS.OPEN
});
});

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

@@ -0,0 +1,13 @@
import { BlobStringReply, NullReply, Command } from '../RESP/types';
import XADD from './XADD';
export default {
FIRST_KEY_INDEX: XADD.FIRST_KEY_INDEX,
IS_READ_ONLY: XADD.IS_READ_ONLY,
transformArguments(...args: Parameters<typeof XADD.transformArguments>) {
const redisArgs = XADD.transformArguments(...args);
redisArgs.push('NOMKSTREAM');
return redisArgs;
},
transformReply: undefined as unknown as () => BlobStringReply | NullReply
} as const satisfies Command;

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

@@ -146,6 +146,8 @@ import UNLINK from './UNLINK';
import UNWATCH from './UNWATCH'; import UNWATCH from './UNWATCH';
import WAIT from './WAIT'; import WAIT from './WAIT';
import WATCH from './WATCH'; import WATCH from './WATCH';
import XADD_NOMKSTREAM from './XADD_NOMKSTREAM';
import XADD from './XADD';
import XLEN from './XLEN'; import XLEN from './XLEN';
import ZADD from './ZADD'; import ZADD from './ZADD';
import ZCARD from './ZCARD'; import ZCARD from './ZCARD';
@@ -467,6 +469,10 @@ export default {
wait: WAIT, wait: WAIT,
WATCH, WATCH,
watch: WATCH, watch: WATCH,
XADD_NOMKSTREAM,
xAddNoMkStream: XADD_NOMKSTREAM,
XADD,
xAdd: XADD,
XLEN, XLEN,
xLen: XLEN, xLen: XLEN,
ZADD, ZADD,