feat: Add interval option for connections (denodrivers#399)

Author: Soremwar

connection/connection.ts

@@ -26,7 +26,14 @@
  * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
  */
 
-import { bold, BufReader, BufWriter, joinPath, yellow } from "../deps.ts";
+import {
+  bold,
+  BufReader,
+  BufWriter,
+  delay,
+  joinPath,
+  yellow,
+} from "../deps.ts";
 import { DeferredStack } from "../utils/deferred.ts";
 import { getSocketName, readUInt32BE } from "../utils/utils.ts";
 import { PacketWriter } from "./packet.ts";
@@ -461,10 +468,23 @@ export class Connection {
         error = e;
       }
     } else {
-      // If the reconnection attempts are set to zero the client won't attempt to
-      // reconnect, but it won't error either, this "no reconnections" behavior
-      // should be handled wherever the reconnection is requested
+      let interval =
+        typeof this.#connection_params.connection.interval === "number"
+          ? this.#connection_params.connection.interval
+          : 0;
       while (reconnection_attempts < max_reconnections) {
+        // Don't wait for the interval on the first connection
+        if (reconnection_attempts > 0) {
+          if (
+            typeof this.#connection_params.connection.interval === "function"
+          ) {
+            interval = this.#connection_params.connection.interval(interval);
+          }
+
+          if (interval > 0) {
+            await delay(interval);
+          }
+        }
         try {
           await this.#startup();
           break;

connection/connection_params.ts

@@ -48,6 +48,14 @@ export interface ConnectionOptions {
    * default: `1`
    */
   attempts: number;
+  /**
+   * The time to wait before attempting each reconnection (in milliseconds)
+   *
+   * You can provide a fixed number or a function to call each time the
+   * connection is attempted. By default, the interval will be a function
+   * with an exponential backoff increasing by 500 milliseconds
+   */
+  interval: number | ((previous_interval: number) => number);
 }
 
 /** https://www.postgresql.org/docs/14/libpq-ssl.html#LIBPQ-SSL-PROTECTION */
@@ -299,6 +307,7 @@ const DEFAULT_OPTIONS:
     applicationName: "deno_postgres",
     connection: {
       attempts: 1,
+      interval: (previous_interval) => previous_interval + 500,
     },
     host: "127.0.0.1",
     socket: "/tmp",
@@ -425,6 +434,8 @@ export function createParams(
     connection: {
       attempts: params?.connection?.attempts ??
         DEFAULT_OPTIONS.connection.attempts,
+      interval: params?.connection?.interval ??
+        DEFAULT_OPTIONS.connection.interval,
     },
     database: params.database ?? pgEnv.database,
     hostname: host,

docs/README.md

@@ -78,6 +78,8 @@ the database name and your user, the rest of them have sensible defaults to save
 up time when configuring your connection, such as the following:
 
 - connection.attempts: "1"
+- connection.interval: Exponential backoff increasing the time by 500 ms on
+  every reconnection
 - hostname: If host_type is set to TCP, it will be "127.0.0.1". Otherwise, it
   will default to the "/tmp" folder to look for a socket connection
 - host_type: "socket", unless a host is manually specified
@@ -195,12 +197,32 @@ try {
 }
 ```
 
-Your initial connection will also be affected by this setting, in a slightly
+Your initial connection will also be affected by this setting in a slightly
 different manner than already active errored connections. If you fail to connect
 to your database in the first attempt, the client will keep trying to connect as
 many times as requested, meaning that if your attempt configuration is three,
 your total first-connection-attempts will ammount to four.
 
+Additionally you can set an interval before each reconnection by using the
+`interval` parameter. This can be either a plane number or a function where the
+developer receives the previous interval and returns the new one, making it easy
+to implement exponential backoff (Note: the initial interval for this function
+is always gonna be zero)
+
+```ts
+// Eg: A client that increases the reconnection time by multiplying the previous interval by 2
+const client = new Client({
+  connection: {
+    attempts: 0,
+    interval: (prev_interval) => {
+      // Initial interval is always gonna be zero
+      if (prev_interval === 0) return 2;
+      return prev_interval * 2;
+    },
+  },
+});
+```
+
 ### Unix socket connection
 
 On Unix systems, it's possible to connect to your database through IPC sockets