@leo-h/create-nodejs-app 1.0.0

package/templates/fastify/src/@types/fastify-zod-type-provider.ts

@@ -0,0 +1,39 @@
+import {
+  ContextConfigDefault,
+  FastifyBaseLogger,
+  FastifyInstance,
+  FastifyReply,
+  FastifyRequest,
+  FastifySchema,
+  RawReplyDefaultExpression,
+  RawRequestDefaultExpression,
+  RawServerDefault,
+  RouteGenericInterface,
+} from "fastify";
+import { ZodTypeProvider } from "fastify-type-provider-zod";
+
+export type FastifyZodInstance = FastifyInstance<
+  RawServerDefault,
+  RawRequestDefaultExpression,
+  RawReplyDefaultExpression,
+  FastifyBaseLogger,
+  ZodTypeProvider
+>;
+
+export type FastifyZodRequest = FastifyRequest<
+  RouteGenericInterface,
+  RawServerDefault,
+  RawRequestDefaultExpression,
+  FastifySchema,
+  ZodTypeProvider
+>;
+
+export type FastifyZodReply = FastifyReply<
+  RawServerDefault,
+  RawRequestDefaultExpression,
+  RawReplyDefaultExpression,
+  RouteGenericInterface,
+  ContextConfigDefault,
+  FastifySchema,
+  ZodTypeProvider
+>;

package/templates/fastify/src/@types/fastify.d.ts

@@ -0,0 +1,16 @@
+import { File } from "fastify-multer/lib/interfaces";
+import { z } from "zod";
+
+export type Upload<Base> = Omit<Base, "fields" | "type">;
+
+declare module "fastify" {
+  interface FastifyRequest {
+    file: File;
+    files: File[];
+  }
+
+  interface FastifySchema {
+    multipartFileFields?: string[];
+    multipartAnotherFieldsSchema?: z.ZodObject<z.ZodRawShape>;
+  }
+}

package/templates/fastify/src/app.ts

@@ -0,0 +1,45 @@
+import fastifyCookie from "@fastify/cookie";
+import fastifyCors from "@fastify/cors";
+import fastifySwagger from "@fastify/swagger";
+import fastifySwaggerUi from "@fastify/swagger-ui";
+import fastify from "fastify";
+import multer from "fastify-multer";
+import {
+  jsonSchemaTransform,
+  serializerCompiler,
+  validatorCompiler,
+} from "fastify-type-provider-zod";
+import { env } from "./env";
+import { errorHandlerPlugin } from "./plugins/error-handler.plugin";
+import { handleSwaggerMultipart } from "./plugins/handle-swagger-multipart.plugin";
+import { routes } from "./routes";
+
+export const app = fastify();
+
+app.setValidatorCompiler(validatorCompiler);
+app.setSerializerCompiler(serializerCompiler);
+
+app.register(fastifySwagger, {
+  openapi: {
+    info: {
+      title: env.API_NAME,
+      description: process.env.npm_package_description ?? "",
+      version: process.env.npm_package_version ?? "",
+    },
+    servers: [],
+  },
+  transform: data => {
+    const jsonSchema = jsonSchemaTransform(data);
+
+    handleSwaggerMultipart(jsonSchema.schema);
+
+    return jsonSchema;
+  },
+});
+app.register(fastifySwaggerUi, { routePrefix: "/docs" });
+app.register(fastifyCors, { origin: env.API_ACCESS_PERMISSION_CLIENT_SIDE });
+app.register(fastifyCookie);
+app.register(multer.contentParser);
+
+app.setErrorHandler(errorHandlerPlugin);
+app.register(routes);

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

@@ -0,0 +1,32 @@
+import { app } from "@/app";
+import { faker } from "@faker-js/faker";
+import { extension } from "mime-types";
+import request from "supertest";
+import { describe, expect, it } from "vitest";
+
+describe("[Controller] Hello", () => {
+  it("[POST] /hello/multipart", async () => {
+    const imageResponse = await fetch(faker.image.urlLoremFlickr());
+    const imageArrayBuffer = await imageResponse.arrayBuffer();
+    const imageContentType = imageResponse.headers.get("content-type")!;
+    const imageExtension = extension(imageContentType) as string;
+
+    const description = faker.lorem.sentence();
+    const response = await request(app.server)
+      .post("/hello/multipart")
+      .attach("attachment", Buffer.from(imageArrayBuffer), {
+        contentType: imageContentType,
+        filename: faker.system.commonFileName(imageExtension),
+      })
+      .field({ description });
+
+    expect(response.statusCode).toEqual(200);
+    expect(response.body).toEqual(
+      expect.objectContaining({
+        message: "Hello world!",
+        description,
+        file: expect.any(Object),
+      }),
+    );
+  });
+});

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

