@nestjs/platform-fastify 12.0.4 → 12.1.1

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,12 +107,23 @@ 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;
-    useStaticAssets(options: FastifyStaticOptions): Promise<any>;
-    setViewEngine(options: FastifyViewOptions | string): Promise<any>;
+    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>;
@@ -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;
         }
@@ -254,8 +280,9 @@ export class FastifyAdapter extends AbstractHttpAdapter {
             }
             body = body.getStream();
         }
-        if (fastifyReply.getHeader('Content-Type') !== undefined &&
-            fastifyReply.getHeader('Content-Type') !== 'application/json' &&
+        const responseContentType = fastifyReply.getHeader('Content-Type');
+        if (typeof responseContentType === 'string' &&
+            !responseContentType.startsWith('application/json') &&
             body?.statusCode >= HttpStatus.BAD_REQUEST) {
             Logger.warn("Content-Type doesn't match Reply body, you might need a custom ExceptionFilter for non-JSON responses", FastifyAdapter.name);
             fastifyReply.header('Content-Type', 'application/json');
@@ -292,35 +319,94 @@ 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);
+    // `register()` accepts a promise of a plugin, so the import is handed over
+    // unawaited on purpose. `NestApplication.useStaticAssets()` discards what
+    // this returns, so awaiting here would enqueue the plugin after the caller
+    // has already moved on to `listen()`.
+    useStaticAssets(options) {
+        return this.register(loadPackage('@fastify/static', 'FastifyAdapter.useStaticAssets()', () => import('@fastify/static')), options);
     }
-    async setViewEngine(options) {
+    // Handed over unawaited for the same reason as `useStaticAssets()` above.
+    setViewEngine(options) {
         if (isString(options)) {
             new Logger('FastifyAdapter').error("setViewEngine() doesn't support a string argument.");
             process.exit(1);
         }
-        return this.register(await loadPackage('@fastify/view', 'FastifyAdapter.setViewEngine()', () => import('@fastify/view')), options);
+        return this.register(loadPackage('@fastify/view', 'FastifyAdapter.setViewEngine()', () => import('@fastify/view')), options);
     }
     isHeadersSent(response) {
         return response.sent;
@@ -356,6 +442,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 +728,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';