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

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 '@redis/client/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);
+}