Connecting via URI

* feat: connection via uri with refactored reference for options
* chore: README.md

Author: jay-l-e-e

README.md

@@ -155,8 +155,7 @@ await client.lpush('list', 'item-1', 'item-2');
 ```typescript
 // Create client (with lazy connect)
 const client = new SolidisClient({
-  host: '127.0.0.1',
-  port: 6379,
+  uri: 'redis://127.0.0.1:6379',
   lazyConnect: true
 }).extend({ get, set });
 
@@ -248,6 +247,7 @@ Solidis provides extensive configuration options:
 ```typescript
 const client = new SolidisClient({
   // Connection
+  uri: 'redis://localhost:6379',
   host: '127.0.0.1',
   port: 6379,
   useTLS: false,

sources/common/constants.ts

@@ -23,6 +23,7 @@ export const SolidisDefaultOptions: SolidisClientFrozenOptions = {
   debugMaxEntries: KB * 10,
   enableReadyCheck: true,
   host: '127.0.0.1',
+  uri: false,
   lazyConnect: false,
   maxConnectionRetries: 20,
   maxCommandsPerPipeline: 300,

sources/modules/connection.ts

@@ -68,7 +68,7 @@ export class SolidisConnection extends EventEmitter {
       return await this.#connectLock;
     }
 
-    this.#connectLock = this.#tryConnectWithRetry(options);
+    this.#connectLock = this.#tryConnectWithRetry();
 
     try {
       await this.#connectLock;
@@ -102,39 +102,37 @@ export class SolidisConnection extends EventEmitter {
     this.emit('end');
   }
 
-  async #tryConnectWithRetry(options: SolidisClientFrozenOptions) {
+  async #tryConnectWithRetry() {
     let attemptIndex = 0;
 
-    const maxConnectionRetries = options.maxConnectionRetries;
+    const maxConnectionRetries = this.#options.maxConnectionRetries;
 
     while (true) {
       attemptIndex += 1;
 
       try {
-        await this.#tryConnect(options);
+        await this.#tryConnect();
         return;
       } catch (error) {
         if (this.#isQuitted) {
           throw wrapWithSolidisConnectionError(error);
         }
 
         if (attemptIndex > maxConnectionRetries) {
-          throw wrapWithSolidisConnectionError(
-            new SolidisConnectionError(
-              `SolidisClient connection failed after ${maxConnectionRetries} retries.`,
-              error,
-            ),
+          throw new SolidisConnectionError(
+            `SolidisClient connection failed after ${maxConnectionRetries} retries.`,
+            error,
           );
         }
 
         await new Promise<void>((resolve) =>
-          setTimeout(resolve, options.connectionRetryDelay),
+          setTimeout(resolve, this.#options.connectionRetryDelay),
         );
       }
     }
   }
 
-  async #tryConnect(options: SolidisClientFrozenOptions) {
+  async #tryConnect() {
     if (this.#isQuitted) {
       throw new SolidisConnectionError(
         'Cannot connect: user quit the connection.',
@@ -155,7 +153,7 @@ export class SolidisConnection extends EventEmitter {
       };
 
       const timeoutHandle = this.#setupConnectionTimeout(
-        options.connectionTimeout,
+        this.#options.connectionTimeout,
         (reason?: unknown) => onFail(reason),
       );
 
@@ -176,18 +174,20 @@ export class SolidisConnection extends EventEmitter {
         this.emit('connect');
       };
 
+      const { host, port, useTLS } = this.#parseSocketOptions();
+
       const socket = this.#createSocket({
-        host: options.host,
-        port: options.port,
-        useTLS: options.useTLS,
+        host,
+        port,
+        useTLS,
         onConnect,
       });
 
       this.#setupSocketErrorHandler(socket);
       this.#setupSocketCloseHandler(socket, onFail);
 
-      socket.setMaxListeners(options.maxEventListenersForSocket);
-      this.setMaxListeners(options.maxEventListenersForClient);
+      socket.setMaxListeners(this.#options.maxEventListenersForSocket);
+      this.setMaxListeners(this.#options.maxEventListenersForClient);
 
       this.#socket = socket;
     });
@@ -202,7 +202,7 @@ export class SolidisConnection extends EventEmitter {
       return await this.#connectLock;
     }
 
-    this.#connectLock = this.#tryConnectWithRetry(this.#options);
+    this.#connectLock = this.#tryConnectWithRetry();
 
     try {
       await this.#connectLock;
@@ -302,4 +302,22 @@ export class SolidisConnection extends EventEmitter {
 
     return timer;
   }
+
+  #parseSocketOptions() {
+    if (this.#options.uri) {
+      const url = new URL(this.#options.uri);
+
+      return {
+        host: url.hostname,
+        port: url.port ? Number.parseInt(url.port) : 6379,
+        useTLS: this.#options.useTLS || url.protocol === 'rediss:',
+      };
+    }
+
+    return {
+      host: this.#options.host,
+      port: this.#options.port,
+      useTLS: this.#options.useTLS,
+    };
+  }
 }

sources/types/solidis.ts

@@ -51,6 +51,7 @@ export interface SolidisClientOptions {
   debugMaxEntries?: number;
   enableReadyCheck?: boolean;
   host?: string;
+  uri?: string | URL | false;
   lazyConnect?: boolean;
   maxConnectionRetries?: number;
   maxCommandsPerPipeline?: number;