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

package/templates/nest/src/infra/http/middlewares/upload-interceptor.ts

@@ -0,0 +1,365 @@
+import {
+  CallHandler,
+  ExecutionContext,
+  NestInterceptor,
+  UseInterceptors,
+  applyDecorators,
+} from "@nestjs/common";
+import { ApiBody, ApiConsumes } from "@nestjs/swagger";
+import { SchemaObject } from "@nestjs/swagger/dist/interfaces/open-api-spec.interface";
+import { randomUUID } from "crypto";
+import { FastifyReply, FastifyRequest } from "fastify";
+import multer, {
+  MulterError,
+  diskStorage,
+  memoryStorage,
+} from "fastify-multer";
+import { File, FileFilter, StorageEngine } from "fastify-multer/lib/interfaces";
+import { extension } from "mime-types";
+import { extname } from "path";
+import prettyBytes from "pretty-bytes";
+import { ZodObject, ZodRawShape, z } from "zod";
+import { UploadValidationError } from "../errors/upload-validation.error";
+import { zodSchemaToSwaggerSchema } from "./zod-schema-pipe";
+
+interface MemoryStorage {
+  /**
+   * The in-memory storage mechanism stores the files in memory as ```Buffer```.
+   *
+   * WARNING: Loading very large files or relatively small files in large quantities very quickly may cause your application to run out of memory when memory storage is used.
+   */
+  storage: "memory";
+}
+
+interface DiskStorage {
+  /**
+   * The disk storage mechanism delegates the file processing to the machine and provides full control of the file on disk.
+   *
+   * Ideal for most cases and essential for large files.
+   */
+  storage: "disk";
+  /**
+   * File storage directory.
+   *
+   * @default "./tmp"
+   */
+  destination?: string;
+}
+
+type Storage = MemoryStorage | DiskStorage;
+
+type UploadInterceptorOptions = Storage & {
+  /**
+   * Name of the file field that will be read when sent in the request with the multipart/form-data format.
+   *
+   * @example "attachment"
+   */
+  fieldName: string;
+  /**
+   * Allowed file extensions. Pass an empty array or ignore this option to accept all file formats.
+   *
+   * @default []
+   * @example ["jpeg", "png"]
+   */
+  allowedExtensions?: string[];
+  /**
+   * Mandatory file upload.
+   *
+   * If a number is specified, a minimum number of files is required (specify the maximum number with the ```maxFileCount``` option).
+   *
+   * @default true
+   */
+  required?: boolean | number;
+  /**
+   * Maximum number of files allowed for the same field.
+   *
+   * @default 1
+   */
+  maxFileCount?: number;
+  /**
+   * Maximum size allowed for each file in megabytes (MB).
+   *
+   * @default 50 // 50MB
+   * @example
+   * 1 / 1000 // 1KB
+   * 1 // 1MB
+   * 1000 // 1GB
+   * 1000 * 100 // 100GB
+   * Infinity
+   */
+  maxFileSize?: number;
+  /**
+   * A zod schema that matches all non-file fields.
+   *
+   * Non-file field values are automatically ```JSON.parse()``` whenever possible, allowing you to send structures that are the same as the ```application/json``` format.
+   *
+   * WARN: The zod schema is only used to be added to Swagger. To validate, use the ```ZodSchemaPipe``` decorator with the ```isMultipart: true``` option.
+   */
+  nonFileFieldsZodSchema?: ZodObject<ZodRawShape>;
+  /**
+   * Maximum allowed size for each non-file field values in megabytes (MB).
+   *
+   * @default 1 // 1MB
+   * @example
+   * 1 / 1000 // 1KB
+   * 1 // 1MB
+   * 1000 // 1GB
+   * 1000 * 100 // 100GB
+   * Infinity
+   */
+  maxNonFileFieldSize?: number;
+};
+
+/**
+ * Assumes the request body as multipart/form-data. Useful for file uploads.
+ */
+export function UploadInterceptor(options: UploadInterceptorOptions) {
+  const {
+    fieldName,
+    storage,
+    destination,
+    required,
+    maxFileCount,
+    maxFileSize,
+    nonFileFieldsZodSchema,
+    maxNonFileFieldSize,
+    ...restOptions
+  } = {
+    destination: "./tmp",
+    allowedExtensions: [],
+    required: true,
+    maxFileCount: 1,
+    maxFileSize: 50,
+    nonFileFieldsZodSchema: z.object({}),
+    maxNonFileFieldSize: 1,
+    ...options,
+  };
+  const nonFileFieldsSwaggerSchema = zodSchemaToSwaggerSchema(
+    nonFileFieldsZodSchema,
+  );
+
+  let allowedExtensions = restOptions.allowedExtensions;
+
+  allowedExtensions = allowedExtensions.map(ext => ext.replace(".", ""));
+
+  const getMulterStorage = (): StorageEngine => {
+    if (storage === "disk") {
+      return diskStorage({
+        destination,
+        filename: (_req, file, cb) => {
+          const ext = extname(file.originalname);
+
+          cb(null, `${randomUUID()}${ext}`);
+        },
+      });
+    }
+
+    return memoryStorage();
+  };
+  const setMulterFileFilter: FileFilter = (
+    _req,
+    { mimetype, originalname, fieldname },
+    cb,
+  ) => {
+    if (
+      !allowedExtensions ||
+      (allowedExtensions && allowedExtensions.length < 1)
+    ) {
+      return cb(null, true);
+    }
+
+    const fileExtension =
+      extension(mimetype) || extname(originalname).replace(".", "");
+
+    if (allowedExtensions.includes(fileExtension)) {
+      cb(null, true);
+    } else {
+      cb(
+        new UploadValidationError(400, {
+          message: "Invalid file format.",
+          fieldName: fieldname,
+          allowedExtensions,
+        }),
+      );
+    }
+  };
+
+  const getFileFieldSwaggerSchema = (): SchemaObject => {
+    if (maxFileCount > 1)
+      return {
+        type: "array",
+        items: {
+          type: "string",
+          format: "binary",
+        },
+      };
+
+    return {
+      type: "string",
+      format: "binary",
+    };
+  };
+  const getRequiredFieldsSwaggerSchema = (): SchemaObject["required"] => {
+    const fields: string[] = [];
+
+    if (required) fields.push(fieldName);
+
+    if (nonFileFieldsSwaggerSchema.required)
+      fields.push(...nonFileFieldsSwaggerSchema.required);
+
+    return fields;
+  };
+
+  const megabytesToBytes = (mb: number) => mb * 1000 * 1000;
+
+  return applyDecorators(
+    UseInterceptors(
+      new ExecuteUploadInterceptor({
+        multerInstance: multer({
+          storage: getMulterStorage(),
+          fileFilter: setMulterFileFilter,
+          limits: {
+            files: maxFileCount,
+            fileSize: megabytesToBytes(maxFileSize),
+            fields: Object.keys(nonFileFieldsZodSchema.shape).length,
+            fieldSize: megabytesToBytes(maxNonFileFieldSize),
+          },
+        }),
+        fieldName,
+        required,
+      }),
+    ),
+    ApiConsumes("multipart/form-data"),
+    ApiBody({
+      schema: {
+        type: "object",
+        properties: {
+          [fieldName]: getFileFieldSwaggerSchema(),
+          ...nonFileFieldsSwaggerSchema.properties,
+        },
+        required: getRequiredFieldsSwaggerSchema(),
+      },
+    }),
+  );
+}
+
+interface ExecuteUploadInterceptorParams {
+  multerInstance: ReturnType<typeof multer>;
+  fieldName: string;
+  required: boolean | number;
+}
+
+interface FastifyRequestWithFile extends FastifyRequest {
+  file?: File;
+  files?: File[];
+}
+
+export class ExecuteUploadInterceptor implements NestInterceptor {
+  public constructor(private params: ExecuteUploadInterceptorParams) {}
+
+  async intercept(context: ExecutionContext, next: CallHandler) {
+    const { multerInstance, fieldName, required } = this.params;
+    const limits = multerInstance.limits!;
+    const isMultipleUpload = limits.files! > 1;
+
+    let middleware = multerInstance.single(fieldName);
+
+    if (isMultipleUpload) middleware = multerInstance.array(fieldName);
+
+    const ctx = context.switchToHttp();
+    const request = ctx.getRequest<FastifyRequestWithFile>();
+    const response = ctx.getResponse<FastifyReply>();
+
+    await new Promise<void>((resolve, reject) => {
+      // @ts-expect-error the method is not passed to the fastify pre hook handler
+      middleware(request, response, 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(413, {
+                  multerError: error.code,
+                  message: error.message,
+                  fieldName: error.field,
+                }),
+              );
+              break;
+          }
+        }
+
+        if (error) return reject(error);
+
+        resolve();
+      });
+    });
+
+    if (required && !isMultipleUpload && !request.file) {
+      throw new UploadValidationError(400, {
+        multerError: null,
+        message: `Field "${fieldName}" is required with a file.`,
+      });
+    }
+
+    const minFileCountIsMissing =
+      typeof required === "number" &&
+      request.files &&
+      request.files.length < required;
+
+    if (
+      required &&
+      isMultipleUpload &&
+      (!request.files || !request.files.length || minFileCountIsMissing)
+    ) {
+      const minFileCount = typeof required === "number" ? required : 1;
+
+      throw new UploadValidationError(400, {
+        multerError: null,
+        message: `Field "${fieldName}" is required with at least ${minFileCount} file(s).`,
+      });
+    }
+
+    const parseNonFileFields = () => {
+      const body = request.body as Record<string, string>;
+
+      return 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,
+      );
+    };
+
+    request.body = parseNonFileFields();
+
+    return next.handle();
+  }
+}

