@nestjs/platform-fastify 12.0.3 → 12.1.0

package/multipart/multipart/multipart.parser.js

@@ -0,0 +1,369 @@
+import { BadRequestException, PayloadTooLargeException } from '@nestjs/common';
+import { diskStorage } from '../storage/disk.storage.js';
+import { memoryStorage } from '../storage/memory.storage.js';
+import { appendField } from './append-field.util.js';
+import { busboyExceptions, MISSING_PLUGIN_MESSAGE, multerExceptions, } from './multipart.constants.js';
+import { MultipartError } from './multipart.error.js';
+import { transformException } from './multipart.utils.js';
+/** Same resolution order as multer: `storage`, then `dest`, then memory. */
+export function resolveStorage(options) {
+    if (options.storage) {
+        return options.storage;
+    }
+    if (options.dest) {
+        return diskStorage({ destination: options.dest });
+    }
+    return memoryStorage();
+}
+function assertPluginRegistered(req) {
+    if (typeof req.isMultipart !== 'function') {
+        throw new Error(MISSING_PLUGIN_MESSAGE);
+    }
+}
+/**
+ * Per-route options handed to `req.parts()`; `@fastify/multipart` deep-merges
+ * them over the options the plugin was registered with. `@fastify/busboy`
+ * treats `fileSize` and `parts` as "max allowed" (it fires once a limit is
+ * exceeded), so unlike multer there is no `+1` adjustment. Truncation is
+ * detected here (`file.truncated`), so the plugin's own throw is disabled.
+ */
+function toBusboyConfig(limits, options) {
+    const config = { throwFileSizeLimit: false };
+    if (limits) {
+        config.limits = { ...limits };
+    }
+    if (options.preservePath !== undefined) {
+        config.preservePath = options.preservePath;
+    }
+    if (options.defParamCharset) {
+        config.defParamCharset = options.defParamCharset;
+    }
+    return config;
+}
+/**
+ * `file()` and `files()` are methods `@fastify/multipart` decorates the
+ * request prototype with. An own property shadows them for this request only,
+ * which is where `@UploadedFile()` / `@UploadedFiles()` read from on Fastify.
+ */
+function setOnRequest(req, key, value) {
+    req[key] = value;
+}
+/**
+ * Shadows both methods up front, so that the one this interceptor does not
+ * populate reads `undefined`, as on Express, rather than the plugin's method.
+ */
+function resetFiles(req) {
+    setOnRequest(req, 'file', undefined);
+    setOnRequest(req, 'files', undefined);
+}
+function toIncomingFile(part) {
+    const file = {
+        fieldname: part.fieldname,
+        originalname: decodeFormDataName(part.filename),
+        encoding: part.encoding,
+        mimetype: part.mimetype,
+    };
+    Object.defineProperty(file, 'stream', {
+        value: part.file,
+        enumerable: false,
+        configurable: true,
+    });
+    return file;
+}
+function applyFileFilter(options, req, file) {
+    if (!options.fileFilter) {
+        return Promise.resolve(true);
+    }
+    return new Promise((resolve, reject) => options.fileFilter(req, file, (err, accept) => err ? reject(err) : resolve(accept)));
+}
+const ABORTED = Symbol('aborted');
+/**
+ * Runs the storage engine. Resolves `ABORTED` when `@fastify/multipart`
+ * destroys the file stream mid-way (it does so, without an error, when the
+ * client disconnects or a limit is hit), because a storage engine waiting
+ * for `end` would otherwise never call back. The actual reason is then read
+ * from the parts iterator. A stream destroyed with an error was destroyed by
+ * the engine (e.g. by a `pipeline()` to a file that cannot be written), which
+ * reports that error itself.
+ *
+ * Whatever the engine stores after an abort is removed once it calls back,
+ * as multer does: what it stored when it succeeds, and the file at `path`
+ * (which engines set before writing, by multer's convention) when it fails.
+ */
+function storeFile(storage, req, file) {
+    return new Promise((resolve, reject) => {
+        const stream = file.stream;
+        if (stream.destroyed) {
+            return resolve(ABORTED);
+        }
+        let aborted = false;
+        const onClose = () => {
+            if (!stream.readableEnded && !stream.errored) {
+                aborted = true;
+                resolve(ABORTED);
+            }
+        };
+        stream.once('close', onClose);
+        storage._handleFile(req, file, (err, info) => {
+            stream.off('close', onClose);
+            if (!aborted) {
+                return err ? reject(err) : resolve(info ?? {});
+            }
+            const stored = Object.assign(file, err ? {} : info);
+            if (!err || stored.path) {
+                removeFiles(storage, req, [stored]).catch(() => undefined);
+            }
+        });
+    });
+}
+function removeFiles(storage, req, files) {
+    return Promise.all(files.map(file => new Promise(resolve => storage._removeFile(req, file, () => resolve()))));
+}
+/**
+ * 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 function drainRequest(raw) {
+    raw.unpipe();
+    if (raw.readableEnded || raw.destroyed) {
+        return Promise.resolve();
+    }
+    return new Promise(resolve => {
+        const done = () => resolve();
+        raw.once('end', done);
+        raw.once('close', done);
+        raw.once('error', done);
+        raw.resume();
+    });
+}
+/**
+ * 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 function validateLimits(limits) {
+    for (const [key, value] of Object.entries(limits ?? {})) {
+        if (value == null ||
+            (Number.isInteger(value) && value >= 0) ||
+            value === Infinity) {
+            continue;
+        }
+        throw new TypeError(`Expected limits.${key} to be a non-negative integer or Infinity`);
+    }
+}
+function resolveLimits(req, options) {
+    if (typeof options.limits !== 'function') {
+        return options.limits;
+    }
+    const limits = options.limits(req);
+    validateLimits(limits);
+    return limits;
+}
+/**
+ * Reverses the escapes browsers apply to form field names (`%0A`, `%0D`,
+ * `%22`), as multer does.
+ */
+function decodeFormDataName(name) {
+    return name.replace(/%0A|%0D|%22/gi, match => {
+        switch (match.toUpperCase()) {
+            case '%0A':
+                return '\n';
+            case '%0D':
+                return '\r';
+            default:
+                return '"';
+        }
+    });
+}
+/**
+ * Decodes the part's field name, and returns the name as it arrived.
+ */
+function decodeFieldName(part) {
+    if (part.fieldname == null) {
+        throw new MultipartError('MISSING_FIELD_NAME');
+    }
+    const rawName = part.fieldname;
+    part.fieldname = decodeFormDataName(rawName);
+    return rawName;
+}
+/**
+ * busboy does not enforce `fieldNameSize` for multipart bodies, so (like
+ * multer) it is checked here, against the name as it arrived.
+ */
+function checkFieldNameSize(rawName, limits) {
+    if (typeof limits?.fieldNameSize === 'number' &&
+        rawName.length > limits.fieldNameSize) {
+        throw new MultipartError('LIMIT_FIELD_KEY');
+    }
+}
+/**
+ * Adds a text field to `body`, with multer's checks, in multer's order.
+ */
+function appendTextField(body, part, limits) {
+    const rawName = decodeFieldName(part);
+    if (part.fieldnameTruncated) {
+        throw new MultipartError('LIMIT_FIELD_KEY');
+    }
+    if (part.valueTruncated) {
+        throw new MultipartError('LIMIT_FIELD_VALUE', part.fieldname);
+    }
+    checkFieldNameSize(rawName, limits);
+    if (!appendField(body, part.fieldname, part.value)) {
+        throw new MultipartError('INVALID_FIELD_NAME', part.fieldname);
+    }
+}
+/**
+ * Returns the stream of a file part, with multer's checks, in multer's
+ * order, or `undefined` for a part without a file name (an empty file
+ * input), which multer ignores.
+ */
+function readFilePart(part, limits) {
+    const rawName = decodeFieldName(part);
+    if (!part.filename) {
+        part.file.resume();
+        return undefined;
+    }
+    checkFieldNameSize(rawName, limits);
+    return part.file;
+}
+/**
+ * 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 async function processMultipart(request, spec, options, storage) {
+    const req = request;
+    assertPluginRegistered(req);
+    resetFiles(req);
+    if (!req.isMultipart()) {
+        return;
+    }
+    const filesLeft = new Map();
+    if (spec.fields !== 'ANY') {
+        for (const field of spec.fields) {
+            filesLeft.set(field.name, field.maxCount ?? Infinity);
+        }
+    }
+    const body = Object.create(null);
+    setOnRequest(req, 'body', body);
+    const stored = [];
+    try {
+        const limits = resolveLimits(req, options);
+        const iterator = req
+            .parts(toBusboyConfig(limits, options))[Symbol.asyncIterator]();
+        for (let result = await iterator.next(); !result.done; result = await iterator.next()) {
+            const part = result.value;
+            if (part.type === 'field') {
+                appendTextField(body, part, limits);
+                continue;
+            }
+            const stream = readFilePart(part, limits);
+            if (!stream) {
+                continue;
+            }
+            const left = spec.fields === 'ANY' ? Infinity : (filesLeft.get(part.fieldname) ?? 0);
+            if (left <= 0) {
+                throw new MultipartError('LIMIT_UNEXPECTED_FILE', part.fieldname);
+            }
+            const incoming = toIncomingFile(part);
+            if (!(await applyFileFilter(options, req, incoming))) {
+                stream.resume();
+                continue;
+            }
+            filesLeft.set(part.fieldname, left - 1);
+            const info = await storeFile(storage, req, incoming);
+            if (info === ABORTED) {
+                // Rejects with what aborted the stream: a limit, or the client
+                // disconnecting.
+                await iterator.next();
+                throw new BadRequestException(busboyExceptions.MULTIPART_UNEXPECTED_END_OF_FILE);
+            }
+            const file = { ...incoming, ...info };
+            stored.push(file);
+            // busboy truncates the file instead of failing; multer rejects it.
+            if (stream.truncated) {
+                throw new MultipartError('LIMIT_FILE_SIZE', part.fieldname);
+            }
+        }
+    }
+    catch (err) {
+        await removeFiles(storage, req, stored);
+        await drainRequest(req.raw);
+        throw transformException(err);
+    }
+    switch (spec.strategy) {
+        case 'VALUE':
+            setOnRequest(req, 'file', stored[0]);
+            break;
+        case 'ARRAY':
+            setOnRequest(req, 'files', stored);
+            break;
+        case 'OBJECT': {
+            const grouped = Object.create(null);
+            for (const file of stored) {
+                (grouped[file.fieldname] ??= []).push(file);
+            }
+            setOnRequest(req, 'files', grouped);
+            break;
+        }
+    }
+}
+/**
+ * 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 async function processStream(request, fieldName, options) {
+    const req = request;
+    assertPluginRegistered(req);
+    resetFiles(req);
+    if (!req.isMultipart()) {
+        return;
+    }
+    const body = Object.create(null);
+    setOnRequest(req, 'body', body);
+    try {
+        const limits = resolveLimits(req, options);
+        const iterator = req
+            .parts(toBusboyConfig(limits, options))[Symbol.asyncIterator]();
+        for (let result = await iterator.next(); !result.done; result = await iterator.next()) {
+            const part = result.value;
+            if (part.type === 'field') {
+                appendTextField(body, part, limits);
+                continue;
+            }
+            const stream = readFilePart(part, limits);
+            if (!stream) {
+                continue;
+            }
+            if (part.fieldname !== fieldName) {
+                throw new MultipartError('LIMIT_UNEXPECTED_FILE', part.fieldname);
+            }
+            const incoming = toIncomingFile(part);
+            if (!(await applyFileFilter(options, req, incoming))) {
+                stream.resume();
+                continue;
+            }
+            // busboy would silently truncate; fail the consumer's read instead.
+            // The limit may have been hit already: busboy parses the part as far
+            // as the chunk at hand goes before the part reaches this loop.
+            const rejectFile = () => stream.destroy(new PayloadTooLargeException(multerExceptions.LIMIT_FILE_SIZE));
+            if (stream.truncated) {
+                rejectFile();
+            }
+            else {
+                stream.once('limit', rejectFile);
+            }
+            const file = { ...incoming, stream };
+            setOnRequest(req, 'file', file);
+            // The iterator is left suspended: the handler now owns the stream.
+            return;
+        }
+    }
+    catch (err) {
+        await drainRequest(req.raw);
+        throw transformException(err);
+    }
+}

package/multipart/multipart/multipart.utils.d.ts

@@ -0,0 +1,28 @@
+import { HttpException } from '@nestjs/common';
+import type { MultipartModuleOptions, MultipartOptions } from '../interfaces/index.js';
+/**
+ * Merges module-level (global) options with interceptor-level (local)
+ * options, with the same rule as platform-express's `mergeMulterOptions`:
+ * `limits` is merged key-by-key when both sides define it as an object, and
+ * the local value wins outright otherwise.
+ */
+export declare function mergeMultipartOptions(options?: MultipartModuleOptions, localOptions?: MultipartOptions): MultipartModuleOptions;
+/**
+ * Maps parser errors to the same HTTP exceptions (status and message)
+ * platform-express's `transformException` produces for multer, so clients
+ * cannot tell the adapters apart.
+ *
+ * Errors raised by `@fastify/multipart` are identified by their `code`; only
+ * `@fastify/busboy`'s errors, which carry no code, are matched by message.
+ */
+export declare function transformException(error: (Error & {
+    code?: string;
+    part?: {
+        fieldname?: string;
+    };
+}) | undefined): HttpException | (Error & {
+    code?: string;
+    part?: {
+        fieldname?: string;
+    };
+}) | undefined;

