Merge remote-tracking branch 'upstream/v5' into cmd-parser-with-commands

sjpotter · sjpotter · commit 72e2673fa258 · 2024-06-19T13:33:47.000+03:00
diff --git a/docs/client-configuration.md b/docs/client-configuration.md
@@ -13,7 +13,7 @@
 | socket.keepAlive             | `true`                                   | Toggle [`keep-alive`](https://nodejs.org/api/net.html#socketsetkeepaliveenable-initialdelay) functionality                                                                                                                                          |
 | socket.keepAliveInitialDelay | `5000`                                   | If set to a positive number, it sets the initial delay before the first keepalive probe is sent on an idle socket                                                                                                                                   |
 | socket.tls                   |                                          | See explanation and examples [below](#TLS)                                                                                                                                                                                                          |
-| socket.reconnectStrategy     | `retries => Math.min(retries * 50, 500)` | A function containing the [Reconnect Strategy](#reconnect-strategy) logic                                                                                                                                                                           |
+| socket.reconnectStrategy     | Exponential backoff with a maximum of 2000 ms; plus 0-200 ms random jitter.       | A function containing the [Reconnect Strategy](#reconnect-strategy) logic                                                                                                                                                                           |
 | username                     |                                          | ACL username ([see ACL guide](https://redis.io/topics/acl))                                                                                                                                                                                         |
 | password                     |                                          | ACL password or the old "--requirepass" password                                                                                                                                                                                                    |
 | name                         |                                          | Client name ([see `CLIENT SETNAME`](https://redis.io/commands/client-setname))                                                                                                                                                                      |
@@ -35,12 +35,19 @@ When the socket closes unexpectedly (without calling `.quit()`/`.disconnect()`),
 2. `number` -> wait for `X` milliseconds before reconnecting.
 3. `(retries: number, cause: Error) => false | number | Error` -> `number` is the same as configuring a `number` directly, `Error` is the same as `false`, but with a custom error.
 
-By default the strategy is `Math.min(retries * 50, 500)`, but it can be overwritten like so:
+By default the strategy uses exponential backoff, but it can be overwritten like so:
 
 ```javascript
 createClient({
   socket: {
-    reconnectStrategy: retries => Math.min(retries * 50, 1000)
+    reconnectStrategy: retries => {
+        // Generate a random jitter between 0 – 200 ms:
+        const jitter = Math.floor(Math.random() * 200);
+        // Delay is an exponential back off, (times^2) * 50 ms, with a maximum value of 2000 ms:
+        const delay = Math.min(Math.pow(2, retries) * 50, 2000);
+
+        return delay + jitter;
+    }
   }
 });
 ```
diff --git a/packages/client/lib/client/index.ts b/packages/client/lib/client/index.ts
@@ -951,6 +951,19 @@ export default class RedisClient<
     } while (cursor !== '0');
   }
 
+  async* hScanValuesIterator(
+    this: RedisClientType<M, F, S, RESP, TYPE_MAPPING>,
+    key: RedisArgument,
+    options?: ScanCommonOptions & ScanIteratorOptions
+  ) {
+    let cursor = options?.cursor ?? '0';
+    do {
+      const reply = await this.hScanNoValues(key, cursor, options);
+      cursor = reply.cursor;
+      yield reply.fields;
+    } while (cursor !== '0');
+  }
+
   async* sScanIterator(
     this: RedisClientType<M, F, S, RESP, TYPE_MAPPING>,
     key: RedisArgument,
diff --git a/packages/client/lib/client/socket.ts b/packages/client/lib/client/socket.ts
@@ -97,12 +97,12 @@ export default class RedisSocket extends EventEmitter {
           return retryIn;
         } catch (err) {
           this.emit('error', err);
-          return Math.min(retries * 50, 500);
+          return this.defaultReconnectStrategy(retries);
         }
       };
     }
 
-    return retries => Math.min(retries * 50, 500);
+    return this.defaultReconnectStrategy;
   }
 
   #createSocketFactory(options?: RedisSocketOptions) {
@@ -333,4 +333,13 @@ export default class RedisSocket extends EventEmitter {
     this.#isSocketUnrefed = true;
     this.#socket?.unref();
   }
+
+  defaultReconnectStrategy(retries: number) {
+    // Generate a random jitter between 0 – 200 ms:
+    const jitter = Math.floor(Math.random() * 200);
+    // Delay is an exponential back off, (times^2) * 50 ms, with a maximum value of 2000 ms:
+    const delay = Math.min(Math.pow(2, retries) * 50, 2000);
+  
+    return delay + jitter;
+  }
 }
diff --git a/packages/client/lib/commands/CLIENT_KILL.spec.ts b/packages/client/lib/commands/CLIENT_KILL.spec.ts
@@ -66,6 +66,16 @@ describe('CLIENT KILL', () => {
       );
     });
 
+    it('MAXAGE', () => {
+      assert.deepEqual(
+        CLIENT_KILL.transformArguments({
+          filter: CLIENT_KILL_FILTERS.MAXAGE,
+          maxAge: 10
+        }),
+        ['CLIENT', 'KILL', 'MAXAGE', '10']
+      );
+    });
+
     describe('SKIP_ME', () => {
       it('undefined', () => {
         assert.deepEqual(
diff --git a/packages/client/lib/commands/CLIENT_KILL.ts b/packages/client/lib/commands/CLIENT_KILL.ts
@@ -7,7 +7,8 @@ export const CLIENT_KILL_FILTERS = {
   ID: 'ID',
   TYPE: 'TYPE',
   USER: 'USER',
-  SKIP_ME: 'SKIPME'
+  SKIP_ME: 'SKIPME',
+  MAXAGE: 'MAXAGE'
 } as const;
 
 type CLIENT_KILL_FILTERS = typeof CLIENT_KILL_FILTERS;
@@ -40,7 +41,11 @@ export type ClientKillSkipMe = CLIENT_KILL_FILTERS['SKIP_ME'] | (ClientKillFilte
   skipMe: boolean;
 });
 
-export type ClientKillFilter = ClientKillAddress | ClientKillLocalAddress | ClientKillId | ClientKillType | ClientKillUser | ClientKillSkipMe;
+export interface ClientKillMaxAge extends ClientKillFilterCommon<CLIENT_KILL_FILTERS['MANAGE']> {
+  maxAge: number;
+}
+
+export type ClientKillFilter = ClientKillAddress | ClientKillLocalAddress | ClientKillId | ClientKillType | ClientKillUser | ClientKillSkipMe | ClientKillMaxAge;
 
 export default {
   FIRST_KEY_INDEX: undefined,
@@ -97,5 +102,9 @@ function pushFilter(parser: CommandParser, filter: ClientKillFilter): void {
     case CLIENT_KILL_FILTERS.SKIP_ME:
       parser.push(filter.skipMe ? 'yes' : 'no');
       break;
+    
+    case CLIENT_KILL_FILTERS.MAXAGE:
+      args.push(filter.maxAge.toString());
+      break;
   }
 }
diff --git a/packages/client/lib/commands/HSCAN_NOVALUES.spec.ts b/packages/client/lib/commands/HSCAN_NOVALUES.spec.ts
@@ -0,0 +1,56 @@
+import { strict as assert } from 'node:assert';
+import testUtils, { GLOBAL } from '../test-utils';
+import HSCAN_NOVALUES from './HSCAN_NOVALUES';
+
+describe('HSCAN_NOVALUES', () => {
+  describe('transformArguments', () => {
+    it('cusror only', () => {
+      assert.deepEqual(
+        HSCAN_NOVALUES.transformArguments('key', '0'),
+        ['HSCAN', 'key', '0', 'NOVALUES']
+      );
+    });
+
+    it('with MATCH', () => {
+      assert.deepEqual(
+        HSCAN_NOVALUES.transformArguments('key', '0', {
+          MATCH: 'pattern'
+        }),
+        ['HSCAN', 'key', '0', 'MATCH', 'pattern', 'NOVALUES']
+      );
+    });
+
+    it('with COUNT', () => {
+      assert.deepEqual(
+        HSCAN_NOVALUES.transformArguments('key', '0', {
+          COUNT: 1
+        }),
+        ['HSCAN', 'key', '0', 'COUNT', '1', 'NOVALUES']
+      );
+    });
+
+    it('with MATCH & COUNT', () => {
+      assert.deepEqual(
+        HSCAN_NOVALUES.transformArguments('key', '0', {
+          MATCH: 'pattern',
+          COUNT: 1
+        }),
+        ['HSCAN', 'key', '0', 'MATCH', 'pattern', 'COUNT', '1', 'NOVALUES']
+      );
+    });
+  });
+
+  testUtils.testWithClient('client.hScanNoValues', async client => {
+    const [, reply] = await Promise.all([
+      client.hSet('key', 'field', 'value'),
+      client.hScanNoValues('key', '0')
+    ]);
+
+    assert.deepEqual(reply, {
+      cursor: '0',
+      fields: [
+        'field',
+      ]
+    });
+  }, GLOBAL.SERVERS.OPEN);
+});
diff --git a/packages/client/lib/commands/HSCAN_NOVALUES.ts b/packages/client/lib/commands/HSCAN_NOVALUES.ts
@@ -0,0 +1,22 @@
+import { RedisArgument, BlobStringReply, Command } from '../RESP/types';
+import { ScanCommonOptions, pushScanArguments } from './SCAN';
+
+export default {
+  FIRST_KEY_INDEX: 1,
+  IS_READ_ONLY: true,
+  transformArguments(
+    key: RedisArgument,
+    cursor: RedisArgument,
+    options?: ScanCommonOptions
+  ) {
+    const args = pushScanArguments(['HSCAN', key], cursor, options);
+    args.push('NOVALUES');
+    return args;
+  },
+  transformReply([cursor, fields]: [BlobStringReply, Array<BlobStringReply>]) {
+    return {
+      cursor,
+      fields
+    };
+  }
+} as const satisfies Command;
diff --git a/packages/client/lib/commands/index.ts b/packages/client/lib/commands/index.ts
@@ -144,6 +144,7 @@ import HRANDFIELD_COUNT_WITHVALUES from './HRANDFIELD_COUNT_WITHVALUES';
 import HRANDFIELD_COUNT from './HRANDFIELD_COUNT';
 import HRANDFIELD from './HRANDFIELD';
 import HSCAN from './HSCAN';
+import HSCAN_NOVALUES from './HSCAN_NOVALUES';
 import HSET from './HSET';
 import HSETNX from './HSETNX';
 import HSTRLEN from './HSTRLEN';
@@ -623,6 +624,8 @@ export default {
   hRandField: HRANDFIELD,
   HSCAN,
   hScan: HSCAN,
+  HSCAN_NOVALUES,
+  hScanNoValues: HSCAN_NOVALUES,
   HSET,
   hSet: HSET,
   HSETNX,

Original file line number	Diff line number	Diff line change
`@@ -97,12 +97,12 @@ export default class RedisSocket extends EventEmitter {`
`97`	`97`	`return retryIn;`
`98`	`98`	`} catch (err) {`
`99`	`99`	`this.emit('error', err);`
`100`		`- return Math.min(retries * 50, 500);`
	`100`	`+ return this.defaultReconnectStrategy(retries);`
`101`	`101`	`}`
`102`	`102`	`};`
`103`	`103`	`}`
`104`	`104`
`105`		`- return retries => Math.min(retries * 50, 500);`
	`105`	`+ return this.defaultReconnectStrategy;`
`106`	`106`	`}`
`107`	`107`
`108`	`108`	`#createSocketFactory(options?: RedisSocketOptions) {`
`@@ -333,4 +333,13 @@ export default class RedisSocket extends EventEmitter {`
`333`	`333`	`this.#isSocketUnrefed = true;`
`334`	`334`	`this.#socket?.unref();`
`335`	`335`	`}`
	`336`	`+`
	`337`	`+ defaultReconnectStrategy(retries: number) {`
	`338`	`+ // Generate a random jitter between 0 – 200 ms:`
	`339`	`+ const jitter = Math.floor(Math.random() * 200);`
	`340`	`+ // Delay is an exponential back off, (times^2) * 50 ms, with a maximum value of 2000 ms:`
	`341`	`+ const delay = Math.min(Math.pow(2, retries) * 50, 2000);`
	`342`	`+`
	`343`	`+ return delay + jitter;`
	`344`	`+ }`
`336`	`345`	`}`