@leo-h/create-nodejs-app 1.0.44 → 1.0.45

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@leo-h/create-nodejs-app",
-  "version": "1.0.44",
+  "version": "1.0.45",
   "packageManager": "pnpm@9.15.9",
   "author": "Leonardo Henrique <leonardo0507.business@gmail.com>",
   "description": "Create a modern Node.js app with TypeScript using one command.",

package/templates/fastify/.lintstagedrc.json

@@ -1,4 +1,4 @@
 {
   "*.{js,ts,json,yaml,yml,md}": "prettier --write --cache",
-  "*.{js,ts}": ["eslint --max-warnings 0 --fix --cache"]
+  "*.{js,ts}": ["eslint --max-warnings 0 --fix --cache --no-ignore"]
 }

package/templates/fastify/package.json

@@ -18,10 +18,12 @@
   "dependencies": {
     "@fastify/cookie": "11.0.2",
     "@fastify/cors": "11.0.1",
+    "@fastify/multipart": "9.0.3",
     "@fastify/swagger": "9.4.2",
     "@fastify/swagger-ui": "5.2.2",
     "dotenv": "16.4.7",
     "fastify": "5.3.2",
+    "fastify-plugin": "5.0.1",
     "fastify-type-provider-zod": "4.0.2",
     "zod": "3.24.2"
   },

package/templates/fastify/pnpm-lock.yaml

@@ -14,6 +14,9 @@ importers:
       '@fastify/cors':
         specifier: 11.0.1
         version: 11.0.1
+      '@fastify/multipart':
+        specifier: 9.0.3
+        version: 9.0.3
       '@fastify/swagger':
         specifier: 9.4.2
         version: 9.4.2
@@ -26,6 +29,9 @@ importers:
       fastify:
         specifier: 5.3.2
         version: 5.3.2
+      fastify-plugin:
+        specifier: 5.0.1
+        version: 5.0.1
       fastify-type-provider-zod:
         specifier: 4.0.2
         version: 4.0.2(fastify@5.3.2)(zod@3.24.2)
@@ -292,12 +298,18 @@ packages:
   '@fastify/ajv-compiler@4.0.2':
     resolution: {integrity: sha512-Rkiu/8wIjpsf46Rr+Fitd3HRP+VsxUFDDeag0hs9L0ksfnwx2g7SPQQTFL0E8Qv+rfXzQOxBJnjUB9ITUDjfWQ==}
 
+  '@fastify/busboy@3.1.1':
+    resolution: {integrity: sha512-5DGmA8FTdB2XbDeEwc/5ZXBl6UbBAyBOOLlPuBnZ/N1SwdH9Ii+cOX3tBROlDgcTXxjOYnLMVoKk9+FXAw0CJw==}
+
   '@fastify/cookie@11.0.2':
     resolution: {integrity: sha512-GWdwdGlgJxyvNv+QcKiGNevSspMQXncjMZ1J8IvuDQk0jvkzgWWZFNC2En3s+nHndZBGV8IbLwOI/sxCZw/mzA==}
 
   '@fastify/cors@11.0.1':
     resolution: {integrity: sha512-dmZaE7M1f4SM8ZZuk5RhSsDJ+ezTgI7v3HHRj8Ow9CneczsPLZV6+2j2uwdaSLn8zhTv6QV0F4ZRcqdalGx1pQ==}
 
+  '@fastify/deepmerge@2.0.2':
+    resolution: {integrity: sha512-3wuLdX5iiiYeZWP6bQrjqhrcvBIf0NHbQH1Ur1WbHvoiuTYUEItgygea3zs8aHpiitn0lOB8gX20u1qO+FDm7Q==}
+
   '@fastify/error@4.1.0':
     resolution: {integrity: sha512-KeFcciOr1eo/YvIXHP65S94jfEEqn1RxTRBT1aJaHxY5FK0/GDXYozsQMMWlZoHgi8i0s+YtrLsgj/JkUUjSkQ==}
 