@@ -0,0 +1,51 @@
+import { requireUpload } from "@/plugins/require-upload.plugin";
+import { FastifyInstance } from "fastify";
+import { ZodTypeProvider } from "fastify-type-provider-zod";
+import { z } from "zod";
+
+const helloMultipartControllerBodySchema = z.object({
+  description: z.string().min(2),
+});
+
+type HelloMultipartControllerBody = z.infer<
+  typeof helloMultipartControllerBodySchema
+>;
+
+export async function helloMultipartController(app: FastifyInstance) {
+  app.withTypeProvider<ZodTypeProvider>().route({
+    method: "POST",
+    url: "/hello/multipart",
+    schema: {
+      tags: ["Hello"],
+      summary: "Hello world with multipart/form-data content-type!",
+      consumes: ["multipart/form-data"],
+      multipartFileFields: ["attachment"],
+      multipartAnotherFieldsSchema: helloMultipartControllerBodySchema,
+      response: {
+        200: z.object({
+          message: z.string(),
+          description: z.string(),
+          file: z.custom(),
+        }),
+      },
+    },
+    preHandler: requireUpload({
+      fieldName: "attachment",
+      allowedExtensions: ["png", "jpg", "jpeg", "webp"],
+      limits: { fileSize: 1000000 * 15, files: 1 },
+      storage: "memory",
+    }),
+    handler: async (req, res) => {
+      // eslint-disable-next-line
+      const { buffer, ...fileInfo } = req.file;
+      const { description } =
+        req.body as unknown as HelloMultipartControllerBody;
+
+      res.status(200).send({
+        message: "Hello world!",
+        description,
+        file: fileInfo,
+      });
+    },
+  });
+}

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

@@ -0,0 +1,14 @@
+import { app } from "@/app";
+import request from "supertest";
+import { describe, expect, it } from "vitest";
+
+describe("[Controller] Hello", () => {
+  it("[GET] /hello", async () => {
+    const response = await request(app.server)
+      .get("/hello")
+      .query({ show: true });
+
+    expect(response.statusCode).toEqual(200);
+    expect(response.body).toEqual({ message: "Hello world!" });
+  });
+});

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

@@ -0,0 +1,36 @@
+import { BadRequestError } from "@/errors/exceptions";
+import { FastifyInstance } from "fastify";
+import { ZodTypeProvider } from "fastify-type-provider-zod";
+import { z } from "zod";
+
+const helloControllerQuerySchema = z.object({
+  show: z
+    .enum(["true", "false"])
+    .transform(val => JSON.parse(val))
+    .default("true"),
+});
+
+export async function helloController(app: FastifyInstance) {
+  app.withTypeProvider<ZodTypeProvider>().route({
+    method: "GET",
+    url: "/hello",
+    schema: {
+      tags: ["Hello"],
+      summary: "Hello world!",
+      querystring: helloControllerQuerySchema,
+      response: {
+        200: z.object({ message: z.string() }),
+      },
+    },
+    handler: async (req, res) => {
+      const { show } = req.query;
+
+      if (!show)
+        throw new BadRequestError(
+          'You don\'t want to display the "hello world"!',
+        );
+
+      res.status(200).send({ message: "Hello world!" });
+    },
+  });
+}

package/templates/fastify/src/env.ts

@@ -0,0 +1,19 @@
+import "dotenv/config";
+import { z } from "zod";
+
+const schema = z.object({
+  NODE_ENV: z.enum(["test", "development", "production"]),
+  API_NAME: z.string(),
+  API_PORT: z.coerce.number(),
+  API_ACCESS_PERMISSION_CLIENT_SIDE: z.string().default("*"),
+});
+
+const parsedEnv = schema.safeParse(process.env);
+
+if (!parsedEnv.success) {
+  console.error(parsedEnv.error.flatten().fieldErrors);
+
+  throw new Error("Invalid environment variables.");
+}
+
+export const env = parsedEnv.data;

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