package/multipart/multipart/multipart.utils.js

@@ -0,0 +1,54 @@
+import { BadRequestException, HttpException, PayloadTooLargeException, } from '@nestjs/common';
+import { isPlainObject } from '@nestjs/common/internal';
+import { busboyExceptions, fastifyBusboyMessages, fastifyMultipartBadRequestCodes, fastifyMultipartErrorCodes, } from './multipart.constants.js';
+import { MultipartError } from './multipart.error.js';
+/**
+ * Merges module-level (global) options with interceptor-level (local)
+ * options, with the same rule as platform-express's `mergeMulterOptions`:
+ * `limits` is merged key-by-key when both sides define it as an object, and
+ * the local value wins outright otherwise.
+ */
+export function mergeMultipartOptions(options = {}, localOptions = {}) {
+    const merged = { ...options, ...localOptions };
+    if (isPlainObject(options.limits) && isPlainObject(localOptions.limits)) {
+        merged.limits = { ...options.limits, ...localOptions.limits };
+    }
+    return merged;
+}
+/**
+ * Maps parser errors to the same HTTP exceptions (status and message)
+ * platform-express's `transformException` produces for multer, so clients
+ * cannot tell the adapters apart.
+ *
+ * Errors raised by `@fastify/multipart` are identified by their `code`; only
+ * `@fastify/busboy`'s errors, which carry no code, are matched by message.
+ */
+export function transformException(error) {
+    if (!error || error instanceof HttpException) {
+        return error;
+    }
+    if (isFastifyMultipartLimitCode(error.code)) {
+        error = new MultipartError(fastifyMultipartErrorCodes[error.code], error.part?.fieldname);
+    }
+    if (error instanceof MultipartError) {
+        if (error.code === 'LIMIT_FILE_SIZE') {
+            return new PayloadTooLargeException(error.message);
+        }
+        return new BadRequestException(error.field ? `${error.message} - ${error.field}` : error.message);
+    }
+    if (error.code && fastifyMultipartBadRequestCodes.includes(error.code)) {
+        return new BadRequestException(error.message);
+    }
+    const message = error.message ?? '';
+    if (message === fastifyBusboyMessages.BOUNDARY_NOT_FOUND) {
+        return new BadRequestException(busboyExceptions.MULTIPART_BOUNDARY_NOT_FOUND);
+    }
+    if (message === fastifyBusboyMessages.UNEXPECTED_END_OF_FORM ||
+        message.includes(fastifyBusboyMessages.PART_TERMINATED_EARLY)) {
+        return new BadRequestException(busboyExceptions.MULTIPART_UNEXPECTED_END_OF_FORM);
+    }
+    return error;
+}
+function isFastifyMultipartLimitCode(code) {
+    return (typeof code === 'string' && Object.hasOwn(fastifyMultipartErrorCodes, code));
+}

