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

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

Browse Source
This commit is contained in:
Leibale
2023-07-11 12:11:38 -04:00
parent 0a46a6c710 ad8d0a0fe1
commit c515bc9571
25 changed files with 361 additions and 294 deletions
Download Patch File Download Diff File Expand all files Collapse all files

4
packages/json/lib/commands/ARRAPPEND.ts
View File

@@ -1,5 +1,5 @@
import { RedisJSON, transformRedisJsonArgument } from '.';
import { RedisArgument, ArrayReply, NumberReply, Command } from '@redis/client/dist/lib/RESP/types';
import { RedisArgument, ArrayReply, NumberReply, NullReply, Command } from '@redis/client/dist/lib/RESP/types';
export default {
FIRST_KEY_INDEX: 1,
@@ -13,5 +13,5 @@ export default {
return args;
},
transformReply: undefined as unknown as () => NumberReply | ArrayReply<NumberReply>
transformReply: undefined as unknown as () => NumberReply | NullReply | ArrayReply<NumberReply | NullReply>
} as const satisfies Command;

4
packages/json/lib/commands/ARRINDEX.ts
View File

@@ -1,4 +1,4 @@
import { RedisArgument, ArrayReply, NumberReply, Command } from '@redis/client/dist/lib/RESP/types';
import { RedisArgument, ArrayReply, NumberReply, NullReply, Command } from '@redis/client/dist/lib/RESP/types';
import { RedisJSON, transformRedisJsonArgument } from '.';
export default {
@@ -23,5 +23,5 @@ export default {
return args;
},
transformReply: undefined as unknown as () => NumberReply | ArrayReply<NumberReply>
transformReply: undefined as unknown as () => NumberReply | NullReply | ArrayReply<NumberReply | NullReply>
} as const satisfies Command;

46
packages/json/lib/commands/ARRINSERT.spec.ts
View File

