v4.0.0-rc.4 (#1723)

* update workflows & README

* add .deepsource.toml

* fix client.quit, add error events on cluster, fix some "deepsource.io" warnings

* Release 4.0.0-rc.1

* add cluster.duplicate, add some tests

* fix #1650 - add support for Buffer in some commands, add GET_BUFFER command

* fix GET and GET_BUFFER return type

* update FAQ

* Update invalid code example in README.md (#1654)

* Update invalid code example in README.md

* Update README.md

Co-authored-by: Leibale Eidelman <leibale1998@gmail.com>

* fix #1652

* ref #1653 - better types

* better types

* fix 54124793ad

* Update GEOSEARCHSTORE.spec.ts

* fix #1660 - add support for client.HSET('key', 'field', 'value')

* upgrade dependencies, update README

* fix #1659 - add support for db-number in client options url

* fix README, remove unused import, downgrade typedoc & typedoc-plugin-markdown

* update client-configurations.md

* fix README

* add CLUSTER_SLOTS, add some tests

* fix "createClient with url" test with redis 5

* remove unused imports

* Release 4.0.0-rc.2

* add missing semicolon

* replace empty "transformReply" functions with typescript "declare"

* fix EVAL & EVALSHA, add some tests, npm update

* fix #1665 - add ZRANGEBYLEX, ZRANGEBYSCORE, ZRANGEBYSCORE_WITHSCORES

* new issue templates

* add all COMMAND commands

* run COMMAND & COMMAND INFO tests only on redis >6

* Create SECURITY.md

* fix #1671 - add support for all client configurations in cluster

* ref #1671 - add support for defaults

* remove some commands from cluster, npm update, clean code,

* lock benny version

* fix #1674 - remove `isolationPoolOptions` when creating isolated connection

* increase test coverage

* update .npmignore

* Release 4.0.0-rc.3

* fix README

* remove whitespace from LICENSE

* use "export { x as y }" instead of import & const

* move from "NodeRedis" to "Redis"

* fix #1676

* update comments

* Auth before select database (#1679)

* Auth before select database

* fix #1681

Co-authored-by: leibale <leibale1998@gmail.com>

* Adds connect-as-acl-user example. (#1684)

* Adds connect-as-acl-user example.

* Adds blank line at end.

* Set to private.

* Adds examples folder to npmignore.

* Adds Apple .DS_Store file to .gitignore (#1685)

* Adds Apple .DS_Store file.

* Add .DS_Store to .npmignore too

Co-authored-by: Leibale Eidelman <leibale1998@gmail.com>

* move examples

* clean some tests

* clean code

* Adds examples table of contents and contribution guidelines. (#1686)

* Updated examples to use named functions. (#1687)

* Updated examples to user named functions.

* Update README.md

Co-authored-by: Leibale Eidelman <leibale1998@gmail.com>

* update docs, add 6.0.x to the tests matrix, add eslint, npm update, fix some commands, fix some types

Co-authored-by: Simon Prickett <simon@crudworks.org>

* fix tests with redis 6.0.x

* fix ACL GETUSER test

* fix client.quit and client.disconnect

* fix ACL GETUSER

* Adds TypeScript note and corrects a typo.

* Fixes a bug in the Scan Iterator section. (#1694)

* Made examples use local version.

* Add `lua-multi-incr.js` example (#1692)

Also fix syntax error in the lua example in the README

Closes #1689.

* Add(examples): Create an example for blPop & lPush (#1696)

* Add(examples): Create an example for blPop & lPush

Signed-off-by: Aditya Rastogi <adit.rastogi2014@gmail.com>

* Update(examples): fix case, add timeout, update readme

Signed-off-by: Aditya Rastogi <adit.rastogi2014@gmail.com>

Closes #1693.

* Add command-with-modifiers.js example (#1695)

* Adds TypeScript note and corrects a typo.

* Adds command-with-modifiers example. (redis#1688)

* Adds command-with-modifiers example. (redis#1688)

* Adds command-with-modifiers example. (redis#1688)

* Removed callbacks.

Co-authored-by: Simon Prickett <simon@redislabs.com>

Closes #1688.

* Issue # 1697 FIX - creates an example script that shows how to use the SSCAN iterator (#1699)

* #1697 fix for set scan example

* adds the js file

* adds comment

* Minor layout and comment adjustment.

Co-authored-by: srawat2 <shashank19aug>
Co-authored-by: Simon Prickett <simon@redislabs.com>

Closes #1697.

* fix #1706 - HSET return type should be number

* use dockers for tests, fix some bugs

* increase dockers timeout to 30s

* release drafter (#1683)

* release drafter

* fixing contributors

* use dockers for tests, use npm workspaces, add rejson & redisearch modules, fix some bugs

* fix #1712 - fix LINDEX return type

* uncomment TIME tests

* use codecov

* fix tests.yml

* uncomment "should handle live resharding" test

* fix #1714 - update README(s)

* add package-lock.json

* update CONTRIBUTING.md

* update examples

* uncomment some tests

* fix test-utils

* move "all-in-one" to root folder

* fix tests workflow

* fix bug in cluster slots, enhance live resharding test

* fix live resharding test

* fix #1707 - handle number arguments in legacy mode

* Add rejectedUnauthorized and other TLS options (#1708)

* Update socket.ts

* fix #1716 - decode username and password from url

* fix some Z (sorted list) commands, increase commands test coverage

* remove empty lines

* fix 'Scenario' typo (#1720)

* update readmes, add createCluster to the `redis` package

* add .release-it.json files, update some md files

* run tests on pull requests too

* Support esModuleInterop set to false. (#1717)

* Support esModuleInterop set to false.

When testing the upcoming 4.x release, we got a bunch of typescript
errors emitted from this project.

We quickly realized this is because the library uses the esModuleInterop
flag. This makes some imports _slightly_ easier to write, but it comes
at a cost: it forces any application or library using this library to
*also* have esModuleInterop on.

The `esModuleInterop` flag is a bit of a holdover from an earlier time,
and I would not recommend using it in libraries. The main issue is that
if it's set to true, you are forcing any users of the library to also
have `esModuleInterop`, where if you keep have it set to `false` (the
default), you leave the decision to the user.

This change should have no rammifications to users with
`esModuleInterop` on, but it will enable support for those that have it
off.

This is especially good for library authors such as myself, because I
would also like to keep this flag off to not force *my* users into this
feature.

* All tests now pass!

* Move @types/redis-parser into client sub-package

and removed a comma

* npm update, remove html from readme

* add tests and licence badges

* update changelog.md

* update .npmignore and .release-it.json

* update .release-it.json

* Release client@1.0.0-rc.0

* revert d32f1edf8a

* fix .npmignore

* replace @redis with @node-redis

* Release client@1.0.0-rc.0

* update json & search version

* Release json@1.0.0-rc.0

* Release search@1.0.0-rc.0

* update dependencies

* Release redis@4.0.0-rc.4

Co-authored-by: Richard Samuelsson <noobtoothfairy@gmail.com>
Co-authored-by: mustard <mhqnwt@gmail.com>
Co-authored-by: Simon Prickett <simon@redislabs.com>
Co-authored-by: Simon Prickett <simon@crudworks.org>
Co-authored-by: Suze Shardlow <SuzeShardlow@users.noreply.github.com>
Co-authored-by: Joshua T <buildingsomethingfun@gmail.com>
Co-authored-by: Aditya Rastogi <adit.rastogi2014@gmail.com>
Co-authored-by: Rohan Kumar <rohan.kr20@gmail.com>
Co-authored-by: Kalki <shashank.kviit@gmail.com>
Co-authored-by: Chayim <chayim@users.noreply.github.com>
Co-authored-by: Da-Jin Chu <dajinchu@gmail.com>
Co-authored-by: Henrique Corrêa <75134774+HeCorr@users.noreply.github.com>
Co-authored-by: Evert Pot <me@evertpot.com>

packages/json/lib/commands/ARRAPPEND.spec.ts

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

packages/json/lib/commands/ARRAPPEND.ts

@@ -0,0 +1,15 @@
+import { RedisJSON, transformRedisJsonArgument } from '.';
+
+export const FIRST_KEY_INDEX = 1;
+
+export function transformArguments(key: string, path: string, ...jsons: Array<RedisJSON>): Array<string> {
+    const args = ['JSON.ARRAPPEND', key, path];
+
+    for (const json of jsons) {
+        args.push(transformRedisJsonArgument(json));
+    }
+
+    return args;
+}
+
+export declare function transformReply(): number | Array<number>;

packages/json/lib/commands/ARRINDEX.spec.ts

@@ -0,0 +1,37 @@
+import { strict as assert } from 'assert';
+import testUtils, { GLOBAL } from '../test-utils';
+import { transformArguments } from './ARRINDEX';
+
+describe('ARRINDEX', () => {
+    describe('transformArguments', () => {
+        it('simple', () => {
+            assert.deepEqual(
+                transformArguments('key', '$', 'json'),
+                ['JSON.ARRINDEX', 'key', '$', '"json"']
+            );
+        });
+
+        it('with start', () => {
+            assert.deepEqual(
+                transformArguments('key', '$', 'json', 1),
+                ['JSON.ARRINDEX', 'key', '$', '"json"', '1']
+            );
+        });
+
+        it('with start, end', () => {
+            assert.deepEqual(
+                transformArguments('key', '$', 'json', 1, 2),
+                ['JSON.ARRINDEX', 'key', '$', '"json"', '1', '2']
+            );
+        });
+    });
+
+    testUtils.testWithClient('client.json.arrIndex', async client => {
+        await client.json.set('key', '$', []);
+
+        assert.deepEqual(
+            await client.json.arrIndex('key', '$', 'json'),
+            [-1]
+        );
+    }, GLOBAL.SERVERS.OPEN);
+});

packages/json/lib/commands/ARRINDEX.ts

@@ -0,0 +1,21 @@
+import { RedisJSON, transformRedisJsonArgument } from '.';
+
+export const FIRST_KEY_INDEX = 1;
+
+export const IS_READ_ONLY = true;
+
+export function transformArguments(key: string, path: string, json: RedisJSON, start?: number, stop?: number): Array<string> {
+    const args = ['JSON.ARRINDEX', key, path, transformRedisJsonArgument(json)];
+
+    if (start !== undefined && start !== null) {
+        args.push(start.toString());
+
+        if (stop !== undefined && stop !== null) {
+            args.push(stop.toString());
+        }
+    }
+
+    return args;
+}
+
+export declare function transformReply(): number | Array<number>;

packages/json/lib/commands/ARRINSERT.spec.ts

@@ -0,0 +1,30 @@
+import { strict as assert } from 'assert';
+import testUtils, { GLOBAL } from '../test-utils';
+import { transformArguments } 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"']
+            );
+        });
+    });
+
+    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);
+});

packages/json/lib/commands/ARRINSERT.ts

@@ -0,0 +1,15 @@
+import { RedisJSON, transformRedisJsonArgument } from '.';
+
+export const FIRST_KEY_INDEX = 1;
+
+export function transformArguments(key: string, path: string, index: number, ...jsons: Array<RedisJSON>): Array<string> {
+    const args = ['JSON.ARRINSERT', key, path, index.toString()];
+
+    for (const json of jsons) {
+        args.push(transformRedisJsonArgument(json));
+    }
+
+    return args;
+}
+
+export declare function transformReply(): number | Array<number>;

packages/json/lib/commands/ARRLEN.spec.ts

@@ -0,0 +1,30 @@
+import { strict as assert } from 'assert';
+import testUtils, { GLOBAL } from '../test-utils';
+import { transformArguments } 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', '$']
+            );
+        });
+    });
+
+    testUtils.testWithClient('client.json.arrLen', async client => {
+        await client.json.set('key', '$', []);
+
+        assert.deepEqual(
+            await client.json.arrLen('key', '$'),
+            [0]
+        );
+    }, GLOBAL.SERVERS.OPEN);
+});

packages/json/lib/commands/ARRLEN.ts

@@ -0,0 +1,15 @@
+export const FIRST_KEY_INDEX = 1;
+
+export const IS_READ_ONLY = true;
+
+export function transformArguments(key: string, path?: string): Array<string> {
+    const args = ['JSON.ARRLEN', key];
+
+    if (path) {
+        args.push(path);
+    }
+
+    return args;
+}
+
+export declare function transformReply(): number | Array<number>;

packages/json/lib/commands/ARRPOP.spec.ts

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

packages/json/lib/commands/ARRPOP.ts

@@ -0,0 +1,17 @@
+export const FIRST_KEY_INDEX = 1;
+
+export function transformArguments(key: string, path?: string, index?: number): Array<string> {
+    const args = ['JSON.ARRPOP', key];
+
+    if (path) {
+        args.push(path);
+
+        if (index !== undefined && index !== null) {
+            args.push(index.toString());
+        }
+    }
+
+    return args;
+}
+
+export { transformRedisJsonNullArrayReply as transformReply } from '.';

packages/json/lib/commands/ARRTRIM.spec.ts

@@ -0,0 +1,21 @@
+import { strict as assert } from 'assert';
+import testUtils, { GLOBAL } from '../test-utils';
+import { transformArguments } from './ARRTRIM';
+
+describe('ARRTRIM', () => {
+    it('transformArguments', () => {
+        assert.deepEqual(
+            transformArguments('key', '$', 0, 1),
+            ['JSON.ARRTRIM', 'key', '$', '0', '1']
+        );
+    });
+
+    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);
+});

packages/json/lib/commands/ARRTRIM.ts

@@ -0,0 +1,7 @@
+export const FIRST_KEY_INDEX = 1;
+
+export function transformArguments(key: string, path: string, start: number, stop: number): Array<string> {
+    return ['JSON.ARRTRIM', key, path, start.toString(), stop.toString()];
+}
+
+export declare function transformReply(): number | Array<number>;

packages/json/lib/commands/DEBUG_MEMORY.spec.ts

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

packages/json/lib/commands/DEBUG_MEMORY.ts

@@ -0,0 +1,13 @@
+export const FIRST_KEY_INDEX = 2;
+
+export function transformArguments(key: string, path?: string): Array<string> {
+    const args = ['JSON.DEBUG', 'MEMORY', key];
+
+    if (path) {
+        args.push(path);
+    }
+
+    return args;
+}
+
+export declare function transformReply(): number;

packages/json/lib/commands/DEL.spec.ts

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

packages/json/lib/commands/DEL.ts

@@ -0,0 +1,13 @@
+export const FIRST_KEY_INDEX = 1;
+
+export function transformArguments(key: string, path?: string): Array<string> {
+    const args = ['JSON.DEL', key];
+
+    if (path) {
+        args.push(path);
+    }
+
+    return args;
+}
+
+export declare function transformReply(): number;

packages/json/lib/commands/FORGET.spec.ts

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

packages/json/lib/commands/FORGET.ts

@@ -0,0 +1,13 @@
+export const FIRST_KEY_INDEX = 1;
+
+export function transformArguments(key: string, path?: string): Array<string> {
+    const args = ['JSON.FORGET', key];
+
+    if (path) {
+        args.push(path);
+    }
+
+    return args;
+}
+
+export declare function transformReply(): number;

packages/json/lib/commands/GET.spec.ts

@@ -0,0 +1,78 @@
+import { strict as assert } from 'assert';
+import testUtils, { GLOBAL } from '../test-utils';
+import { transformArguments } from './GET';
+
+describe('GET', () => {
+    describe('transformArguments', () => {
+        describe('path', () => {
+            it('string', () => {
+                assert.deepEqual(
+                    transformArguments('key', { path: '$' }),
+                    ['JSON.GET', 'key', '$']
+                );
+            });
+
+            it('array', () => {
+                assert.deepEqual(
+                    transformArguments('key', { path: ['$.1', '$.2'] }),
+                    ['JSON.GET', 'key', '$.1', '$.2']
+                );
+            });
+        });
+
+        it('key', () => {
+            assert.deepEqual(
+                transformArguments('key'),
+                ['JSON.GET', 'key']
+            );
+        });
+
+        it('INDENT', () => {
+            assert.deepEqual(
+                transformArguments('key', { INDENT: 'indent' }),
+                ['JSON.GET', 'key', 'INDENT', 'indent']
+            );
+        });
+
+        it('NEWLINE', () => {
+            assert.deepEqual(
+                transformArguments('key', { NEWLINE: 'newline' }),
+                ['JSON.GET', 'key', 'NEWLINE', 'newline']
+            );
+        });
+
+        it('SPACE', () => {
+            assert.deepEqual(
+                transformArguments('key', { SPACE: 'space' }),
+                ['JSON.GET', 'key', 'SPACE', 'space']
+            );
+        });
+
+        it('NOESCAPE', () => {
+            assert.deepEqual(
+                transformArguments('key', { NOESCAPE: true }),
+                ['JSON.GET', 'key', 'NOESCAPE']
+            );
+        });
+
+        it('INDENT, NEWLINE, SPACE, NOESCAPE, path', () => {
+            assert.deepEqual(
+                transformArguments('key', {
+                    path: '$.path',
+                    INDENT: 'indent',
+                    NEWLINE: 'newline',
+                    SPACE: 'space',
+                    NOESCAPE: true
+                }),
+                ['JSON.GET', 'key', '$.path', 'INDENT', 'indent', 'NEWLINE', 'newline', 'SPACE', 'space', 'NOESCAPE']
+            );
+        });
+    });
+
+    testUtils.testWithClient('client.json.get', async client => {
+        assert.equal(
+            await client.json.get('key'),
+            null
+        );
+    }, GLOBAL.SERVERS.OPEN);
+});

packages/json/lib/commands/GET.ts

@@ -0,0 +1,41 @@
+import { pushVerdictArguments } from '@node-redis/client/dist/lib/commands/generic-transformers';
+
+export const FIRST_KEY_INDEX = 1;
+
+export const IS_READ_ONLY = true;
+
+interface GetOptions {
+    path?: string | Array<string>;
+    INDENT?: string;
+    NEWLINE?: string;
+    SPACE?: string;
+    NOESCAPE?: true;
+}
+
+export function transformArguments(key: string, options?: GetOptions): Array<string> {
+    const args = ['JSON.GET', key];
+
+    if (options?.path) {
+        pushVerdictArguments(args, options.path);
+    }
+
+    if (options?.INDENT) {
+        args.push('INDENT', options.INDENT);
+    }
+
+    if (options?.NEWLINE) {
+        args.push('NEWLINE', options.NEWLINE);
+    }
+
+    if (options?.SPACE) {
+        args.push('SPACE', options.SPACE);
+    }
+
+    if (options?.NOESCAPE) {
+        args.push('NOESCAPE');
+    }
+
+    return args;
+}
+
+export { transformRedisJsonNullReply as transformReply } from '.';

packages/json/lib/commands/MGET.spec.ts

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

packages/json/lib/commands/MGET.ts

@@ -0,0 +1,15 @@
+import { RedisJSON, transformRedisJsonNullReply } from '.';
+
+export const FIRST_KEY_INDEX = 1;
+
+export function transformArguments(keys: Array<string>, path: string): Array<string> {
+    return [
+        'JSON.MGET',
+        ...keys,
+        path
+    ];
+}
+
+export function transformReply(reply: Array<string | null>): Array<RedisJSON | null> {
+    return reply.map(transformRedisJsonNullReply);
+}

packages/json/lib/commands/NUMINCRBY.spec.ts

@@ -0,0 +1,21 @@
+import { strict as assert } from 'assert';
+import testUtils, { GLOBAL } from '../test-utils';
+import { transformArguments } from './NUMINCRBY';
+
+describe('NUMINCRBY', () => {
+    it('transformArguments', () => {
+        assert.deepEqual(
+            transformArguments('key', '$', 1),
+            ['JSON.NUMINCRBY', 'key', '$', '1']
+        );
+    });
+
+    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);
+});

packages/json/lib/commands/NUMINCRBY.ts

@@ -0,0 +1,7 @@
+export const FIRST_KEY_INDEX = 1;
+
+export function transformArguments(key: string, path: string, by: number): Array<string> {
+    return ['JSON.NUMINCRBY', key, path, by.toString()];
+}
+
+export { transformNumbersReply as transformReply } from '.';

packages/json/lib/commands/NUMMULTBY.spec.ts

@@ -0,0 +1,21 @@
+import { strict as assert } from 'assert';
+import testUtils, { GLOBAL } from '../test-utils';
+import { transformArguments } from './NUMMULTBY';
+
+describe('NUMMULTBY', () => {
+    it('transformArguments', () => {
+        assert.deepEqual(
+            transformArguments('key', '$', 2),
+            ['JSON.NUMMULTBY', 'key', '$', '2']
+        );
+    });
+
+    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);
+});

