@leo-h/create-nodejs-app 1.0.29 → 1.0.31

package/templates/fastify/build.config.ts

@@ -1,56 +0,0 @@
-import { readdirSync } from "fs";
-import { resolve } from "path";
-import { BuildOptions, defineBuildConfig } from "unbuild";
-import packageJson from "./package.json";
-import { compilerOptions } from "./tsconfig.json";
-
-// eslint-disable-next-line @typescript-eslint/no-unused-vars
-const getAllFiles = (path: string) => {
-  return readdirSync(path, {
-    recursive: true,
-    encoding: "utf-8",
-  })
-    .filter(reading => reading.endsWith(".ts"))
-    .map(filename => `${path}/${filename}`);
-};
-
-const pathAliases = Object.keys(compilerOptions.paths).reduce(
-  (resolvedAliases, alias) => {
-    const unbuildAlias = alias.replace("/*", "");
-    const unbuildPath = compilerOptions.paths[
-      alias as keyof typeof compilerOptions.paths
-    ][0].replace("/*", "");
-
-    resolvedAliases[unbuildAlias] = resolve(
-      compilerOptions.baseUrl,
-      unbuildPath,
-    );
-
-    return resolvedAliases;
-  },
-  {} as BuildOptions["alias"],
-);
-
-export default defineBuildConfig({
-  outDir: "./dist",
-  entries: ["./src/infra/server.ts"],
-  clean: true,
-  alias: pathAliases,
-  externals: Object.keys(packageJson.dependencies),
-  rollup: {
-    emitCJS: true,
-    cjsBridge: true,
-    inlineDependencies: true,
-    output: {
-      format: "cjs",
-      entryFileNames: "[name].js",
-      preserveModules: true,
-      strict: false,
-      exports: "named",
-    },
-    esbuild: {
-      minifySyntax: true,
-      treeShaking: true,
-    },
-  },
-});

package/templates/fastify/src/core/domain-error.ts

@@ -1,17 +0,0 @@
-export type DomainErrorCoreProperties = Pick<
-  DomainError,
-  "error" | "message" | "debug"
->;
-
-export abstract class DomainError extends Error {
-  public abstract error: string;
-  public abstract debug: unknown;
-
-  constructor(public message: string) {
-    super(message);
-  }
-}
-
-export abstract class HttpError extends DomainError {
-  public abstract statusCode: number;
-}

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

@@ -1,22 +0,0 @@
-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/fastify/src/infra/http/@types/fastify.d.ts

@@ -1,16 +0,0 @@
-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/infra/http/controllers/hello/hello-multipart.controller.integration-spec.ts

@@ -1,35 +0,0 @@
-import { app } from "@/infra/http/app";
-import { faker } from "@faker-js/faker";
-import { lookup } from "mime-types";
-import { basename, extname } from "path";
-import request from "supertest";
-import { describe, expect, it } from "vitest";
-import { HelloMultipartControllerBody } from "./hello-multipart.controller";
-
-const SAMPLE_UPLOAD_PATH = "./test/integration/sample-upload.jpg";
-
-describe("[Controller] POST /hello/multipart", () => {
-  it("should be able to upload a image", async () => {
-    const fieldName = "attachment";
-    const description = faker.lorem.sentence();
-
-    const response = await request(app.server)
-      .post("/hello/multipart")
-      .attach(fieldName, SAMPLE_UPLOAD_PATH)
-      .field({ description } satisfies HelloMultipartControllerBody);
-
-    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/fastify/src/infra/http/controllers/hello/hello-multipart.controller.ts

@@ -1,65 +0,0 @@
-import { requireUpload } from "@/infra/http/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),
-});
-
-export 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.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(),
-          }),
-        }),
-      },
-    },
-    preHandler: requireUpload({
-      fieldName: "attachment",
-      storage: "memory",
-      allowedExtensions: ["jpeg", "png", "webp"],
-      limits: {
-        fileSize: 10 * 1000 * 1000, // 10MB
-        files: 1,
-      },
-    }),
-    handler: async (req, res) => {
-      const { fieldname, originalname, encoding, mimetype, size } = req.file;
-      const { description } =
-        req.body as unknown as HelloMultipartControllerBody;
-
-      res.status(200).send({
-        message: "Hello world!",
-        description,
-        file: {
-          fieldname,
-          originalname,
-          encoding,
-          mimetype,
-          size,
-        },
-      });
-    },
-  });
-}

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

