node-fastify 5.8.3

package/examples/plugin.js

@@ -0,0 +1,12 @@
+'use strict'
+
+module.exports = function (fastify, opts, done) {
+  fastify
+    .get('/', opts, function (req, reply) {
+      reply.send({ hello: 'world' })
+    })
+    .post('/', opts, function (req, reply) {
+      reply.send({ hello: 'world' })
+    })
+  done()
+}

package/examples/route-prefix.js

@@ -0,0 +1,38 @@
+'use strict'
+
+const fastify = require('../fastify')({ logger: true })
+
+const opts = {
+  schema: {
+    response: {
+      '2xx': {
+        type: 'object',
+        properties: {
+          greet: { type: 'string' }
+        }
+      }
+    }
+  }
+}
+
+fastify.register(function (instance, options, done) {
+  // the route will be '/english/hello'
+  instance.get('/hello', opts, (req, reply) => {
+    reply.send({ greet: 'hello' })
+  })
+  done()
+}, { prefix: '/english' })
+
+fastify.register(function (instance, options, done) {
+  // the route will be '/italian/hello'
+  instance.get('/hello', opts, (req, reply) => {
+    reply.send({ greet: 'ciao' })
+  })
+  done()
+}, { prefix: '/italian' })
+
+fastify.listen({ port: 8000 }, function (err) {
+  if (err) {
+    throw err
+  }
+})

package/examples/shared-schema.js

@@ -0,0 +1,38 @@
+'use strict'
+
+const fastify = require('../fastify')({ logger: true })
+
+fastify.addSchema({
+  $id: 'https://foo/common.json',
+  definitions: {
+    response: {
+      $id: '#reply',
+      type: 'object',
+      properties: {
+        hello: {
+          $id: '#bar',
+          type: 'string'
+        }
+      }
+    }
+  }
+})
+
+const opts = {
+  schema: {
+    response: {
+      200: { $ref: 'https://foo/common.json#reply' }
+    }
+  }
+}
+
+fastify
+  .get('/', opts, function (req, reply) {
+    reply.send({ hello: 'world' })
+  })
+
+fastify.listen({ port: 3000 }, err => {
+  if (err) {
+    throw err
+  }
+})

package/examples/simple-stream.js

@@ -0,0 +1,20 @@
+'use strict'
+
+const fastify = require('../fastify')({
+  logger: false
+})
+
+const Readable = require('node:stream').Readable
+
+fastify
+  .get('/', function (req, reply) {
+    const stream = Readable.from(['hello world'])
+    reply.send(stream)
+  })
+
+fastify.listen({ port: 3000 }, (err, address) => {
+  if (err) {
+    throw err
+  }
+  fastify.log.info(`server listening on ${address}`)
+})

package/examples/simple.js

@@ -0,0 +1,32 @@
+'use strict'
+
+const fastify = require('../fastify')({
+  logger: false
+})
+
+const schema = {
+  schema: {
+    response: {
+      200: {
+        type: 'object',
+        properties: {
+          hello: {
+            type: 'string'
+          }
+        }
+      }
+    }
+  }
+}
+
+fastify
+  .get('/', schema, function (req, reply) {
+    reply
+      .send({ hello: 'world' })
+  })
+
+fastify.listen({ port: 3000 }, (err, address) => {
+  if (err) {
+    throw err
+  }
+})

package/examples/simple.mjs

@@ -0,0 +1,27 @@
+// works on Node v14.13.0+
+import { fastify } from '../fastify.js'
+
+const app = fastify({
+  logger: true
+})
+
+const schema = {
+  schema: {
+    response: {
+      200: {
+        type: 'object',
+        properties: {
+          hello: {
+            type: 'string'
+          }
+        }
+      }
+    }
+  }
+}
+
+app.get('/', schema, async function (req, reply) {
+  return { hello: 'world' }
+})
+
+app.listen({ port: 3000 }).catch(console.error)

package/examples/typescript-server.ts

