fix: types

README.md

@@ -254,7 +254,7 @@ The `context` object is passed to all hooks and contains the `log` property.
 
 - `onIncomingMessage`: A hook function that is called when the request is received from the client `onIncomingMessage(context, source, target, { data, binary })` (default: `undefined`).
 - `onOutgoingMessage`: A hook function that is called when the response is received from the target `onOutgoingMessage(context, source, target, { data, binary })` (default: `undefined`).
-- `onConnect`: A hook function that is called when the connection is established `onConnect(source, target)` (default: `undefined`).
+- `onConnect`: A hook function that is called when the connection is established `onConnect(context, source, target)` (default: `undefined`).
 - `onDisconnect`: A hook function that is called when the connection is closed `onDisconnect(context, source)` (default: `undefined`).
 - `onReconnect`: A hook function that is called when the connection is reconnected `onReconnect(context, source, target)` (default: `undefined`). The function is called if reconnection feature is enabled.
 - `onPong`: A hook function that is called when the target responds to the ping `onPong(context, source, target)` (default: `undefined`). The function is called if reconnection feature is enabled.

types/index.d.ts

@@ -14,11 +14,33 @@ import {
   FastifyReplyFromHooks,
 } from '@fastify/reply-from'
 
-import { ClientOptions, ServerOptions } from 'ws'
+import { ClientOptions, ServerOptions, WebSocket } from 'ws'
+import { Logger } from 'pino'
+
+interface WebSocketHooks {
+  onConnect?: (context: { log: Logger }, source: WebSocket, target: WebSocket) => void;
+  onDisconnect?: (context: { log: Logger }, source: WebSocket) => void;
+  onIncomingMessage?: (context: { log: Logger }, source: WebSocket, target: WebSocket, message: { data: Buffer | ArrayBuffer | Buffer[], binary: boolean }) => void;
+  onOutgoingMessage?: (context: { log: Logger }, source: WebSocket, target: WebSocket, message: { data: Buffer | ArrayBuffer | Buffer[], binary: boolean }) => void;
+  onPong?: (context: { log: Logger }, source: WebSocket, target: WebSocket) => void;
+  onReconnect?: (context: { log: Logger }, source: WebSocket, target: WebSocket) => void;
+}
+
+interface WebSocketReconnectOptions {
+  pingInterval?: number;
+  reconnectInterval?: number;
+  reconnectDecay?: number;
+  maxReconnectionRetries?: number;
+  connectionTimeout?: number;
+  reconnectOnClose?: boolean;
+  logs?: boolean;
+}
 
 interface FastifyHttpProxyWebsocketOptionsEnabled {
   websocket: true;
   wsUpstream?: string;
+  wsHooks?: WebSocketHooks;
+  wsReconnect?: WebSocketReconnectOptions;
 }
 interface FastifyHttpProxyWebsocketOptionsDisabled {
   websocket?: false | never;

types/index.test-d.ts

@@ -5,7 +5,7 @@ import fastify, {
   type RawServerBase,
   type RequestGenericInterface,
 } from 'fastify'
-import { expectError, expectType } from 'tsd'
+import { expectType } from 'tsd'
 import fastifyHttpProxy from '..'
 
 const app = fastify()
@@ -63,34 +63,72 @@ app.register(fastifyHttpProxy, {
       return ''
     },
   },
+  wsHooks: {
+    onConnect: (context, source, target) => {
+      expectType<{ log: import('pino').Logger }>(context)
+      expectType<import('ws').WebSocket>(source)
+      expectType<import('ws').WebSocket>(target)
+    },
+    onDisconnect: (context, source) => {
+      expectType<{ log: import('pino').Logger }>(context)
+      expectType<import('ws').WebSocket>(source)
+    },
+    onIncomingMessage: (context, source, target, message) => {
+      expectType<{ log: import('pino').Logger }>(context)
+      expectType<import('ws').WebSocket>(source)
+      expectType<import('ws').WebSocket>(target)
+      expectType<{ data: Buffer | ArrayBuffer | Buffer[], binary: boolean }>(message)
+    },
+    onOutgoingMessage: (context, source, target, message) => {
+      expectType<{ log: import('pino').Logger }>(context)
+      expectType<import('ws').WebSocket>(source)
+      expectType<import('ws').WebSocket>(target)
+      expectType<{ data: Buffer | ArrayBuffer | Buffer[], binary: boolean }>(message)
+    },
+    onPong: (context, source, target) => {
+      expectType<{ log: import('pino').Logger }>(context)
+      expectType<import('ws').WebSocket>(source)
+      expectType<import('ws').WebSocket>(target)
+    },
+    onReconnect: (context, source, target) => {
+      expectType<{ log: import('pino').Logger }>(context)
+      expectType<import('ws').WebSocket>(source)
+      expectType<import('ws').WebSocket>(target)
+    }
+  },
+  wsReconnect: {
+    pingInterval: 3000,
+    reconnectInterval: 1000,
+    reconnectDecay: 1.5,
+    maxReconnectionRetries: 5,
+    connectionTimeout: 5000,
+    reconnectOnClose: true,
+    logs: true
+  },
   internalRewriteLocationHeader: true,
 })
 
-expectError(
-  app.register(fastifyHttpProxy, {
-    thisOptionDoesNotExist: 'triggers a typescript error',
-  })
-)
+// @ts-expect-error
+app.register(fastifyHttpProxy, {
+  thisOptionDoesNotExist: 'triggers a typescript error',
+})
 
-expectError(
-  app.register(fastifyHttpProxy, {
-    upstream: 'http://origin.asd',
-    wsUpstream: 'ws://origin.asd',
-  })
-)
+// @ts-expect-error
+app.register(fastifyHttpProxy, {
+  upstream: 'http://origin.asd',
+  wsUpstream: 'ws://origin.asd',
+})
 
-expectError(
-  app.register(fastifyHttpProxy, {
-    upstream: 'http://origin.asd',
-    websocket: false,
-    wsUpstream: 'asdf',
-  })
-)
+// @ts-expect-error
+app.register(fastifyHttpProxy, {
+  upstream: 'http://origin.asd',
+  websocket: false,
+  wsUpstream: 'asdf',
+})
 
-expectError(
-  app.register(fastifyHttpProxy, {
-    upstream: 'http://origin.asd',
-    websocket: false,
-    internalRewriteLocationHeader: 'NON_BOOLEAN_VALUE'
-  })
-)
+// @ts-expect-error
+app.register(fastifyHttpProxy, {
+  upstream: 'http://origin.asd',
+  websocket: false,
+  internalRewriteLocationHeader: 'NON_BOOLEAN_VALUE'
+})