packages/json/lib/commands/NUMMULTBY.ts

@@ -0,0 +1,7 @@
+export const FIRST_KEY_INDEX = 1;
+
+export function transformArguments(key: string, path: string, by: number): Array<string> {
+    return ['JSON.NUMMULTBY', key, path, by.toString()];
+}
+
+export { transformNumbersReply as transformReply } from '.';

packages/json/lib/commands/OBJKEYS.spec.ts

@@ -0,0 +1,28 @@
+import { strict as assert } from 'assert';
+import testUtils, { GLOBAL } from '../test-utils';
+import { transformArguments } 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', '$']
+            );
+        });
+    });
+
+    // testUtils.testWithClient('client.json.objKeys', async client => {
+    //     assert.deepEqual(
+    //         await client.json.objKeys('key', '$'),
+    //         [null]
+    //     );
+    // }, GLOBAL.SERVERS.OPEN);
+});

packages/json/lib/commands/OBJKEYS.ts

@@ -0,0 +1,13 @@
+export const FIRST_KEY_INDEX = 1;
+
+export function transformArguments(key: string, path?: string): Array<string> {
+    const args = ['JSON.OBJKEYS', key];
+
+    if (path) {
+        args.push(path);
+    }
+
+    return args;
+}
+
+export declare function transformReply(): Array<string> | null | Array<Array<string> | null>;