package/templates/nest/src/infra/http/middlewares/zod-schema-pipe.ts

@@ -0,0 +1,78 @@
+import { createZodDto } from "@anatine/zod-nestjs";
+import { extendApi, generateSchema } from "@anatine/zod-openapi";
+import { UsePipes, applyDecorators } from "@nestjs/common";
+import { ZodType } from "zod";
+import {
+  ZodValidationPipe,
+  ZodValidationPipeSchemas,
+} from "./zod-validation-pipe";
+
+import { ApiBody, ApiParam, ApiQuery, ApiResponse } from "@nestjs/swagger";
+import { SchemaObject } from "@nestjs/swagger/dist/interfaces/open-api-spec.interface";
+import { RequireAtLeastOne } from "type-fest";
+
+export function zodSchemaToSwaggerSchema(schema: ZodType) {
+  return generateSchema(schema, false, "3.0") as SchemaObject;
+}
+
+export function zodSchemaToNestDto(schema: ZodType) {
+  return class Dto extends createZodDto(extendApi(schema)) {};
+}
+
+interface ZodSchemaPipeParams extends ZodValidationPipeSchemas {
+  isMultipart?: boolean;
+  response?: ZodType | Record<number, ZodType>;
+}
+
+type NestSwaggerDecorator =
+  | (MethodDecorator & ClassDecorator)
+  | MethodDecorator;
+
+export function ZodSchemaPipe({
+  isMultipart,
+  routeParams,
+  queryParams,
+  body,
+  response,
+}: RequireAtLeastOne<ZodSchemaPipeParams>) {
+  const apiDecorators: NestSwaggerDecorator[] = [];
+
+  if (routeParams) {
+    apiDecorators.push(
+      ApiParam({ type: zodSchemaToNestDto(routeParams), name: "" }),
+    );
+  }
+
+  if (queryParams) {
+    apiDecorators.push(ApiQuery({ type: zodSchemaToNestDto(queryParams) }));
+  }
+
+  if (body && !isMultipart) {
+    apiDecorators.push(ApiBody({ type: zodSchemaToNestDto(body) }));
+  }
+
+  if (response) {
+    if (response instanceof ZodType) {
+      apiDecorators.push(
+        ApiResponse({ schema: zodSchemaToSwaggerSchema(response) }),
+      );
+    } else {
+      for (const statusCode in response) {
+        apiDecorators.push(
+          ApiResponse({
+            schema: zodSchemaToSwaggerSchema(response[statusCode]),
+            status: Number(statusCode),
+          }),
+        );
+      }
+    }
+  }
+
+  const zodValidationPipe = new ZodValidationPipe({
+    routeParams,
+    queryParams,
+    body,
+  });
+
+  return applyDecorators(UsePipes(zodValidationPipe), ...apiDecorators);
+}

