feat(api): normalize reversed array ranges before issuing command (RI-8219)

ARGETRANGE and ARSCAN require start <= end. The DTOs now accept either
order so the UI doesn't have to enforce it; the service swaps the
bounds before issuing the command. assertRangeWithinCap continues to
guard the span (still symmetric in effect).

Author: pawelangelow

redisinsight/api/src/modules/browser/array/array.service.spec.ts

@@ -222,6 +222,30 @@ describe('ArrayService', () => {
       ).rejects.toThrow(BadRequestException);
     });
 
+    it('should swap reversed bounds before issuing ARGETRANGE', async () => {
+      when(mockStandaloneRedisClient.sendCommand)
+        .calledWith([
+          BrowserToolArrayCommands.ArGetRange,
+          mockGetArrayRangeDto.keyName,
+          '0',
+          '5',
+        ])
+        .mockResolvedValue(mockArrayRangeWithGaps);
+
+      await service.getRange(mockBrowserClientMetadata, {
+        ...mockGetArrayRangeDto,
+        start: '5',
+        end: '0',
+      });
+
+      expect(mockStandaloneRedisClient.sendCommand).toHaveBeenCalledWith([
+        BrowserToolArrayCommands.ArGetRange,
+        mockGetArrayRangeDto.keyName,
+        '0',
+        '5',
+      ]);
+    });
+
     it('should rethrow BadRequest on WrongType', async () => {
       const replyError: ReplyError = {
         ...mockRedisWrongTypeError,
@@ -388,6 +412,30 @@ describe('ArrayService', () => {
       ).rejects.toThrow(BadRequestException);
     });
 
+    it('should swap reversed bounds before issuing ARSCAN', async () => {
+      when(mockStandaloneRedisClient.sendCommand)
+        .calledWith([
+          BrowserToolArrayCommands.ArScan,
+          mockGetArrayScanDto.keyName,
+          '0',
+          '5',
+        ])
+        .mockResolvedValue(flatReply);
+
+      await service.scan(mockBrowserClientMetadata, {
+        ...mockGetArrayScanDto,
+        start: '5',
+        end: '0',
+      });
+
+      expect(mockStandaloneRedisClient.sendCommand).toHaveBeenCalledWith([
+        BrowserToolArrayCommands.ArScan,
+        mockGetArrayScanDto.keyName,
+        '0',
+        '5',
+      ]);
+    });
+
     it('should rethrow BadRequest on WrongType', async () => {
       const replyError: ReplyError = {
         ...mockRedisWrongTypeError,

redisinsight/api/src/modules/browser/array/array.service.ts

@@ -84,14 +84,10 @@ export class ArrayService {
   }
 
   // Inputs are validated as canonical decimal strings ≤ 2^64-1, so BigInt()
-  // is safe. Ranges are reversible (start > end).
+  // is safe. Callers receive the bounds in canonical ascending order so the
+  // Redis-facing commands always issue start ≤ end (see normalizeRange).
   private assertRangeWithinCap(start: string, end: string): void {
-    const startBig = BigInt(start);
-    const endBig = BigInt(end);
-    const span =
-      startBig > endBig
-        ? startBig - endBig + BigInt(1)
-        : endBig - startBig + BigInt(1);
+    const span = BigInt(end) - BigInt(start) + BigInt(1);
 
     if (span > BigInt(ARRAY_RANGE_MAX_ELEMENTS)) {
       throw new BadRequestException(
@@ -100,13 +96,21 @@ export class ArrayService {
     }
   }
 
+  // The DTO accepts start/end in either order so the UI doesn't have to
+  // enforce ordering; swap before forwarding because ARGETRANGE / ARSCAN
+  // require start ≤ end.
+  private normalizeRange(start: string, end: string): [string, string] {
+    return BigInt(start) > BigInt(end) ? [end, start] : [start, end];
+  }
+
   public async getRange(
     clientMetadata: ClientMetadata,
     dto: GetArrayRangeDto,
   ): Promise<GetArrayRangeResponse> {
     try {
       this.logger.debug('Getting array range.', clientMetadata);
-      const { keyName, start, end } = dto;
+      const { keyName } = dto;
+      const [start, end] = this.normalizeRange(dto.start, dto.end);
 
       this.assertRangeWithinCap(start, end);
 
@@ -180,7 +184,8 @@ export class ArrayService {
   ): Promise<GetArrayScanResponse> {
     try {
       this.logger.debug('Scanning array range.', clientMetadata);
-      const { keyName, start, end, limit } = dto;
+      const { keyName, limit } = dto;
+      const [start, end] = this.normalizeRange(dto.start, dto.end);
 
       // ARSCAN skips empty slots in the response but still walks the index
       // range server-side (O(|end-start|+1)). Apply the same span cap as

redisinsight/api/src/modules/browser/array/dto/get.array-range.dto.ts

@@ -15,7 +15,8 @@ export class GetArrayRangeDto extends KeyDto {
   @ApiProperty({
     description:
       'End index of the range (inclusive). Unsigned 64-bit integer as string. ' +
-      'If start > end, the range is returned reversed.',
+      'May be passed in either order relative to start; the service normalizes ' +
+      'the pair to ascending order before issuing the command.',
     type: String,
     example: '99',
   })

redisinsight/api/src/modules/browser/array/dto/get.array-scan.dto.ts

@@ -16,7 +16,9 @@ export class GetArrayScanDto extends KeyDto {
 
   @ApiProperty({
     description:
-      'End index of the range (inclusive). Unsigned 64-bit integer as string.',
+      'End index of the range (inclusive). Unsigned 64-bit integer as string. ' +
+      'May be passed in either order relative to start; the service normalizes ' +
+      'the pair to ascending order before issuing the command.',
     type: String,
     example: '99',
   })