@nestjs/platform-fastify 12.0.4 → 12.1.0

package/multipart/interfaces/files-upload-module.interface.d.ts

@@ -0,0 +1,18 @@
+import type { InjectionToken, ModuleMetadata, OptionalFactoryDependency, Type } from '@nestjs/common';
+import type { MultipartOptions } from './multipart-options.interface.js';
+export type MultipartModuleOptions = MultipartOptions;
+/**
+ * @publicApi
+ */
+export interface MultipartOptionsFactory {
+    createMultipartOptions(): Promise<MultipartModuleOptions> | MultipartModuleOptions;
+}
+/**
+ * @publicApi
+ */
+export interface MultipartModuleAsyncOptions extends Pick<ModuleMetadata, 'imports'> {
+    useExisting?: Type<MultipartOptionsFactory>;
+    useClass?: Type<MultipartOptionsFactory>;
+    useFactory?: (...args: any[]) => Promise<MultipartModuleOptions> | MultipartModuleOptions;
+    inject?: Array<InjectionToken | OptionalFactoryDependency>;
+}

package/multipart/interfaces/files-upload-module.interface.js

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

package/multipart/interfaces/index.d.ts

@@ -0,0 +1,3 @@
+export * from './files-upload-module.interface.js';
+export * from './multipart-file.interface.js';
+export * from './multipart-options.interface.js';

package/multipart/interfaces/index.js

@@ -0,0 +1,3 @@
+export * from './files-upload-module.interface.js';
+export * from './multipart-file.interface.js';
+export * from './multipart-options.interface.js';

package/multipart/interfaces/multipart-file.interface.d.ts

@@ -0,0 +1,70 @@
+import type { Readable } from 'stream';
+/**
+ * A stored upload, in the shape multer produces (`Express.Multer.File`), so
+ * `@UploadedFile()`, `ParseFilePipe` and the built-in file validators work
+ * unchanged. Memory storage sets `buffer`; disk storage sets `destination`,
+ * `filename` and `path`.
+ *
+ * @publicApi
+ */
+export interface UploadedMultipartFile {
+    /** Field name specified in the form */
+    fieldname: string;
+    /** Name of the file on the user's computer */
+    originalname: string;
+    /** Encoding type of the file */
+    encoding: string;
+    /** Mime type of the file */
+    mimetype: string;
+    /** Size of the file in bytes */
+    size: number;
+    /** A Buffer of the entire file (memory storage) */
+    buffer?: Buffer;
+    /** The folder to which the file has been saved (disk storage) */
+    destination?: string;
+    /** The name of the file within the destination (disk storage) */
+    filename?: string;
+    /** Location of the uploaded file (disk storage) */
+    path?: string;
+}
+/**
+ * What a storage engine and `fileFilter` see before the file is stored.
+ *
+ * @publicApi
+ */
+export interface IncomingMultipartFile {
+    /** Field name specified in the form */
+    fieldname: string;
+    /** Name of the file on the user's computer */
+    originalname: string;
+    /** Encoding type of the file */
+    encoding: string;
+    /** Mime type of the file */
+    mimetype: string;
+    /**
+     * The file contents. Non-enumerable; meant to be consumed by
+     * `MultipartStorageEngine._handleFile` only.
+     */
+    readonly stream: Readable;
+}
+/**
+ * The file `FileStreamInterceptor` hands to the route handler. Its size is
+ * not known up front.
+ *
+ * @publicApi
+ */
+export interface MultipartFileStream {
+    /** Field name specified in the form */
+    fieldname: string;
+    /** Name of the file on the user's computer */
+    originalname: string;
+    /** Encoding type of the file */
+    encoding: string;
+    /** Mime type of the file */
+    mimetype: string;
+    /**
+     * The file contents. Errors with a `PayloadTooLargeException` once
+     * `limits.fileSize` is exceeded.
+     */
+    stream: Readable;
+}

package/multipart/interfaces/multipart-file.interface.js

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

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