package/multipart/multipart.constants.d.ts

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

package/multipart/multipart.constants.js

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

package/multipart/multipart.module.d.ts

@@ -0,0 +1,18 @@
+import { type DynamicModule } from '@nestjs/common';
+import type { MultipartModuleAsyncOptions, MultipartModuleOptions } from './interfaces/files-upload-module.interface.js';
+/**
+ * Provides default options for every upload interceptor in the importing
+ * module. The Fastify counterpart of platform-express's `MulterModule`.
+ *
+ * It does not configure the `@fastify/multipart` plugin itself (which the
+ * FastifyAdapter registers); pass plugin-wide options through the
+ * adapter's `multipart` option.
+ *
+ * @publicApi
+ */
+export declare class MultipartModule {
+    static register(options?: MultipartModuleOptions): DynamicModule;
+    static registerAsync(options: MultipartModuleAsyncOptions): DynamicModule;
+    private static createAsyncProviders;
+    private static createAsyncOptionsProvider;
+}

package/multipart/multipart.module.js

@@ -0,0 +1,75 @@
+var MultipartModule_1;
+import { __decorate } from "tslib";
+import { Module } from '@nestjs/common';
+import { randomStringGenerator } from '@nestjs/common/internal';
+import { MULTIPART_MODULE_OPTIONS } from './files.constants.js';
+import { MULTIPART_MODULE_ID } from './multipart.constants.js';
+/**
+ * Provides default options for every upload interceptor in the importing
+ * module. The Fastify counterpart of platform-express's `MulterModule`.
+ *
+ * It does not configure the `@fastify/multipart` plugin itself (which the
+ * FastifyAdapter registers); pass plugin-wide options through the
+ * adapter's `multipart` option.
+ *
+ * @publicApi
+ */
+let MultipartModule = MultipartModule_1 = class MultipartModule {
+    static register(options = {}) {
+        return {
+            module: MultipartModule_1,
+            providers: [
+                { provide: MULTIPART_MODULE_OPTIONS, useFactory: () => options },
+                {
+                    provide: MULTIPART_MODULE_ID,
+                    useValue: randomStringGenerator(),
+                },
+            ],
+            exports: [MULTIPART_MODULE_OPTIONS],
+        };
+    }
+    static registerAsync(options) {
+        return {
+            module: MultipartModule_1,
+            imports: options.imports,
+            providers: [
+                ...this.createAsyncProviders(options),
+                {
+                    provide: MULTIPART_MODULE_ID,
+                    useValue: randomStringGenerator(),
+                },
+            ],
+            exports: [MULTIPART_MODULE_OPTIONS],
+        };
+    }
+    static createAsyncProviders(options) {
+        if (options.useExisting || options.useFactory) {
+            return [this.createAsyncOptionsProvider(options)];
+        }
+        return [
+            this.createAsyncOptionsProvider(options),
+            {
+                provide: options.useClass,
+                useClass: options.useClass,
+            },
+        ];
+    }
+    static createAsyncOptionsProvider(options) {
+        if (options.useFactory) {
+            return {
+                provide: MULTIPART_MODULE_OPTIONS,
+                useFactory: options.useFactory,
+                inject: options.inject || [],
+            };
+        }
+        return {
+            provide: MULTIPART_MODULE_OPTIONS,
+            useFactory: async (optionsFactory) => optionsFactory.createMultipartOptions(),
+            inject: [options.useExisting || options.useClass],
+        };
+    }
+};
+MultipartModule = MultipartModule_1 = __decorate([
+    Module({})
+], MultipartModule);
+export { MultipartModule };