@@ -0,0 +1,79 @@
+/**
+ * Most type annotations in this file are not strictly necessary but are
+ * included for this example.
+ *
+ * To run this example execute the following commands to install typescript,
+ * transpile the code, and start the server:
+ *
+ * npm i -g typescript
+ * tsc examples/typescript-server.ts --target es6 --module commonjs
+ * node examples/typescript-server.js
+ */
+
+import fastify, { FastifyInstance, RouteShorthandOptions } from '../fastify'
+import { Server, IncomingMessage, ServerResponse } from 'node:http'
+
+// Create an http server. We pass the relevant typings for our http version used.
+// By passing types we get correctly typed access to the underlying http objects in routes.
+// If using http2 we'd pass <http2.Http2Server, http2.Http2ServerRequest, http2.Http2ServerResponse>
+const server: FastifyInstance<
+  Server,
+  IncomingMessage,
+  ServerResponse
+> = fastify({ logger: true })
+
+// Define interfaces for our request. We can create these automatically
+// off our JSON Schema files (See TypeScript.md) but for the purpose of this
+// example we manually define them.
+interface PingQuerystring {
+  foo?: number;
+}
+
+interface PingParams {
+  bar?: string;
+}
+
+interface PingHeaders {
+  a?: string;
+}
+
+interface PingBody {
+  baz?: string;
+}
+
+// Define our route options with schema validation
+const opts: RouteShorthandOptions = {
+  schema: {
+    body: {
+      type: 'object',
+      properties: {
+        pong: {
+          type: 'string'
+        }
+      }
+    }
+  }
+}
+
+// Add our route handler with correct types
+server.post<{
+  Querystring: PingQuerystring;
+  Params: PingParams;
+  Headers: PingHeaders;
+  Body: PingBody;
+}>('/ping/:bar', opts, (request, reply) => {
+  console.log(request.query) // this is of type `PingQuerystring`
+  console.log(request.params) // this is of type `PingParams`
+  console.log(request.headers) // this is of type `PingHeaders`
+  console.log(request.body) // this is of type `PingBody`
+  reply.code(200).send({ pong: 'it worked!' })
+})
+
+// Start your server
+server.listen({ port: 8080 }, (err, address) => {
+  if (err) {
+    console.error(err)
+    process.exit(1)
+  }
+  console.log(`server listening on ${address}`)
+})

package/examples/use-plugin.js

@@ -0,0 +1,29 @@
+'use strict'
+
+const fastify = require('../fastify')({ logger: true })
+
+const opts = {
+  schema: {
+    response: {
+      '2xx': {
+        type: 'object',
+        properties: {
+          hello: {
+            type: 'string'
+          }
+        }
+      }
+    }
+  }
+}
+fastify.register(require('./plugin'), opts, function (err) {
+  if (err) {
+    throw err
+  }
+})
+
+fastify.listen({ port: 3000 }, function (err) {
+  if (err) {
+    throw err
+  }
+})

package/fastify.d.ts

