@nestjs/platform-fastify 11.2.5 → 11.2.6

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/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>;

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

@@ -0,0 +1,13 @@
+import { createMultipartInterceptor } from '../multipart/multipart-interceptor.factory.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 function NoFilesInterceptor(localOptions) {
+    return createMultipartInterceptor({ fields: [], strategy: 'NONE' }, localOptions);
+}

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>;