@@ -0,0 +1,77 @@
+import type { IncomingMultipartFile, UploadedMultipartFile } from './multipart-file.interface.js';
+/**
+ * multer's storage engine contract (`_handleFile` / `_removeFile`), kept
+ * as-is so existing multer storage engines can be passed as `storage`.
+ *
+ * @publicApi
+ */
+export interface MultipartStorageEngine {
+    _handleFile(req: any, file: IncomingMultipartFile, callback: (error?: any, info?: Partial<UploadedMultipartFile>) => void): void;
+    _removeFile(req: any, file: UploadedMultipartFile, callback: (error: Error | null) => void): void;
+}
+/**
+ * Same keys as platform-express's `MulterLimits`.
+ *
+ * Limits that are not set fall back to the options `@fastify/multipart` was
+ * registered with, and then to its own defaults. Unlike multer (which
+ * defaults `fileSize` and `parts` to `Infinity`), `@fastify/multipart` caps
+ * `fileSize` at the Fastify instance's `bodyLimit` (1 MiB unless configured)
+ * and `parts` at 1000.
+ *
+ * @publicApi
+ */
+export interface MultipartLimits {
+    /**
+     * Max field name size in bytes (Default: unlimited). Unlike the other
+     * limits, it does not fall back to the options `@fastify/multipart` was
+     * registered with.
+     */
+    fieldNameSize?: number;
+    /** Max field value size (Default: 1MB) */
+    fieldSize?: number;
+    /** Max number of non-file fields (Default: Infinity) */
+    fields?: number;
+    /** For multipart forms, the max file size in bytes (Default: the Fastify `bodyLimit`, 1 MiB) */
+    fileSize?: number;
+    /** For multipart forms, the max number of file fields (Default: Infinity) */
+    files?: number;
+    /** For multipart forms, the max number of parts (fields + files) (Default: 1000) */
+    parts?: number;
+    /** For multipart forms, the max number of header key => value pairs to parse (Default: 2000) */
+    headerPairs?: number;
+}
+/**
+ * Same keys and semantics as platform-express's `MulterOptions`, so option
+ * objects can be moved between adapters as-is.
+ *
+ * @publicApi
+ */
+export interface MultipartOptions {
+    /** Where to store the files (disk storage). Ignored when `storage` is set. */
+    dest?: string;
+    /** The storage engine to use for uploaded files (Default: memory storage). */
+    storage?: MultipartStorageEngine;
+    /**
+     * An object specifying the size limits, or a function of the request that
+     * returns one. Merged over the limits `@fastify/multipart` was registered with.
+     */
+    limits?: MultipartLimits | ((req: any) => MultipartLimits);
+    /** Keep the full path of files instead of just the base name (Default: false) */
+    preservePath?: boolean;
+    /** Default character set for part header values (e.g. filename) (Default: 'latin1') */
+    defParamCharset?: string;
+    /**
+     * Decides which files are stored. Call `callback(null, false)` to skip a
+     * file, or `callback(error, false)` to fail the request with `error`.
+     */
+    fileFilter?(req: any, file: IncomingMultipartFile, callback: (error: Error | null, acceptFile: boolean) => void): void;
+}
+/**
+ * @publicApi
+ */
+export interface MultipartField {
+    /** The field name. */
+    name: string;
+    /** Optional maximum number of files per field to accept. */
+    maxCount?: number;
+}

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

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

package/multipart/multipart/append-field.util.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Appends a text field to `store` using multer's bracket notation.
+ * Returns `false` (leaving `store` untouched) for names that would pollute a
+ * prototype.
+ */
+export declare function appendField(store: object, key: string, value: unknown): boolean;

package/multipart/multipart/append-field.util.js