@@ -0,0 +1,87 @@
+import { capitalizeWord } from "@/utils/capitalize-word";
+
+export abstract class BaseError extends Error {
+  public abstract error: string;
+  public abstract statusCode: number;
+  public debug: unknown = null;
+
+  constructor(public message: string) {
+    super(message);
+  }
+}
+
+export class HTTPError extends BaseError {
+  public error = "HTTPGenericError";
+
+  constructor(
+    public statusCode: number,
+    text: string,
+  ) {
+    super(text);
+  }
+}
+
+export class RequestFormatError extends BaseError {
+  public error = "RequestFormatError";
+  public statusCode = 406;
+
+  constructor(text: string) {
+    super(text);
+  }
+}
+
+export class UnauthorizedError extends BaseError {
+  public error = "UnauthorizedError";
+  public statusCode = 401;
+
+  constructor() {
+    super("Não autorizado.");
+  }
+}
+
+export class UploadError extends BaseError {
+  public error = "UploadError";
+
+  constructor(
+    public statusCode: number,
+    public message: string,
+  ) {
+    super(message);
+  }
+}
+
+export class ResourceAlreadyExistsError extends BaseError {
+  public error = "ResourceAlreadyExistsError";
+  public statusCode = 409;
+
+  constructor(resource: string) {
+    super(`${capitalizeWord(resource)} já existente.`);
+  }
+}
+
+export class ResourceNotFoundError extends BaseError {
+  public error = "ResourceNotFoundError";
+  public statusCode = 400;
+
+  constructor(resource: string) {
+    super(`${capitalizeWord(resource)} inexistente.`);
+  }
+}
+
+export class InvalidCredentialsError extends BaseError {
+  public error = "InvalidCredentialsError";
+  public statusCode = 401;
+
+  constructor() {
+    super("Credenciais inválidas.");
+  }
+}
+
+export class BadRequestError extends BaseError {
+  public error = "BadRequestError";
+  public statusCode = 400;
+
+  constructor(public message: string) {
+    super(message);
+  }
+}

package/templates/fastify/src/errors/http-error-handler.ts

@@ -0,0 +1,111 @@
+import { env } from "@/env";
+import { FastifyError, FastifyReply } from "fastify";
+import { MulterError } from "fastify-multer";
+import { SetOptional } from "type-fest";
+import { ZodError } from "zod";
+import { fromZodError } from "zod-validation-error";
+import {
+  BaseError,
+  HTTPError,
+  UnauthorizedError,
+  UploadError,
+} from "./exceptions";
+
+export class HTTPErrorHandler {
+  constructor(
+    protected error: FastifyError,
+    protected response: FastifyReply,
+  ) {}
+
+  protected send({
+    statusCode,
+    error,
+    message,
+    debug,
+  }: SetOptional<BaseError, "debug" | "name">) {
+    const parsedDebug = () => {
+      if (!debug || env.NODE_ENV !== "development") return {};
+
+      return { debug };
+    };
+
+    this.response
+      .status(statusCode)
+      .send({ statusCode, error, message, ...parsedDebug() });
+
+    return true;
+  }
+
+  async customHTTPErrorHandler() {
+    if (this.error instanceof HTTPError) return this.send(this.error);
+  }
+
+  async unknownErrorHandler() {
+    if (this.error instanceof BaseError) return this.send(this.error);
+
+    if (this.error.statusCode) {
+      return this.send({
+        statusCode: this.error.statusCode,
+        error: this.error.name,
+        message: this.error.message,
+      });
+    }
+
+    return this.send({
+      statusCode: 500,
+      error: "InternalServerError",
+      message: "Desculpe, um erro inesperado ocorreu.",
+      debug: this.error.message,
+    });
+  }
+
+  async JWTErrorHandler() {
+    if (this.error.code && this.error.code.includes("_JWT_")) {
+      const { statusCode, error, message } = new UnauthorizedError();
+
+      return this.send({
+        statusCode: this.error.statusCode || statusCode,
+        error,
+        message,
+        debug: this.error.message,
+      });
+    }
+  }
+
+  async multerErrorHandler() {
+    if (
+      this.error instanceof MulterError ||
+      this.error instanceof UploadError
+    ) {
+      return this.send({
+        statusCode: (this.error as UploadError)?.statusCode || 400,
+        error: (this.error as UploadError).error || "UploadError",
+        message: this.error.message,
+      });
+    }
+
+    if (this.error.message === "Multipart: Boundary not found") {
+      return this.send({
+        statusCode: 415,
+        error: "UnsupportedMultipartMediaTypeError",
+        message: "Cabeçalho multipart inválido.",
+      });
+    }
+  }
+
+  async zodErrorHandler() {
+    if (this.error instanceof ZodError) {
+      const { message } = fromZodError(this.error, {
+        maxIssuesInMessage: 1,
+        prefix: null,
+      });
+
+      return this.send({
+        statusCode: 400,
+        error: "ValidationError",
+        message: message,
+        debug: this.error.flatten().fieldErrors,
+      });
+    }
+  }
+}

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

