Support all GEORADIUS Commands (#2017)

* Support all GEORADIUS Commands

* move store bool to options

* simplify transformReply for store commands

* clean code

Co-authored-by: leibale <[email protected]>

Author: Avital-Fine

packages/client/lib/cluster/commands.ts

@@ -32,6 +32,16 @@ import * as GEOADD from '../commands/GEOADD';
 import * as GEODIST from '../commands/GEODIST';
 import * as GEOHASH from '../commands/GEOHASH';
 import * as GEOPOS from '../commands/GEOPOS';
+import * as GEORADIUS_RO_WITH from '../commands/GEORADIUS_RO_WITH';
+import * as GEORADIUS_RO from '../commands/GEORADIUS_RO';
+import * as GEORADIUS_WITH from '../commands/GEORADIUS_WITH';
+import * as GEORADIUS from '../commands/GEORADIUS';
+import * as GEORADIUSBYMEMBER_RO_WITH from '../commands/GEORADIUSBYMEMBER_RO_WITH';
+import * as GEORADIUSBYMEMBER_RO from '../commands/GEORADIUSBYMEMBER_RO';
+import * as GEORADIUSBYMEMBER_WITH from '../commands/GEORADIUSBYMEMBER_WITH';
+import * as GEORADIUSBYMEMBER from '../commands/GEORADIUSBYMEMBER';
+import * as GEORADIUSBYMEMBERSTORE from '../commands/GEORADIUSBYMEMBERSTORE';
+import * as GEORADIUSSTORE from '../commands/GEORADIUSSTORE';
 import * as GEOSEARCH_WITH from '../commands/GEOSEARCH_WITH';
 import * as GEOSEARCH from '../commands/GEOSEARCH';
 import * as GEOSEARCHSTORE from '../commands/GEOSEARCHSTORE';
@@ -263,6 +273,26 @@ export default {
     geoHash: GEOHASH,
     GEOPOS,
     geoPos: GEOPOS,
+    GEORADIUS_RO_WITH,
+    geoRadiusRoWith: GEORADIUS_RO_WITH,
+    GEORADIUS_RO,
+    geoRadiusRo: GEORADIUS_RO,
+    GEORADIUS_WITH,
+    geoRadiusWith: GEORADIUS_WITH,
+    GEORADIUS,
+    geoRadius: GEORADIUS,
+    GEORADIUSBYMEMBER_RO_WITH,
+    geoRadiusByMemberRoWith: GEORADIUSBYMEMBER_RO_WITH,
+    GEORADIUSBYMEMBER_RO,
+    geoRadiusByMemberRo: GEORADIUSBYMEMBER_RO,
+    GEORADIUSBYMEMBER_WITH,
+    geoRadiusByMemberWith: GEORADIUSBYMEMBER_WITH,
+    GEORADIUSBYMEMBER,
+    geoRadiusByMember: GEORADIUSBYMEMBER,
+    GEORADIUSBYMEMBERSTORE,
+    geoRadiusByMemberStore: GEORADIUSBYMEMBERSTORE,
+    GEORADIUSSTORE,
+    geoRadiusStore: GEORADIUSSTORE,
     GEOSEARCH_WITH,
     geoSearchWith: GEOSEARCH_WITH,
     GEOSEARCH,

packages/client/lib/commands/GEORADIUS.spec.ts

@@ -0,0 +1,35 @@
+import { strict as assert } from 'assert';
+import testUtils, { GLOBAL } from '../test-utils';
+import { transformArguments } from './GEORADIUS';
+
+describe('GEORADIUS', () => {
+    it('transformArguments', () => {
+        assert.deepEqual(
+            transformArguments('key', {
+                longitude: 1,
+                latitude: 2
+            }, 3 , 'm'),
+            ['GEORADIUS', 'key', '1', '2', '3', 'm']
+        );
+    });
+
+    testUtils.testWithClient('client.geoRadius', async client => {
+        assert.deepEqual(
+            await client.geoRadius('key', {
+                longitude: 1,
+                latitude: 2
+            }, 3 , 'm'),
+            []
+        );
+    }, GLOBAL.SERVERS.OPEN);
+
+    testUtils.testWithCluster('cluster.geoRadius', async cluster => {
+        assert.deepEqual(
+            await cluster.geoRadius('key', {
+                longitude: 1,
+                latitude: 2
+            }, 3 , 'm'),
+            []
+        );
+    }, GLOBAL.CLUSTERS.OPEN);
+});

packages/client/lib/commands/GEORADIUS.ts

@@ -0,0 +1,25 @@
+import { RedisCommandArgument, RedisCommandArguments } from '.';
+import { GeoSearchOptions, GeoCoordinates, pushGeoRadiusArguments, GeoUnits } from './generic-transformers';
+
+export const FIRST_KEY_INDEX = 1;
+
+export const IS_READ_ONLY = true;
+
+export function transformArguments(
+    key: RedisCommandArgument,
+    coordinates: GeoCoordinates,
+    radius: number,
+    unit: GeoUnits,
+    options?: GeoSearchOptions
+): RedisCommandArguments {
+    return pushGeoRadiusArguments(
+        ['GEORADIUS'],
+        key,
+        coordinates,
+        radius,
+        unit,
+        options
+    );
+}
+
+export declare function transformReply(): Array<RedisCommandArgument>;

packages/client/lib/commands/GEORADIUSBYMEMBER.spec.ts

@@ -0,0 +1,26 @@
+import { strict as assert } from 'assert';
+import testUtils, { GLOBAL } from '../test-utils';
+import { transformArguments } from './GEORADIUSBYMEMBER';
+
+describe('GEORADIUSBYMEMBER', () => {
+    it('transformArguments', () => {
+        assert.deepEqual(
+            transformArguments('key', 'member', 3 , 'm'),
+            ['GEORADIUSBYMEMBER', 'key', 'member', '3', 'm']
+        );
+    });
+
+    testUtils.testWithClient('client.geoRadiusByMember', async client => {
+        assert.deepEqual(
+            await client.geoRadiusByMember('key',  'member', 3 , 'm'),
+            []
+        );
+    }, GLOBAL.SERVERS.OPEN);
+
+    testUtils.testWithCluster('cluster.geoRadiusByMember', async cluster => {
+        assert.deepEqual(
+            await cluster.geoRadiusByMember('key', 'member', 3 , 'm'),
+            []
+        );
+    }, GLOBAL.CLUSTERS.OPEN);
+});

packages/client/lib/commands/GEORADIUSBYMEMBER.ts

@@ -0,0 +1,25 @@
+import { RedisCommandArgument, RedisCommandArguments } from '.';
+import { GeoSearchOptions, pushGeoRadiusArguments, GeoUnits } from './generic-transformers';
+
+export const FIRST_KEY_INDEX = 1;
+
+export const IS_READ_ONLY = true;
+
+export function transformArguments(
+    key: RedisCommandArgument,
+    member: string,
+    radius: number,
+    unit: GeoUnits,
+    options?: GeoSearchOptions
+): RedisCommandArguments {
+    return pushGeoRadiusArguments(
+        ['GEORADIUSBYMEMBER'],
+        key,
+        member,
+        radius,
+        unit,
+        options
+    );
+}
+
+export declare function transformReply(): Array<RedisCommandArgument>;

packages/client/lib/commands/GEORADIUSBYMEMBERSTORE.spec.ts

@@ -0,0 +1,53 @@
+import { strict as assert } from 'assert';
+import testUtils, { GLOBAL } from '../test-utils';
+import { transformArguments, transformReply } from './GEORADIUSBYMEMBERSTORE';
+
+describe('GEORADIUSBYMEMBERSTORE', () => {
+    describe('transformArguments', () => {
+        it('STORE', () => {
+            assert.deepEqual(
+                transformArguments('key', 'member', 3 , 'm', 'dest', {
+                    SORT: 'ASC',
+                    COUNT: {
+                        value: 1,
+                        ANY: true
+                    }
+                }),
+                ['GEORADIUSBYMEMBER', 'key', 'member', '3', 'm', 'ASC', 'COUNT', '1', 'ANY', 'STORE', 'dest']
+            );
+        });
+
+        it('STOREDIST', () => {
+            assert.deepEqual(
+                transformArguments('key', 'member', 3 , 'm', 'dest', { STOREDIST: true }),
+                ['GEORADIUSBYMEMBER', 'key', 'member', '3', 'm', 'STOREDIST', 'dest']
+            );
+        });
+    });
+
+    testUtils.testWithClient('client.geoRadiusByMemberStore', async client => {
+        await client.geoAdd('source', {
+            longitude: 1,
+            latitude: 1,
+            member: 'member'
+        });
+
+        assert.equal(
+            await client.geoRadiusByMemberStore('source', 'member', 3 , 'm', 'dest'),
+            1
+        );
+    }, GLOBAL.SERVERS.OPEN);
+
+    testUtils.testWithCluster('cluster.geoRadiusByMemberStore', async cluster => {
+        await cluster.geoAdd('{tag}source', {
+            longitude: 1,
+            latitude: 1,
+            member: 'member'
+        });
+
+        assert.equal(
+            await cluster.geoRadiusByMemberStore('{tag}source', 'member', 3 , 'm','{tag}destination'),
+            1
+        );
+    }, GLOBAL.CLUSTERS.OPEN);
+});

packages/client/lib/commands/GEORADIUSBYMEMBERSTORE.ts

@@ -0,0 +1,25 @@
+import { RedisCommandArgument, RedisCommandArguments } from '.';
+import { GeoUnits, GeoRadiusStoreOptions, pushGeoRadiusStoreArguments } from './generic-transformers';
+
+export { FIRST_KEY_INDEX, IS_READ_ONLY } from './GEORADIUSBYMEMBER';
+
+export function transformArguments(
+    key: RedisCommandArgument,
+    member: string,
+    radius: number,
+    unit: GeoUnits,
+    destination: RedisCommandArgument,
+    options?: GeoRadiusStoreOptions,
+): RedisCommandArguments {
+    return pushGeoRadiusStoreArguments(
+        ['GEORADIUSBYMEMBER'],
+        key,
+        member,
+        radius,
+        unit,
+        destination,
+        options
+    );
+}
+
+export declare function transformReply(): number

packages/client/lib/commands/GEORADIUSBYMEMBER_RO.spec.ts

@@ -0,0 +1,26 @@
+import { strict as assert } from 'assert';
+import testUtils, { GLOBAL } from '../test-utils';
+import { transformArguments } from './GEORADIUSBYMEMBER_RO';
+
+describe('GEORADIUSBYMEMBER_RO', () => {
+    it('transformArguments', () => {
+        assert.deepEqual(
+            transformArguments('key', 'member', 3 , 'm'),
+            ['GEORADIUSBYMEMBER_RO', 'key', 'member', '3', 'm']
+        );
+    });
+
+    testUtils.testWithClient('client.geoRadiusByMemberRo', async client => {
+        assert.deepEqual(
+            await client.geoRadiusByMemberRo('key',  'member', 3 , 'm'),
+            []
+        );
+    }, GLOBAL.SERVERS.OPEN);
+
+    testUtils.testWithCluster('cluster.geoRadiusByMemberRo', async cluster => {
+        assert.deepEqual(
+            await cluster.geoRadiusByMemberRo('key', 'member', 3 , 'm'),
+            []
+        );
+    }, GLOBAL.CLUSTERS.OPEN);
+});

packages/client/lib/commands/GEORADIUSBYMEMBER_RO.ts

@@ -0,0 +1,25 @@
+import { RedisCommandArgument, RedisCommandArguments } from '.';
+import { GeoSearchOptions, pushGeoRadiusArguments, GeoUnits } from './generic-transformers';
+
+export const FIRST_KEY_INDEX = 1;
+
+export const IS_READ_ONLY = true;
+
+export function transformArguments(
+    key: RedisCommandArgument,
+    member: string,
+    radius: number,
+    unit: GeoUnits,
+    options?: GeoSearchOptions
+): RedisCommandArguments {
+    return pushGeoRadiusArguments(
+        ['GEORADIUSBYMEMBER_RO'],
+        key,
+        member,
+        radius,
+        unit,
+        options
+    );
+}
+
+export declare function transformReply(): Array<RedisCommandArgument>;

packages/client/lib/commands/GEORADIUSBYMEMBER_RO_WITH.spec.ts

@@ -0,0 +1,31 @@
+import { strict as assert } from 'assert';
+import testUtils, { GLOBAL } from '../test-utils';
+import { RedisCommandArguments } from '.';
+import { GeoReplyWith } from './generic-transformers';
+import { transformArguments } from './GEORADIUSBYMEMBER_RO_WITH';
+
+describe('GEORADIUSBYMEMBER_RO WITH', () => {
+    it('transformArguments', () => {
+        const expectedReply: RedisCommandArguments = ['GEORADIUSBYMEMBER_RO', 'key', 'member', '3', 'm', 'WITHDIST'];
+        expectedReply.preserve = ['WITHDIST'];
+
+        assert.deepEqual(
+            transformArguments('key', 'member', 3 , 'm', [GeoReplyWith.DISTANCE]),
+            expectedReply
+        );
+    });
+
+    testUtils.testWithClient('client.geoRadiusByMemberRoWith', async client => {
+        assert.deepEqual(
+            await client.geoRadiusByMemberRoWith('key', 'member', 3 , 'm', [GeoReplyWith.DISTANCE]),
+            []
+        );
+    }, GLOBAL.SERVERS.OPEN);
+
+    testUtils.testWithCluster('cluster.geoRadiusByMemberRoWith', async cluster => {
+        assert.deepEqual(
+            await cluster.geoRadiusByMemberRoWith('key', 'member', 3 , 'm', [GeoReplyWith.DISTANCE]),
+            []
+        );
+    }, GLOBAL.CLUSTERS.OPEN);
+});