createClient url+tls invariant violation check

Author: dearlordylord

packages/client/lib/client/index.spec.ts

@@ -58,7 +58,8 @@ describe('Client', () => {
                 {
                     socket: {
                         host: 'localhost',
-                        port: 6379
+                        port: 6379,
+                        tls: false
                     },
                     username: 'user',
                     password: 'secret',
@@ -103,12 +104,58 @@ describe('Client', () => {
                 {
                     socket: {
                         host: 'localhost',
+                        tls: false
                     }
                 }
             );
         });
     });
 
+    describe('parseOptions', () => {
+        it('should throw error if tls socket option is set to true and the url protocol is "redis:"', () => {
+            assert.throws(
+                () => RedisClient.parseOptions({
+                    url: 'redis://localhost',
+                    socket: {
+                        tls: true
+                    }
+                }),
+                TypeError
+            );
+        });
+        it('should throw error if tls socket option is set to false and the url protocol is "rediss:"', () => {
+            assert.throws(
+                () => RedisClient.parseOptions({
+                    url: 'rediss://localhost',
+                    socket: {
+                        tls: false
+                    }
+                }),
+                TypeError
+            );
+        });
+        it('should not throw when tls socket option and url protocol matches"', () => {
+            assert.equal(
+                RedisClient.parseOptions({
+                    url: 'rediss://localhost',
+                    socket: {
+                        tls: true
+                    }
+                }).socket.tls,
+                true
+            );
+            assert.equal(
+                RedisClient.parseOptions({
+                    url: 'redis://localhost',
+                    socket: {
+                        tls: false
+                    }
+                }).socket.tls,
+                false
+            );
+        });
+    });
+
     describe('connect', () => {
         testUtils.testWithClient('connect should return the client instance', async client => {
             try {

packages/client/lib/client/index.ts

@@ -157,21 +157,45 @@ export default class RedisClient<
         return new (RedisClient.extend(options))(options);
     }
 
-    static parseURL(url: string): RedisClientOptions {
+    static parseOptions<O extends RedisClientOptions>(options: O): O {
+        if (options?.url) {
+            const parsed = RedisClient.parseURL(options.url);
+            if (options.socket) {
+                if (options.socket.tls !== undefined && options.socket.tls !== parsed.socket.tls) {
+                    throw new TypeError(`tls socket option is set to ${options.socket.tls} which is mismatch with protocol or the URL ${options.url} passed`)
+                }
+                parsed.socket = Object.assign(options.socket, parsed.socket);
+            }
+
+            Object.assign(options, parsed);
+        }
+        return options;
+    }
+
+    static parseURL(url: string): RedisClientOptions & {
+        socket: Exclude<RedisClientOptions['socket'], undefined> & {
+            tls: boolean
+        }
+    } {
         // https://www.iana.org/assignments/uri-schemes/prov/redis
         const { hostname, port, protocol, username, password, pathname } = new URL(url),
-            parsed: RedisClientOptions = {
+            parsed: RedisClientOptions & {
+              socket: Exclude<RedisClientOptions['socket'], undefined> & {
+                tls: boolean
+              }
+            } = {
                 socket: {
-                    host: hostname
+                    host: hostname,
+                    tls: false
                 }
             };
 
-        if (protocol === 'rediss:') {
-            (parsed.socket as RedisTlsSocketOptions).tls = true;
-        } else if (protocol !== 'redis:') {
+        if (protocol !== 'redis:' && protocol !== 'rediss:') {
             throw new TypeError('Invalid protocol');
         }
 
+        parsed.socket.tls = protocol === 'rediss:';
+
         if (port) {
             (parsed.socket as TcpSocketConnectOpts).port = Number(port);
         }
@@ -239,19 +263,14 @@ export default class RedisClient<
     }
 
     #initiateOptions(options?: RedisClientOptions<M, F, S>): RedisClientOptions<M, F, S> | undefined {
-        if (options?.url) {
-            const parsed = RedisClient.parseURL(options.url);
-            if (options.socket) {
-                parsed.socket = Object.assign(options.socket, parsed.socket);
-            }
-
-            Object.assign(options, parsed);
-        }
-
         if (options?.database) {
             this.#selectedDB = options.database;
         }
 
+        if (options) {
+            return RedisClient.parseOptions(options);
+        }
+
         return options;
     }