@@ -0,0 +1,112 @@
+const FORBIDDEN_KEYS = new Set(['__proto__', 'constructor', 'prototype']);
+function parsePath(key) {
+    const failure = () => [{ type: 'object', key, last: true }];
+    const firstKey = /^[^[]*/.exec(key)[0];
+    if (!firstKey) {
+        return failure();
+    }
+    let pos = firstKey.length;
+    let tail = { type: 'object', key: firstKey };
+    const steps = [tail];
+    while (pos < key.length) {
+        if (key[pos] === '[' && key[pos + 1] === ']') {
+            pos += 2;
+            tail.append = true;
+            if (pos !== key.length) {
+                return failure();
+            }
+            continue;
+        }
+        const rest = key.substring(pos);
+        let match = /^\[(\d+)\]/.exec(rest);
+        if (match) {
+            pos += match[0].length;
+            tail.nextType = 'array';
+            tail = { type: 'array', key: parseInt(match[1], 10) };
+            steps.push(tail);
+            continue;
+        }
+        match = /^\[([^\]]+)\]/.exec(rest);
+        if (match) {
+            pos += match[0].length;
+            tail.nextType = 'object';
+            tail = { type: 'object', key: match[1] };
+            steps.push(tail);
+            continue;
+        }
+        return failure();
+    }
+    tail.last = true;
+    return steps;
+}
+function valueType(value) {
+    if (value === undefined) {
+        return 'undefined';
+    }
+    if (Array.isArray(value)) {
+        return 'array';
+    }
+    if (typeof value === 'object') {
+        return 'object';
+    }
+    return 'scalar';
+}
+function setLastValue(ctx, step, current, value) {
+    switch (valueType(current)) {
+        case 'undefined':
+            ctx[step.key] = step.append ? [value] : value;
+            break;
+        case 'array':
+            ctx[step.key].push(value);
+            break;
+        case 'object':
+            return setLastValue(current, { type: 'object', key: '', last: true }, current[''], value);
+        case 'scalar':
+            ctx[step.key] = [ctx[step.key], value];
+            break;
+    }
+    return ctx;
+}
+function setValue(ctx, step, current, value) {
+    if (step.last) {
+        return setLastValue(ctx, step, current, value);
+    }
+    let obj;
+    switch (valueType(current)) {
+        case 'undefined':
+            ctx[step.key] = step.nextType === 'array' ? [] : Object.create(null);
+            return ctx[step.key];
+        case 'object':
+            return current;
+        case 'array':
+            if (step.nextType === 'array') {
+                return current;
+            }
+            obj = Object.create(null);
+            ctx[step.key] = obj;
+            current.forEach((item, i) => {
+                if (item !== undefined) {
+                    obj['' + i] = item;
+                }
+            });
+            return obj;
+        case 'scalar':
+            obj = Object.create(null);
+            obj[''] = current;
+            ctx[step.key] = obj;
+            return obj;
+    }
+}
+/**
+ * Appends a text field to `store` using multer's bracket notation.
+ * Returns `false` (leaving `store` untouched) for names that would pollute a
+ * prototype.
+ */
+export function appendField(store, key, value) {
+    const steps = parsePath(key);
+    if (steps.some(step => FORBIDDEN_KEYS.has(String(step.key)))) {
+        return false;
+    }
+    steps.reduce((ctx, step) => setValue(ctx, step, ctx[step.key], value), store);
+    return true;
+}

package/multipart/multipart/multipart-interceptor.factory.d.ts

@@ -0,0 +1,13 @@
+import { type NestInterceptor, type Type } from '@nestjs/common';
+import type { MultipartOptions } from '../interfaces/index.js';
+import { type UploadSpec } from './multipart.parser.js';
+/**
+ * Creates an interceptor that parses the multipart body with multer's
+ * semantics, as described by `spec`.
+ */
+export declare function createMultipartInterceptor(spec: UploadSpec, localOptions?: MultipartOptions): Type<NestInterceptor>;
+/**
+ * Creates an interceptor that hands the route handler the stream of a single
+ * file in `fieldName`.
+ */
+export declare function createMultipartStreamInterceptor(fieldName: string, localOptions?: MultipartOptions): Type<NestInterceptor>;

package/multipart/multipart/multipart-interceptor.factory.js