package/multipart/storage/disk.storage.d.ts

@@ -0,0 +1,24 @@
+import type { IncomingMultipartFile, MultipartStorageEngine } from '../interfaces/index.js';
+type NameCallback = (error: Error | null, value: string) => void;
+type NameResolver = (req: any, file: IncomingMultipartFile, callback: NameCallback) => void;
+/**
+ * @publicApi
+ */
+export interface DiskStorageOptions {
+    /**
+     * The folder files are written to (Default: `os.tmpdir()`). A string is
+     * created when the storage engine is; a function must return a folder that
+     * already exists.
+     */
+    destination?: string | NameResolver;
+    /** The file name within `destination` (Default: 32 random hex characters, no extension). */
+    filename?: NameResolver;
+}
+/**
+ * Writes each file to disk, with multer's `diskStorage` defaults and file
+ * shape (`destination`, `filename`, `path`, `size`).
+ *
+ * @publicApi
+ */
+export declare function diskStorage(options?: DiskStorageOptions): MultipartStorageEngine;
+export {};

package/multipart/storage/disk.storage.js

@@ -0,0 +1,58 @@
+import { randomBytes } from 'crypto';
+import { createWriteStream, mkdirSync } from 'fs';
+import { unlink } from 'fs/promises';
+import { tmpdir } from 'os';
+import { join } from 'path';
+import { pipeline } from 'stream/promises';
+function resolveName(resolver, req, file) {
+    return new Promise((resolve, reject) => resolver(req, file, (err, value) => (err ? reject(err) : resolve(value))));
+}
+/**
+ * Writes each file to disk, with multer's `diskStorage` defaults and file
+ * shape (`destination`, `filename`, `path`, `size`).
+ *
+ * @publicApi
+ */
+export function diskStorage(options = {}) {
+    let resolveDestination;
+    if (typeof options.destination === 'string') {
+        const destination = options.destination;
+        mkdirSync(destination, { recursive: true });
+        resolveDestination = (_req, _file, callback) => callback(null, destination);
+    }
+    else {
+        resolveDestination =
+            options.destination ??
+                ((_req, _file, callback) => callback(null, tmpdir()));
+    }
+    const resolveFilename = options.filename ??
+        ((_req, _file, callback) => callback(null, randomBytes(16).toString('hex')));
+    const store = async (req, file) => {
+        const destination = await resolveName(resolveDestination, req, file);
+        const filename = await resolveName(resolveFilename, req, file);
+        const path = join(destination, filename);
+        // As in multer, `path` is known to the file before it is written.
+        file.path = path;
+        const out = createWriteStream(path);
+        try {
+            await pipeline(file.stream, out);
+        }
+        catch (err) {
+            await unlink(path).catch(() => undefined);
+            throw err;
+        }
+        return { destination, filename, path, size: out.bytesWritten };
+    };
+    return {
+        _handleFile(req, file, callback) {
+            store(req, file).then(info => callback(null, info), err => callback(err));
+        },
+        _removeFile(_req, file, callback) {
+            const path = file.path;
+            delete file.destination;
+            delete file.filename;
+            delete file.path;
+            unlink(path).then(() => callback(null), err => callback(err));
+        },
+    };
+}