packages/json/lib/commands/OBJLEN.spec.ts

@@ -0,0 +1,28 @@
+import { strict as assert } from 'assert';
+import testUtils, { GLOBAL } from '../test-utils';
+import { transformArguments } 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', '$']
+            );
+        });
+    });
+
+    // testUtils.testWithClient('client.json.objLen', async client => {
+    //     assert.equal(
+    //         await client.json.objLen('key', '$'),
+    //         [null]
+    //     );
+    // }, GLOBAL.SERVERS.OPEN);
+});

packages/json/lib/commands/OBJLEN.ts

@@ -0,0 +1,13 @@
+export const FIRST_KEY_INDEX = 1;
+
+export function transformArguments(key: string, path?: string): Array<string> {
+    const args = ['JSON.OBJLEN', key];
+
+    if (path) {
+        args.push(path);
+    }
+
+    return args;
+}
+
+export declare function transformReply(): number | null | Array<number | null>;

packages/json/lib/commands/RESP.spec.ts

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

packages/json/lib/commands/RESP.ts

@@ -0,0 +1,15 @@
+export const FIRST_KEY_INDEX = 1;
+
+export function transformArguments(key: string, path?: string): Array<string> {
+    const args = ['JSON.RESP', key];
+
+    if (path) {
+        args.push(path);
+    }
+
+    return args;
+}
+
+type RESPReply = Array<string | number | RESPReply>;
+
+export declare function transfromReply(): RESPReply;