@@ -0,0 +1,130 @@
+import { __decorate, __metadata, __param } from "tslib";
+import { Inject, mixin, Optional, StreamableFile, } from '@nestjs/common';
+import { HttpAdapterHost } from '@nestjs/core';
+import { catchError, concatMap, from, throwError } from 'rxjs';
+import { MULTIPART_MODULE_OPTIONS } from '../files.constants.js';
+import { MISSING_PLUGIN_MESSAGE, PLUGIN_NOT_REGISTERED_AT_STARTUP_MESSAGE, WRONG_ADAPTER_MESSAGE, } from './multipart.constants.js';
+import { drainRequest, processMultipart, processStream, resolveStorage, validateLimits, } from './multipart.parser.js';
+import { mergeMultipartOptions } from './multipart.utils.js';
+const verifiedInstances = new WeakSet();
+/**
+ * Asks the FastifyAdapter to register the `@fastify/multipart` plugin (it
+ * skips that when the plugin is registered already, or when its
+ * `multipart` option is `false`), and fails the application's startup with
+ * an actionable message if the plugin still is not registered once every
+ * plugin has loaded. Without the plugin, Fastify answers every multipart
+ * request with a bare 415 before any interceptor runs.
+ *
+ * This runs from `onModuleInit`, before Fastify's `ready()`: the plugin
+ * registered here loads with the others, before the server starts, and
+ * the check is deferred to an `onReady` hook.
+ */
+function setUpHttpAdapter(adapterHost) {
+    const httpAdapter = adapterHost?.httpAdapter;
+    if (!httpAdapter) {
+        return;
+    }
+    if (httpAdapter.getType() !== 'fastify') {
+        throw new Error(WRONG_ADAPTER_MESSAGE);
+    }
+    const instance = httpAdapter.getInstance();
+    if (verifiedInstances.has(instance)) {
+        return;
+    }
+    const isRegistered = () => instance.hasRequestDecorator('isMultipart');
+    try {
+        httpAdapter.useMultipart?.();
+        instance.addHook('onReady', async () => {
+            if (!isRegistered()) {
+                throw new Error(MISSING_PLUGIN_MESSAGE);
+            }
+        });
+    }
+    catch {
+        // The instance has already started (e.g. the interceptor was created
+        // by a lazy-loaded module): no plugin can be registered any more, and
+        // every plugin is loaded.
+        if (!isRegistered()) {
+            throw new Error(PLUGIN_NOT_REGISTERED_AT_STARTUP_MESSAGE);
+        }
+    }
+    verifiedInstances.add(instance);
+}
+class MultipartInterceptorHost {
+    adapterHost;
+    options;
+    constructor(moduleOptions = {}, adapterHost, localOptions) {
+        this.adapterHost = adapterHost;
+        this.options = mergeMultipartOptions(moduleOptions, localOptions);
+        if (typeof this.options.limits !== 'function') {
+            validateLimits(this.options.limits);
+        }
+    }
+    onModuleInit() {
+        setUpHttpAdapter(this.adapterHost);
+    }
+}
+/**
+ * Creates an interceptor that parses the multipart body with multer's
+ * semantics, as described by `spec`.
+ */
+export function createMultipartInterceptor(spec, localOptions) {
+    let MixinInterceptor = class MixinInterceptor extends MultipartInterceptorHost {
+        // Resolved once per interceptor, as multer does, so that a `dest`
+        // folder is created at bootstrap.
+        storage;
+        constructor(options = {}, adapterHost) {
+            super(options, adapterHost, localOptions);
+            this.storage = resolveStorage(this.options);
+        }
+        async intercept(context, next) {
+            const req = context.switchToHttp().getRequest();
+            await processMultipart(req, spec, this.options, this.storage);
+            return next.handle();
+        }
+    };
+    MixinInterceptor = __decorate([
+        __param(0, Optional()),
+        __param(0, Inject(MULTIPART_MODULE_OPTIONS)),
+        __param(1, Optional()),
+        __param(1, Inject(HttpAdapterHost)),
+        __metadata("design:paramtypes", [Object, HttpAdapterHost])
+    ], MixinInterceptor);
+    return mixin(MixinInterceptor);
+}
+/**
+ * Creates an interceptor that hands the route handler the stream of a single
+ * file in `fieldName`.
+ */
+export function createMultipartStreamInterceptor(fieldName, localOptions) {
+    let MixinInterceptor = class MixinInterceptor extends MultipartInterceptorHost {
+        constructor(options = {}, adapterHost) {
+            super(options, adapterHost, localOptions);
+        }
+        async intercept(context, next) {
+            const ctx = context.switchToHttp();
+            const req = ctx.getRequest();
+            const reply = ctx.getResponse();
+            await processStream(req, fieldName, this.options);
+            // Whatever the handler leaves unread is discarded before the response
+            // is sent, as multer does: responding while the client is still
+            // uploading makes Node.js close the connection under it (EPIPE /
+            // ECONNRESET on the client) when it is not kept alive, and leaves a
+            // kept-alive connection with an unread body. A StreamableFile
+            // response is the exception, as it may be the upload itself, which
+            // only drains while the response is sent; what it leaves unread is
+            // discarded once the response is out.
+            reply.raw.once('close', () => void drainRequest(req.raw));
+            const drainBefore = (result) => from(drainRequest(req.raw).then(() => result));
+            return next.handle().pipe(concatMap(result => result instanceof StreamableFile ? [result] : drainBefore(result)), catchError(err => drainBefore(undefined).pipe(concatMap(() => throwError(() => err)))));
+        }
+    };
+    MixinInterceptor = __decorate([
+        __param(0, Optional()),
+        __param(0, Inject(MULTIPART_MODULE_OPTIONS)),
+        __param(1, Optional()),
+        __param(1, Inject(HttpAdapterHost)),
+        __metadata("design:paramtypes", [Object, HttpAdapterHost])
+    ], MixinInterceptor);
+    return mixin(MixinInterceptor);
+}

