@nestjs/platform-fastify 12.1.2 → 12.2.0

package/adapters/fastify-adapter.d.ts

@@ -61,23 +61,31 @@ export declare class FastifyAdapter<TServer extends RawServerBase = RawServerDef
     protected _pathPrefix?: string;
     private readonly openConnections;
     private isClosing;
+    private isShuttingDown;
+    private return503OnClosing;
     private _isParserRegistered;
+    private readonly registeredContentTypes;
     private onRequestHook?;
     private onResponseHook?;
+    private securityHook?;
     private isMiddieRegistered;
     private multipartMode;
     private multipartOptions;
     private isMultipartRequested;
     private pendingMiddlewares;
+    private readonly middieContexts;
     private versioningOptions?;
+    private readonly versionExtractorErrors;
     private readonly versionConstraint;
     get isParserRegistered(): boolean;
     constructor(instanceOrOptions?: TInstance | FastifyHttp2Options<any> | FastifyHttp2SecureOptions<any> | FastifyHttpsOptions<any> | FastifyHttpOptions<any> | FastifyAdapterBaseOptions<TServer>);
+    private runLifecycleHook;
     setOnRequestHook(hook: (request: TRequest, reply: TReply, done: (err?: Error) => void) => void | Promise<void>): void;
     setOnResponseHook(hook: (request: TRequest, reply: TReply, done: (err?: Error) => void) => void | Promise<void>): void;
     init(): Promise<void>;
     listen(port: string | number, callback?: () => void): void;
     listen(port: string | number, hostname: string, callback?: () => void): void;
+    private isValidPort;
     get(...args: any[]): FastifyInstance<TServer, TRawRequest, TRawResponse, FastifyBaseLogger, import("fastify").FastifyTypeProviderDefault>;
     post(...args: any[]): FastifyInstance<TServer, TRawRequest, TRawResponse, FastifyBaseLogger, import("fastify").FastifyTypeProviderDefault>;
     head(...args: any[]): FastifyInstance<TServer, TRawRequest, TRawResponse, FastifyBaseLogger, import("fastify").FastifyTypeProviderDefault>;
@@ -94,10 +102,11 @@ export declare class FastifyAdapter<TServer extends RawServerBase = RawServerDef
     move(...args: any[]): FastifyInstance<TServer, TRawRequest, TRawResponse, FastifyBaseLogger, import("fastify").FastifyTypeProviderDefault>;
     lock(...args: any[]): FastifyInstance<TServer, TRawRequest, TRawResponse, FastifyBaseLogger, import("fastify").FastifyTypeProviderDefault>;
     unlock(...args: any[]): FastifyInstance<TServer, TRawRequest, TRawResponse, FastifyBaseLogger, import("fastify").FastifyTypeProviderDefault>;
+    all(...args: any[]): any;
     applyVersionFilter(handler: Function, version: VersionValue, versioningOptions: VersioningOptions): VersionedRoute<TRequest, TReply>;
     reply(response: TRawResponse | TReply, body: any, statusCode?: number): FastifyReply<RouteGenericInterface, TServer, TRawRequest, TRawResponse, unknown, import("fastify").FastifySchema, import("fastify").FastifyTypeProviderDefault, unknown>;
     status(response: TRawResponse | TReply, statusCode: number): any;
-    end(response: TReply, message?: string): void;
+    end(response: TRawResponse | TReply, message?: string): void;
     render(response: TReply & {
         view: Function;
     }, view: string, options: any): FastifyReply<RouteGenericInterface, RawServerDefault, http.IncomingMessage, http.ServerResponse<http.IncomingMessage>, unknown, import("fastify").FastifySchema, import("fastify").FastifyTypeProviderDefault, unknown>;
@@ -120,14 +129,15 @@ export declare class FastifyAdapter<TServer extends RawServerBase = RawServerDef
     useMultipart(): void;
     inject(): LightMyRequestChain;
     inject(opts: InjectOptions | string): Promise<LightMyRequestResponse>;
+    beforeClose(): void;
     close(): Promise<void>;
     initHttpServer(options?: NestApplicationOptions): void;
     useStaticAssets(options: FastifyStaticOptions): any;
     setViewEngine(options: FastifyViewOptions | string): any;
-    isHeadersSent(response: TReply): boolean;
-    getHeader(response: any, name: string): any;
-    setHeader(response: TReply, name: string, value: string): FastifyReply<RouteGenericInterface, TServer, TRawRequest, TRawResponse, unknown, import("fastify").FastifySchema, import("fastify").FastifyTypeProviderDefault, unknown>;
-    appendHeader(response: any, name: string, value: string): any;
+    isHeadersSent(response: TRawResponse | TReply): boolean;
+    getHeader(response: TRawResponse | TReply, name: string): string | number | string[] | undefined;
+    setHeader(response: TRawResponse | TReply, name: string, value: string): void | http.ServerResponse<http.IncomingMessage> | FastifyReply<RouteGenericInterface, TServer, TRawRequest, TRawResponse, unknown, import("fastify").FastifySchema, import("fastify").FastifyTypeProviderDefault, unknown>;
+    appendHeader(response: TRawResponse | TReply, name: string, value: string): void | http.ServerResponse<http.IncomingMessage> | FastifyReply<RouteGenericInterface, TServer, TRawRequest, TRawResponse, unknown, import("fastify").FastifySchema, import("fastify").FastifyTypeProviderDefault, unknown>;
     getRequestHostname(request: TRequest): string;
     getRequestMethod(request: TRequest): string;
     getRequestUrl(request: TRequest): string;