packages/json/lib/commands/SET.spec.ts

@@ -0,0 +1,35 @@
+import { strict as assert } from 'assert';
+import testUtils, { GLOBAL } from '../test-utils';
+import { transformArguments } 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']
+            );
+        });
+    });
+
+    testUtils.testWithClient('client.json.mGet', async client => {
+        assert.equal(
+            await client.json.set('key', '$', 'json'),
+            'OK'
+        );
+    }, GLOBAL.SERVERS.OPEN);
+});

packages/json/lib/commands/SET.ts

@@ -0,0 +1,25 @@
+import { RedisJSON, transformRedisJsonArgument } from '.';
+
+export const FIRST_KEY_INDEX = 1;
+
+interface NX {
+    NX: true;
+}
+
+interface XX {
+    XX: true;
+}
+
+export function transformArguments(key: string, path: string, json: RedisJSON, options?: NX | XX): Array<string> {
+    const args = ['JSON.SET', key, path, transformRedisJsonArgument(json)];
+
+    if ((<NX>options)?.NX) {
+        args.push('NX');
+    } else if ((<XX>options)?.XX) {
+        args.push('XX');
+    }
+
+    return args;
+}
+
+export declare function transformReply(): 'OK' | null;

packages/json/lib/commands/STRAPPEND.spec.ts