package/multipart/multipart/multipart.constants.d.ts

@@ -0,0 +1,55 @@
+/**
+ * Same codes and messages as multer's `MulterError`, copied from
+ * `@nestjs/platform-express` (`multer/multer/multer.constants.ts`) so that
+ * clients see identical error responses on both adapters without this
+ * package depending on platform-express.
+ */
+export declare const multerExceptions: {
+    readonly LIMIT_PART_COUNT: "Too many parts";
+    readonly LIMIT_FILE_SIZE: "File too large";
+    readonly LIMIT_FILE_COUNT: "Too many files";
+    readonly LIMIT_FIELD_KEY: "Field name too long";
+    readonly LIMIT_FIELD_VALUE: "Field value too long";
+    readonly LIMIT_FIELD_COUNT: "Too many fields";
+    readonly LIMIT_UNEXPECTED_FILE: "Unexpected file field";
+    readonly MISSING_FIELD_NAME: "Field name missing";
+    readonly LIMIT_FIELD_NESTING: "Field name nesting too deep";
+    readonly INVALID_FIELD_NAME: "Invalid field name";
+};
+export type MultipartErrorCode = keyof typeof multerExceptions;
+/**
+ * The messages platform-express reports for busboy 1.x parser errors
+ * (prefixed with "Multipart: "), which is what multer bundles.
+ */
+export declare const busboyExceptions: {
+    readonly MULTIPART_BOUNDARY_NOT_FOUND: "Multipart: Boundary not found";
+    readonly MULTIPART_UNEXPECTED_END_OF_FORM: "Multipart: Unexpected end of form";
+    readonly MULTIPART_UNEXPECTED_END_OF_FILE: "Multipart: Unexpected end of file";
+};
+/**
+ * `@fastify/busboy` raises plain `Error`s without a `code`, so these are the
+ * only messages matched verbatim. Everything `@fastify/multipart` raises is
+ * matched by its `code` instead (see `fastifyMultipartErrorCodes`).
+ *
+ * @see https://github.com/fastify/busboy/blob/main/deps/dicer/lib/Dicer.js
+ */
+export declare const fastifyBusboyMessages: {
+    readonly BOUNDARY_NOT_FOUND: "Multipart: Boundary not found";
+    readonly UNEXPECTED_END_OF_FORM: "Unexpected end of multipart data";
+    readonly PART_TERMINATED_EARLY: "terminated early due to unexpected end";
+};
+/**
+ * `@fastify/multipart` error codes (created with `@fastify/error`) mapped to
+ * the multer code that describes the same condition.
+ *
+ * @see https://github.com/fastify/fastify-multipart/blob/main/index.js
+ */
+export declare const fastifyMultipartErrorCodes: Record<string, MultipartErrorCode>;
+/**
+ * `@fastify/multipart` error codes that already describe a client error and
+ * are reported as a 400 with their own message.
+ */
+export declare const fastifyMultipartBadRequestCodes: string[];
+export declare const MISSING_PLUGIN_MESSAGE: string;
+export declare const PLUGIN_NOT_REGISTERED_AT_STARTUP_MESSAGE: string;
+export declare const WRONG_ADAPTER_MESSAGE: string;