@@ -1,38 +0,0 @@
-import { app } from "@/infra/http/app";
-import request from "supertest";
-import { describe, expect, it } from "vitest";
-import { HelloControllerQuery } from "./hello.controller";
-
-describe("[Controller] GET /hello", () => {
-  it("should be able to show hello world when setting true in the query parameter", async () => {
-    const response = await request(app.server)
-      .get("/hello")
-      .query({ show: true } satisfies HelloControllerQuery);
-
-    expect(response.statusCode).toEqual(200);
-    expect(response.body).toStrictEqual({ message: "Hello world!" });
-  });
-
-  it("should not be able to show hello world when setting false in the query parameter", async () => {
-    const response = await request(app.server)
-      .get("/hello")
-      .query({ show: false } satisfies HelloControllerQuery);
-
-    expect(response.statusCode).toEqual(400);
-    expect(response.body.error).toEqual("BAD_REQUEST_ERROR");
-  });
-
-  describe("Input data validations", () => {
-    it("with invalid show property", async () => {
-      const response = await request(app.server)
-        .get("/hello")
-        .query({
-          // @ts-expect-error the value must be a boolean
-          show: 0,
-        } satisfies HelloControllerQuery);
-
-      expect(response.statusCode).toEqual(400);
-      expect(response.body.error).toEqual("VALIDATION_ERROR");
-    });
-  });
-});

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

@@ -1,40 +0,0 @@
-import { FastifyInstance } from "fastify";
-import { ZodTypeProvider } from "fastify-type-provider-zod";
-import { z } from "zod";
-import { BadRequestError } from "../../errors/bad-request.error";
-
-const helloControllerQuerySchema = z.object({
-  show: z
-    .enum(["true", "false"])
-    .transform<boolean>(val => JSON.parse(val))
-    .default("true"),
-});
-
-export type HelloControllerQuery = z.infer<typeof helloControllerQuerySchema>;
-
-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.literal("Hello world!"),
-        }),
-      },
-    },
-    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/infra/http/errors/bad-request.error.ts

@@ -1,11 +0,0 @@
-import { HttpError } from "@/core/domain-error";
-
-export class BadRequestError extends HttpError {
-  readonly error = "BAD_REQUEST_ERROR";
-  readonly statusCode = 400;
-  readonly debug = null;
-
-  constructor(public message: string) {
-    super(message);
-  }
-}

package/templates/fastify/src/infra/http/errors/internal-server.error.ts

@@ -1,13 +0,0 @@
-import { HttpError } from "@/core/domain-error";
-
-const message = "Desculpe, um erro inesperado ocorreu.";
-
-export class InternalServerError extends HttpError {
-  readonly statusCode = 500;
-  readonly error = "INTERNAL_SERVER_ERROR";
-  readonly message = message;
-
-  constructor(public debug: unknown) {
-    super(message);
-  }
-}

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

@@ -1,21 +0,0 @@
-import { HttpError } from "@/core/domain-error";
-
-const message = "Os dados enviados são inválidos.";
-
-export class UploadValidationError extends HttpError {
-  readonly error = "UPLOAD_VALIDATION_ERROR";
-  readonly message = message;
-  public debug: object;
-
-  constructor(
-    public statusCode = 400,
-    debug = {},
-  ) {
-    super(message);
-
-    this.debug = {
-      multerError: null,
-      ...debug,
-    };
-  }
-}

package/templates/fastify/src/infra/http/errors/validation.error.ts

@@ -1,13 +0,0 @@
-import { HttpError } from "@/core/domain-error";
-
-export class ValidationError extends HttpError {
-  readonly statusCode = 400;
-  readonly error = "VALIDATION_ERROR";
-
-  constructor(
-    public debug: unknown = null,
-    public message = "Os dados enviados são inválidos.",
-  ) {
-    super(message);
-  }
-}

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

@@ -1,31 +0,0 @@
-import { HttpError } from "@/core/domain-error";
-import { ErrorPresenter } from "@/infra/presenters/error.presenter";
-import { FastifyReply, FastifyRequest } from "fastify";
-import { ZodError } from "zod";
-import { InternalServerError } from "../errors/internal-server.error";
-import { ValidationError } from "../errors/validation.error";
-
-export async function errorHandlerPlugin(
-  error: unknown,
-  _req: FastifyRequest,
-  res: FastifyReply,
-) {
-  let httpError: HttpError;
-
-  if (error instanceof HttpError) httpError = error;
-  else if (error instanceof ZodError)
-    httpError = new ValidationError(error.flatten().fieldErrors);
-  else {
-    const debugFromUnknownError =
-      error && typeof error === "object" && "message" in error
-        ? error.message
-        : null;
-
-    httpError = new InternalServerError(debugFromUnknownError);
-    console.error(httpError);
-  }
-
-  const httpResponse = ErrorPresenter.toHttp(httpError.statusCode, httpError);
-
-  res.status(httpResponse.statusCode).send(httpResponse);
-}

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

@@ -1,96 +0,0 @@
-// 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;
-}

package/templates/fastify/src/infra/http/plugins/require-upload.plugin.ts