@@ -0,0 +1,253 @@
+import * as http from 'node:http'
+import * as http2 from 'node:http2'
+import * as https from 'node:https'
+import { Socket } from 'node:net'
+
+import { BuildCompilerFromPool, ValidatorFactory } from '@fastify/ajv-compiler'
+import { FastifyError } from '@fastify/error'
+import { Options as FJSOptions, SerializerFactory } from '@fastify/fast-json-stringify-compiler'
+import { Config as FindMyWayConfig, ConstraintStrategy, HTTPVersion } from 'find-my-way'
+import { InjectOptions, CallbackFunc as LightMyRequestCallback, Chain as LightMyRequestChain, Response as LightMyRequestResponse } from 'light-my-request'
+
+import { AddContentTypeParser, ConstructorAction, FastifyBodyParser, FastifyContentTypeParser, getDefaultJsonParser, hasContentTypeParser, ProtoAction } from './types/content-type-parser'
+import { FastifyContextConfig, FastifyReplyContext, FastifyRequestContext } from './types/context'
+import { FastifyErrorCodes } from './types/errors'
+import { DoneFuncWithErrOrRes, HookHandlerDoneFunction, onCloseAsyncHookHandler, onCloseHookHandler, onErrorAsyncHookHandler, onErrorHookHandler, onListenAsyncHookHandler, onListenHookHandler, onReadyAsyncHookHandler, onReadyHookHandler, onRegisterHookHandler, onRequestAbortAsyncHookHandler, onRequestAbortHookHandler, onRequestAsyncHookHandler, onRequestHookHandler, onResponseAsyncHookHandler, onResponseHookHandler, onRouteHookHandler, onSendAsyncHookHandler, onSendHookHandler, onTimeoutAsyncHookHandler, onTimeoutHookHandler, preCloseAsyncHookHandler, preCloseHookHandler, preHandlerAsyncHookHandler, preHandlerHookHandler, preParsingAsyncHookHandler, preParsingHookHandler, preSerializationAsyncHookHandler, preSerializationHookHandler, preValidationAsyncHookHandler, preValidationHookHandler, RequestPayload } from './types/hooks'
+import { FastifyInstance, FastifyListenOptions, PrintRoutesOptions } from './types/instance'
+import {
+  FastifyBaseLogger,
+  FastifyChildLoggerFactory,
+  FastifyLogFn,
+  FastifyLoggerInstance,
+  FastifyLoggerOptions,
+  LogLevel,
+  PinoLoggerOptions
+} from './types/logger'
+import { FastifyPlugin, FastifyPluginAsync, FastifyPluginCallback, FastifyPluginOptions } from './types/plugin'
+import { FastifyRegister, FastifyRegisterOptions, RegisterOptions } from './types/register'
+import { FastifyReply } from './types/reply'
+import { FastifyRequest, RequestGenericInterface } from './types/request'
+import { RouteGenericInterface, RouteHandler, RouteHandlerMethod, RouteOptions, RouteShorthandMethod, RouteShorthandOptions, RouteShorthandOptionsWithHandler } from './types/route'
+import { FastifySchema, FastifySchemaValidationError, FastifySchemaCompiler, FastifySerializerCompiler, SchemaErrorDataVar, SchemaErrorFormatter } from './types/schema'
+import { FastifyServerFactory, FastifyServerFactoryHandler } from './types/server-factory'
+import { FastifyTypeProvider, FastifyTypeProviderDefault, SafePromiseLike } from './types/type-provider'
+import { ContextConfigDefault, HTTPMethods, RawReplyDefaultExpression, RawRequestDefaultExpression, RawServerBase, RawServerDefault, RequestBodyDefault, RequestHeadersDefault, RequestParamsDefault, RequestQuerystringDefault } from './types/utils'
+
+declare module '@fastify/error' {
+  interface FastifyError {
+    validationContext?: SchemaErrorDataVar;
+    validation?: FastifySchemaValidationError[];
+  }
+}
+
+type Fastify = typeof fastify
+
+declare namespace fastify {
+  export const errorCodes: FastifyErrorCodes
+
+  export type FastifyHttp2SecureOptions<
+    Server extends http2.Http2SecureServer,
+    Logger extends FastifyBaseLogger = FastifyBaseLogger
+  > = FastifyServerOptions<Server, Logger> & {
+    http2: true,
+    https: http2.SecureServerOptions,
+    http2SessionTimeout?: number
+  }
+
+  export type FastifyHttp2Options<
+    Server extends http2.Http2Server,
+    Logger extends FastifyBaseLogger = FastifyBaseLogger
+  > = FastifyServerOptions<Server, Logger> & {
+    http2: true,
+    http2SessionTimeout?: number
+  }
+
+  export type FastifyHttpsOptions<
+    Server extends https.Server,
+    Logger extends FastifyBaseLogger = FastifyBaseLogger
+  > = FastifyServerOptions<Server, Logger> & {
+    https: https.ServerOptions | null
+  }
+
+  export type FastifyHttpOptions<
+    Server extends http.Server,
+    Logger extends FastifyBaseLogger = FastifyBaseLogger
+  > = FastifyServerOptions<Server, Logger> & {
+    http?: http.ServerOptions | null
+  }
+
+  type FindMyWayVersion<RawServer extends RawServerBase> = RawServer extends http.Server ? HTTPVersion.V1 : HTTPVersion.V2
+  type FindMyWayConfigForServer<RawServer extends RawServerBase> = FindMyWayConfig<FindMyWayVersion<RawServer>>
+
+  export interface ConnectionError extends Error {
+    code: string,
+    bytesParsed: number,
+    rawPacket: {
+      type: string,
+      data: number[]
+    }
+  }
+
+  type TrustProxyFunction = (address: string, hop: number) => boolean
+
+  export type FastifyRouterOptions<RawServer extends RawServerBase> = Omit<FindMyWayConfigForServer<RawServer>, 'defaultRoute' | 'onBadUrl' | 'querystringParser'> & {
+    defaultRoute?: (
+      req: RawRequestDefaultExpression<RawServer>,
+      res: RawReplyDefaultExpression<RawServer>
+    ) => void,
+    onBadUrl?: (
+      path: string,
+      req: RawRequestDefaultExpression<RawServer>,
+      res: RawReplyDefaultExpression<RawServer>
+    ) => void,
+    querystringParser?: (str: string) => { [key: string]: unknown }
+  }
+
+  /**
+   * Options for a fastify server instance. Utilizes conditional logic on the generic server parameter to enforce certain https and http2
+   */
+  export type FastifyServerOptions<
+    RawServer extends RawServerBase = RawServerDefault,
+    Logger extends FastifyBaseLogger = FastifyBaseLogger
+  > = {
+    ignoreTrailingSlash?: boolean,
+    ignoreDuplicateSlashes?: boolean,
+    connectionTimeout?: number,
+    keepAliveTimeout?: number,
+    maxRequestsPerSocket?: number,
+    forceCloseConnections?: boolean | 'idle',
+    requestTimeout?: number,
+    pluginTimeout?: number,
+    bodyLimit?: number,
+    handlerTimeout?: number,
+    maxParamLength?: number,
+    disableRequestLogging?: boolean | ((req: FastifyRequest) => boolean),
+    exposeHeadRoutes?: boolean,
+    onProtoPoisoning?: ProtoAction,
+    onConstructorPoisoning?: ConstructorAction,
+    logger?: boolean | FastifyLoggerOptions<RawServer> & PinoLoggerOptions,
+    loggerInstance?: Logger
+    serializerOpts?: FJSOptions | Record<string, unknown>,
+    serverFactory?: FastifyServerFactory<RawServer>,
+    caseSensitive?: boolean,
+    allowUnsafeRegex?: boolean,
+    requestIdHeader?: string | false,
+    requestIdLogLabel?: string;
+    useSemicolonDelimiter?: boolean,
+    genReqId?: (req: RawRequestDefaultExpression<RawServer>) => string,
+    trustProxy?: boolean | string | string[] | number | TrustProxyFunction,
+    querystringParser?: (str: string) => { [key: string]: unknown },
+    constraints?: {
+      [name: string]: ConstraintStrategy<FindMyWayVersion<RawServer>, unknown>,
+    },
+    schemaController?: {
+      bucket?: (parentSchemas?: unknown) => {
+        add(schema: unknown): FastifyInstance;
+        getSchema(schemaId: string): unknown;
+        getSchemas(): Record<string, unknown>;
+      };
+      compilersFactory?: {
+        buildValidator?: ValidatorFactory;
+        buildSerializer?: SerializerFactory;
+      };
+    };
+    return503OnClosing?: boolean,
+    ajv?: Parameters<BuildCompilerFromPool>[1],
+    frameworkErrors?: <RequestGeneric extends RequestGenericInterface = RequestGenericInterface, TypeProvider extends FastifyTypeProvider = FastifyTypeProviderDefault, SchemaCompiler extends FastifySchema = FastifySchema>(
+      error: FastifyError,
+      req: FastifyRequest<RequestGeneric, RawServer, RawRequestDefaultExpression<RawServer>, FastifySchema, TypeProvider>,
+      res: FastifyReply<RequestGeneric, RawServer, RawRequestDefaultExpression<RawServer>, RawReplyDefaultExpression<RawServer>, FastifyContextConfig, SchemaCompiler, TypeProvider>
+    ) => void,
+    rewriteUrl?: (
+      // The RawRequestDefaultExpression, RawReplyDefaultExpression, and FastifyTypeProviderDefault parameters
+      // should be narrowed further but those generic parameters are not passed to this FastifyServerOptions type
+      this: FastifyInstance<RawServer, RawRequestDefaultExpression<RawServer>, RawReplyDefaultExpression<RawServer>, Logger, FastifyTypeProviderDefault>,
+      req: RawRequestDefaultExpression<RawServer>
+    ) => string,
+    schemaErrorFormatter?: SchemaErrorFormatter,
+    /**
+     * listener to error events emitted by client connections
+     */
+    clientErrorHandler?: (error: ConnectionError, socket: Socket) => void,
+    childLoggerFactory?: FastifyChildLoggerFactory,
+    allowErrorHandlerOverride?: boolean
+    routerOptions?: FastifyRouterOptions<RawServer>,
+  }
+
+  /**
+   * @deprecated use {@link FastifySchemaValidationError}
+   */
+  export type ValidationResult = FastifySchemaValidationError
+
+  /* Export additional types */
+  export type {
+    LightMyRequestChain, InjectOptions, LightMyRequestResponse, LightMyRequestCallback, // 'light-my-request'
+    FastifyRequest, RequestGenericInterface, // './types/request'
+    FastifyReply, // './types/reply'
+    FastifyPluginCallback, FastifyPluginAsync, FastifyPluginOptions, FastifyPlugin, // './types/plugin'
+    FastifyListenOptions, FastifyInstance, PrintRoutesOptions, // './types/instance'
+    FastifyLoggerOptions, FastifyBaseLogger, FastifyLoggerInstance, FastifyLogFn, LogLevel, // './types/logger'
+    FastifyRequestContext, FastifyContextConfig, FastifyReplyContext, // './types/context'
+    RouteHandler, RouteHandlerMethod, RouteOptions, RouteShorthandMethod, RouteShorthandOptions, RouteShorthandOptionsWithHandler, RouteGenericInterface, // './types/route'
+    FastifyRegister, FastifyRegisterOptions, RegisterOptions, // './types/register'
+    FastifyBodyParser, FastifyContentTypeParser, AddContentTypeParser, hasContentTypeParser, getDefaultJsonParser, ProtoAction, ConstructorAction, // './types/content-type-parser'
+    FastifyError, // '@fastify/error'
+    FastifySchema, FastifySchemaValidationError, FastifySchemaCompiler, FastifySerializerCompiler, // './types/schema'
+    HTTPMethods, RawServerBase, RawRequestDefaultExpression, RawReplyDefaultExpression, RawServerDefault, ContextConfigDefault, RequestBodyDefault, RequestQuerystringDefault, RequestParamsDefault, RequestHeadersDefault, // './types/utils'
+    DoneFuncWithErrOrRes, HookHandlerDoneFunction, RequestPayload, onCloseAsyncHookHandler, onCloseHookHandler, onErrorAsyncHookHandler, onErrorHookHandler, onReadyAsyncHookHandler, onReadyHookHandler, onListenAsyncHookHandler, onListenHookHandler, onRegisterHookHandler, onRequestAsyncHookHandler, onRequestHookHandler, onResponseAsyncHookHandler, onResponseHookHandler, onRouteHookHandler, onSendAsyncHookHandler, onSendHookHandler, onTimeoutAsyncHookHandler, onTimeoutHookHandler, preHandlerAsyncHookHandler, preHandlerHookHandler, preParsingAsyncHookHandler, preParsingHookHandler, preSerializationAsyncHookHandler, preSerializationHookHandler, preValidationAsyncHookHandler, preValidationHookHandler, onRequestAbortHookHandler, onRequestAbortAsyncHookHandler, preCloseAsyncHookHandler, preCloseHookHandler, // './types/hooks'
+    FastifyServerFactory, FastifyServerFactoryHandler, // './types/serverFactory'
+    FastifyTypeProvider, FastifyTypeProviderDefault, SafePromiseLike, // './types/type-provider'
+    FastifyErrorCodes // './types/errors'
+  }
+  // named export
+  // import { plugin } from 'plugin'
+  // const { plugin } = require('plugin')
+  export const fastify: Fastify
+  // default export
+  // import plugin from 'plugin'
+  export { fastify as default }
+}
+
+/**
+ * Fastify factory function for the standard fastify http, https, or http2 server instance.
+ *
+ * The default function utilizes http
+ *
+ * @param opts Fastify server options
+ * @returns Fastify server instance
+ */
+declare function fastify<
+  Server extends http2.Http2SecureServer,
+  Request extends RawRequestDefaultExpression<Server> = RawRequestDefaultExpression<Server>,
+  Reply extends RawReplyDefaultExpression<Server> = RawReplyDefaultExpression<Server>,
+  Logger extends FastifyBaseLogger = FastifyBaseLogger,
+  TypeProvider extends FastifyTypeProvider = FastifyTypeProviderDefault
+> (opts: fastify.FastifyHttp2SecureOptions<Server, Logger>): FastifyInstance<Server, Request, Reply, Logger, TypeProvider> & SafePromiseLike<FastifyInstance<Server, Request, Reply, Logger, TypeProvider>>
+
+declare function fastify<
+  Server extends http2.Http2Server,
+  Request extends RawRequestDefaultExpression<Server> = RawRequestDefaultExpression<Server>,
+  Reply extends RawReplyDefaultExpression<Server> = RawReplyDefaultExpression<Server>,
+  Logger extends FastifyBaseLogger = FastifyBaseLogger,
+  TypeProvider extends FastifyTypeProvider = FastifyTypeProviderDefault
+> (opts: fastify.FastifyHttp2Options<Server, Logger>): FastifyInstance<Server, Request, Reply, Logger, TypeProvider> & SafePromiseLike<FastifyInstance<Server, Request, Reply, Logger, TypeProvider>>
+
+declare function fastify<
+  Server extends https.Server,
+  Request extends RawRequestDefaultExpression<Server> = RawRequestDefaultExpression<Server>,
+  Reply extends RawReplyDefaultExpression<Server> = RawReplyDefaultExpression<Server>,
+  Logger extends FastifyBaseLogger = FastifyBaseLogger,
+  TypeProvider extends FastifyTypeProvider = FastifyTypeProviderDefault
+> (opts: fastify.FastifyHttpsOptions<Server, Logger>): FastifyInstance<Server, Request, Reply, Logger, TypeProvider> & SafePromiseLike<FastifyInstance<Server, Request, Reply, Logger, TypeProvider>>
+
+declare function fastify<
+  Server extends http.Server,
+  Request extends RawRequestDefaultExpression<Server> = RawRequestDefaultExpression<Server>,
+  Reply extends RawReplyDefaultExpression<Server> = RawReplyDefaultExpression<Server>,
+  Logger extends FastifyBaseLogger = FastifyBaseLogger,
+  TypeProvider extends FastifyTypeProvider = FastifyTypeProviderDefault
+> (opts?: fastify.FastifyHttpOptions<Server, Logger>): FastifyInstance<Server, Request, Reply, Logger, TypeProvider> & SafePromiseLike<FastifyInstance<Server, Request, Reply, Logger, TypeProvider>>
+
+// CJS export
+// const fastify = require('fastify')
+export = fastify