package/multipart/multipart/multipart.constants.js

@@ -0,0 +1,74 @@
+/**
+ * Same codes and messages as multer's `MulterError`, copied from
+ * `@nestjs/platform-express` (`multer/multer/multer.constants.ts`) so that
+ * clients see identical error responses on both adapters without this
+ * package depending on platform-express.
+ */
+export const multerExceptions = {
+    // from https://github.com/expressjs/multer/blob/master/lib/multer-error.js
+    LIMIT_PART_COUNT: 'Too many parts',
+    LIMIT_FILE_SIZE: 'File too large',
+    LIMIT_FILE_COUNT: 'Too many files',
+    LIMIT_FIELD_KEY: 'Field name too long',
+    LIMIT_FIELD_VALUE: 'Field value too long',
+    LIMIT_FIELD_COUNT: 'Too many fields',
+    LIMIT_UNEXPECTED_FILE: 'Unexpected file field',
+    MISSING_FIELD_NAME: 'Field name missing',
+    LIMIT_FIELD_NESTING: 'Field name nesting too deep',
+    // A multer 2.4 code that platform-express's table lacks. Raised here for
+    // field names that would pollute a prototype, which multer accepts.
+    INVALID_FIELD_NAME: 'Invalid field name',
+};
+/**
+ * The messages platform-express reports for busboy 1.x parser errors
+ * (prefixed with "Multipart: "), which is what multer bundles.
+ */
+export const busboyExceptions = {
+    MULTIPART_BOUNDARY_NOT_FOUND: 'Multipart: Boundary not found',
+    MULTIPART_UNEXPECTED_END_OF_FORM: 'Multipart: Unexpected end of form',
+    MULTIPART_UNEXPECTED_END_OF_FILE: 'Multipart: Unexpected end of file',
+};
+/**
+ * `@fastify/busboy` raises plain `Error`s without a `code`, so these are the
+ * only messages matched verbatim. Everything `@fastify/multipart` raises is
+ * matched by its `code` instead (see `fastifyMultipartErrorCodes`).
+ *
+ * @see https://github.com/fastify/busboy/blob/main/deps/dicer/lib/Dicer.js
+ */
+export const fastifyBusboyMessages = {
+    BOUNDARY_NOT_FOUND: 'Multipart: Boundary not found',
+    // Emitted on the parser when the body ends early...
+    UNEXPECTED_END_OF_FORM: 'Unexpected end of multipart data',
+    // ...and on the file stream that was being read at that moment. Both are
+    // reported as "Unexpected end of form", as multer does for a truncated body.
+    PART_TERMINATED_EARLY: 'terminated early due to unexpected end',
+};
+/**
+ * `@fastify/multipart` error codes (created with `@fastify/error`) mapped to
+ * the multer code that describes the same condition.
+ *
+ * @see https://github.com/fastify/fastify-multipart/blob/main/index.js
+ */
+export const fastifyMultipartErrorCodes = {
+    FST_PARTS_LIMIT: 'LIMIT_PART_COUNT',
+    FST_FILES_LIMIT: 'LIMIT_FILE_COUNT',
+    FST_FIELDS_LIMIT: 'LIMIT_FIELD_COUNT',
+    FST_REQ_FILE_TOO_LARGE: 'LIMIT_FILE_SIZE',
+    FST_PROTO_VIOLATION: 'INVALID_FIELD_NAME',
+};
+/**
+ * `@fastify/multipart` error codes that already describe a client error and
+ * are reported as a 400 with their own message.
+ */
+export const fastifyMultipartBadRequestCodes = [
+    'FST_MP_PREMATURE_CLOSE',
+    'FST_INVALID_JSON_FIELD_ERROR',
+];
+export const MISSING_PLUGIN_MESSAGE = 'File upload interceptors from "@nestjs/platform-fastify/multipart" require the "@fastify/multipart" plugin, ' +
+    'which the FastifyAdapter registers unless its "multipart" option is false. ' +
+    'Either remove that option, or register the plugin yourself (`await app.register(multipart)`).';
+export const PLUGIN_NOT_REGISTERED_AT_STARTUP_MESSAGE = 'File upload interceptors from "@nestjs/platform-fastify/multipart" require the "@fastify/multipart" plugin, ' +
+    'which was not registered before the Fastify instance started. ' +
+    'Register it at startup: `new FastifyAdapter({ multipart: true })`, or `await app.register(multipart)`.';
+export const WRONG_ADAPTER_MESSAGE = 'File upload interceptors from "@nestjs/platform-fastify/multipart" only work with the FastifyAdapter. ' +
+    'With the ExpressAdapter, import them from "@nestjs/platform-express" instead.';