@@ -310,6 +322,9 @@ packages:
   '@fastify/merge-json-schemas@0.2.1':
     resolution: {integrity: sha512-OA3KGBCy6KtIvLf8DINC5880o5iBlDX4SxzLQS8HorJAbqluzLRn80UXU0bxZn7UOFhFgpRJDasfwn9nG4FG4A==}
 
+  '@fastify/multipart@9.0.3':
+    resolution: {integrity: sha512-pJogxQCrT12/6I5Fh6jr3narwcymA0pv4B0jbC7c6Bl9wnrxomEUnV0d26w6gUls7gSXmhG8JGRMmHFIPsxt1g==}
+
   '@fastify/proxy-addr@5.0.0':
     resolution: {integrity: sha512-37qVVA1qZ5sgH7KpHkkC4z9SK6StIsIcOmpjvMPXNb3vx2GQxhZocogVYbr2PbbeLCQxYIPDok307xEvRZOzGA==}
 
@@ -1729,6 +1744,9 @@ packages:
     resolution: {integrity: sha512-b3rppTKm9T+PsVCBEOUR46GWI7fdOs00VKZ1+9c1EWDaDMvjQc6tUwuFyIprgGgTcWoVHSKrU8H31ZHA2e0RHA==}
     engines: {node: '>=10'}
 
+  secure-json-parse@3.0.2:
+    resolution: {integrity: sha512-H6nS2o8bWfpFEV6U38sOSjS7bTbdgbCGU9wEM6W14P5H0QOsz94KCusifV44GpHDTu2nqZbuDNhTzu+mjDSw1w==}
+
   secure-json-parse@4.0.0:
     resolution: {integrity: sha512-dxtLJO6sc35jWidmLxo7ij+Eg48PM/kleBsxpC8QJE0qJICe+KawkDQmvCMZUr9u7WKVHgMW6vy3fQ7zMiFZMA==}
 
@@ -2231,6 +2249,8 @@ snapshots:
       ajv-formats: 3.0.1(ajv@8.17.1)
       fast-uri: 3.0.6
 
+  '@fastify/busboy@3.1.1': {}
+
   '@fastify/cookie@11.0.2':
     dependencies:
       cookie: 1.0.2
@@ -2241,6 +2261,8 @@ snapshots:
       fastify-plugin: 5.0.1
       toad-cache: 3.7.0
 
+  '@fastify/deepmerge@2.0.2': {}
+
   '@fastify/error@4.1.0': {}
 
   '@fastify/fast-json-stringify-compiler@5.0.3':
@@ -2253,6 +2275,14 @@ snapshots:
     dependencies:
       dequal: 2.0.3
 
+  '@fastify/multipart@9.0.3':
+    dependencies:
+      '@fastify/busboy': 3.1.1
+      '@fastify/deepmerge': 2.0.2
+      '@fastify/error': 4.1.0
+      fastify-plugin: 5.0.1
+      secure-json-parse: 3.0.2
+
   '@fastify/proxy-addr@5.0.0':
     dependencies:
       '@fastify/forwarded': 3.0.0
@@ -3652,6 +3682,8 @@ snapshots:
 
   safe-stable-stringify@2.5.0: {}
 
+  secure-json-parse@3.0.2: {}
+
   secure-json-parse@4.0.0: {}
 
   seek-bzip@2.0.0:

package/templates/fastify/src/core/create-controller-response-schema.ts

