diff --git a/packages/client/lib/cluster/commands.ts b/packages/client/lib/cluster/commands.ts index 48ca4b2987..dcce3629a1 100644 --- a/packages/client/lib/cluster/commands.ts +++ b/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, diff --git a/packages/client/lib/commands/GEORADIUS.spec.ts b/packages/client/lib/commands/GEORADIUS.spec.ts new file mode 100644 index 0000000000..786b266502 --- /dev/null +++ b/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); +}); diff --git a/packages/client/lib/commands/GEORADIUS.ts b/packages/client/lib/commands/GEORADIUS.ts new file mode 100644 index 0000000000..f47cf50884 --- /dev/null +++ b/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; diff --git a/packages/client/lib/commands/GEORADIUSBYMEMBER.spec.ts b/packages/client/lib/commands/GEORADIUSBYMEMBER.spec.ts new file mode 100644 index 0000000000..8cc4212c83 --- /dev/null +++ b/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); +}); diff --git a/packages/client/lib/commands/GEORADIUSBYMEMBER.ts b/packages/client/lib/commands/GEORADIUSBYMEMBER.ts new file mode 100644 index 0000000000..96bb622fb8 --- /dev/null +++ b/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; diff --git a/packages/client/lib/commands/GEORADIUSBYMEMBERSTORE.spec.ts b/packages/client/lib/commands/GEORADIUSBYMEMBERSTORE.spec.ts new file mode 100644 index 0000000000..100ecc0336 --- /dev/null +++ b/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); +}); diff --git a/packages/client/lib/commands/GEORADIUSBYMEMBERSTORE.ts b/packages/client/lib/commands/GEORADIUSBYMEMBERSTORE.ts new file mode 100644 index 0000000000..28f3c25fac --- /dev/null +++ b/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 diff --git a/packages/client/lib/commands/GEORADIUSBYMEMBER_RO.spec.ts b/packages/client/lib/commands/GEORADIUSBYMEMBER_RO.spec.ts new file mode 100644 index 0000000000..f3a47856e8 --- /dev/null +++ b/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); +}); diff --git a/packages/client/lib/commands/GEORADIUSBYMEMBER_RO.ts b/packages/client/lib/commands/GEORADIUSBYMEMBER_RO.ts new file mode 100644 index 0000000000..63f29ae65b --- /dev/null +++ b/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; diff --git a/packages/client/lib/commands/GEORADIUSBYMEMBER_RO_WITH.spec.ts b/packages/client/lib/commands/GEORADIUSBYMEMBER_RO_WITH.spec.ts new file mode 100644 index 0000000000..7904a76399 --- /dev/null +++ b/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); +}); diff --git a/packages/client/lib/commands/GEORADIUSBYMEMBER_RO_WITH.ts b/packages/client/lib/commands/GEORADIUSBYMEMBER_RO_WITH.ts new file mode 100644 index 0000000000..6061be734b --- /dev/null +++ b/packages/client/lib/commands/GEORADIUSBYMEMBER_RO_WITH.ts @@ -0,0 +1,30 @@ +import { RedisCommandArgument, RedisCommandArguments } from '.'; +import { GeoReplyWith, GeoSearchOptions, GeoUnits } from './generic-transformers'; +import { transformArguments as geoRadiusTransformArguments } from './GEORADIUSBYMEMBER_RO'; + +export { FIRST_KEY_INDEX, IS_READ_ONLY } from './GEORADIUSBYMEMBER_RO'; + +export function transformArguments( + key: RedisCommandArgument, + member: string, + radius: number, + unit: GeoUnits, + replyWith: Array, + options?: GeoSearchOptions +): RedisCommandArguments { + const args: RedisCommandArguments = geoRadiusTransformArguments( + key, + member, + radius, + unit, + options + ); + + args.push(...replyWith); + + args.preserve = replyWith; + + return args; +} + +export { transformGeoMembersWithReply as transformReply } from './generic-transformers'; diff --git a/packages/client/lib/commands/GEORADIUSBYMEMBER_WITH.spec.ts b/packages/client/lib/commands/GEORADIUSBYMEMBER_WITH.spec.ts new file mode 100644 index 0000000000..24bffd9e89 --- /dev/null +++ b/packages/client/lib/commands/GEORADIUSBYMEMBER_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_WITH'; + +describe('GEORADIUSBYMEMBER WITH', () => { + it('transformArguments', () => { + const expectedReply: RedisCommandArguments = ['GEORADIUSBYMEMBER', 'key', 'member', '3', 'm', 'WITHDIST']; + expectedReply.preserve = ['WITHDIST']; + + assert.deepEqual( + transformArguments('key', 'member', 3 , 'm', [GeoReplyWith.DISTANCE]), + expectedReply + ); + }); + + testUtils.testWithClient('client.geoRadiusByMemberWith', async client => { + assert.deepEqual( + await client.geoRadiusByMemberWith('key', 'member', 3 , 'm', [GeoReplyWith.DISTANCE]), + [] + ); + }, GLOBAL.SERVERS.OPEN); + + testUtils.testWithCluster('cluster.geoRadiusByMemberWith', async cluster => { + assert.deepEqual( + await cluster.geoRadiusByMemberWith('key', 'member', 3 , 'm', [GeoReplyWith.DISTANCE]), + [] + ); + }, GLOBAL.CLUSTERS.OPEN); +}); diff --git a/packages/client/lib/commands/GEORADIUSBYMEMBER_WITH.ts b/packages/client/lib/commands/GEORADIUSBYMEMBER_WITH.ts new file mode 100644 index 0000000000..7d7dbe06a5 --- /dev/null +++ b/packages/client/lib/commands/GEORADIUSBYMEMBER_WITH.ts @@ -0,0 +1,30 @@ +import { RedisCommandArgument, RedisCommandArguments } from '.'; +import { GeoReplyWith, GeoSearchOptions, GeoUnits } from './generic-transformers'; +import { transformArguments as transformGeoRadiusArguments } from './GEORADIUSBYMEMBER'; + +export { FIRST_KEY_INDEX, IS_READ_ONLY } from './GEORADIUSBYMEMBER'; + +export function transformArguments( + key: RedisCommandArgument, + member: string, + radius: number, + unit: GeoUnits, + replyWith: Array, + options?: GeoSearchOptions +): RedisCommandArguments { + const args: RedisCommandArguments = transformGeoRadiusArguments( + key, + member, + radius, + unit, + options + ); + + args.push(...replyWith); + + args.preserve = replyWith; + + return args; +} + +export { transformGeoMembersWithReply as transformReply } from './generic-transformers'; diff --git a/packages/client/lib/commands/GEORADIUSSTORE.spec.ts b/packages/client/lib/commands/GEORADIUSSTORE.spec.ts new file mode 100644 index 0000000000..4c6372732e --- /dev/null +++ b/packages/client/lib/commands/GEORADIUSSTORE.spec.ts @@ -0,0 +1,53 @@ +import { strict as assert } from 'assert'; +import testUtils, { GLOBAL } from '../test-utils'; +import { transformArguments, transformReply } from './GEORADIUSSTORE'; + +describe('GEORADIUSSTORE', () => { + describe('transformArguments', () => { + it('STORE', () => { + assert.deepEqual( + transformArguments('key', {longitude: 1, latitude: 2}, 3 , 'm', 'dest', { + SORT: 'ASC', + COUNT: { + value: 1, + ANY: true + } + }), + ['GEORADIUS', 'key', '1', '2', '3', 'm', 'ASC', 'COUNT', '1', 'ANY', 'STORE', 'dest'] + ); + }); + + it('STOREDIST', () => { + assert.deepEqual( + transformArguments('key', {longitude: 1, latitude: 2}, 3 , 'm', 'dest', { STOREDIST: true }), + ['GEORADIUS', 'key', '1', '2', '3', 'm', 'STOREDIST', 'dest'] + ); + }); + }); + + testUtils.testWithClient('client.geoRadiusStore', async client => { + await client.geoAdd('source', { + longitude: 1, + latitude: 1, + member: 'member' + }); + + assert.equal( + await client.geoRadiusStore('source', {longitude: 1, latitude: 1}, 3 , 'm', 'dest'), + 1 + ); + }, GLOBAL.SERVERS.OPEN); + + testUtils.testWithCluster('cluster.geoRadiusStore', async cluster => { + await cluster.geoAdd('{tag}source', { + longitude: 1, + latitude: 1, + member: 'member' + }); + + assert.equal( + await cluster.geoRadiusStore('{tag}source', {longitude: 1, latitude: 1}, 3 , 'm', '{tag}destination'), + 1 + ); + }, GLOBAL.CLUSTERS.OPEN); +}); diff --git a/packages/client/lib/commands/GEORADIUSSTORE.ts b/packages/client/lib/commands/GEORADIUSSTORE.ts new file mode 100644 index 0000000000..ad2317aa3a --- /dev/null +++ b/packages/client/lib/commands/GEORADIUSSTORE.ts @@ -0,0 +1,25 @@ +import { RedisCommandArgument, RedisCommandArguments } from '.'; +import { GeoCoordinates, GeoUnits, GeoRadiusStoreOptions, pushGeoRadiusStoreArguments } from './generic-transformers'; + +export { FIRST_KEY_INDEX, IS_READ_ONLY } from './GEORADIUS'; + +export function transformArguments( + key: RedisCommandArgument, + coordinates: GeoCoordinates, + radius: number, + unit: GeoUnits, + destination: RedisCommandArgument, + options?: GeoRadiusStoreOptions, +): RedisCommandArguments { + return pushGeoRadiusStoreArguments( + ['GEORADIUS'], + key, + coordinates, + radius, + unit, + destination, + options + ); +} + +export declare function transformReply(): number; diff --git a/packages/client/lib/commands/GEORADIUS_RO.spec.ts b/packages/client/lib/commands/GEORADIUS_RO.spec.ts new file mode 100644 index 0000000000..b3cdca18d3 --- /dev/null +++ b/packages/client/lib/commands/GEORADIUS_RO.spec.ts @@ -0,0 +1,35 @@ +import { strict as assert } from 'assert'; +import testUtils, { GLOBAL } from '../test-utils'; +import { transformArguments } from './GEORADIUS_RO'; + +describe('GEORADIUS_RO', () => { + it('transformArguments', () => { + assert.deepEqual( + transformArguments('key', { + longitude: 1, + latitude: 2 + }, 3 , 'm'), + ['GEORADIUS_RO', 'key', '1', '2', '3', 'm'] + ); + }); + + testUtils.testWithClient('client.geoRadiusRo', async client => { + assert.deepEqual( + await client.geoRadiusRo('key', { + longitude: 1, + latitude: 2 + }, 3 , 'm'), + [] + ); + }, GLOBAL.SERVERS.OPEN); + + testUtils.testWithCluster('cluster.geoRadiusRo', async cluster => { + assert.deepEqual( + await cluster.geoRadiusRo('key', { + longitude: 1, + latitude: 2 + }, 3 , 'm'), + [] + ); + }, GLOBAL.CLUSTERS.OPEN); +}); diff --git a/packages/client/lib/commands/GEORADIUS_RO.ts b/packages/client/lib/commands/GEORADIUS_RO.ts new file mode 100644 index 0000000000..ac378a5150 --- /dev/null +++ b/packages/client/lib/commands/GEORADIUS_RO.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_RO'], + key, + coordinates, + radius, + unit, + options + ); +} + +export declare function transformReply(): Array; diff --git a/packages/client/lib/commands/GEORADIUS_RO_WITH.spec.ts b/packages/client/lib/commands/GEORADIUS_RO_WITH.spec.ts new file mode 100644 index 0000000000..21b00ff90b --- /dev/null +++ b/packages/client/lib/commands/GEORADIUS_RO_WITH.spec.ts @@ -0,0 +1,40 @@ +import { strict as assert } from 'assert'; +import testUtils, { GLOBAL } from '../test-utils'; +import { RedisCommandArguments } from '.'; +import { GeoReplyWith } from './generic-transformers'; +import { transformArguments } from './GEORADIUS_RO_WITH'; + +describe('GEORADIUS_RO WITH', () => { + it('transformArguments', () => { + const expectedReply: RedisCommandArguments = ['GEORADIUS_RO', 'key', '1', '2', '3', 'm', 'WITHDIST']; + expectedReply.preserve = ['WITHDIST']; + + assert.deepEqual( + transformArguments('key', { + longitude: 1, + latitude: 2 + }, 3 , 'm', [GeoReplyWith.DISTANCE]), + expectedReply + ); + }); + + testUtils.testWithClient('client.geoRadiusRoWith', async client => { + assert.deepEqual( + await client.geoRadiusRoWith('key', { + longitude: 1, + latitude: 2 + }, 3 , 'm', [GeoReplyWith.DISTANCE]), + [] + ); + }, GLOBAL.SERVERS.OPEN); + + testUtils.testWithCluster('cluster.geoRadiusReadOnlyWith', async cluster => { + assert.deepEqual( + await cluster.geoRadiusRoWith('key', { + longitude: 1, + latitude: 2 + }, 3 , 'm', [GeoReplyWith.DISTANCE]), + [] + ); + }, GLOBAL.CLUSTERS.OPEN); +}); diff --git a/packages/client/lib/commands/GEORADIUS_RO_WITH.ts b/packages/client/lib/commands/GEORADIUS_RO_WITH.ts new file mode 100644 index 0000000000..424e5fcd99 --- /dev/null +++ b/packages/client/lib/commands/GEORADIUS_RO_WITH.ts @@ -0,0 +1,30 @@ +import { RedisCommandArgument, RedisCommandArguments } from '.'; +import { GeoReplyWith, GeoSearchOptions, GeoCoordinates, GeoUnits } from './generic-transformers'; +import { transformArguments as transformGeoRadiusRoArguments } from './GEORADIUS_RO'; + +export { FIRST_KEY_INDEX, IS_READ_ONLY } from './GEORADIUS_RO'; + +export function transformArguments( + key: RedisCommandArgument, + coordinates: GeoCoordinates, + radius: number, + unit: GeoUnits, + replyWith: Array, + options?: GeoSearchOptions +): RedisCommandArguments { + const args: RedisCommandArguments = transformGeoRadiusRoArguments( + key, + coordinates, + radius, + unit, + options + ); + + args.push(...replyWith); + + args.preserve = replyWith; + + return args; +} + +export { transformGeoMembersWithReply as transformReply } from './generic-transformers'; diff --git a/packages/client/lib/commands/GEORADIUS_WITH.spec.ts b/packages/client/lib/commands/GEORADIUS_WITH.spec.ts new file mode 100644 index 0000000000..44366198be --- /dev/null +++ b/packages/client/lib/commands/GEORADIUS_WITH.spec.ts @@ -0,0 +1,40 @@ +import { strict as assert } from 'assert'; +import testUtils, { GLOBAL } from '../test-utils'; +import { RedisCommandArguments } from '.'; +import { GeoReplyWith } from './generic-transformers'; +import { transformArguments } from './GEORADIUS_WITH'; + +describe('GEORADIUS WITH', () => { + it('transformArguments', () => { + const expectedReply: RedisCommandArguments = ['GEORADIUS', 'key', '1', '2', '3', 'm', 'WITHDIST']; + expectedReply.preserve = ['WITHDIST']; + + assert.deepEqual( + transformArguments('key', { + longitude: 1, + latitude: 2 + }, 3 , 'm', [GeoReplyWith.DISTANCE]), + expectedReply + ); + }); + + testUtils.testWithClient('client.geoRadiusWith', async client => { + assert.deepEqual( + await client.geoRadiusWith('key', { + longitude: 1, + latitude: 2 + }, 3 , 'm', [GeoReplyWith.DISTANCE]), + [] + ); + }, GLOBAL.SERVERS.OPEN); + + testUtils.testWithCluster('cluster.geoRadiusWith', async cluster => { + assert.deepEqual( + await cluster.geoRadiusWith('key', { + longitude: 1, + latitude: 2 + }, 3 , 'm', [GeoReplyWith.DISTANCE]), + [] + ); + }, GLOBAL.CLUSTERS.OPEN); +}); diff --git a/packages/client/lib/commands/GEORADIUS_WITH.ts b/packages/client/lib/commands/GEORADIUS_WITH.ts new file mode 100644 index 0000000000..dc3f4288f0 --- /dev/null +++ b/packages/client/lib/commands/GEORADIUS_WITH.ts @@ -0,0 +1,30 @@ +import { RedisCommandArgument, RedisCommandArguments } from '.'; +import { GeoReplyWith, GeoSearchOptions, GeoCoordinates, GeoUnits } from './generic-transformers'; +import { transformArguments as transformGeoRadiusArguments } from './GEORADIUS'; + +export { FIRST_KEY_INDEX, IS_READ_ONLY } from './GEORADIUS'; + +export function transformArguments( + key: RedisCommandArgument, + coordinates: GeoCoordinates, + radius: number, + unit: GeoUnits, + replyWith: Array, + options?: GeoSearchOptions +): RedisCommandArguments { + const args: RedisCommandArguments = transformGeoRadiusArguments( + key, + coordinates, + radius, + unit, + options + ); + + args.push(...replyWith); + + args.preserve = replyWith; + + return args; +} + +export { transformGeoMembersWithReply as transformReply } from './generic-transformers'; diff --git a/packages/client/lib/commands/GEOSEARCHSTORE.ts b/packages/client/lib/commands/GEOSEARCHSTORE.ts index bc06659ef0..7a91450cd9 100644 --- a/packages/client/lib/commands/GEOSEARCHSTORE.ts +++ b/packages/client/lib/commands/GEOSEARCHSTORE.ts @@ -1,9 +1,7 @@ import { RedisCommandArgument, RedisCommandArguments } from '.'; import { GeoSearchFrom, GeoSearchBy, GeoSearchOptions, pushGeoSearchArguments } from './generic-transformers'; -export const FIRST_KEY_INDEX = 1; - -export const IS_READ_ONLY = true; +export { FIRST_KEY_INDEX, IS_READ_ONLY } from './GEOSEARCH'; interface GeoSearchStoreOptions extends GeoSearchOptions { STOREDIST?: true; diff --git a/packages/client/lib/commands/generic-transformers.ts b/packages/client/lib/commands/generic-transformers.ts index 0477caffd4..697dbcfa4e 100644 --- a/packages/client/lib/commands/generic-transformers.ts +++ b/packages/client/lib/commands/generic-transformers.ts @@ -286,6 +286,63 @@ export function pushGeoSearchArguments( return args; } +export function pushGeoRadiusArguments( + args: RedisCommandArguments, + key: RedisCommandArgument, + from: GeoSearchFrom, + radius: number, + unit: GeoUnits, + options?: GeoSearchOptions +): RedisCommandArguments { + args.push(key); + + if (typeof from === 'string') { + args.push(from); + } else { + args.push( + from.longitude.toString(), + from.latitude.toString() + ); + } + + args.push( + radius.toString(), + unit + ); + + if (options?.SORT) { + args.push(options.SORT); + } + + pushGeoCountArgument(args, options?.COUNT); + + return args; +} + +export interface GeoRadiusStoreOptions extends GeoSearchOptions { + STOREDIST?: boolean; +} + +export function pushGeoRadiusStoreArguments( + args: RedisCommandArguments, + key: RedisCommandArgument, + from: GeoSearchFrom, + radius: number, + unit: GeoUnits, + destination: RedisCommandArgument, + options?: GeoRadiusStoreOptions +): RedisCommandArguments { + pushGeoRadiusArguments(args, key, from, radius, unit, options); + + if (options?.STOREDIST) { + args.push('STOREDIST', destination); + } else { + args.push('STORE', destination); + } + + return args; +} + export enum GeoReplyWith { DISTANCE = 'WITHDIST', HASH = 'WITHHASH',