@@ -1,30 +1,30 @@
import { strict as assert } from 'assert';
import testUtils, { GLOBAL } from '../test-utils';
import { transformArguments } from './ARRINSERT';
import ARRINSERT from './ARRINSERT';
describe('ARRINSERT', () => {
describe('transformArguments', () => {
it('single JSON', () => {
assert.deepEqual(
transformArguments('key', '$', 0, 'json'),
['JSON.ARRINSERT', 'key', '$', '0', '"json"']
);
});
it('multiple JSONs', () => {
assert.deepEqual(
transformArguments('key', '$', 0, '1', '2'),
['JSON.ARRINSERT', 'key', '$', '0', '"1"', '"2"']
);
});
describe('JSON.ARRINSERT', () => {
describe('transformArguments', () => {
it('single JSON', () => {
assert.deepEqual(
ARRINSERT.transformArguments('key', '$', 0, 'json'),
['JSON.ARRINSERT', 'key', '$', '0', '"json"']
);
});
testUtils.testWithClient('client.json.arrInsert', async client => {
await client.json.set('key', '$', []);
it('multiple JSONs', () => {
assert.deepEqual(
ARRINSERT.transformArguments('key', '$', 0, '1', '2'),
['JSON.ARRINSERT', 'key', '$', '0', '"1"', '"2"']
);
});
});
assert.deepEqual(
await client.json.arrInsert('key', '$', 0, 'json'),
[1]
);
}, GLOBAL.SERVERS.OPEN);
testUtils.testWithClient('client.json.arrInsert', async client => {
await client.json.set('key', '$', []);
assert.deepEqual(
await client.json.arrInsert('key', '$', 0, 'json'),
[1]
);
}, GLOBAL.SERVERS.OPEN);
});

16
packages/json/lib/commands/ARRINSERT.ts
View File

@@ -1,15 +1,17 @@
import { RedisArgument, ArrayReply, NumberReply, NullReply, Command } from '@redis/client/dist/lib/RESP/types';
import { RedisJSON, transformRedisJsonArgument } from '.';
export const FIRST_KEY_INDEX = 1;
export function transformArguments(key: string, path: string, index: number, ...jsons: Array<RedisJSON>): Array<string> {
export default {
FIRST_KEY_INDEX: 1,
IS_READ_ONLY: false,
transformArguments(key: RedisArgument, path: RedisArgument, index: number, ...jsons: Array<RedisJSON>) {
const args = ['JSON.ARRINSERT', key, path, index.toString()];
for (const json of jsons) {
args.push(transformRedisJsonArgument(json));
args.push(transformRedisJsonArgument(json));
}
return args;
}
export declare function transformReply(): number | Array<number>;
},
transformReply: undefined as unknown as () => NumberReply | NullReply | ArrayReply<NumberReply | NullReply>
} as const satisfies Command;

46
packages/json/lib/commands/ARRLEN.spec.ts
View File

@@ -1,30 +1,30 @@
import { strict as assert } from 'assert';
import testUtils, { GLOBAL } from '../test-utils';
import { transformArguments } from './ARRLEN';
import ARRLEN from './ARRLEN';
describe('ARRLEN', () => {
describe('transformArguments', () => {
it('without path', () => {
assert.deepEqual(
transformArguments('key'),
['JSON.ARRLEN', 'key']
);
});
it('with path', () => {
assert.deepEqual(
transformArguments('key', '$'),
['JSON.ARRLEN', 'key', '$']
);
});
describe('JSON.ARRLEN', () => {
describe('transformArguments', () => {
it('without path', () => {
assert.deepEqual(
ARRLEN.transformArguments('key'),
['JSON.ARRLEN', 'key']
);
});
testUtils.testWithClient('client.json.arrLen', async client => {
await client.json.set('key', '$', []);
it('with path', () => {
assert.deepEqual(
ARRLEN.transformArguments('key', '$'),
['JSON.ARRLEN', 'key', '$']
);
});
});
assert.deepEqual(
await client.json.arrLen('key', '$'),
[0]
);
}, GLOBAL.SERVERS.OPEN);
testUtils.testWithClient('client.json.arrLen', async client => {
await client.json.set('key', '$', []);
assert.deepEqual(
await client.json.arrLen('key', '$'),
[0]
);
}, GLOBAL.SERVERS.OPEN);
});

17
packages/json/lib/commands/ARRLEN.ts
View File

@@ -1,15 +1,16 @@
export const FIRST_KEY_INDEX = 1;
import { RedisArgument, ArrayReply, NumberReply, NullReply, Command } from '@redis/client/dist/lib/RESP/types';
export const IS_READ_ONLY = true;
export function transformArguments(key: string, path?: string): Array<string> {
export default {
FIRST_KEY_INDEX: 1,
IS_READ_ONLY: true,
transformArguments(key: RedisArgument, path?: RedisArgument) {
const args = ['JSON.ARRLEN', key];
if (path) {
args.push(path);
args.push(path);
}
return args;
}
export declare function transformReply(): number | Array<number>;
},
transformReply: undefined as unknown as () => NumberReply | NullReply | ArrayReply<NumberReply | NullReply>
} as const satisfies Command;

30
packages/json/lib/commands/ARRTRIM.spec.ts
View File

@@ -1,21 +1,21 @@
import { strict as assert } from 'assert';
import testUtils, { GLOBAL } from '../test-utils';
import { transformArguments } from './ARRTRIM';
import ARRTRIM from './ARRTRIM';
describe('ARRTRIM', () => {
it('transformArguments', () => {
assert.deepEqual(
transformArguments('key', '$', 0, 1),
['JSON.ARRTRIM', 'key', '$', '0', '1']
);
});
describe('JSON.ARRTRIM', () => {
it('transformArguments', () => {
assert.deepEqual(
ARRTRIM.transformArguments('key', '$', 0, 1),
['JSON.ARRTRIM', 'key', '$', '0', '1']
);
});
testUtils.testWithClient('client.json.arrTrim', async client => {
await client.json.set('key', '$', []);
testUtils.testWithClient('client.json.arrTrim', async client => {
await client.json.set('key', '$', []);
assert.deepEqual(
await client.json.arrTrim('key', '$', 0, 1),
[0]
);
}, GLOBAL.SERVERS.OPEN);
assert.deepEqual(
await client.json.arrTrim('key', '$', 0, 1),
[0]
);
}, GLOBAL.SERVERS.OPEN);
});

13
packages/json/lib/commands/ARRTRIM.ts
View File

@@ -1,7 +1,10 @@
export const FIRST_KEY_INDEX = 1;
import { RedisArgument, ArrayReply, NumberReply, NullReply, Command } from '@redis/client/dist/lib/RESP/types';
export function transformArguments(key: string, path: string, start: number, stop: number): Array<string> {
export default {
FIRST_KEY_INDEX: 1,
IS_READ_ONLY: false,
transformArguments(key: RedisArgument, path: RedisArgument, start: number, stop: number) {
return ['JSON.ARRTRIM', key, path, start.toString(), stop.toString()];
}
export declare function transformReply(): number | Array<number>;
},
transformReply: undefined as unknown as () => NumberReply | NullReply | ArrayReply<NumberReply | NullReply>
} as const satisfies Command;

2
packages/json/lib/commands/CLEAR.spec.ts
View File

@@ -2,7 +2,7 @@ import { strict as assert } from 'assert';
import testUtils, { GLOBAL } from '../test-utils';
import CLEAR from './CLEAR';
describe('CLEAR', () => {
describe('JSON.CLEAR', () => {
describe('transformArguments', () => {
it('key', () => {
assert.deepEqual(

30
packages/json/lib/commands/NUMINCRBY.spec.ts
View File

@@ -1,21 +1,21 @@
import { strict as assert } from 'assert';
import testUtils, { GLOBAL } from '../test-utils';
import { transformArguments } from './NUMINCRBY';
import NUMINCRBY from './NUMINCRBY';
describe('NUMINCRBY', () => {
it('transformArguments', () => {
assert.deepEqual(
transformArguments('key', '$', 1),
['JSON.NUMINCRBY', 'key', '$', '1']
);
});
describe('JSON.NUMINCRBY', () => {
it('transformArguments', () => {
assert.deepEqual(
NUMINCRBY.transformArguments('key', '$', 1),
['JSON.NUMINCRBY', 'key', '$', '1']
);
});
testUtils.testWithClient('client.json.numIncrBy', async client => {
await client.json.set('key', '$', 0);
testUtils.testWithClient('client.json.numIncrBy', async client => {
await client.json.set('key', '$', 0);
assert.deepEqual(
await client.json.numIncrBy('key', '$', 1),
[1]
);
}, GLOBAL.SERVERS.OPEN);
assert.deepEqual(
await client.json.numIncrBy('key', '$', 1),
[1]
);
}, GLOBAL.SERVERS.OPEN);
});

13
packages/json/lib/commands/NUMINCRBY.ts
View File

@@ -1,7 +1,10 @@
export const FIRST_KEY_INDEX = 1;
import { RedisArgument, Command, ArrayReply, NumberReply, DoubleReply, NullReply } from '@redis/client/dist/lib/RESP/types';
export function transformArguments(key: string, path: string, by: number): Array<string> {
export default {
FIRST_KEY_INDEX: 1,
IS_READ_ONLY: false,
transformArguments(key: RedisArgument, path: RedisArgument, by: number) {
return ['JSON.NUMINCRBY', key, path, by.toString()];
}
export { transformNumbersReply as transformReply } from '.';
},
transformReply: undefined as unknown as () => ArrayReply<NumberReply | DoubleReply | NullReply>
} as const satisfies Command;

30
packages/json/lib/commands/NUMMULTBY.spec.ts
View File

@@ -1,21 +1,21 @@
import { strict as assert } from 'assert';
import testUtils, { GLOBAL } from '../test-utils';
import { transformArguments } from './NUMMULTBY';
import NUMMULTBY from './NUMMULTBY';
describe('NUMMULTBY', () => {
it('transformArguments', () => {
assert.deepEqual(
transformArguments('key', '$', 2),
['JSON.NUMMULTBY', 'key', '$', '2']
);
});
describe('JSON.NUMMULTBY', () => {
it('transformArguments', () => {
assert.deepEqual(
NUMMULTBY.transformArguments('key', '$', 2),
['JSON.NUMMULTBY', 'key', '$', '2']
);
});
testUtils.testWithClient('client.json.numMultBy', async client => {
await client.json.set('key', '$', 1);
testUtils.testWithClient('client.json.numMultBy', async client => {
await client.json.set('key', '$', 1);
assert.deepEqual(
await client.json.numMultBy('key', '$', 2),
[2]
);
}, GLOBAL.SERVERS.OPEN);
assert.deepEqual(
await client.json.numMultBy('key', '$', 2),
[2]
);
}, GLOBAL.SERVERS.OPEN);
});

13
packages/json/lib/commands/NUMMULTBY.ts
View File

@@ -1,7 +1,10 @@
export const FIRST_KEY_INDEX = 1;
import { RedisArgument, Command, ArrayReply, NumberReply, DoubleReply, NullReply } from '@redis/client/dist/lib/RESP/types';
export function transformArguments(key: string, path: string, by: number): Array<string> {
export default {
FIRST_KEY_INDEX: 1,
IS_READ_ONLY: false,
transformArguments(key: RedisArgument, path: RedisArgument, by: number) {
return ['JSON.NUMMULTBY', key, path, by.toString()];
}
export { transformNumbersReply as transformReply } from '.';
},
transformReply: undefined as unknown as () => ArrayReply<NumberReply | DoubleReply | NullReply>
} as const satisfies Command;

44
packages/json/lib/commands/OBJKEYS.spec.ts
View File

@@ -1,28 +1,28 @@
import { strict as assert } from 'assert';
import testUtils, { GLOBAL } from '../test-utils';
import { transformArguments } from './OBJKEYS';
import OBJKEYS from './OBJKEYS';
describe('OBJKEYS', () => {
describe('transformArguments', () => {
it('without path', () => {
assert.deepEqual(
transformArguments('key'),
['JSON.OBJKEYS', 'key']
);
});
it('with path', () => {
assert.deepEqual(
transformArguments('key', '$'),
['JSON.OBJKEYS', 'key', '$']
);
});
describe('JSON.OBJKEYS', () => {
describe('transformArguments', () => {
it('without path', () => {
assert.deepEqual(
OBJKEYS.transformArguments('key'),
['JSON.OBJKEYS', 'key']
);
});
// testUtils.testWithClient('client.json.objKeys', async client => {
// assert.deepEqual(
// await client.json.objKeys('key', '$'),
// [null]
// );
// }, GLOBAL.SERVERS.OPEN);
it('with path', () => {
assert.deepEqual(
OBJKEYS.transformArguments('key', '$'),
['JSON.OBJKEYS', 'key', '$']
);
});
});
testUtils.testWithClient('client.json.objKeys', async client => {
assert.deepEqual(
await client.json.objKeys('key', '$'),
[null]
);
}, GLOBAL.SERVERS.OPEN);
});

17
packages/json/lib/commands/OBJKEYS.ts
View File

@@ -1,13 +1,18 @@
export const FIRST_KEY_INDEX = 1;
import { RedisArgument, ArrayReply, BlobStringReply, NullReply, Command } from '@redis/client/dist/lib/RESP/types';
export function transformArguments(key: string, path?: string): Array<string> {
type ReplyItem = ArrayReply<BlobStringReply> | NullReply;
export default {
FIRST_KEY_INDEX: 1,
IS_READ_ONLY: false,
transformArguments(key: RedisArgument, path?: RedisArgument) {
const args = ['JSON.OBJKEYS', key];
if (path) {
args.push(path);
args.push(path);
}
return args;
}
export declare function transformReply(): Array<string> | null | Array<Array<string> | null>;
},
transformReply: undefined as unknown as () => ReplyItem | ArrayReply<ReplyItem>
} as const satisfies Command;

44
packages/json/lib/commands/OBJLEN.spec.ts
View File

@@ -1,28 +1,28 @@
import { strict as assert } from 'assert';
import testUtils, { GLOBAL } from '../test-utils';
import { transformArguments } from './OBJLEN';
import OBJLEN from './OBJLEN';
describe('OBJLEN', () => {
describe('transformArguments', () => {
it('without path', () => {
assert.deepEqual(
transformArguments('key'),
['JSON.OBJLEN', 'key']
);
});
it('with path', () => {
assert.deepEqual(
transformArguments('key', '$'),
['JSON.OBJLEN', 'key', '$']
);
});
describe('JSON.OBJLEN', () => {
describe('transformArguments', () => {
it('without path', () => {
assert.deepEqual(
OBJLEN.transformArguments('key'),
['JSON.OBJLEN', 'key']
);
});
// testUtils.testWithClient('client.json.objLen', async client => {
// assert.equal(
// await client.json.objLen('key', '$'),
// [null]
// );
// }, GLOBAL.SERVERS.OPEN);
it('with path', () => {
assert.deepEqual(
OBJLEN.transformArguments('key', '$'),
['JSON.OBJLEN', 'key', '$']
);
});
});
// testUtils.testWithClient('client.json.objLen', async client => {
// assert.equal(
// await client.json.objLen('key', '$'),
// [null]
// );
// }, GLOBAL.SERVERS.OPEN);
});

15
packages/json/lib/commands/OBJLEN.ts
View File

@@ -1,13 +1,16 @@
export const FIRST_KEY_INDEX = 1;
import { RedisArgument, ArrayReply, NumberReply, NullReply, Command } from '@redis/client/dist/lib/RESP/types';
export function transformArguments(key: string, path?: string): Array<string> {
export default {
FIRST_KEY_INDEX: 1,
IS_READ_ONLY: false,
transformArguments(key: RedisArgument, path?: RedisArgument) {
const args = ['JSON.OBJLEN', key];
if (path) {
args.push(path);
args.push(path);
}
return args;
}
export declare function transformReply(): number | null | Array<number | null>;
},
transformReply: undefined as unknown as () => NumberReply | NullReply | ArrayReply<NumberReply | NullReply>
} as const satisfies Command;

58
packages/json/lib/commands/SET.spec.ts
View File

@@ -1,35 +1,35 @@
import { strict as assert } from 'assert';
import testUtils, { GLOBAL } from '../test-utils';
import { transformArguments } from './SET';
import SET from './SET';
describe('SET', () => {
describe('transformArguments', () => {
it('transformArguments', () => {
assert.deepEqual(
transformArguments('key', '$', 'json'),
['JSON.SET', 'key', '$', '"json"']
);
});
it('NX', () => {
assert.deepEqual(
transformArguments('key', '$', 'json', { NX: true }),
['JSON.SET', 'key', '$', '"json"', 'NX']
);
});
it('XX', () => {
assert.deepEqual(
transformArguments('key', '$', 'json', { XX: true }),
['JSON.SET', 'key', '$', '"json"', 'XX']
);
});
describe('JSON.SET', () => {
describe('transformArguments', () => {
it('transformArguments', () => {
assert.deepEqual(
SET.transformArguments('key', '$', 'json'),
['JSON.SET', 'key', '$', '"json"']
);
});
testUtils.testWithClient('client.json.mGet', async client => {
assert.equal(
await client.json.set('key', '$', 'json'),
'OK'
);
}, GLOBAL.SERVERS.OPEN);
it('NX', () => {
assert.deepEqual(
SET.transformArguments('key', '$', 'json', { NX: true }),
['JSON.SET', 'key', '$', '"json"', 'NX']
);
});
it('XX', () => {
assert.deepEqual(
SET.transformArguments('key', '$', 'json', { XX: true }),
['JSON.SET', 'key', '$', '"json"', 'XX']
);
});
});
testUtils.testWithClient('client.json.set', async client => {
assert.equal(
await client.json.set('key', '$', 'json'),
'OK'
);
}, GLOBAL.SERVERS.OPEN);
});

26
packages/json/lib/commands/SET.ts
View File

@@ -1,25 +1,27 @@
import { RedisArgument, SimpleStringReply, NullReply, Command } from '@redis/client/dist/lib/RESP/types';
import { RedisJSON, transformRedisJsonArgument } from '.';
export const FIRST_KEY_INDEX = 1;
interface NX {
NX: true;
export interface NX {
NX: true;
}
interface XX {
XX: true;
export interface XX {
XX: true;
}
export function transformArguments(key: string, path: string, json: RedisJSON, options?: NX | XX): Array<string> {
export default {
FIRST_KEY_INDEX: 1,
IS_READ_ONLY: false,
transformArguments(key: RedisArgument, path: RedisArgument, json: RedisJSON, options?: NX | XX) {
const args = ['JSON.SET', key, path, transformRedisJsonArgument(json)];
if ((<NX>options)?.NX) {
args.push('NX');
args.push('NX');
} else if ((<XX>options)?.XX) {
args.push('XX');
args.push('XX');
}
return args;
}
export declare function transformReply(): 'OK' | null;
},
transformReply: undefined as unknown as () => SimpleStringReply<'OK'> | NullReply
} as const satisfies Command;

52
packages/json/lib/commands/STRAPPEND.spec.ts
View File

@@ -1,30 +1,30 @@
import { strict as assert } from 'assert';
import testUtils, { GLOBAL } from '../test-utils';
import { transformArguments } from './STRAPPEND';
// import { strict as assert } from 'assert';
// import testUtils, { GLOBAL } from '../test-utils';
// import { transformArguments } from './STRAPPEND';
describe('STRAPPEND', () => {
describe('transformArguments', () => {
it('without path', () => {
assert.deepEqual(
transformArguments('key', 'append'),
['JSON.STRAPPEND', 'key', '"append"']
);
});
// describe('STRAPPEND', () => {
// describe('transformArguments', () => {
// it('without path', () => {
// assert.deepEqual(
// transformArguments('key', 'append'),
// ['JSON.STRAPPEND', 'key', '"append"']
// );
// });
it('with path', () => {
assert.deepEqual(
transformArguments('key', '$', 'append'),
['JSON.STRAPPEND', 'key', '$', '"append"']
);
});
});
// it('with path', () => {
// assert.deepEqual(
// transformArguments('key', '$', 'append'),
// ['JSON.STRAPPEND', 'key', '$', '"append"']
// );
// });
// });
testUtils.testWithClient('client.json.strAppend', async client => {
await client.json.set('key', '$', '');
// testUtils.testWithClient('client.json.strAppend', async client => {
// await client.json.set('key', '$', '');
assert.deepEqual(
await client.json.strAppend('key', '$', 'append'),
[6]
);
}, GLOBAL.SERVERS.OPEN);
});
// assert.deepEqual(
// await client.json.strAppend('key', '$', 'append'),
// [6]
// );
// }, GLOBAL.SERVERS.OPEN);
// });

28
packages/json/lib/commands/STRAPPEND.ts
View File

@@ -1,21 +1,21 @@
import { transformRedisJsonArgument } from '.';
// import { transformRedisJsonArgument } from '.';
export const FIRST_KEY_INDEX = 1;
// export const FIRST_KEY_INDEX = 1;
type AppendArguments = [key: string, append: string];
// type AppendArguments = [key: string, append: string];
type AppendWithPathArguments = [key: string, path: string, append: string];
// type AppendWithPathArguments = [key: string, path: string, append: string];
export function transformArguments(...[key, pathOrAppend, append]: AppendArguments | AppendWithPathArguments): Array<string> {
const args = ['JSON.STRAPPEND', key];
// export function transformArguments(...[key, pathOrAppend, append]: AppendArguments | AppendWithPathArguments): Array<string> {
// const args = ['JSON.STRAPPEND', key];
if (append !== undefined && append !== null) {
args.push(pathOrAppend, transformRedisJsonArgument(append));
} else {
args.push(transformRedisJsonArgument(pathOrAppend));
}
// if (append !== undefined && append !== null) {
// args.push(pathOrAppend, transformRedisJsonArgument(append));
// } else {
// args.push(transformRedisJsonArgument(pathOrAppend));
// }
return args;
}
// return args;
// }
export declare function transformReply(): number | Array<number>;
// export declare function transformReply(): number | Array<number>;

46
packages/json/lib/commands/STRLEN.spec.ts
View File

@@ -1,30 +1,30 @@
import { strict as assert } from 'assert';
import testUtils, { GLOBAL } from '../test-utils';
import { transformArguments } from './STRLEN';
import STRLEN from './STRLEN';
describe('STRLEN', () => {
describe('transformArguments', () => {
it('without path', () => {
assert.deepEqual(
transformArguments('key'),
['JSON.STRLEN', 'key']
);
});
it('with path', () => {
assert.deepEqual(
transformArguments('key', '$'),
['JSON.STRLEN', 'key', '$']
);
});
describe('JSON.STRLEN', () => {
describe('transformArguments', () => {
it('without path', () => {
assert.deepEqual(
STRLEN.transformArguments('key'),
['JSON.STRLEN', 'key']
);
});
testUtils.testWithClient('client.json.strLen', async client => {
await client.json.set('key', '$', '');
it('with path', () => {
assert.deepEqual(
STRLEN.transformArguments('key', '$'),
['JSON.STRLEN', 'key', '$']
);
});
});
assert.deepEqual(
await client.json.strLen('key', '$'),
[0]
);
}, GLOBAL.SERVERS.OPEN);
testUtils.testWithClient('client.json.strLen', async client => {
await client.json.set('key', '$', '');
assert.deepEqual(
await client.json.strLen('key', '$'),
[0]
);
}, GLOBAL.SERVERS.OPEN);
});

17
packages/json/lib/commands/STRLEN.ts
View File

@@ -1,15 +1,16 @@
export const FIRST_KEY_INDEX = 1;
import { RedisArgument, ArrayReply, NumberReply, NullReply, Command } from '@redis/client/dist/lib/RESP/types';
export const IS_READ_ONLY = true;
export function transformArguments(key: string, path?: string): Array<string> {
export default {
FIRST_KEY_INDEX: 1,
IS_READ_ONLY: false,
transformArguments(key: RedisArgument, path?: RedisArgument) {
const args = ['JSON.STRLEN', key];
if (path) {
args.push(path);
args.push(path);
}
return args;
}
export declare function transformReply(): number;
},
transformReply: undefined as unknown as () => NumberReply | NullReply | ArrayReply<NumberReply | NullReply>
} as const satisfies Command;

30
packages/json/lib/commands/TOGGLE.spec.ts Normal file
View File

@@ -0,0 +1,30 @@
import { strict as assert } from 'assert';
import testUtils, { GLOBAL } from '../test-utils';
import TOGGLE from './TOGGLE';
describe('JSON.TOGGLE', () => {
describe('transformArguments', () => {
it('without path', () => {
assert.deepEqual(
TOGGLE.transformArguments('key'),
['JSON.TOGGLE', 'key']
);
});
it('with path', () => {
assert.deepEqual(
TOGGLE.transformArguments('key', '$'),
['JSON.TOGGLE', 'key', '$']
);
});
});
testUtils.testWithClient('client.json.toggle', async client => {
await client.json.set('key', '$', '');
assert.deepEqual(
await client.json.toggle('key', '$'),
[0]
);
}, GLOBAL.SERVERS.OPEN);
});

14
packages/json/lib/commands/TOGGLE.ts Normal file
View File

@@ -0,0 +1,14 @@
import { RedisArgument, ArrayReply, NumberReply, NullReply, Command, } from '@redis/client/dist/lib/RESP/types';
export default {
FIRST_KEY_INDEX: undefined,
IS_READ_ONLY: false,
transformArguments(key: RedisArgument, path?: RedisArgument) {
const args = ['JSON.TOGGLE', key]
if (path) args.push(path);
return args;
},
transformReply: undefined as unknown as () => NumberReply | NullReply | ArrayReply<NumberReply | NullReply>
} as const satisfies Command;