@@ -29,9 +29,18 @@ export function createControllerResponseSchema<
       >
     : ErrorInstance<ErrorClasses, K>["schema"];
 } {
-  const errorInstances = errorClasses.map(ErrorClass => {
-    return new ErrorClass();
-  });
+  const errorInstances = errorClasses
+    .map(ErrorClass => {
+      return new ErrorClass();
+    })
+    .filter((errorInstance, index, array) => {
+      const prevErrorInstances = array.slice(0, index);
+      const errorAlreadyFiltered = prevErrorInstances.some(({ error }) => {
+        return error === errorInstance.error;
+      });
+
+      return !errorAlreadyFiltered;
+    });
   const statusCodes = [
     ...new Set([
       ...Object.keys(successResponses),

package/templates/fastify/src/env.ts

@@ -1,5 +1,6 @@
 import packageJson from "@/../package.json";
 import { config } from "dotenv";
+import { existsSync, mkdirSync } from "node:fs";
 import { resolve } from "node:path";
 import { z } from "zod";
 
@@ -21,21 +22,33 @@ if (process.env.npm_lifecycle_event?.includes(":test"))
 if (!process.env.NODE_ENV)
   throw new Error("Could not set to the environment variables to use.");
 
-const envFileName =
-  envFileNames[process.env.NODE_ENV as keyof typeof envFileNames];
+const nodeEnv = process.env.NODE_ENV as keyof typeof envFileNames;
+const envFileName = envFileNames[nodeEnv];
 
 config({
-  path: resolve(__dirname, "..", envFileName),
+  path: resolve(
+    __dirname,
+    nodeEnv === "production" ? "../../" : "..",
+    envFileName,
+  ),
   override: true,
 });
 
 const schema = z.object({
-  NODE_ENV: z
-    .enum(["production", "development", "test"])
-    .default(process.env.NODE_ENV as keyof typeof envFileNames),
+  NODE_ENV: z.enum(["production", "development", "test"]).default(nodeEnv),
   API_NAME: z.string().default(packageJson.name),
   API_PORT: z.coerce.number().default(3333),
   API_ACCESS_PERMISSION_CLIENT_SIDE: z.string().default("*"),
+  TMP_FILES_PATH: z
+    .string()
+    .default("./tmp")
+    .transform(pathFromSrc => {
+      const tmpPath = resolve(__dirname, "..", pathFromSrc);
+
+      if (!existsSync(tmpPath)) mkdirSync(tmpPath);
+
+      return tmpPath;
+    }),
 });
 
 const parsedEnv = schema.safeParse(process.env);

package/templates/fastify/src/http/app.ts

@@ -12,8 +12,9 @@ import {
 import { env } from "../env";
 import { errorHandlerPlugin } from "./plugins/error-handler.plugin";
 import { notFoundErrorHandlerPlugin } from "./plugins/not-found-error-handler.plugin";
-import { swaggerUiPlugin } from "./plugins/swagger-ui.plugin";
 import { routesPlugin } from "./plugins/routes.plugin";
+import { swaggerFileZodSchemaTransformPlugin } from "./plugins/swagger-file-zod-schema-transform.plugin";
+import { swaggerUiPlugin } from "./plugins/swagger-ui.plugin";
 
 export const app = fastify().withTypeProvider<ZodTypeProvider>();
 export const appPrefix = "/v1";
@@ -31,7 +32,13 @@ app.register(fastifySwagger, {
     },
     servers: [],
   },
-  transform: jsonSchemaTransform,
+  transform: data => {
+    const jsonSchema = jsonSchemaTransform(data);
+
+    swaggerFileZodSchemaTransformPlugin(data, jsonSchema);
+
+    return jsonSchema;
+  },
 });
 app.register(swaggerUiPlugin);
 app.register(routesPlugin, { prefix: appPrefix });

package/templates/fastify/src/http/controllers/hello-multipart.controller.spec.ts

@@ -0,0 +1,122 @@
+import { env } from "@/env";
+import { faker } from "@faker-js/faker";
+import {
+  createSafeFormData,
+  CreateSafeFormDataOutput,
+} from "test/integration/create-safe-form-data";
+import { createTestRequest } from "test/integration/create-test-request";
+import { OverrideProperties } from "type-fest";
+import { beforeEach, describe, expect, test } from "vitest";
+import { appPrefix } from "../app";
+import { ValidationError } from "../errors";
+import {
+  HelloMultipartControllerBodyInput,
+  helloMultipartControllerMethod,
+  helloMultipartControllerUrl,
+} from "./hello-multipart.controller";
+
+const sutMethod = helloMultipartControllerMethod;
+const sutUrl = appPrefix + helloMultipartControllerUrl;
+
+type FormDataInput = OverrideProperties<
+  HelloMultipartControllerBodyInput,
+  {
+    attachment: Blob;
+  }
+>;
+
+const createFormData = createSafeFormData<FormDataInput>;
+
+const sut = createTestRequest<{
+  body: FormData;
+}>({
+  method: sutMethod,
+  url: sutUrl,
+});
+
+describe(`[Controller] ${sutMethod} ${sutUrl}`, () => {
+  let defaultFormDataInput: CreateSafeFormDataOutput<FormDataInput>;
+
+  beforeEach(() => {
+    const randomText = faker.lorem.sentences(2);
+    const randomTextBlob = new Blob([randomText], { type: "text/plain" });
+
+    defaultFormDataInput = createFormData({
+      show: "true",
+      attachment: randomTextBlob,
+    });
+  });
+
+  describe("should not be able to get hello world with multipart/form-data content-type", () => {
+    describe("if invalid input", () => {
+      const error = new ValidationError(null);
+
+      test("with invalid property show", async () => {
+        const formDataInput = createFormData({
+          ...defaultFormDataInput.input,
+          // @ts-expect-error the value must be a string
+          show: 0,
+        });
+
+        const result = await sut({
+          body: formDataInput.formData,
+        });
+
+        expect(result.statusCode).toEqual(error.statusCode);
+        expect(result.body).toMatchObject({
+          ...error.serialize(),
+          debug: [
+            expect.objectContaining({
+              instancePath: "/show",
+            }),
+          ],
+        });
+      });
+    });
+
+    test("if property show is set to false", async () => {
+      const formDataInput = createFormData({
+        ...defaultFormDataInput.input,
+        show: "false",
+      });
+
+      const result = await sut({
+        body: formDataInput.formData,
+      });
+
+      const error = new ValidationError(
+        `Você não quer exibir o "Hello world" :(`,
+      );
+
+      expect(result.statusCode).toEqual(error.statusCode);
+      expect(result.body).toStrictEqual(error.serialize());
+    });
+  });
+
+  describe("should be able to get hello world with multipart/form-data content-type", async () => {
+    test("if property show is set to true", async () => {
+      const formDataInput = createFormData({
+        ...defaultFormDataInput.input,
+        show: "true",
+      });
+
+      const result = await sut({
+        body: formDataInput.formData,
+      });
+
+      expect(result.statusCode).toEqual(200);
+      expect(result.body).toStrictEqual({
+        message: "Hello world!",
+        attachment: {
+          type: "file",
+          encoding: "7bit",
+          mimetype: "text/plain",
+          fileStream: expect.any(Object),
+          fileOriginalName: "blob",
+          fileName: expect.any(String),
+          filePath: expect.stringContaining(env.TMP_FILES_PATH),
+        },
+      });
+    });
+  });
+});

package/templates/fastify/src/http/controllers/hello-multipart.controller.ts

@@ -0,0 +1,67 @@
+import { FastifyZodInstance } from "@/@types/fastify";
+import { createControllerResponseSchema } from "@/core/create-controller-response-schema";
+import { z } from "zod";
+import { InternalServerError, ValidationError } from "../errors";
+import {
+  MultipartFormDataDiskFile,
+  multipartFormDataPlugin,
+} from "../plugins/multipart-form-data.plugin";
+
+export const helloMultipartControllerMethod = "POST" as const;
+export const helloMultipartControllerUrl = "/hello/multipart" as const;
+
+export type HelloMultipartControllerBodyInput = z.input<
+  typeof helloMultipartControllerBodySchema
+>;
+
+const helloMultipartControllerBodySchema = z.object({
+  show: z
+    .enum(["true", "false"])
+    .transform<boolean>(val => JSON.parse(val))
+    .default("true"),
+  attachment: MultipartFormDataDiskFile.schema,
+});
+
+export default function helloMultipartController(app: FastifyZodInstance) {
+  app.register(multipartFormDataPlugin.plugin, {
+    attachments: {
+      storage: "disk",
+      allowedMimeTypes: ["text/plain"],
+      maxCount: 1,
+      maxSize: 1024 * 1024 * 50, // 50MB
+    },
+  });
+
+  app.route({
+    method: helloMultipartControllerMethod,
+    url: helloMultipartControllerUrl,
+    schema: {
+      operationId: "helloMultipartController",
+      tags: ["Hello"],
+      summary: "Hello world!",
+      consumes: ["multipart/form-data"],
+      body: helloMultipartControllerBodySchema,
+      response: createControllerResponseSchema(
+        {
+          200: z.object({
+            message: z.literal("Hello world!"),
+            attachment: z.custom(),
+          }),
+        },
+        InternalServerError,
+        ValidationError,
+      ),
+    },
+    handler: async (request, response) => {
+      const { show, attachment } = request.body;
+
+      if (!show)
+        return new ValidationError(`Você não quer exibir o "Hello world" :(`);
+
+      response.status(200).send({
+        message: "Hello world!",
+        attachment: attachment,
+      });
+    },
+  });
+}

package/templates/fastify/src/http/controllers/hello.controller.ts

@@ -7,10 +7,10 @@ export const helloControllerMethod = "GET" as const;
 export const helloControllerUrl = "/hello" as const;
 
 export type HelloControllerQueryParamsInput = z.input<
-  typeof helloControllerQueryParamsInputSchema
+  typeof helloControllerQueryParamsSchema
 >;
 
-const helloControllerQueryParamsInputSchema = z.object({
+const helloControllerQueryParamsSchema = z.object({
   show: z
     .enum(["true", "false"])
     .transform<boolean>(val => JSON.parse(val))
@@ -25,7 +25,7 @@ export default function helloController(app: FastifyZodInstance) {
       operationId: "helloController",
       tags: ["Hello"],
       summary: "Hello world!",
-      querystring: helloControllerQueryParamsInputSchema,
+      querystring: helloControllerQueryParamsSchema,
       response: createControllerResponseSchema(
         {
           200: z.object({

package/templates/fastify/src/http/errors.ts

@@ -35,7 +35,7 @@ export class InternalServerError extends BaseError {
   public readonly error = "INTERNAL_SERVER_ERROR";
   public readonly statusCode = 500;
   public readonly message =
-    "Desculpe, um erro inesperado ocorreu. Tente novamente alguns minutos ou nos contate.";
+    "Desculpe, um erro inesperado ocorreu. Tente novamente em alguns minutos ou nos contate.";
 
   public constructor(public debug: unknown) {
     super();

package/templates/fastify/src/http/plugins/error-handler.plugin.ts

@@ -1,6 +1,8 @@
 import { FastifyZodReply, FastifyZodRequest } from "@/@types/fastify";
+import { FastifyError } from "fastify";
 import { hasZodFastifySchemaValidationErrors } from "fastify-type-provider-zod";
 import { BaseError, InternalServerError, ValidationError } from "../errors";
+import { multipartFormDataPluginErrorCodes } from "./multipart-form-data.plugin";
 
 export function errorHandlerPlugin(
   error: unknown,
@@ -9,14 +11,48 @@ export function errorHandlerPlugin(
 ) {
   let httpError: BaseError;
 
-  if (error instanceof BaseError) {
-    httpError = error;
-  } else if (error instanceof SyntaxError) {
-    httpError = new ValidationError(error.message);
-  } else if (hasZodFastifySchemaValidationErrors(error)) {
-    httpError = new ValidationError(error.validation);
-  } else {
-    httpError = new InternalServerError(error);
+  switch (true) {
+    case error instanceof BaseError: {
+      httpError = error;
+      break;
+    }
+
+    case error instanceof SyntaxError: {
+      httpError = new ValidationError(error.message);
+      break;
+    }
+
+    case hasZodFastifySchemaValidationErrors(error): {
+      httpError = new ValidationError(error.validation);
+      break;
+    }
+
+    case error instanceof Error && error.name === "FastifyError": {
+      const fastifyError = error as FastifyError;
+
+      if (fastifyError.code.startsWith("FST_ERR_CTP")) {
+        httpError = new ValidationError(error);
+        break;
+      }
+
+      const multipartErrorCodes =
+        multipartFormDataPluginErrorCodes as unknown as string[];
+
+      if (multipartErrorCodes.includes(fastifyError.code)) {
+        if ("part" in error) delete error.part;
+
+        httpError = new ValidationError(error);
+        break;
+      }
+
+      httpError = new InternalServerError(error);
+      break;
+    }
+
+    default: {
+      httpError = new InternalServerError(error);
+      break;
+    }
   }
 
   const isCriticalError = httpError.statusCode.toString().startsWith("5");

package/templates/fastify/src/http/plugins/multipart-form-data.plugin.ts

@@ -0,0 +1,241 @@
+import { FastifyZodInstance } from "@/@types/fastify";
+import { env } from "@/env";
+import fastifyMultipart, { MultipartFile } from "@fastify/multipart";
+import { errorCodes } from "fastify";
+import fastifyPlugin from "fastify-plugin";
+import { randomUUID } from "node:crypto";
+import { createWriteStream } from "node:fs";
+import { rm } from "node:fs/promises";
+import { basename, extname, resolve } from "node:path";
+import { pipeline } from "node:stream/promises";
+import { z } from "zod";
+import { ValidationError } from "../errors";
+
+type InMemoryAttachmentStorage = {
+  /**
+   * File storage strategy.
+   *
+   * @default "disk"
+   */
+  storage?: "in-memory";
+};
+
+type DiskAttachmentStorage = {
+  storage?: "disk";
+  /**
+   * File storage directory.
+   *
+   * @default env.TMP_FILES_PATH
+   */
+  destinationPath?: string;
+  /**
+   * Remove files after route handler execution
+   *
+   * @default true
+   */
+  removeAfterHandlerExecution?: boolean;
+};
+
+type AttachmentsStorage = InMemoryAttachmentStorage | DiskAttachmentStorage;
+
+type MultipartFormDataPluginOptions = {
+  attachments?: AttachmentsStorage & {
+    /**
+     * Allowed mime types of files.
+     *
+     * @example ["image/webp", "image/jpeg"]
+     *
+     * @default []
+     */
+    allowedMimeTypes?: string[];
+    /**
+     * Maximum number of files allowed.
+     *
+     * @default 1
+     */
+    maxCount?: number;
+    /**
+     * Maximum size allowed for each file in bytes.
+     *
+     * @default 1024 * 1024 * 10 // 10MB
+     */
+    maxSize?: number;
+  };
+};
+
+const plugin = fastifyPlugin(
+  (app: FastifyZodInstance, _options: MultipartFormDataPluginOptions, done) => {
+    const options = {
+      ..._options,
+      attachments: {
+        storage: "disk",
+        destinationPath: env.TMP_FILES_PATH,
+        removeAfterHandlerExecution: true,
+        allowedMimeTypes: [],
+        maxCount: 1,
+        maxSize: 1024 * 1024 * 10, // 10MB
+        ..._options.attachments,
+      },
+    } satisfies MultipartFormDataPluginOptions;
+
+    app.addHook("onRequest", async request => {
+      const contentType = request.headers["content-type"];
+      const { FST_ERR_CTP_INVALID_MEDIA_TYPE } = errorCodes;
+
+      if (!contentType?.startsWith("multipart/form-data")) {
+        throw new ValidationError(FST_ERR_CTP_INVALID_MEDIA_TYPE(contentType));
+      }
+    });
+
+    app.register(fastifyMultipart, {
+      attachFieldsToBody: "keyValues",
+      limits: {
+        fieldNameSize: 100,
+        fieldSize: 1024 * 1024, // 1MB
+        fields: Infinity,
+        parts: Infinity,
+        headerPairs: 2000,
+        files: options.attachments.maxCount,
+        fileSize: options.attachments.maxSize,
+      },
+      async onFile(file) {
+        const allowedMimeTypes = options.attachments
+          .allowedMimeTypes as string[];
+
+        if (
+          !allowedMimeTypes.includes(file.mimetype) &&
+          !allowedMimeTypes.length
+        ) {
+          throw new ValidationError(
+            `Nenhum MIME type de arquivo foi configurado para ser aceito.`,
+          );
+        }
+
+        if (
+          !allowedMimeTypes.includes(file.mimetype) &&
+          allowedMimeTypes.length
+        ) {
+          throw new ValidationError(
+            `Apenas os seguintes MIME types são aceitos: ${allowedMimeTypes.join(", ")}.`,
+          );
+        }
+
+        if (options.attachments.storage === "in-memory") {
+          const buffer = await file.toBuffer();
+
+          // eslint-disable-next-line @typescript-eslint/no-explicit-any
+          (file as any).value = new MultipartFormDataInMemoryFile(file, buffer);
+          return;
+        }
+
+        const uniqueFileName = randomUUID() + extname(file.filename);
+        const filePath = resolve(env.TMP_FILES_PATH, uniqueFileName);
+
+        await pipeline(file.file, createWriteStream(filePath));
+
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        (file as any).value = new MultipartFormDataDiskFile(file, filePath);
+      },
+    });
+
+    if (
+      options.attachments.storage === "disk" &&
+      options.attachments.removeAfterHandlerExecution
+    ) {
+      app.addHook("onResponse", async request => {
+        if (!request.body || typeof request.body !== "object") return;
+
+        const bodyDiskFiles = Object.values(request.body)
+          .filter(value => {
+            const valueIsDiskFile = value instanceof MultipartFormDataDiskFile;
+            const valueIsArrayOfDiskFile =
+              Array.isArray(value) &&
+              value.some(item => item instanceof MultipartFormDataDiskFile);
+
+            return valueIsDiskFile || valueIsArrayOfDiskFile;
+          })
+          .flat() as MultipartFormDataDiskFile[];
+
+        if (!bodyDiskFiles.length) return;
+
+        await Promise.all(
+          bodyDiskFiles.map(diskFile => rm(diskFile.filePath, { force: true })),
+        );
+      });
+    }
+
+    done();
+  },
+);
+
+export const multipartFormDataPlugin = Object.freeze({
+  plugin,
+} as const);
+
+export const multipartFormDataPluginErrorCodes = [
+  "FST_PARTS_LIMIT",
+  "FST_FILES_LIMIT",
+  "FST_FIELDS_LIMIT",
+  "FST_REQ_FILE_TOO_LARGE",
+  "FST_PROTO_VIOLATION",
+  "FST_INVALID_MULTIPART_CONTENT_TYPE",
+  "FST_INVALID_JSON_FIELD_ERROR",
+  "FST_FILE_BUFFER_NOT_FOUND",
+  "FST_NO_FORM_DATA",
+] as const;
+
+export const MULTIPART_FORM_DATA_FILE_SCHEMA_DESCRIPTION =
+  "MULTIPART_FORM_DATA_ATTACHMENT";
+
+export class MultipartFormDataFile {
+  public type: MultipartFile["type"];
+  public encoding: MultipartFile["encoding"];
+  public mimetype: MultipartFile["mimetype"];
+  public fileStream: MultipartFile["file"];
+  public fileOriginalName: MultipartFile["filename"];
+
+  public constructor(multipartFile: MultipartFile) {
+    this.type = multipartFile.type;
+    this.encoding = multipartFile.encoding;
+    this.mimetype = multipartFile.mimetype;
+    this.fileStream = multipartFile.file;
+    this.fileOriginalName = multipartFile.filename;
+  }
+}
+
+export class MultipartFormDataDiskFile extends MultipartFormDataFile {
+  public fileName: string;
+  public filePath: string;
+
+  public constructor(multipartFile: MultipartFile, filePath: string) {
+    super(multipartFile);
+
+    this.fileName = basename(filePath);
+    this.filePath = filePath;
+  }
+
+  public static get schema() {
+    return z
+      .instanceof(MultipartFormDataDiskFile)
+      .describe(MULTIPART_FORM_DATA_FILE_SCHEMA_DESCRIPTION);
+  }
+}
+
+export class MultipartFormDataInMemoryFile extends MultipartFormDataFile {
+  public buffer: Buffer<ArrayBufferLike>;
+
+  public constructor(
+    multipartFile: MultipartFile,
+    buffer: Buffer<ArrayBufferLike>,
+  ) {
+    super(multipartFile);
+
+    this.buffer = buffer;
+  }
+
+  public static get schema() {
+    return z
+      .instanceof(MultipartFormDataInMemoryFile)
+      .describe(MULTIPART_FORM_DATA_FILE_SCHEMA_DESCRIPTION);
+  }
+}

package/templates/fastify/src/http/plugins/swagger-file-zod-schema-transform.plugin.ts

@@ -0,0 +1,45 @@
+import { FastifyDynamicSwaggerOptions } from "@fastify/swagger";
+import { jsonSchemaTransform } from "fastify-type-provider-zod";
+import { ZodArray, ZodObject } from "zod";
+import { MULTIPART_FORM_DATA_FILE_SCHEMA_DESCRIPTION } from "./multipart-form-data.plugin";
+
+type RouteData = Parameters<
+  NonNullable<FastifyDynamicSwaggerOptions["transform"]>
+>[0];
+
+type JsonSchema = ReturnType<typeof jsonSchemaTransform>;
+
+export function swaggerFileZodSchemaTransformPlugin(
+  routeData: RouteData,
+  jsonSchema: JsonSchema,
+) {
+  if (
+    routeData.schema.consumes?.includes("multipart/form-data") &&
+    routeData.schema.body instanceof ZodObject
+  ) {
+    for (const bodyFieldName in routeData.schema.body.shape) {
+      const bodyFieldSchema = routeData.schema.body.shape[bodyFieldName];
+
+      if (
+        bodyFieldSchema._def.description ===
+        MULTIPART_FORM_DATA_FILE_SCHEMA_DESCRIPTION
+      ) {
+        jsonSchema.schema.body.properties[bodyFieldName] = {
+          type: "string",
+          format: "binary",
+        };
+      }
+
+      if (
+        bodyFieldSchema instanceof ZodArray &&
+        bodyFieldSchema._def.type._def.description ===
+          MULTIPART_FORM_DATA_FILE_SCHEMA_DESCRIPTION
+      ) {
+        jsonSchema.schema.body.properties[bodyFieldName] = {
+          type: "array",
+          items: { type: "string", format: "binary" },
+        };
+      }
+    }
+  }
+}

package/templates/fastify/test/integration/create-safe-form-data.ts

@@ -0,0 +1,18 @@
+type CreateSafeFormDataInput = Record<string, string | Blob>;
+
+export type CreateSafeFormDataOutput<Input extends CreateSafeFormDataInput> =
+  ReturnType<typeof createSafeFormData<Input>>;
+
+export function createSafeFormData<Input extends CreateSafeFormDataInput>(
+  input: Input,
+) {
+  const formData = new FormData();
+
+  for (const inputProperty in input)
+    formData.set(inputProperty, input[inputProperty]);
+
+  return {
+    input,
+    formData,
+  };
+}

package/templates/fastify/vitest.config.mts

@@ -4,6 +4,7 @@ import { defineConfig } from "vitest/config";
 export default defineConfig({
   plugins: [viteTsconfigPaths()],
   test: {
+    reporters: ["verbose"],
     fakeTimers: {
       toFake: [
         "Date",