@@ -0,0 +1,30 @@
+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"']
+            );
+        });
+
+        it('with path', () => {
+            assert.deepEqual(
+                transformArguments('key', '$', 'append'),
+                ['JSON.STRAPPEND', 'key', '$', '"append"']
+            );
+        });
+    });
+
+    testUtils.testWithClient('client.json.strAppend', async client => {
+        await client.json.set('key', '$', '');
+
+        assert.deepEqual(
+            await client.json.strAppend('key', '$', 'append'),
+            [6]
+        );
+    }, GLOBAL.SERVERS.OPEN);
+});

packages/json/lib/commands/STRAPPEND.ts

@@ -0,0 +1,21 @@
+import { transformRedisJsonArgument } from '.';
+
+export const FIRST_KEY_INDEX = 1;
+
+type AppendArguments = [key: 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];
+
+    if (append !== undefined && append !== null) {
+        args.push(pathOrAppend, transformRedisJsonArgument(append));
+    } else {
+        args.push(transformRedisJsonArgument(pathOrAppend));
+    }
+
+    return args;
+}
+
+export declare function transformReply(): number | Array<number>;

packages/json/lib/commands/STRLEN.spec.ts

@@ -0,0 +1,30 @@
+import { strict as assert } from 'assert';
+import testUtils, { GLOBAL } from '../test-utils';
+import { transformArguments } 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', '$']
+            );
+        });
+    });
+
+    testUtils.testWithClient('client.json.strLen', async client => {
+        await client.json.set('key', '$', '');
+
+        assert.deepEqual(
+            await client.json.strLen('key', '$'),
+            [0]
+        );
+    }, GLOBAL.SERVERS.OPEN);
+});

