@leo-h/create-nodejs-app 1.0.5 → 1.0.6

package/templates/nest/src/core/errors/domain-error.ts

@@ -0,0 +1,8 @@
+export abstract class DomainError extends Error {
+  public abstract error: string;
+  public abstract debug: unknown;
+
+  constructor(public message: string) {
+    super(message);
+  }
+}

package/templates/nest/src/core/errors/errors.ts

@@ -0,0 +1,9 @@
+import { DomainError } from "./domain-error";
+
+export class ValidationError extends DomainError {
+  public error = "ValidationError";
+
+  constructor(public debug: object | null = null) {
+    super("Os dados enviados são inválidos.");
+  }
+}

package/templates/nest/src/infra/app.module.ts

@@ -0,0 +1,7 @@
+import { Module } from "@nestjs/common";
+import { HttpModule } from "./http/http.module";
+
+@Module({
+  imports: [HttpModule],
+})
+export class AppModule {}

package/templates/nest/src/infra/env.ts

@@ -0,0 +1,22 @@
+import packageJson from "@/../package.json";
+import { config } from "dotenv";
+import { z } from "zod";
+
+config({ override: true });
+
+const schema = z.object({
+  NODE_ENV: z.enum(["test", "development", "production"]),
+  API_NAME: z.string().default(packageJson.name),
+  API_PORT: z.coerce.number().default(3333),
+  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/nest/src/infra/http/controllers/hello/hello-multipart.controller.e2e-spec.ts

@@ -0,0 +1,58 @@
+import { AppModule } from "@/infra/app.module";
+import { faker } from "@faker-js/faker";
+import {
+  FastifyAdapter,
+  NestFastifyApplication,
+} from "@nestjs/platform-fastify";
+import { Test } from "@nestjs/testing";
+import { lookup } from "mime-types";
+import { basename, extname } from "path";
+import request from "supertest";
+import { afterAll, beforeAll, describe, expect, it } from "vitest";
+
+const SAMPLE_UPLOAD_PATH = "./test/e2e/sample-upload.jpg";
+
+describe("[Controller] Hello multipart", () => {
+  let app: NestFastifyApplication;
+
+  beforeAll(async () => {
+    const moduleRef = await Test.createTestingModule({
+      imports: [AppModule],
+    }).compile();
+
+    app = moduleRef.createNestApplication<NestFastifyApplication>(
+      new FastifyAdapter(),
+    );
+
+    await app.init();
+    await app.getHttpAdapter().getInstance().ready();
+  });
+
+  afterAll(async () => {
+    await app.close();
+  });
+
+  it("[POST] /hello/multipart", async () => {
+    const fieldName = "attachment";
+    const description = faker.lorem.sentence();
+
+    const response = await request(app.getHttpServer())
+      .post("/hello/multipart")
+      .attach(fieldName, SAMPLE_UPLOAD_PATH)
+      .field({ description });
+
+    expect(response.statusCode).toEqual(200);
+    expect(response.body).toEqual(
+      expect.objectContaining({
+        message: "Hello world!",
+        description,
+        file: expect.objectContaining({
+          fieldname: fieldName,
+          originalname: basename(SAMPLE_UPLOAD_PATH),
+          mimetype: lookup(extname(SAMPLE_UPLOAD_PATH)),
+          size: expect.any(Number),
+        }),
+      }),
+    );
+  });
+});

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

@@ -0,0 +1,75 @@
+import { Body, Controller, HttpCode, Post, UploadedFile } from "@nestjs/common";
+import { ApiOperation, ApiTags } from "@nestjs/swagger";
+import { File } from "fastify-multer/lib/interfaces";
+import { z } from "zod";
+import { UploadInterceptor } from "../../middlewares/upload-interceptor";
+import { ZodSchemaPipe } from "../../middlewares/zod-schema-pipe";
+
+const helloMultipartControllerBodySchema = z.object({
+  description: z.string().min(2),
+});
+
+type HelloMultipartControllerBody = z.infer<
+  typeof helloMultipartControllerBodySchema
+>;
+
+const helloMultipartControllerResponseSchema = z.object({
+  message: z.literal("Hello world!"),
+  description: z.string().min(2),
+  file: z.object({
+    fieldname: z.string(),
+    originalname: z.string(),
+    encoding: z.string(),
+    mimetype: z.string(),
+    size: z.number().optional(),
+  }),
+});
+
+type HelloMultipartControllerResponse = z.infer<
+  typeof helloMultipartControllerResponseSchema
+>;
+
+@Controller()
+export class HelloMultipartController {
+  @ApiTags("Hello")
+  @ApiOperation({
+    summary: "Hello world with multipart/form-data content-type!",
+  })
+  @Post("/hello/multipart")
+  @HttpCode(200)
+  @UploadInterceptor({
+    fieldName: "attachment",
+    storage: "memory",
+    allowedExtensions: ["jpeg", "png", "webp"],
+    maxFileSize: 10, // 10MB
+    nonFileFieldsZodSchema: helloMultipartControllerBodySchema,
+  })
+  @ZodSchemaPipe({
+    isMultipart: true,
+    body: helloMultipartControllerBodySchema,
+    response: {
+      200: helloMultipartControllerResponseSchema,
+    },
+  })
+  async handle(
+    @UploadedFile()
+    file: File,
+    @Body()
+    body: HelloMultipartControllerBody,
+  ): Promise<HelloMultipartControllerResponse> {
+    const { fieldname, originalname, encoding, mimetype, size } = file;
+    const { description } = body;
+
+    return {
+      message: "Hello world!",
+      description,
+      file: {
+        fieldname,
+        originalname,
+        encoding,
+        mimetype,
+        size,
+      },
+    };
+  }
+}

package/templates/nest/src/infra/http/controllers/hello/hello.controller.e2e-spec.ts

@@ -0,0 +1,38 @@
+import { AppModule } from "@/infra/app.module";
+import {
+  FastifyAdapter,
+  NestFastifyApplication,
+} from "@nestjs/platform-fastify";
+import { Test } from "@nestjs/testing";
+import request from "supertest";
+import { afterAll, beforeAll, describe, expect, it } from "vitest";
+
+describe("[Controller] Hello", () => {
+  let app: NestFastifyApplication;
+
+  beforeAll(async () => {
+    const moduleRef = await Test.createTestingModule({
+      imports: [AppModule],
+    }).compile();
+
+    app = moduleRef.createNestApplication<NestFastifyApplication>(
+      new FastifyAdapter(),
+    );
+
+    await app.init();
+    await app.getHttpAdapter().getInstance().ready();
+  });
+
+  afterAll(async () => {
+    await app.close();
+  });
+
+  it("[GET] /hello", async () => {
+    const response = await request(app.getHttpServer())
+      .get("/hello")
+      .query({ show: true });
+
+    expect(response.statusCode).toEqual(200);
+    expect(response.body).toEqual({ message: "Hello world!" });
+  });
+});

package/templates/nest/src/infra/http/controllers/hello/hello.controller.ts

@@ -0,0 +1,51 @@
+import {
+  BadRequestException,
+  Controller,
+  Get,
+  HttpCode,
+  Query,
+} from "@nestjs/common";
+import { ApiOperation, ApiTags } from "@nestjs/swagger";
+import { z } from "zod";
+import { ZodSchemaPipe } from "../../middlewares/zod-schema-pipe";
+
+export const helloControllerQuerySchema = z.object({
+  show: z
+    .enum(["true", "false"])
+    .default("true")
+    .transform<boolean>(val => JSON.parse(val)),
+});
+
+type HelloControllerQuery = z.infer<typeof helloControllerQuerySchema>;
+
+const helloControllerResponseSchema = z.object({
+  message: z.literal("Hello world!"),
+});
+
+type HelloControllerResponse = z.infer<typeof helloControllerResponseSchema>;
+
+@Controller()
+export class HelloController {
+  @ApiTags("Hello")
+  @ApiOperation({ summary: "Hello world!" })
+  @Get("/hello")
+  @HttpCode(200)
+  @ZodSchemaPipe({
+    queryParams: helloControllerQuerySchema,
+    response: {
+      200: helloControllerResponseSchema,
+    },
+  })
+  async handle(
+    @Query() query: HelloControllerQuery,
+  ): Promise<HelloControllerResponse> {
+    const { show } = query;
+
+    if (!show)
+      throw new BadRequestException(
+        `You don't want to display the "hello world"!`,
+      );
+
+    return { message: "Hello world!" };
+  }
+}

package/templates/nest/src/infra/http/errors/upload-validation.error.ts

@@ -0,0 +1,17 @@
+import { ErrorPresenter } from "@/infra/presenters/error.presenter";
+import { HttpException } from "@nestjs/common";
+
+export class UploadValidationError extends HttpException {
+  constructor(statusCode = 400, debug: object = {}) {
+    const presenter = ErrorPresenter.toHttp(statusCode, {
+      error: "UploadValidationError",
+      message: "Os dados enviados são inválidos.",
+      debug: {
+        multerError: null,
+        ...debug,
+      },
+    });
+
+    super(presenter, statusCode);
+  }
+}

package/templates/nest/src/infra/http/events/fastify-multer.event.module.ts

@@ -0,0 +1,15 @@
+import { Module, OnApplicationBootstrap } from "@nestjs/common";
+import { HttpAdapterHost } from "@nestjs/core";
+import { FastifyAdapter } from "@nestjs/platform-fastify";
+import multer from "fastify-multer";
+
+@Module({})
+export class FastifyMulterEventModule implements OnApplicationBootstrap {
+  constructor(private httpAdapterHost: HttpAdapterHost<FastifyAdapter>) {}
+
+  onApplicationBootstrap() {
+    const app = this.httpAdapterHost.httpAdapter.getInstance();
+
+    app.register(multer.contentParser);
+  }
+}

package/templates/nest/src/infra/http/filters/domain-exception.filter.ts

@@ -0,0 +1,53 @@
+import { DomainError } from "@/core/errors/domain-error";
+import { ValidationError } from "@/core/errors/errors";
+import { env } from "@/infra/env";
+import { ErrorPresenter } from "@/infra/presenters/error.presenter";
+import {
+  ArgumentsHost,
+  BadRequestException,
+  Catch,
+  ExceptionFilter,
+  HttpException,
+  HttpStatus,
+  InternalServerErrorException,
+} from "@nestjs/common";
+import { FastifyReply } from "fastify";
+
+@Catch(DomainError)
+export class DomainExceptionFilter implements ExceptionFilter {
+  catch(exception: DomainError, host: ArgumentsHost): void {
+    const ctx = host.switchToHttp();
+    const response = ctx.getResponse<FastifyReply>();
+
+    let httpException: HttpException;
+
+    switch (exception.constructor) {
+      case ValidationError:
+        httpException = new BadRequestException(
+          ErrorPresenter.toHttp(HttpStatus.BAD_REQUEST, exception),
+        );
+        break;
+
+      default:
+        httpException = new InternalServerErrorException(
+          ErrorPresenter.toHttp(HttpStatus.INTERNAL_SERVER_ERROR, {
+            error: "InternalServerError",
+            message: "Desculpe, um erro inesperado ocorreu.",
+            debug: exception.message,
+          }),
+        );
+        break;
+    }
+
+    const httpResponse = httpException.getResponse();
+
+    if (
+      env.NODE_ENV === "production" &&
+      typeof httpResponse === "object" &&
+      "debug" in httpResponse
+    )
+      delete httpResponse.debug;
+
+    response.status(httpException.getStatus()).send(httpResponse);
+  }
+}

package/templates/nest/src/infra/http/filters/http-exception.filter.ts

@@ -0,0 +1,26 @@
+import { env } from "@/infra/env";
+import {
+  ArgumentsHost,
+  Catch,
+  ExceptionFilter,
+  HttpException,
+} from "@nestjs/common";
+import { FastifyReply } from "fastify";
+
+@Catch(HttpException)
+export class HttpExceptionFilter implements ExceptionFilter {
+  catch(httpException: HttpException, host: ArgumentsHost): void {
+    const ctx = host.switchToHttp();
+    const response = ctx.getResponse<FastifyReply>();
+    const httpResponse = httpException.getResponse();
+
+    if (
+      env.NODE_ENV === "production" &&
+      typeof httpResponse === "object" &&
+      "debug" in httpResponse
+    )
+      delete httpResponse.debug;
+
+    response.status(httpException.getStatus()).send(httpResponse);
+  }
+}

package/templates/nest/src/infra/http/http.module.ts

@@ -0,0 +1,23 @@
+import { Module } from "@nestjs/common";
+import { APP_FILTER } from "@nestjs/core";
+import { HelloMultipartController } from "./controllers/hello/hello-multipart.controller";
+import { HelloController } from "./controllers/hello/hello.controller";
+import { FastifyMulterEventModule } from "./events/fastify-multer.event.module";
+import { DomainExceptionFilter } from "./filters/domain-exception.filter";
+import { HttpExceptionFilter } from "./filters/http-exception.filter";
+
+@Module({
+  imports: [FastifyMulterEventModule],
+  providers: [
+    {
+      provide: APP_FILTER,
+      useClass: DomainExceptionFilter,
+    },
+    {
+      provide: APP_FILTER,
+      useClass: HttpExceptionFilter,
+    },
+  ],
+  controllers: [HelloController, HelloMultipartController],
+})
+export class HttpModule {}