@@ -0,0 +1,27 @@
+import { HTTPErrorHandler } from "@/errors/http-error-handler";
+import { FastifyError, FastifyReply, FastifyRequest } from "fastify";
+
+export async function errorHandlerPlugin(
+  error: FastifyError,
+  _req: FastifyRequest,
+  response: FastifyReply,
+) {
+  console.error(error);
+
+  const methodNames = Object.getOwnPropertyNames(HTTPErrorHandler.prototype);
+  const unknownErrorName = "unknownErrorHandler";
+  const handlerNames = methodNames.filter(name => {
+    return name.endsWith("ErrorHandler") && !name.includes(unknownErrorName);
+  });
+
+  handlerNames.push(unknownErrorName);
+
+  const handlerInstance = new HTTPErrorHandler(error, response);
+
+  for (const handlerName of handlerNames) {
+    const hasError =
+      await handlerInstance[handlerName as keyof HTTPErrorHandler]();
+
+    if (hasError) break;
+  }
+}

package/templates/fastify/src/plugins/handle-swagger-multipart.plugin.ts

@@ -0,0 +1,96 @@
+// https://github.com/turkerdev/fastify-type-provider-zod/issues/82
+
+import { Class } from "type-fest";
+import { z } from "zod";
+
+const getTypeNameFromZodType = (zodType: z.ZodType) => {
+  const mapping = {
+    string: z.ZodString,
+    number: [z.ZodNumber, z.ZodBigInt],
+    boolean: z.ZodBoolean,
+    object: z.ZodObject,
+    array: z.ZodArray,
+    undefined: z.ZodUndefined,
+    null: z.ZodNull,
+  };
+  const primitiveTypeNames = Object.keys(mapping);
+
+  for (const primitiveTypeName of primitiveTypeNames) {
+    const zodTypeClass = mapping[primitiveTypeName as keyof typeof mapping];
+
+    if (Array.isArray(zodTypeClass)) {
+      for (const _zodTypeClass of zodTypeClass) {
+        if (zodType instanceof _zodTypeClass) return primitiveTypeName;
+      }
+    } else if (zodType instanceof zodTypeClass) {
+      return primitiveTypeName;
+    }
+  }
+
+  return "string";
+};
+
+const zodTypeContainsInnerType = (
+  target: z.ZodType,
+  innerType: Class<unknown>,
+): boolean => {
+  if (target instanceof innerType) return true;
+
+  if ("innerType" in target._def)
+    return zodTypeContainsInnerType(
+      target._def.innerType as z.ZodType,
+      innerType,
+    );
+
+  return false;
+};
+
+// eslint-disable-next-line
+export function handleSwaggerMultipart(schema: Record<string, any>) {
+  let isMultipartFormat = false;
+
+  if ("consumes" in schema && schema.consumes.includes("multipart/form-data"))
+    isMultipartFormat = true;
+
+  for (const key in schema) {
+    if (typeof schema[key] === "object" && schema[key] !== null) {
+      if (key === "consumes" && isMultipartFormat) {
+        // eslint-disable-next-line
+        const fields: Record<string, any> = {};
+        const requiredFields = [];
+
+        if (schema.multipartFileFields) {
+          for (const multipartFileField of schema.multipartFileFields) {
+            fields[multipartFileField] = { type: "file" };
+            requiredFields.push(multipartFileField);
+          }
+        }
+
+        if (schema.multipartAnotherFieldsSchema) {
+          for (const multipartAnotherField in schema
+            .multipartAnotherFieldsSchema.shape) {
+            const zodType =
+              schema.multipartAnotherFieldsSchema.shape[multipartAnotherField];
+
+            fields[multipartAnotherField] = {
+              type: getTypeNameFromZodType(zodType),
+            };
+
+            if (!zodTypeContainsInnerType(zodType, z.ZodOptional))
+              requiredFields.push(multipartAnotherField);
+          }
+        }
+
+        schema.body = {
+          type: "object",
+          properties: fields,
+          required: requiredFields,
+        };
+      } else {
+        handleSwaggerMultipart(schema[key]);
+      }
+    }
+  }
+
+  return schema;
+}