packages/json/lib/commands/STRLEN.ts

@@ -0,0 +1,15 @@
+export const FIRST_KEY_INDEX = 1;
+
+export const IS_READ_ONLY = true;
+
+export function transformArguments(key: string, path?: string): Array<string> {
+    const args = ['JSON.STRLEN', key];
+
+    if (path) {
+        args.push(path);
+    }
+
+    return args;
+}
+
+export declare function transformReply(): number;

packages/json/lib/commands/TYPE.spec.ts

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

packages/json/lib/commands/TYPE.ts

@@ -0,0 +1,13 @@
+export const FIRST_KEY_INDEX = 1;
+
+export function transformArguments(key: string, path?: string): Array<string> {
+    const args = ['JSON.TYPE', key];
+
+    if (path) {
+        args.push(path);
+    }
+
+    return args;
+}
+
+export declare function transformReply(): string | null | Array<string | null>;

packages/json/lib/commands/index.ts

@@ -0,0 +1,94 @@
+import * as ARRAPPEND from './ARRAPPEND';
+import * as ARRINDEX from './ARRINDEX';
+import * as ARRINSERT from './ARRINSERT';
+import * as ARRLEN from './ARRLEN';
+import * as ARRPOP from './ARRPOP';
+import * as ARRTRIM from './ARRTRIM';
+import * as DEBUG_MEMORY from './DEBUG_MEMORY';
+import * as DEL from './DEL';
+import * as FORGET from './FORGET';
+import * as GET from './GET';
+import * as MGET from './MGET';
+import * as NUMINCRBY from './NUMINCRBY';
+import * as NUMMULTBY from './NUMMULTBY';
+import * as OBJKEYS from './OBJKEYS';
+import * as OBJLEN from './OBJLEN';
+import * as RESP from './RESP';
+import * as SET from './SET';
+import * as STRAPPEND from './STRAPPEND';
+import * as STRLEN from './STRLEN';
+import * as TYPE from './TYPE';
+
+export default {
+    ARRAPPEND,
+    arrAppend: ARRAPPEND,
+    ARRINDEX,
+    arrIndex: ARRINDEX,
+    ARRINSERT,
+    arrInsert: ARRINSERT,
+    ARRLEN,
+    arrLen: ARRLEN,
+    ARRPOP,
+    arrPop: ARRPOP,
+    ARRTRIM,
+    arrTrim: ARRTRIM,
+    DEBUG_MEMORY,
+    debugMemory: DEBUG_MEMORY,
+    DEL,
+    del: DEL,
+    FORGET,
+    forget: FORGET,
+    GET,
+    get: GET,
+    MGET,
+    mGet: MGET,
+    NUMINCRBY,
+    numIncrBy: NUMINCRBY,
+    NUMMULTBY,
+    numMultBy: NUMMULTBY,
+    OBJKEYS,
+    objKeys: OBJKEYS,
+    OBJLEN,
+    objLen: OBJLEN,
+    RESP,
+    resp: RESP,
+    SET,
+    set: SET,
+    STRAPPEND,
+    strAppend: STRAPPEND,
+    STRLEN,
+    strLen: STRLEN,
+    TYPE,
+    type: TYPE
+};
+
+// using two "objects" and not `Record<string | number, RedisJSON>` cause of:
+// https://github.com/microsoft/TypeScript/issues/14174
+export type RedisJSON = null | boolean | number | string | Date | Array<RedisJSON> | { [key: string]: RedisJSON } | { [key: number]: RedisJSON };
+
+export function transformRedisJsonArgument(json: RedisJSON): string {
+    return JSON.stringify(json);
+}
+
+export function transformRedisJsonReply(json: string): RedisJSON {
+    return JSON.parse(json);
+}
+
+export function transformRedisJsonArrayReply(jsons: Array<string>): Array<RedisJSON> {
+    return jsons.map(transformRedisJsonReply)
+}
+
+export function transformRedisJsonNullReply(json: string | null): RedisJSON | null {
+    if (json === null) return null;
+
+    return transformRedisJsonReply(json);
+}
+
+
+export function transformRedisJsonNullArrayReply(jsons: Array<string | null>): Array<RedisJSON | null> {
+    return jsons.map(transformRedisJsonNullReply);
+}
+
+export function transformNumbersReply(reply: string): number | Array<number> {
+    return JSON.parse(reply);
+}