package/templates/nest/src/infra/http/middlewares/zod-validation-pipe.ts

@@ -0,0 +1,33 @@
+import { ValidationError } from "@/core/errors/errors";
+import { ArgumentMetadata, PipeTransform } from "@nestjs/common";
+import { ZodError, ZodType } from "zod";
+
+export interface ZodValidationPipeSchemas {
+  routeParams?: ZodType;
+  queryParams?: ZodType;
+  body?: ZodType;
+}
+
+export class ZodValidationPipe implements PipeTransform {
+  constructor(private schemas: ZodValidationPipeSchemas) {}
+
+  transform(value: unknown, { type }: ArgumentMetadata) {
+    try {
+      const mappedSchema = {
+        param: this.schemas.routeParams,
+        query: this.schemas.queryParams,
+        body: this.schemas.body,
+      };
+      const schema = mappedSchema[type as keyof typeof mappedSchema];
+
+      if (schema) return schema.parse(value);
+
+      return value;
+    } catch (error) {
+      if (error instanceof ZodError)
+        throw new ValidationError(error.flatten().fieldErrors);
+
+      throw new ValidationError();
+    }
+  }
+}

package/templates/nest/src/infra/presenters/error.presenter.ts

@@ -0,0 +1,14 @@
+import { DomainError } from "@/core/errors/domain-error";
+
+type CustomError = Pick<DomainError, "error" | "message" | "debug">;
+
+export class ErrorPresenter {
+  public static toHttp(statusCode: number, error: DomainError | CustomError) {
+    return {
+      error: error.error,
+      message: error.message,
+      statusCode,
+      debug: error.debug,
+    };
+  }
+}

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

