From 6b70c29c7bb8e717cc845eff12ef851c185b71d8 Mon Sep 17 00:00:00 2001 From: Simone Sanfratello Date: Wed, 26 Feb 2025 11:11:58 +0100 Subject: [PATCH] fix: types --- README.md | 2 +- types/index.d.ts | 24 +++++++++++- types/index.test-d.ts | 90 ++++++++++++++++++++++++++++++------------- 3 files changed, 88 insertions(+), 28 deletions(-) diff --git a/README.md b/README.md index 434337a..d98f58d 100644 --- a/README.md +++ b/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. diff --git a/types/index.d.ts b/types/index.d.ts index 6958556..7edaac1 100644 --- a/types/index.d.ts +++ b/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; diff --git a/types/index.test-d.ts b/types/index.test-d.ts index 38685da..5106bed 100644 --- a/types/index.test-d.ts +++ b/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(source) + expectType(target) + }, + onDisconnect: (context, source) => { + expectType<{ log: import('pino').Logger }>(context) + expectType(source) + }, + onIncomingMessage: (context, source, target, message) => { + expectType<{ log: import('pino').Logger }>(context) + expectType(source) + expectType(target) + expectType<{ data: Buffer | ArrayBuffer | Buffer[], binary: boolean }>(message) + }, + onOutgoingMessage: (context, source, target, message) => { + expectType<{ log: import('pino').Logger }>(context) + expectType(source) + expectType(target) + expectType<{ data: Buffer | ArrayBuffer | Buffer[], binary: boolean }>(message) + }, + onPong: (context, source, target) => { + expectType<{ log: import('pino').Logger }>(context) + expectType(source) + expectType(target) + }, + onReconnect: (context, source, target) => { + expectType<{ log: import('pino').Logger }>(context) + expectType(source) + expectType(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' +})