package/multipart/storage/index.d.ts

@@ -0,0 +1,2 @@
+export * from './disk.storage.js';
+export * from './memory.storage.js';

package/multipart/storage/index.js

@@ -0,0 +1,2 @@
+export * from './disk.storage.js';
+export * from './memory.storage.js';

package/multipart/storage/memory.storage.d.ts

@@ -0,0 +1,8 @@
+import type { MultipartStorageEngine } from '../interfaces/index.js';
+/**
+ * Buffers each file into `file.buffer`. The default storage engine, as in
+ * multer.
+ *
+ * @publicApi
+ */
+export declare function memoryStorage(): MultipartStorageEngine;

package/multipart/storage/memory.storage.js

@@ -0,0 +1,23 @@
+/**
+ * Buffers each file into `file.buffer`. The default storage engine, as in
+ * multer.
+ *
+ * @publicApi
+ */
+export function memoryStorage() {
+    return {
+        _handleFile(_req, file, callback) {
+            const chunks = [];
+            file.stream.on('data', (chunk) => chunks.push(chunk));
+            file.stream.once('error', callback);
+            file.stream.once('end', () => {
+                const buffer = Buffer.concat(chunks);
+                callback(null, { buffer, size: buffer.length });
+            });
+        },
+        _removeFile(_req, file, callback) {
+            delete file.buffer;
+            callback(null);
+        },
+    };
+}