@@ -0,0 +1,45 @@
+import { NestFactory } from "@nestjs/core";
+import {
+  FastifyAdapter,
+  NestFastifyApplication,
+} from "@nestjs/platform-fastify";
+import { DocumentBuilder, SwaggerModule } from "@nestjs/swagger";
+import packageJson from "package.json";
+import { AppModule } from "./app.module";
+import { env } from "./env";
+
+(async () => {
+  const app = await NestFactory.create<NestFastifyApplication>(
+    AppModule,
+    new FastifyAdapter(),
+    {
+      cors: {
+        origin: env.API_ACCESS_PERMISSION_CLIENT_SIDE,
+      },
+    },
+  );
+
+  const swaggerDocumentConfig = new DocumentBuilder()
+    .setTitle(env.API_NAME)
+    .setDescription("")
+    .setVersion(packageJson.version)
+    .build();
+  const swaggerDocument = SwaggerModule.createDocument(
+    app,
+    swaggerDocumentConfig,
+  );
+  const swaggerPath = "docs";
+
+  SwaggerModule.setup(swaggerPath, app, swaggerDocument, {
+    swaggerOptions: {
+      defaultModelsExpandDepth: -1,
+    },
+  });
+
+  await app.listen(env.API_PORT, "0.0.0.0");
+
+  console.log(`Application "${env.API_NAME}" is running!`);
+
+  if (env.NODE_ENV === "development")
+    console.log(`http://localhost:${env.API_PORT}/${swaggerPath}`);
+})();

package/templates/nest/tsconfig.json

@@ -0,0 +1,17 @@
+{
+  "compilerOptions": {
+    "target": "esnext",
+    "module": "CommonJS",
+    "emitDecoratorMetadata": true,
+    "experimentalDecorators": true,
+    "esModuleInterop": true,
+    "resolveJsonModule": true,
+    "forceConsistentCasingInFileNames": true,
+    "strict": true,
+    "skipLibCheck": true,
+    "baseUrl": ".",
+    "paths": {
+      "@/*": ["./src/*"]
+    }
+  }
+}

package/templates/nest/vitest.config.e2e.mts

@@ -0,0 +1,8 @@
+import { mergeConfig } from "vitest/config";
+import defaultConfig from "./vitest.config.mjs";
+
+export default mergeConfig(defaultConfig, {
+  test: {
+    include: ["./**/*.e2e-spec.ts"],
+  },
+});

package/templates/nest/vitest.config.mts

@@ -0,0 +1,6 @@
+import swc from "unplugin-swc";
+import { defineConfig } from "vitest/config";
+
+export default defineConfig({
+  plugins: [swc.vite({ module: { type: "es6" } })],
+});