@@ -1,197 +0,0 @@
-import {
-  FastifyZodInstance,
-  FastifyZodReply,
-  FastifyZodRequest,
-} from "@/infra/http/@types/fastify-zod-type-provider";
-import { randomUUID } from "crypto";
-import multer, { MulterError } from "fastify-multer";
-import { Options } from "fastify-multer/lib/interfaces";
-import { extension } from "mime-types";
-import path, { extname } from "path";
-import prettyBytes from "pretty-bytes";
-import { UploadValidationError } from "../errors/upload-validation.error";
-
-interface MemoryStorage {
-  storage?: "memory";
-}
-
-interface DiskStorage {
-  storage?: "disk";
-  storageDir?: string;
-}
-
-type Storage = MemoryStorage | DiskStorage;
-
-type RequireUploadOptions = Storage & {
-  fieldName: string;
-  allowedExtensions: string[];
-  limits?: Pick<NonNullable<Options["limits"]>, "fileSize" | "files">;
-  isRequiredUpload?: boolean;
-};
-
-const defaultOptions = {
-  storage: "memory",
-  storageDir: "./tmp",
-  limits: {
-    fileSize: 1000000 * 10, // 10 MB
-    files: 1,
-  },
-  isRequiredUpload: true,
-};
-
-export function requireUpload(
-  options: RequireUploadOptions = { fieldName: "", allowedExtensions: [] },
-) {
-  const {
-    storage,
-    storageDir,
-    fieldName,
-    allowedExtensions,
-    limits,
-    isRequiredUpload,
-  } = {
-    ...defaultOptions,
-    ...options,
-    limits: {
-      ...defaultOptions.limits,
-      ...(options.limits ? options.limits : {}),
-    },
-  };
-  const handleStorage = () => {
-    if (storage === "disk") {
-      return multer.diskStorage({
-        destination: storageDir,
-        filename: (_req, file, cb) => {
-          const ext = path.extname(file.originalname);
-
-          cb(null, `${randomUUID()}${ext}`);
-        },
-      });
-    }
-
-    return multer.memoryStorage();
-  };
-
-  const upload = multer({
-    limits,
-    storage: handleStorage(),
-    fileFilter: (_req, { mimetype, originalname }, cb) => {
-      const fileExtension = extension(mimetype) || extname(originalname);
-
-      if (allowedExtensions.includes(fileExtension)) {
-        cb(null, true);
-      } else {
-        cb(
-          new UploadValidationError(400, {
-            message: "Invalid file format.",
-            fieldName,
-            allowedExtensions,
-          }),
-        );
-      }
-    },
-  });
-  const isMultipleUpload = limits.files > 1;
-
-  return [
-    async function (
-      this: FastifyZodInstance,
-      req: FastifyZodRequest,
-      res: FastifyZodReply,
-    ) {
-      let middleware = upload.single(fieldName);
-
-      if (isMultipleUpload) middleware = upload.array(fieldName);
-
-      await new Promise<void>((resolve, reject) => {
-        middleware.bind(this)(req, res, error => {
-          if (error && error instanceof MulterError) {
-            switch (error.code) {
-              case "LIMIT_FILE_COUNT":
-                reject(
-                  new UploadValidationError(413, {
-                    multerError: error.code,
-                    message: error.message,
-                    maxFileCount: limits.files!,
-                  }),
-                );
-                break;
-
-              case "LIMIT_FILE_SIZE":
-                reject(
-                  new UploadValidationError(413, {
-                    multerError: error.code,
-                    message: error.message,
-                    fieldName: error.field,
-                    maxFileSize: prettyBytes(limits.fileSize!),
-                  }),
-                );
-                break;
-
-              default:
-                reject(
-                  new UploadValidationError(
-                    error.code === "LIMIT_UNEXPECTED_FILE" ? 400 : 413,
-                    {
-                      multerError: error.code,
-                      message: error.message,
-                      fieldName: error.field,
-                    },
-                  ),
-                );
-                break;
-            }
-          }
-
-          if (error) return reject(error);
-
-          resolve();
-        });
-      });
-    },
-    async (req: FastifyZodRequest) => {
-      if (isRequiredUpload) {
-        if (!isMultipleUpload && !req.file) {
-          throw new UploadValidationError(400, {
-            multerError: null,
-            message: `Field "${fieldName}" is required with a file.`,
-          });
-        }
-
-        if (isMultipleUpload && (!req.files || !req.files.length)) {
-          throw new UploadValidationError(400, {
-            multerError: null,
-            message: `Field "${fieldName}" is required with at least 1 file.`,
-          });
-        }
-      }
-
-      const body = req.body as Record<string, string>;
-      const parsedStringValues = Object.keys(body).reduce(
-        (obj, key) => {
-          const value = body[key];
-
-          try {
-            obj[key] = JSON.parse(value);
-          } catch {
-            obj[key] = value;
-          }
-
-          return obj;
-        },
-        {} as typeof body,
-      );
-
-      if (
-        req.routeOptions.schema &&
-        req.routeOptions.schema.multipartAnotherFieldsSchema
-      ) {
-        req.routeOptions.schema.multipartAnotherFieldsSchema.parse(
-          parsedStringValues,
-        );
-      }
-
-      req.body = parsedStringValues;
-    },
-  ];
-}

package/templates/fastify/src/infra/http/routes.ts

@@ -1,8 +0,0 @@
-import { FastifyInstance } from "fastify";
-import { helloController } from "./controllers/hello/hello.controller";
-import { helloMultipartController } from "./controllers/hello/hello-multipart.controller";
-
-export async function routes(app: FastifyInstance) {
-  app.register(helloController);
-  app.register(helloMultipartController);
-}