package/multipart/multipart/multipart.error.d.ts

@@ -0,0 +1,10 @@
+import { type MultipartErrorCode } from './multipart.constants.js';
+/**
+ * Mirrors multer's `MulterError`: identified by `code`, and may carry the
+ * name of the offending `field`.
+ */
+export declare class MultipartError extends Error {
+    readonly code: MultipartErrorCode;
+    readonly field?: string | undefined;
+    constructor(code: MultipartErrorCode, field?: string | undefined);
+}

package/multipart/multipart/multipart.error.js

@@ -0,0 +1,15 @@
+import { multerExceptions, } from './multipart.constants.js';
+/**
+ * Mirrors multer's `MulterError`: identified by `code`, and may carry the
+ * name of the offending `field`.
+ */
+export class MultipartError extends Error {
+    code;
+    field;
+    constructor(code, field) {
+        super(multerExceptions[code]);
+        this.code = code;
+        this.field = field;
+        this.name = 'MultipartError';
+    }
+}

package/multipart/multipart/multipart.parser.d.ts

@@ -0,0 +1,39 @@
+import type { FastifyRequest } from 'fastify';
+import type { IncomingMessage } from 'http';
+import type { MultipartField, MultipartLimits, MultipartOptions, MultipartStorageEngine } from '../interfaces/index.js';
+/**
+ * Where accepted files end up, named after multer's `FileAppender` strategies.
+ */
+export type FileStrategy = 'VALUE' | 'ARRAY' | 'OBJECT' | 'NONE';
+export interface UploadSpec {
+    /** Accepted file fields; `'ANY'` accepts every field without a count limit. */
+    fields: MultipartField[] | 'ANY';
+    strategy: FileStrategy;
+}
+/** Same resolution order as multer: `storage`, then `dest`, then memory. */
+export declare function resolveStorage(options: MultipartOptions): MultipartStorageEngine;
+/**
+ * Stops parsing and discards the rest of the body, so that an error response
+ * does not race a client that is still uploading (multer does the same
+ * before it reports an error).
+ */
+export declare function drainRequest(raw: IncomingMessage): Promise<void>;
+/**
+ * Rejects limits that are not a non-negative integer or `Infinity`, as
+ * multer does: busboy compares most limits with strict equality, so such a
+ * value would silently disable the limit.
+ */
+export declare function validateLimits(limits: MultipartLimits | undefined): void;
+/**
+ * Parses the multipart body with multer's semantics and populates
+ * `req.body` and `req.file` / `req.files`. Requests that are not multipart
+ * are passed through untouched, as multer does.
+ */
+export declare function processMultipart(request: FastifyRequest, spec: UploadSpec, options: MultipartOptions, storage: MultipartStorageEngine): Promise<void>;
+/**
+ * Parses up to and including the first file in `fieldName`, then stops and
+ * hands that file's stream to the route handler (`req.file.stream`). Text
+ * fields sent before the file are in `req.body`; anything after it is not
+ * parsed.
+ */
+export declare function processStream(request: FastifyRequest, fieldName: string, options: MultipartOptions): Promise<void>;