node-fastify 5.8.3

package/test/types/reply.test-d.ts

@@ -0,0 +1,254 @@
+import { Buffer } from 'node:buffer'
+import { expectAssignable, expectError, expectType } from 'tsd'
+import fastify, { FastifyContextConfig, FastifyReply, FastifyRequest, FastifySchema, FastifyTypeProviderDefault, RawRequestDefaultExpression, RouteHandler, RouteHandlerMethod } from '../../fastify'
+import { FastifyInstance } from '../../types/instance'
+import { FastifyBaseLogger } from '../../types/logger'
+import { ResolveReplyTypeWithRouteGeneric } from '../../types/reply'
+import { FastifyRouteConfig, RouteGenericInterface } from '../../types/route'
+import { ContextConfigDefault, RawReplyDefaultExpression, RawServerDefault } from '../../types/utils'
+
+type DefaultSerializationFunction = (payload: { [key: string]: unknown }) => string
+type DefaultFastifyReplyWithCode<Code extends number> = FastifyReply<RouteGenericInterface, RawServerDefault, RawRequestDefaultExpression, RawReplyDefaultExpression, ContextConfigDefault, FastifySchema, FastifyTypeProviderDefault, ResolveReplyTypeWithRouteGeneric<RouteGenericInterface['Reply'], Code, FastifySchema, FastifyTypeProviderDefault>>
+
+const getHandler: RouteHandlerMethod = function (_request, reply) {
+  expectType<RawReplyDefaultExpression>(reply.raw)
+  expectType<FastifyBaseLogger>(reply.log)
+  expectType<FastifyRequest<RouteGenericInterface, RawServerDefault, RawRequestDefaultExpression>>(reply.request)
+  expectType<<Code extends number>(statusCode: Code) => DefaultFastifyReplyWithCode<Code>>(reply.code)
+  expectType<<Code extends number>(statusCode: Code) => DefaultFastifyReplyWithCode<Code>>(reply.status)
+  expectType<(...args: [payload?: unknown]) => FastifyReply>(reply.code(100 as number).send)
+  expectType<number>(reply.elapsedTime)
+  expectType<number>(reply.statusCode)
+  expectType<boolean>(reply.sent)
+  expectType<
+          (hints: Record<string, string | string[]>, callback?: (() => void) | undefined) => void
+            >(reply.writeEarlyHints)
+  expectType<((...args: [payload?: unknown]) => FastifyReply)>(reply.send)
+  expectAssignable<(key: string, value: any) => FastifyReply>(reply.header)
+  expectAssignable<(values: { [key: string]: any }) => FastifyReply>(reply.headers)
+  expectAssignable<(key: string) => number | string | string[] | undefined>(reply.getHeader)
+  expectAssignable<() => { [key: string]: number | string | string[] | undefined }>(reply.getHeaders)
+  expectAssignable<(key: string) => FastifyReply>(reply.removeHeader)
+  expectAssignable<(key: string) => boolean>(reply.hasHeader)
+  expectType<(url: string, statusCode?: number) => FastifyReply>(reply.redirect)
+  expectType<() => FastifyReply>(reply.hijack)
+  expectType<() => void>(reply.callNotFound)
+  expectType<(contentType: string) => FastifyReply>(reply.type)
+  expectType<(fn: (payload: any) => string) => FastifyReply>(reply.serializer)
+  expectType<(payload: any) => string | ArrayBuffer | Buffer>(reply.serialize)
+  expectType<(fulfilled: () => void, rejected: (err: Error) => void) => void>(reply.then)
+  expectType<
+      (
+      key: string,
+      fn: ((reply: FastifyReply, payload: string | Buffer | null) => Promise<string>) |
+        ((reply: FastifyReply, payload: string | Buffer | null,
+          done: (err: Error | null, value?: string) => void) => void)
+      ) => FastifyReply
+        >(reply.trailer)
+  expectType<(key: string) => boolean>(reply.hasTrailer)
+  expectType<(key: string) => FastifyReply>(reply.removeTrailer)
+  expectType<FastifyInstance>(reply.server)
+  expectAssignable<
+          ((httpStatus: string) => DefaultSerializationFunction | undefined)
+            >(reply.getSerializationFunction)
+  expectAssignable<
+          ((schema: { [key: string]: unknown }) => DefaultSerializationFunction | undefined)
+            >(reply.getSerializationFunction)
+  expectAssignable<
+          ((schema: { [key: string]: unknown }, httpStatus?: string) => DefaultSerializationFunction)
+            >(reply.compileSerializationSchema)
+  expectAssignable<
+          ((input: { [key: string]: unknown }, schema: { [key: string]: unknown }, httpStatus?: string) => unknown)
+            >(reply.serializeInput)
+  expectAssignable<((input: { [key: string]: unknown }, httpStatus: string) => unknown)>(reply.serializeInput)
+  expectType<ContextConfigDefault & FastifyRouteConfig & FastifyContextConfig>(reply.routeOptions.config)
+  expectType<string>(reply.getDecorator<string>('foo'))
+}
+
+interface ReplyPayload {
+  Reply: {
+    test: boolean;
+  };
+}
+
+interface ReplyArrayPayload {
+  Reply: string[]
+}
+
+interface ReplyUnion {
+  Reply: {
+    success: boolean;
+  } | {
+    error: string;
+  }
+}
+
+interface ReplyHttpCodes {
+  Reply: {
+    '1xx': number,
+    200: 'abc',
+    201: boolean,
+    300: { foo: string },
+  }
+}
+
+interface InvalidReplyHttpCodes {
+  Reply: {
+    '1xx': number,
+    200: string,
+    999: boolean,
+  }
+}
+
+interface ReplyVoid {
+  Reply: void;
+}
+
+interface ReplyUndefined {
+  Reply: undefined;
+}
+
+// Issue #5534 scenario: 204 No Content should allow empty send(), 201 Created should require payload
+// Note: `204: undefined` gets converted to `unknown` via UndefinedToUnknown in type-provider.d.ts,
+// meaning send() is optional but send({}) is also allowed. Use `void` instead of `undefined`
+// if you want stricter "no payload allowed" semantics.
+interface ReplyHttpCodesWithNoContent {
+  Reply: {
+    201: { id: string };
+    204: undefined;
+  }
+}
+
+const typedHandler: RouteHandler<ReplyPayload> = async (request, reply) => {
+  // When Reply type is specified, send() requires a payload argument
+  expectType<((...args: [payload: ReplyPayload['Reply']]) => FastifyReply<ReplyPayload, RawServerDefault, RawRequestDefaultExpression<RawServerDefault>, RawReplyDefaultExpression<RawServerDefault>>)>(reply.send)
+  expectType<((...args: [payload: ReplyPayload['Reply']]) => FastifyReply<ReplyPayload, RawServerDefault, RawRequestDefaultExpression<RawServerDefault>, RawReplyDefaultExpression<RawServerDefault>>)>(reply.code(100).send)
+}
+
+const server = fastify()
+server.get('/get', getHandler)
+server.get('/typed', typedHandler)
+server.get<ReplyPayload>('/get-generic-send', async function handler (request, reply) {
+  reply.send({ test: true })
+})
+// When Reply type is specified, send() requires a payload - calling without arguments should error
+expectError(server.get<ReplyPayload>('/get-generic-send-missing-payload', async function handler (request, reply) {
+  reply.send()
+}))
+server.get<ReplyPayload>('/get-generic-return', async function handler (request, reply) {
+  return { test: false }
+})
+expectError(server.get<ReplyPayload>('/get-generic-send-error', async function handler (request, reply) {
+  reply.send({ foo: 'bar' })
+}))
+expectError(server.get<ReplyPayload>('/get-generic-return-error', async function handler (request, reply) {
+  return { foo: 'bar' }
+}))
+server.get<ReplyUnion>('/get-generic-union-send', async function handler (request, reply) {
+  if (0 as number === 0) {
+    reply.send({ success: true })
+  } else {
+    reply.send({ error: 'error' })
+  }
+})
+server.get<ReplyUnion>('/get-generic-union-return', async function handler (request, reply) {
+  if (0 as number === 0) {
+    return { success: true }
+  } else {
+    return { error: 'error' }
+  }
+})
+expectError(server.get<ReplyUnion>('/get-generic-union-send-error-1', async function handler (request, reply) {
+  reply.send({ successes: true })
+}))
+expectError(server.get<ReplyUnion>('/get-generic-union-send-error-2', async function handler (request, reply) {
+  reply.send({ error: 500 })
+}))
+expectError(server.get<ReplyUnion>('/get-generic-union-return-error-1', async function handler (request, reply) {
+  return { successes: true }
+}))
+expectError(server.get<ReplyUnion>('/get-generic-union-return-error-2', async function handler (request, reply) {
+  return { error: 500 }
+}))
+server.get<ReplyHttpCodes>('/get-generic-http-codes-send', async function handler (request, reply) {
+  reply.code(200).send('abc')
+  reply.code(201).send(true)
+  reply.code(300).send({ foo: 'bar' })
+  reply.code(101).send(123)
+})
+expectError(server.get<ReplyHttpCodes>('/get-generic-http-codes-send-error-1', async function handler (request, reply) {
+  reply.code(200).send('def')
+}))
+expectError(server.get<ReplyHttpCodes>('/get-generic-http-codes-send-error-2', async function handler (request, reply) {
+  reply.code(201).send(0)
+}))
+expectError(server.get<ReplyHttpCodes>('/get-generic-http-codes-send-error-3', async function handler (request, reply) {
+  reply.code(300).send({ foo: 123 })
+}))
+expectError(server.get<ReplyHttpCodes>('/get-generic-http-codes-send-error-4', async function handler (request, reply) {
+  reply.code(100).send('asdasd')
+}))
+expectError(server.get<ReplyHttpCodes>('/get-generic-http-codes-send-error-5', async function handler (request, reply) {
+  reply.code(401).send({ foo: 123 })
+}))
+server.get<ReplyArrayPayload>('/get-generic-array-send', async function handler (request, reply) {
+  reply.code(200).send([''])
+})
+expectError(server.get<InvalidReplyHttpCodes>('get-invalid-http-codes-reply-error', async function handler (request, reply) {
+  reply.code(200).send('')
+}))
+server.get<InvalidReplyHttpCodes>('get-invalid-http-codes-reply-error', async function handler (request, reply) {
+  reply.code(200).send({
+    '1xx': 0,
+    200: '',
+    999: false
+  })
+})
+
+/* eslint-disable @typescript-eslint/no-unused-vars */
+const httpHeaderHandler: RouteHandlerMethod = function (_request, reply) {
+  // accept is a header provided by @types/node
+  reply.getHeader('accept')
+  /* eslint-disable @typescript-eslint/no-unused-expressions */
+  reply.getHeaders().accept
+  reply.hasHeader('accept')
+  reply.header('accept', 'test')
+  reply.headers({ accept: 'test' })
+  reply.removeHeader('accept')
+
+  // x-fastify-test is not a header provided by @types/node
+  // and should not result in a typing error
+  reply.getHeader('x-fastify-test')
+  reply.getHeaders()['x-fastify-test']
+  reply.hasHeader('x-fastify-test')
+  reply.header('x-fastify-test', 'test')
+  reply.headers({ 'x-fastify-test': 'test' })
+  reply.removeHeader('x-fastify-test')
+}
+
+// Test: send() without arguments is valid when no Reply type is specified (default unknown)
+server.get('/get-no-type-send-empty', async function handler (request, reply) {
+  reply.send()
+})
+
+// Test: send() without arguments is valid when Reply type is void
+server.get<ReplyVoid>('/get-void-send-empty', async function handler (request, reply) {
+  reply.send()
+})
+
+// Test: send() without arguments is valid when Reply type is undefined
+server.get<ReplyUndefined>('/get-undefined-send-empty', async function handler (request, reply) {
+  reply.send()
+})
+
+// Issue #5534 scenario: HTTP status codes with 204 No Content
+server.get<ReplyHttpCodesWithNoContent>('/get-http-codes-no-content', async function handler (request, reply) {
+  // 204 No Content - send() without payload is valid because Reply is undefined
+  reply.code(204).send()
+  // 201 Created - send() requires payload
+  reply.code(201).send({ id: '123' })
+})
+// 201 Created without payload should error
+expectError(server.get<ReplyHttpCodesWithNoContent>('/get-http-codes-201-missing-payload', async function handler (request, reply) {
+  reply.code(201).send()
+}))