@@ -135,21 +145,27 @@ export declare class FastifyAdapter<TServer extends RawServerBase = RawServerDef
     enableCors(options?: FastifyCorsOptions): void;
     /**
      * Runs the request hook of the built-in HTTP security features in an
-     * `onRequest` hook: before middie (Nest middleware), content-type parsing,
-     * guards and handlers, and also for unmatched routes. Headers set by the
-     * hook go to the Node.js response (`reply.raw`): Fastify merges them into
-     * every response it sends, errors and `404`s included, while
+     * `onRequest` hook added by the constructor: before middie (Nest middleware
+     * and `app.use()` middleware, whenever they are registered), content-type
+     * parsing, guards and handlers, and also for unmatched routes. Headers set
+     * by the hook go to the Node.js response (`reply.raw`): Fastify merges them
+     * into every response it sends, errors and `404`s included, while
      * `reply.header()` / `@Header()` values take precedence, and responses
-     * written to `reply.raw` directly (e.g. `@Sse()`) carry them too. A
-     * rejection goes to `done(error)`, i.e. to the Nest exception layer
+     * written to `reply.raw` directly (e.g. `@Sse()`, or middleware) carry them
+     * too. A rejection goes to `done(error)`, i.e. to the Nest exception layer
      * installed with `setErrorHandler()`.
      */
     registerSecurityHook(hook: SecurityRequestHook<TRequest>): void;
     registerParserMiddleware(prefix?: string, rawBody?: boolean): void;
     useBodyParser(type: string | string[] | RegExp, rawBody: boolean, options?: NestFastifyBodyParserOptions, parser?: FastifyBodyParser<Buffer, TServer>): void;
     createMiddlewareFactory(requestMethod: RequestMethod): Promise<(path: string, callback: Function) => any>;
+    private runMiddleware;
     getType(): string;
     isRouteOrderSensitive(): boolean;
+    getRouteMatchingOptions(): {
+        caseSensitive: boolean;
+        ignoreTrailingSlash: boolean;
+    };
     use(...args: any[]): any;
     mapException(error: unknown): unknown;
     private isHttpFastifyError;
@@ -163,9 +179,22 @@ export declare class FastifyAdapter<TServer extends RawServerBase = RawServerDef
     private isNativeResponse;
     private registerJsonContentParser;
     private registerUrlencodedContentParser;
+    private hasCustomBodyParser;
+    private normalizeContentType;
+    private getDefaultBodyParser;
     private registerMiddie;
     private getRequestOriginalUrl;
     private injectRouteOptions;
+    /**
+     * "find-my-way" matches an empty path segment for a route parameter
+     * ("/users//profile" -> { id: "" }), while "path-to-regexp", which
+     * middleware paths (and the ExpressAdapter's routes) are matched with,
+     * needs at least one character per parameter. Requests with an empty route
+     * parameter are passed to the not-found handler instead, as with the
+     * ExpressAdapter, so that middleware and routes always match the same
+     * requests. Only the wildcard ("*") may be empty.
+     */
+    private requireNonEmptyParams;
     /**
      * Fastify still accepts the router options ("ignoreTrailingSlash",
      * "caseSensitive", ...) at the top level, but "initialConfig.routerOptions"
@@ -185,6 +214,24 @@ export declare class FastifyAdapter<TServer extends RawServerBase = RawServerDef
      * and leaves any other request target untouched.
      */
     private getPathFromRequestTarget;
+    /**
+     * Whether the request target is in origin-form ("/users") or in the
+     * absolute-form of an "http(s)" URL ("http://host/users"), the only forms
+     * middleware paths can match.
+     *
+     * Node.js accepts other targets too (e.g. "GET *users HTTP/1.1").
+     * "find-my-way" routes those as if their first character were the leading
+     * "/" ("*users" is served by the "/users" route), while no middleware path
+     * matches them, so the route would run without its middleware. They are
+     * answered by the not-found handler instead, as with the ExpressAdapter,
+     * whose router never matches a path that does not start with "/".
+     *
+     * That includes the asterisk-form "OPTIONS *" (RFC 9112, section 3.2.4),
+     * which asks about the server as a whole rather than about a resource:
+     * Nest has no handler for it, and "find-my-way" would serve it with the
+     * "OPTIONS /" route.
+     */
+    private isRoutableRequestTarget;
     private trackOpenConnections;
     private closeOpenConnections;
 }