@nestjs/platform-fastify 12.0.3 → 12.1.0

package/Readme.md

@@ -47,6 +47,10 @@ For questions and support please use the official [Discord channel](https://disc
 
 Please make sure to read the [Issue Reporting Checklist](https://github.com/nestjs/nest/blob/master/CONTRIBUTING.md#-submitting-an-issue) before opening an issue. Issues not conforming to the guidelines may be closed immediately.
 
+## Observability
+
+[NestJS Observe](https://observe.nestjs.com) is the official observability platform for Nest applications. Install the `@nestjs/observe` SDK, pass an API key, and requests, background jobs, errors, logs, and distributed traces start streaming to a dashboard - no manual span wiring and no collector to run. Because the SDK hooks into Nest's own request lifecycle, a trace reads like a call graph of your controllers and providers instead of a bare HTTP route. Free for up to 300,000 events a month, and there is a [live demo](https://www.observe-demo.nestjs.com/dashboard) with no signup.
+
 ## Consulting
 
 With official support, you can get expert help straight from the Nest core team. We provide dedicated technical support, migration strategies, advice on best practices (and design decisions), PR reviews, and team augmentation. Read more about [support here](https://enterprise.nestjs.com).

package/adapters/fastify-adapter.d.ts

@@ -1,16 +1,29 @@
 import { FastifyCorsOptions } from '@fastify/cors';
-import { Logger, type RequestMethod, type VersioningOptions } from '@nestjs/common';
+import { Logger, type NestApplicationOptions, type RequestMethod, type VersioningOptions } from '@nestjs/common';
 import { FastifyBaseLogger, FastifyBodyParser, FastifyInstance, FastifyPluginAsync, FastifyPluginCallback, FastifyRegister, FastifyReply, FastifyRequest, FastifyServerOptions, RawReplyDefaultExpression, RawRequestDefaultExpression, RawServerBase, RawServerDefault, RequestGenericInterface, RouteGenericInterface } from 'fastify';
 import * as http from 'http';
 import * as http2 from 'http2';
 import * as https from 'https';
 import { InjectOptions, Chain as LightMyRequestChain, Response as LightMyRequestResponse } from 'light-my-request';
-import { type VersionValue } from '@nestjs/common/internal';
+import { type SecurityRequestHook, type VersionValue } from '@nestjs/common/internal';
 import { AbstractHttpAdapter } from '@nestjs/core';
-import { FastifyStaticOptions, FastifyViewOptions } from '../interfaces/external/index.js';
+import { FastifyMultipartOptions, FastifyStaticOptions, FastifyViewOptions } from '../interfaces/external/index.js';
 import { NestFastifyBodyParserOptions } from '../interfaces/index.js';
 type FastifyAdapterBaseOptions<Server extends RawServerBase = RawServerDefault, Logger extends FastifyBaseLogger = FastifyBaseLogger> = FastifyServerOptions<Server, Logger> & {
     skipMiddie?: boolean;
+    /**
+     * Controls the "@fastify/multipart" plugin (an optional peer dependency),
+     * which the upload interceptors from "@nestjs/platform-fastify/multipart"
+     * require.
+     *
+     * - unset (default): the adapter registers the plugin when an upload
+     *   interceptor is used, unless it is already registered.
+     * - an object: plugin options (e.g. `limits`); the plugin is registered
+     *   when the application initializes.
+     * - `true`: the same, with the plugin defaults.
+     * - `false`: the adapter never registers the plugin.
+     */
+    multipart?: boolean | FastifyMultipartOptions;
 };
 type FastifyHttp2SecureOptions<Server extends http2.Http2SecureServer, Logger extends FastifyBaseLogger = FastifyBaseLogger> = FastifyAdapterBaseOptions<Server, Logger> & {
     http2: true;
@@ -46,10 +59,15 @@ export declare class FastifyAdapter<TServer extends RawServerBase = RawServerDef
     protected readonly logger: Logger;
     protected readonly instance: TInstance;
     protected _pathPrefix?: string;
+    private readonly openConnections;
+    private isClosing;
     private _isParserRegistered;
     private onRequestHook?;
     private onResponseHook?;
     private isMiddieRegistered;
+    private multipartMode;
+    private multipartOptions;
+    private isMultipartRequested;
     private pendingMiddlewares;
     private versioningOptions?;
     private readonly versionConstraint;
@@ -89,10 +107,21 @@ export declare class FastifyAdapter<TServer extends RawServerBase = RawServerDef
     getHttpServer<T = TServer>(): T;
     getInstance<T = TInstance>(): T;
     register<TRegister extends Parameters<FastifyRegister<FastifyInstance<TServer, TRawRequest, TRawResponse>>>>(plugin: TRegister['0'], opts?: TRegister['1']): any;
+    /**
+     * Registers the "@fastify/multipart" plugin, unless the adapter's
+     * `multipart` option is `false`, or the plugin has been registered
+     * already by the time it loads. Idempotent. Called by the upload
+     * interceptors from "@nestjs/platform-fastify/multipart".
+     *
+     * The plugin is loaded lazily, and a missing package fails the
+     * application's startup (`ready()`) with an error naming the package,
+     * rather than exiting the process.
+     */
+    useMultipart(): void;
     inject(): LightMyRequestChain;
     inject(opts: InjectOptions | string): Promise<LightMyRequestResponse>;
-    close(): Promise<undefined>;
-    initHttpServer(): void;
+    close(): Promise<void>;
+    initHttpServer(options?: NestApplicationOptions): void;
     useStaticAssets(options: FastifyStaticOptions): Promise<any>;
     setViewEngine(options: FastifyViewOptions | string): Promise<any>;
     isHeadersSent(response: TReply): boolean;
@@ -104,6 +133,18 @@ export declare class FastifyAdapter<TServer extends RawServerBase = RawServerDef
     getRequestUrl(request: TRequest): string;
     getRequestUrl(request: TRawRequest): string;
     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
+     * `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
+     * 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>;
@@ -144,5 +185,7 @@ export declare class FastifyAdapter<TServer extends RawServerBase = RawServerDef
      * and leaves any other request target untouched.
      */
     private getPathFromRequestTarget;
+    private trackOpenConnections;
+    private closeOpenConnections;
 }
 export {};

package/adapters/fastify-adapter.js

@@ -2,9 +2,10 @@ import { HttpException, HttpStatus, Logger, StreamableFile, VERSION_NEUTRAL, Ver
 import { fastify, } from 'fastify';
 import Reply from 'fastify/lib/reply.js';
 import fastifySymbols from 'fastify/lib/symbols.js';
+import * as net from 'net';
 import { pathToRegexp } from 'path-to-regexp';
 import middie from '@fastify/middie';
-import { loadPackage, isNil, isString, isUndefined, } from '@nestjs/common/internal';
+import { loadPackage, tryLoadPackage, isNil, isString, isUndefined, } from '@nestjs/common/internal';
 import { AbstractHttpAdapter } from '@nestjs/core';
 import { LegacyRouteConverter } from '@nestjs/core/internal';
 const { kRouteContext } = fastifySymbols;
@@ -13,16 +14,29 @@ import { parse as querystringParse } from 'fast-querystring';
 import urlSanitizer from 'find-my-way/lib/url-sanitizer.js';
 import { FASTIFY_ROUTE_CONFIG_METADATA, FASTIFY_ROUTE_CONSTRAINTS_METADATA, FASTIFY_ROUTE_SCHEMA_METADATA, } from '../constants.js';
 const { safeDecodeURI } = urlSanitizer;
+const MISSING_MULTIPART_PACKAGE_MESSAGE = 'The "@fastify/multipart" package is missing. Please, make sure to install it (npm i @fastify/multipart) ' +
+    'to use the file upload interceptors from "@nestjs/platform-fastify/multipart".';
+function isFastifyMultipartPlugin(plugin) {
+    const fn = plugin?.default ?? plugin;
+    return (typeof fn === 'function' &&
+        (fn[Symbol.for('plugin-meta')]?.name === '@fastify/multipart' ||
+            fn.name === 'fastifyMultipart'));
+}
 /**
  * @publicApi
  */
 export class FastifyAdapter extends AbstractHttpAdapter {
     logger = new Logger(FastifyAdapter.name);
     _pathPrefix;
+    openConnections = new Set();
+    isClosing = false;
     _isParserRegistered;
     onRequestHook;
     onResponseHook;
     isMiddieRegistered;
+    multipartMode = 'auto';
+    multipartOptions = {};
+    isMultipartRequested = false;
     pendingMiddlewares = [];
     versioningOptions;
     versionConstraint = {
@@ -110,6 +124,15 @@ export class FastifyAdapter extends AbstractHttpAdapter {
         if (instanceOrOptions?.skipMiddie) {
             this.isMiddieRegistered = true;
         }
+        const multipart = instanceOrOptions
+            ?.multipart;
+        if (multipart === false) {
+            this.multipartMode = 'off';
+        }
+        else if (multipart) {
+            this.multipartMode = 'eager';
+            this.multipartOptions = multipart === true ? {} : { ...multipart };
+        }
         this.instance.addHook('onRequest', (request, reply, done) => {
             if (this.onRequestHook) {
                 this.onRequestHook(request, reply, done);
@@ -134,6 +157,9 @@ export class FastifyAdapter extends AbstractHttpAdapter {
         this.onResponseHook = hook;
     }
     async init() {
+        if (this.multipartMode === 'eager') {
+            this.useMultipart();
+        }
         if (this.isMiddieRegistered) {
             return;
         }
@@ -292,25 +318,79 @@ export class FastifyAdapter extends AbstractHttpAdapter {
         return this.instance;
     }
     register(plugin, opts) {
+        if (this.multipartMode !== 'off' &&
+            isFastifyMultipartPlugin(plugin) &&
+            !this.instance.hasRequestDecorator('isMultipart')) {
+            // The adapter owns the "@fastify/multipart" registration, so that the
+            // plugin is registered once whether or not the user registers it too.
+            // The user's options apply over the adapter's.
+            this.multipartOptions = { ...this.multipartOptions, ...opts };
+            this.useMultipart();
+            return this.instance;
+        }
         return this.instance.register(plugin, opts);
     }
+    /**
+     * Registers the "@fastify/multipart" plugin, unless the adapter's
+     * `multipart` option is `false`, or the plugin has been registered
+     * already by the time it loads. Idempotent. Called by the upload
+     * interceptors from "@nestjs/platform-fastify/multipart".
+     *
+     * The plugin is loaded lazily, and a missing package fails the
+     * application's startup (`ready()`) with an error naming the package,
+     * rather than exiting the process.
+     */
+    useMultipart() {
+        if (this.multipartMode === 'off' || this.isMultipartRequested) {
+            return;
+        }
+        this.isMultipartRequested = true;
+        const registerMultipart = async (instance) => {
+            // Plugins load in registration order, so one the user registered
+            // before this point has loaded by now.
+            if (instance.hasRequestDecorator('isMultipart')) {
+                return;
+            }
+            const multipart = await tryLoadPackage('@fastify/multipart', () => import('@fastify/multipart'));
+            if (!multipart) {
+                throw new Error(MISSING_MULTIPART_PACKAGE_MESSAGE);
+            }
+            // Copied: the plugin writes its defaults into the options it receives.
+            const { limits, ...options } = this.multipartOptions;
+            await instance.register(multipart, {
+                ...options,
+                ...(limits && { limits: { ...limits } }),
+            });
+        };
+        // Like `fastify-plugin`: register on the root context, not a child one.
+        Object.assign(registerMultipart, {
+            [Symbol.for('skip-override')]: true,
+            [Symbol.for('fastify.display-name')]: 'nestjs-multipart',
+        });
+        this.instance.register(registerMultipart);
+    }
     inject(opts) {
         return this.instance.inject(opts);
     }
     async close() {
+        this.isClosing = true;
         try {
-            return await this.instance.close();
+            this.closeOpenConnections();
         }
-        catch (err) {
-            // Check if server is still running
-            if (err.code !== 'ERR_SERVER_NOT_RUNNING') {
-                throw err;
-            }
-            return;
+        finally {
+            await this.instance.close().catch(err => {
+                // Check if server is still running
+                if (err.code !== 'ERR_SERVER_NOT_RUNNING') {
+                    throw err;
+                }
+            });
         }
     }
-    initHttpServer() {
+    initHttpServer(options = {}) {
         this.httpServer = this.instance.server;
+        if (options?.forceCloseConnections) {
+            this.trackOpenConnections();
+        }
     }
     async useStaticAssets(options) {
         return this.register(await loadPackage('@fastify/static', 'FastifyAdapter.useStaticAssets()', () => import('@fastify/static')), options);
@@ -356,6 +436,22 @@ export class FastifyAdapter extends AbstractHttpAdapter {
     enableCors(options) {
         this.register(import('@fastify/cors'), options);
     }
+    /**
+     * 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
+     * `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
+     * installed with `setErrorHandler()`.
+     */
+    registerSecurityHook(hook) {
+        this.instance.addHook('onRequest', (request, reply, done) => {
+            done(hook(request, reply.raw));
+        });
+    }
     registerParserMiddleware(prefix, rawBody) {
         if (this._isParserRegistered) {
             return;
@@ -626,4 +722,36 @@ export class FastifyAdapter extends AbstractHttpAdapter {
         }
         return pathStart === -1 ? '/' : url.slice(pathStart);
     }
+    trackOpenConnections() {
+        const track = (socket) => {
+            if (this.isClosing) {
+                // Fastify runs its `preClose` hooks before it stops accepting
+                // connections, so destroy anything that arrives in the meantime
+                socket.destroy();
+                return;
+            }
+            if (this.openConnections.has(socket)) {
+                return;
+            }
+            this.openConnections.add(socket);
+            socket.on('close', () => this.openConnections.delete(socket));
+        };
+        this.httpServer.on('connection', track);
+        // Sockets accepted by the secondary servers Fastify binds for every
+        // address `listen()` resolves to are only reachable through requests.
+        // `inject()` requests carry a mock socket, which must not be tracked.
+        this.instance.addHook('onRequest', (request, _reply, done) => {
+            const socket = request.raw.socket;
+            if (socket instanceof net.Socket) {
+                track(socket);
+            }
+            done();
+        });
+    }
+    closeOpenConnections() {
+        for (const socket of this.openConnections) {
+            socket.destroy();
+            this.openConnections.delete(socket);
+        }
+    }
 }

package/index.d.ts

@@ -1,3 +1,4 @@
 export * from './adapters/index.js';
 export * from './interfaces/index.js';
 export * from './decorators/index.js';
+export * from './multipart/index.js';

package/index.js

@@ -7,3 +7,4 @@
 export * from './adapters/index.js';
 export * from './interfaces/index.js';
 export * from './decorators/index.js';
+export * from './multipart/index.js';

package/interfaces/external/fastify-multipart-options.interface.d.ts

@@ -0,0 +1,53 @@
+/**
+ * "@fastify/multipart" plugin options, as accepted by the FastifyAdapter's
+ * `multipart` option. Declared locally so the adapter's typings do not
+ * require the (optional) plugin to be installed.
+ *
+ * `attachFieldsToBody` is deliberately left out: it consumes the body before
+ * the upload interceptors from "@nestjs/platform-fastify/multipart" run.
+ *
+ * @see https://github.com/fastify/fastify-multipart/blob/main/types/index.d.ts
+ * @publicApi
+ */
+export interface FastifyMultipartOptions {
+    /**
+     * Limits applied to every multipart request. The upload interceptors merge
+     * their own `limits` over these.
+     */
+    limits?: {
+        /**
+         * Max field name size in bytes. Not enforced by the plugin for multipart
+         * bodies; the upload interceptors enforce their own `limits.fieldNameSize`.
+         */
+        fieldNameSize?: number;
+        /** Max field value size in bytes (Default: 1 MiB) */
+        fieldSize?: number;
+        /** Max number of non-file fields (Default: Infinity) */
+        fields?: number;
+        /** Max file size in bytes (Default: the Fastify `bodyLimit`, 1 MiB) */
+        fileSize?: number;
+        /** Max number of file fields (Default: Infinity) */
+        files?: number;
+        /** Max number of header key => value pairs (Default: 2000) */
+        headerPairs?: number;
+        /** Max number of parts, fields and files together (Default: 1000) */
+        parts?: number;
+    };
+    /**
+     * Throw when a file exceeds `limits.fileSize` while it is read through
+     * `req.file()` / `req.files()`. The upload interceptors always reject such
+     * a file, whatever this is set to.
+     */
+    throwFileSizeLimit?: boolean;
+    /** Keep the full path of files instead of just the base name (Default: false) */
+    preservePath?: boolean;
+    /** Default character set for part header values (Default: 'latin1') */
+    defParamCharset?: string;
+    /** Default character set when one isn't defined (Default: 'utf8') */
+    defCharset?: string;
+    /**
+     * Detect if a part is a file. By default a part is a file if its content
+     * type is `application/octet-stream` or it has a file name.
+     */
+    isPartAFile?: (fieldName: string | undefined, contentType: string | undefined, fileName: string | undefined) => boolean;
+}

package/interfaces/external/fastify-multipart-options.interface.js

@@ -0,0 +1 @@
+export {};

package/interfaces/external/index.d.ts

@@ -1,2 +1,3 @@
 export * from './fastify-static-options.interface.js';
 export * from './fastify-view-options.interface.js';
+export * from './fastify-multipart-options.interface.js';

package/interfaces/external/index.js

@@ -1,2 +1,3 @@
 export * from './fastify-static-options.interface.js';
 export * from './fastify-view-options.interface.js';
+export * from './fastify-multipart-options.interface.js';

package/multipart/files.constants.d.ts

@@ -0,0 +1 @@
+export declare const MULTIPART_MODULE_OPTIONS = "MULTIPART_MODULE_OPTIONS";

package/multipart/files.constants.js

@@ -0,0 +1 @@
+export const MULTIPART_MODULE_OPTIONS = 'MULTIPART_MODULE_OPTIONS';

package/multipart/index.d.ts

@@ -0,0 +1,4 @@
+export * from './interceptors/index.js';
+export * from './interfaces/index.js';
+export * from './multipart.module.js';
+export * from './storage/index.js';

package/multipart/index.js

@@ -0,0 +1,4 @@
+export * from './interceptors/index.js';
+export * from './interfaces/index.js';
+export * from './multipart.module.js';
+export * from './storage/index.js';

package/multipart/interceptors/any-files.interceptor.d.ts

@@ -0,0 +1,12 @@
+import type { NestInterceptor, Type } from '@nestjs/common';
+import type { MultipartOptions } from '../interfaces/index.js';
+/**
+ * Accepts every file, in any field, and exposes them as an array in
+ * `req.files` (`@UploadedFiles()`). The Fastify counterpart of
+ * platform-express's `AnyFilesInterceptor`.
+ *
+ * @param localOptions options merged over the `MultipartModule` defaults
+ *
+ * @publicApi
+ */
+export declare function AnyFilesInterceptor(localOptions?: MultipartOptions): Type<NestInterceptor>;

package/multipart/interceptors/any-files.interceptor.js

@@ -0,0 +1,13 @@
+import { createMultipartInterceptor } from '../multipart/multipart-interceptor.factory.js';
+/**
+ * Accepts every file, in any field, and exposes them as an array in
+ * `req.files` (`@UploadedFiles()`). The Fastify counterpart of
+ * platform-express's `AnyFilesInterceptor`.
+ *
+ * @param localOptions options merged over the `MultipartModule` defaults
+ *
+ * @publicApi
+ */
+export function AnyFilesInterceptor(localOptions) {
+    return createMultipartInterceptor({ fields: 'ANY', strategy: 'ARRAY' }, localOptions);
+}

package/multipart/interceptors/file-fields.interceptor.d.ts

@@ -0,0 +1,13 @@
+import type { NestInterceptor, Type } from '@nestjs/common';
+import type { MultipartField, MultipartOptions } from '../interfaces/index.js';
+/**
+ * Accepts files in each of `uploadFields` and exposes them grouped by field
+ * name in `req.files` (`@UploadedFiles()`). The Fastify counterpart of
+ * platform-express's `FileFieldsInterceptor`.
+ *
+ * @param uploadFields accepted fields, each with an optional `maxCount`
+ * @param localOptions options merged over the `MultipartModule` defaults
+ *
+ * @publicApi
+ */
+export declare function FileFieldsInterceptor(uploadFields: MultipartField[], localOptions?: MultipartOptions): Type<NestInterceptor>;

package/multipart/interceptors/file-fields.interceptor.js

@@ -0,0 +1,14 @@
+import { createMultipartInterceptor } from '../multipart/multipart-interceptor.factory.js';
+/**
+ * Accepts files in each of `uploadFields` and exposes them grouped by field
+ * name in `req.files` (`@UploadedFiles()`). The Fastify counterpart of
+ * platform-express's `FileFieldsInterceptor`.
+ *
+ * @param uploadFields accepted fields, each with an optional `maxCount`
+ * @param localOptions options merged over the `MultipartModule` defaults
+ *
+ * @publicApi
+ */
+export function FileFieldsInterceptor(uploadFields, localOptions) {
+    return createMultipartInterceptor({ fields: uploadFields, strategy: 'OBJECT' }, localOptions);
+}

package/multipart/interceptors/file-stream.interceptor.d.ts

@@ -0,0 +1,31 @@
+import type { NestInterceptor, Type } from '@nestjs/common';
+import type { MultipartOptions } from '../interfaces/index.js';
+/**
+ * Hands the route handler a single file in `fieldName` as a stream
+ * (`req.file.stream`, see `MultipartFileStream`), without buffering it or
+ * writing it to disk. Fastify only; there is no platform-express
+ * counterpart.
+ *
+ * - Text fields must precede the file in the form: parts that follow it are
+ *   not parsed.
+ * - Whatever the handler leaves unread is discarded before the response is
+ *   sent, so that the client can finish uploading. When the handler returns
+ *   a `StreamableFile` (which may be the upload itself), it is discarded
+ *   once the response has been sent instead. So a handler that responds
+ *   with a `StreamableFile` of something other than the upload should read
+ *   the upload first: otherwise, when the connection is not kept alive
+ *   (`Connection: close`), Node.js closes it right after the response, and
+ *   a client still uploading fails with EPIPE / ECONNRESET.
+ * - A file in any other field fails the request with a 400.
+ * - The file size is unknown up front, so `MaxFileSizeValidator` does not
+ *   apply, and neither does `FileTypeValidator`'s magic-number check.
+ * - Once `limits.fileSize` is exceeded, the stream errors with a
+ *   `PayloadTooLargeException`.
+ *
+ * @param fieldName name of the form field that carries the file
+ * @param localOptions options merged over the `MultipartModule` defaults
+ *   (`dest` and `storage` do not apply)
+ *
+ * @publicApi
+ */
+export declare function FileStreamInterceptor(fieldName: string, localOptions?: Omit<MultipartOptions, 'dest' | 'storage'>): Type<NestInterceptor>;

package/multipart/interceptors/file-stream.interceptor.js

@@ -0,0 +1,32 @@
+import { createMultipartStreamInterceptor } from '../multipart/multipart-interceptor.factory.js';
+/**
+ * Hands the route handler a single file in `fieldName` as a stream
+ * (`req.file.stream`, see `MultipartFileStream`), without buffering it or
+ * writing it to disk. Fastify only; there is no platform-express
+ * counterpart.
+ *
+ * - Text fields must precede the file in the form: parts that follow it are
+ *   not parsed.
+ * - Whatever the handler leaves unread is discarded before the response is
+ *   sent, so that the client can finish uploading. When the handler returns
+ *   a `StreamableFile` (which may be the upload itself), it is discarded
+ *   once the response has been sent instead. So a handler that responds
+ *   with a `StreamableFile` of something other than the upload should read
+ *   the upload first: otherwise, when the connection is not kept alive
+ *   (`Connection: close`), Node.js closes it right after the response, and
+ *   a client still uploading fails with EPIPE / ECONNRESET.
+ * - A file in any other field fails the request with a 400.
+ * - The file size is unknown up front, so `MaxFileSizeValidator` does not
+ *   apply, and neither does `FileTypeValidator`'s magic-number check.
+ * - Once `limits.fileSize` is exceeded, the stream errors with a
+ *   `PayloadTooLargeException`.
+ *
+ * @param fieldName name of the form field that carries the file
+ * @param localOptions options merged over the `MultipartModule` defaults
+ *   (`dest` and `storage` do not apply)
+ *
+ * @publicApi
+ */
+export function FileStreamInterceptor(fieldName, localOptions) {
+    return createMultipartStreamInterceptor(fieldName, localOptions);
+}

package/multipart/interceptors/file.interceptor.d.ts

@@ -0,0 +1,17 @@
+import type { NestInterceptor, Type } from '@nestjs/common';
+import type { MultipartOptions } from '../interfaces/index.js';
+/**
+ * Accepts a single file in `fieldName` and exposes it as `req.file`
+ * (`@UploadedFile()`), with the text fields in `req.body`. The Fastify
+ * counterpart of platform-express's `FileInterceptor`.
+ *
+ * Requires the `@fastify/multipart` package, which the FastifyAdapter
+ * registers as a plugin when an upload interceptor is used (see its
+ * `multipart` option).
+ *
+ * @param fieldName name of the form field that carries the file
+ * @param localOptions options merged over the `MultipartModule` defaults
+ *
+ * @publicApi
+ */
+export declare function FileInterceptor(fieldName: string, localOptions?: MultipartOptions): Type<NestInterceptor>;

package/multipart/interceptors/file.interceptor.js

@@ -0,0 +1,18 @@
+import { createMultipartInterceptor } from '../multipart/multipart-interceptor.factory.js';
+/**
+ * Accepts a single file in `fieldName` and exposes it as `req.file`
+ * (`@UploadedFile()`), with the text fields in `req.body`. The Fastify
+ * counterpart of platform-express's `FileInterceptor`.
+ *
+ * Requires the `@fastify/multipart` package, which the FastifyAdapter
+ * registers as a plugin when an upload interceptor is used (see its
+ * `multipart` option).
+ *
+ * @param fieldName name of the form field that carries the file
+ * @param localOptions options merged over the `MultipartModule` defaults
+ *
+ * @publicApi
+ */
+export function FileInterceptor(fieldName, localOptions) {
+    return createMultipartInterceptor({ fields: [{ name: fieldName, maxCount: 1 }], strategy: 'VALUE' }, localOptions);
+}

package/multipart/interceptors/files.interceptor.d.ts

@@ -0,0 +1,14 @@
+import type { NestInterceptor, Type } from '@nestjs/common';
+import type { MultipartOptions } from '../interfaces/index.js';
+/**
+ * Accepts up to `maxCount` files in `fieldName` and exposes them as an array
+ * in `req.files` (`@UploadedFiles()`). The Fastify counterpart of
+ * platform-express's `FilesInterceptor`.
+ *
+ * @param fieldName name of the form field that carries the files
+ * @param maxCount maximum number of files to accept
+ * @param localOptions options merged over the `MultipartModule` defaults
+ *
+ * @publicApi
+ */
+export declare function FilesInterceptor(fieldName: string, maxCount?: number, localOptions?: MultipartOptions): Type<NestInterceptor>;

package/multipart/interceptors/files.interceptor.js

@@ -0,0 +1,15 @@
+import { createMultipartInterceptor } from '../multipart/multipart-interceptor.factory.js';
+/**
+ * Accepts up to `maxCount` files in `fieldName` and exposes them as an array
+ * in `req.files` (`@UploadedFiles()`). The Fastify counterpart of
+ * platform-express's `FilesInterceptor`.
+ *
+ * @param fieldName name of the form field that carries the files
+ * @param maxCount maximum number of files to accept
+ * @param localOptions options merged over the `MultipartModule` defaults
+ *
+ * @publicApi
+ */
+export function FilesInterceptor(fieldName, maxCount, localOptions) {
+    return createMultipartInterceptor({ fields: [{ name: fieldName, maxCount }], strategy: 'ARRAY' }, localOptions);
+}

package/multipart/interceptors/index.d.ts

@@ -0,0 +1,6 @@
+export * from './any-files.interceptor.js';
+export * from './file-fields.interceptor.js';
+export * from './file-stream.interceptor.js';
+export * from './file.interceptor.js';
+export * from './files.interceptor.js';
+export * from './no-files.interceptor.js';

package/multipart/interceptors/index.js

@@ -0,0 +1,6 @@
+export * from './any-files.interceptor.js';
+export * from './file-fields.interceptor.js';
+export * from './file-stream.interceptor.js';
+export * from './file.interceptor.js';
+export * from './files.interceptor.js';
+export * from './no-files.interceptor.js';

package/multipart/interceptors/no-files.interceptor.d.ts

@@ -0,0 +1,12 @@
+import type { NestInterceptor, Type } from '@nestjs/common';
+import type { MultipartOptions } from '../interfaces/index.js';
+/**
+ * Accepts text fields only (exposed in `req.body`); any file fails the
+ * request with a 400. The Fastify counterpart of platform-express's
+ * `NoFilesInterceptor`.
+ *
+ * @param localOptions options merged over the `MultipartModule` defaults
+ *
+ * @publicApi
+ */
+export declare function NoFilesInterceptor(localOptions?: MultipartOptions): Type<NestInterceptor>;