package/test/types/request.test-d.ts

@@ -0,0 +1,188 @@
+import { expectAssignable, expectError, expectType } from 'tsd'
+import fastify, {
+  ContextConfigDefault,
+  FastifyContextConfig,
+  FastifyLogFn,
+  FastifySchema,
+  FastifyTypeProviderDefault,
+  RawReplyDefaultExpression,
+  RawRequestDefaultExpression,
+  RawServerDefault,
+  RequestBodyDefault,
+  RequestGenericInterface,
+  RouteHandler,
+  RouteHandlerMethod,
+  SafePromiseLike
+} from '../../fastify'
+import { FastifyInstance } from '../../types/instance'
+import { FastifyBaseLogger } from '../../types/logger'
+import { FastifyReply } from '../../types/reply'
+import { FastifyRequest, RequestRouteOptions } from '../../types/request'
+import { FastifyRouteConfig, RouteGenericInterface } from '../../types/route'
+import { RequestHeadersDefault, RequestParamsDefault, RequestQuerystringDefault } from '../../types/utils'
+
+interface RequestBody {
+  content: string;
+}
+
+interface RequestQuerystring {
+  from: string;
+}
+
+interface RequestParams {
+  id: number;
+}
+
+interface RequestHeaders {
+  'x-foobar': string;
+}
+
+interface RequestData extends RequestGenericInterface {
+  Body: RequestBody;
+  Querystring: RequestQuerystring;
+  Params: RequestParams;
+  Headers: RequestHeaders;
+}
+
+type Handler = RouteHandler<RequestData>
+
+type CustomRequest = FastifyRequest<{
+  Body: RequestBody | undefined;
+  Querystring: RequestQuerystring;
+  Params: RequestParams;
+  Headers: RequestHeaders;
+}>
+
+type HTTPRequestPart = 'body' | 'query' | 'querystring' | 'params' | 'headers'
+type ExpectedGetValidationFunction = (input: { [key: string]: unknown }) => boolean
+
+interface CustomLoggerInterface extends FastifyBaseLogger {
+  foo: FastifyLogFn; // custom severity logger method
+}
+
+const getHandler: RouteHandler = function (request, _reply) {
+  expectType<string>(request.url)
+  expectType<string>(request.originalUrl)
+  expectType<string>(request.method)
+  expectType<Readonly<RequestRouteOptions>>(request.routeOptions)
+  expectType<boolean>(request.is404)
+  expectType<string>(request.hostname)
+  expectType<string>(request.host)
+  expectType<number>(request.port)
+  expectType<string>(request.ip)
+  expectType<string[] | undefined>(request.ips)
+  expectType<RawRequestDefaultExpression>(request.raw)
+  expectType<RequestBodyDefault>(request.body)
+  expectType<RequestParamsDefault>(request.params)
+  expectType<ContextConfigDefault & FastifyRouteConfig & FastifyContextConfig>(request.routeOptions.config)
+  expectType<FastifySchema | undefined>(request.routeOptions.schema)
+  expectType<RouteHandlerMethod>(request.routeOptions.handler)
+  expectType<string | undefined>(request.routeOptions.url)
+  expectType<string | undefined>(request.routeOptions.version)
+
+  expectType<RequestHeadersDefault & RawRequestDefaultExpression['headers']>(request.headers)
+  request.headers = {}
+
+  expectType<RequestQuerystringDefault>(request.query)
+  expectType<string>(request.id)
+  expectType<FastifyBaseLogger>(request.log)
+  expectType<RawRequestDefaultExpression['socket']>(request.socket)
+  expectType<AbortSignal>(request.signal)
+  expectType<Error & { validation: any; validationContext: string } | undefined>(request.validationError)
+  expectType<FastifyInstance>(request.server)
+  expectAssignable<(httpPart: HTTPRequestPart) => ExpectedGetValidationFunction>(request.getValidationFunction)
+  expectAssignable<(schema: { [key: string]: unknown }) => ExpectedGetValidationFunction>(request.getValidationFunction)
+  expectAssignable<
+          (input: { [key: string]: unknown }, schema: { [key: string]: unknown }, httpPart?: HTTPRequestPart) => boolean
+            >(request.validateInput)
+  expectAssignable<(input: { [key: string]: unknown }, httpPart?: HTTPRequestPart) => boolean>(request.validateInput)
+  expectType<string>(request.getDecorator<string>('foo'))
+  expectType<void>(request.setDecorator('foo', 'hello'))
+  expectType<void>(request.setDecorator<string>('foo', 'hello'))
+  expectError(request.setDecorator<string>('foo', true))
+}
+
+const getHandlerWithCustomLogger: RouteHandlerMethod<
+  RawServerDefault,
+  RawRequestDefaultExpression,
+  RawReplyDefaultExpression,
+  RouteGenericInterface,
+  ContextConfigDefault,
+  FastifySchema,
+  FastifyTypeProviderDefault,
+  CustomLoggerInterface
+> = function (request, _reply) {
+  expectType<CustomLoggerInterface>(request.log)
+}
+
+const postHandler: Handler = function (request) {
+  expectType<RequestBody>(request.body)
+  expectType<RequestParams>(request.params)
+  expectType<RequestHeaders & RawRequestDefaultExpression['headers']>(
+    request.headers
+  )
+  expectType<RequestQuerystring>(request.query)
+  expectType<string>(request.body.content)
+  expectType<string>(request.query.from)
+  expectType<number>(request.params.id)
+  expectType<string>(request.headers['x-foobar'])
+  expectType<FastifyInstance>(request.server)
+  expectType<FastifyContextConfig & FastifyRouteConfig>(request.routeOptions.config)
+}
+
+function putHandler (request: CustomRequest, reply: FastifyReply) {
+  expectType<RequestBody | undefined>(request.body)
+  expectType<RequestParams>(request.params)
+  expectType<RequestHeaders & RawRequestDefaultExpression['headers']>(request.headers)
+  expectType<RequestQuerystring>(request.query)
+  if (request.body === undefined) {
+    expectType<undefined>(request.body)
+  } else {
+    expectType<string>(request.body.content)
+  }
+  expectType<string>(request.query.from)
+  expectType<number>(request.params.id)
+  expectType<string>(request.headers['x-foobar'])
+  expectType<FastifyInstance>(request.server)
+  expectType<ContextConfigDefault & FastifyRouteConfig & FastifyContextConfig>(request.routeOptions.config)
+}
+
+const server = fastify()
+server.get('/get', getHandler)
+server.post('/post', postHandler)
+server.put('/put', putHandler)
+
+const customLogger: CustomLoggerInterface = {
+  level: 'info',
+  silent: () => { },
+  info: () => { },
+  warn: () => { },
+  error: () => { },
+  fatal: () => { },
+  trace: () => { },
+  debug: () => { },
+  foo: () => { }, // custom severity logger method
+  child: () => customLogger
+}
+
+const serverWithCustomLogger = fastify({ loggerInstance: customLogger })
+expectError<
+FastifyInstance<RawServerDefault, RawRequestDefaultExpression, RawReplyDefaultExpression, CustomLoggerInterface>
+& Promise<
+  FastifyInstance<RawServerDefault, RawRequestDefaultExpression, RawReplyDefaultExpression, CustomLoggerInterface>
+>
+>(serverWithCustomLogger)
+expectAssignable<
+FastifyInstance<RawServerDefault, RawRequestDefaultExpression, RawReplyDefaultExpression, CustomLoggerInterface>
+& PromiseLike<
+  FastifyInstance<RawServerDefault, RawRequestDefaultExpression, RawReplyDefaultExpression, CustomLoggerInterface>
+>
+>(serverWithCustomLogger)
+expectType<
+FastifyInstance<RawServerDefault, RawRequestDefaultExpression, RawReplyDefaultExpression, CustomLoggerInterface>
+& SafePromiseLike<
+  FastifyInstance<RawServerDefault, RawRequestDefaultExpression, RawReplyDefaultExpression, CustomLoggerInterface>
+>
+>(serverWithCustomLogger)
+
+serverWithCustomLogger.get('/get', getHandlerWithCustomLogger)