create-charcole 2.2.0 → 2.2.2

package/template/ts/src/middlewares/errorHandler.ts

@@ -1,201 +1,201 @@
-import { ZodError } from "zod";
-import { HTTP_STATUS, ERROR_MESSAGES } from "../config/constants.ts";
-import { logger } from "../utils/logger.ts";
-import {
-  AppError,
-  ValidationError,
-  InternalServerError,
-  AuthenticationError,
-  AuthorizationError,
-  NotFoundError,
-  ConflictError,
-  BadRequestError,
-} from "../utils/AppError.ts";
-import { env } from "../config/env.ts";
-import { Request, Response, NextFunction } from "express";
-
-// Custom type for async route handlers
-type AsyncRequestHandler = (
-  req: Request,
-  res: Response,
-  next: NextFunction,
-) => Promise<any> | any;
-
-const normalizeError = (err: unknown): AppError => {
-  if (err instanceof AppError) {
-    return err;
-  }
-
-  if (err instanceof ZodError) {
-    const errors = err.errors.map((e) => ({
-      field: e.path.join("."),
-      message: e.message,
-      code: e.code,
-    }));
-    return new ValidationError(ERROR_MESSAGES.VALIDATION_ERROR, errors);
-  }
-
-  if (err instanceof Error) {
-    if (err instanceof SyntaxError) {
-      return new InternalServerError("Syntax error in application code", err, {
-        type: "SyntaxError",
-      });
-    }
-
-    if (err instanceof TypeError) {
-      return new InternalServerError("Type error in application", err, {
-        type: "TypeError",
-      });
-    }
-
-    if (err instanceof ReferenceError) {
-      return new InternalServerError("Reference error in application", err, {
-        type: "ReferenceError",
-      });
-    }
-
-    if (err instanceof RangeError) {
-      return new InternalServerError("Range error in application", err, {
-        type: "RangeError",
-      });
-    }
-
-    return new InternalServerError(
-      err.message || ERROR_MESSAGES.SERVER_ERROR,
-      err,
-      { type: "UnknownError" },
-    );
-  }
-
-  const errorMessage =
-    typeof err === "string"
-      ? err
-      : err &&
-          typeof err === "object" &&
-          "message" in err &&
-          typeof err.message === "string"
-        ? err.message
-        : ERROR_MESSAGES.SERVER_ERROR;
-
-  return new InternalServerError(
-    errorMessage,
-    err instanceof Error ? err : new Error(String(err)),
-    { type: "UnknownError" },
-  );
-};
-
-const logError = (appError: AppError, req: Request): void => {
-  const errorDetails = {
-    type: appError.isOperational ? "OPERATIONAL" : "PROGRAMMER",
-    code: appError.code,
-    message: appError.message,
-    statusCode: appError.statusCode,
-    method: req.method,
-    path: req.path,
-    query: req.query,
-    ip: req.ip,
-    userAgent: req.get("user-agent"),
-  };
-
-  if (appError.isOperational) {
-    logger.warn(`Operational Error: ${appError.code}`, errorDetails);
-  } else {
-    logger.error(
-      `Programmer Error: ${appError.code}`,
-      errorDetails,
-      appError.stack,
-    );
-  }
-
-  if (
-    appError instanceof ValidationError &&
-    (appError as ValidationError).errors
-  ) {
-    const validationError = appError as ValidationError;
-    logger.debug("Validation errors", { errors: validationError.errors });
-  }
-
-  if (appError.cause) {
-    const causeMessage =
-      appError.cause instanceof Error
-        ? appError.cause.message
-        : String(appError.cause);
-    logger.debug("Error cause", { cause: causeMessage });
-  }
-};
-
-const sendErrorResponse = (res: Response, appError: AppError): void => {
-  const statusCode = appError.statusCode || HTTP_STATUS.INTERNAL_SERVER_ERROR;
-
-  if (!appError.isOperational && env.isProduction) {
-    res.status(statusCode).json({
-      success: false,
-      message: ERROR_MESSAGES.SERVER_ERROR,
-      code: "INTERNAL_SERVER_ERROR",
-      timestamp: new Date().toISOString(),
-    });
-    return;
-  }
-
-  const response =
-    (appError as any).toJSON && typeof (appError as any).toJSON === "function"
-      ? (appError as any).toJSON()
-      : {
-          success: false,
-          message: appError.message,
-          code: appError.code,
-          statusCode,
-          timestamp: new Date().toISOString(),
-        };
-
-  res.status(statusCode).json(response);
-};
-
-/**
- * Global Error Handler Middleware
- *
- * This middleware catches all errors and provides a unified way to handle them.
- * MUST be the last middleware in the app.
- *
- * Features:
- * - Distinguishes between operational and programmer errors
- * - Logs errors with full context
- * - Hides sensitive info in production
- * - Formats JSON responses consistently
- */
-export const errorHandler = (
-  err: unknown,
-  req: Request,
-  res: Response,
-  next: NextFunction,
-): void => {
-  const appError = normalizeError(err);
-
-  logError(appError, req);
-
-  sendErrorResponse(res, appError);
-};
-
-/**
- * Async error wrapper
- * Wrap async route handlers to catch errors and pass to middleware
- *
- * Example:
- * router.get('/users/:id', asyncHandler(getUserHandler))
- */
-export const asyncHandler = (fn: AsyncRequestHandler) => {
-  return (req: Request, res: Response, next: NextFunction): void => {
-    Promise.resolve(fn(req, res, next)).catch(next);
-  };
-};
-
-export {
-  AppError,
-  ValidationError,
-  InternalServerError,
-  AuthenticationError,
-  AuthorizationError,
-  NotFoundError,
-  ConflictError,
-  BadRequestError,
-};
+import { ZodError } from "zod";
+import { HTTP_STATUS, ERROR_MESSAGES } from "../config/constants.ts";
+import { logger } from "../utils/logger.ts";
+import {
+  AppError,
+  ValidationError,
+  InternalServerError,
+  AuthenticationError,
+  AuthorizationError,
+  NotFoundError,
+  ConflictError,
+  BadRequestError,
+} from "../utils/AppError.ts";
+import { env } from "../config/env.ts";
+import { Request, Response, NextFunction } from "express";
+
+// Custom type for async route handlers
+type AsyncRequestHandler = (
+  req: Request,
+  res: Response,
+  next: NextFunction,
+) => Promise<any> | any;
+
+const normalizeError = (err: unknown): AppError => {
+  if (err instanceof AppError) {
+    return err;
+  }
+
+  if (err instanceof ZodError) {
+    const errors = err.errors.map((e) => ({
+      field: e.path.join("."),
+      message: e.message,
+      code: e.code,
+    }));
+    return new ValidationError(ERROR_MESSAGES.VALIDATION_ERROR, errors);
+  }
+
+  if (err instanceof Error) {
+    if (err instanceof SyntaxError) {
+      return new InternalServerError("Syntax error in application code", err, {
+        type: "SyntaxError",
+      });
+    }
+
+    if (err instanceof TypeError) {
+      return new InternalServerError("Type error in application", err, {
+        type: "TypeError",
+      });
+    }
+
+    if (err instanceof ReferenceError) {
+      return new InternalServerError("Reference error in application", err, {
+        type: "ReferenceError",
+      });
+    }
+
+    if (err instanceof RangeError) {
+      return new InternalServerError("Range error in application", err, {
+        type: "RangeError",
+      });
+    }
+
+    return new InternalServerError(
+      err.message || ERROR_MESSAGES.SERVER_ERROR,
+      err,
+      { type: "UnknownError" },
+    );
+  }
+
+  const errorMessage =
+    typeof err === "string"
+      ? err
+      : err &&
+          typeof err === "object" &&
+          "message" in err &&
+          typeof err.message === "string"
+        ? err.message
+        : ERROR_MESSAGES.SERVER_ERROR;
+
+  return new InternalServerError(
+    errorMessage,
+    err instanceof Error ? err : new Error(String(err)),
+    { type: "UnknownError" },
+  );
+};
+
+const logError = (appError: AppError, req: Request): void => {
+  const errorDetails = {
+    type: appError.isOperational ? "OPERATIONAL" : "PROGRAMMER",
+    code: appError.code,
+    message: appError.message,
+    statusCode: appError.statusCode,
+    method: req.method,
+    path: req.path,
+    query: req.query,
+    ip: req.ip,
+    userAgent: req.get("user-agent"),
+  };
+
+  if (appError.isOperational) {
+    logger.warn(`Operational Error: ${appError.code}`, errorDetails);
+  } else {
+    logger.error(
+      `Programmer Error: ${appError.code}`,
+      errorDetails,
+      appError.stack,
+    );
+  }
+
+  if (
+    appError instanceof ValidationError &&
+    (appError as ValidationError).errors
+  ) {
+    const validationError = appError as ValidationError;
+    logger.debug("Validation errors", { errors: validationError.errors });
+  }
+
+  if (appError.cause) {
+    const causeMessage =
+      appError.cause instanceof Error
+        ? appError.cause.message
+        : String(appError.cause);
+    logger.debug("Error cause", { cause: causeMessage });
+  }
+};
+
+const sendErrorResponse = (res: Response, appError: AppError): void => {
+  const statusCode = appError.statusCode || HTTP_STATUS.INTERNAL_SERVER_ERROR;
+
+  if (!appError.isOperational && env.isProduction) {
+    res.status(statusCode).json({
+      success: false,
+      message: ERROR_MESSAGES.SERVER_ERROR,
+      code: "INTERNAL_SERVER_ERROR",
+      timestamp: new Date().toISOString(),
+    });
+    return;
+  }
+
+  const response =
+    (appError as any).toJSON && typeof (appError as any).toJSON === "function"
+      ? (appError as any).toJSON()
+      : {
+          success: false,
+          message: appError.message,
+          code: appError.code,
+          statusCode,
+          timestamp: new Date().toISOString(),
+        };
+
+  res.status(statusCode).json(response);
+};
+
+/**
+ * Global Error Handler Middleware
+ *
+ * This middleware catches all errors and provides a unified way to handle them.
+ * MUST be the last middleware in the app.
+ *
+ * Features:
+ * - Distinguishes between operational and programmer errors
+ * - Logs errors with full context
+ * - Hides sensitive info in production
+ * - Formats JSON responses consistently
+ */
+export const errorHandler = (
+  err: unknown,
+  req: Request,
+  res: Response,
+  next: NextFunction,
+): void => {
+  const appError = normalizeError(err);
+
+  logError(appError, req);
+
+  sendErrorResponse(res, appError);
+};
+
+/**
+ * Async error wrapper
+ * Wrap async route handlers to catch errors and pass to middleware
+ *
+ * Example:
+ * router.get('/users/:id', asyncHandler(getUserHandler))
+ */
+export const asyncHandler = (fn: AsyncRequestHandler) => {
+  return (req: Request, res: Response, next: NextFunction): void => {
+    Promise.resolve(fn(req, res, next)).catch(next);
+  };
+};
+
+export {
+  AppError,
+  ValidationError,
+  InternalServerError,
+  AuthenticationError,
+  AuthorizationError,
+  NotFoundError,
+  ConflictError,
+  BadRequestError,
+};

package/template/ts/src/middlewares/requestLogger.ts

@@ -1,38 +1,38 @@
-import { Request, Response, NextFunction } from "express";
-import { logger } from "../utils/logger.ts";
-
-/**
- * Request logging middleware
- * Logs all HTTP requests with method, path, status, duration, and IP
- */
-export const requestLogger = (
-  req: Request,
-  res: Response,
-  next: NextFunction,
-): void => {
-  const start = Date.now();
-
-  res.on("finish", () => {
-    const duration = Date.now() - start;
-    const statusCode = res.statusCode;
-    const isError = statusCode >= 400;
-
-    const logData = {
-      method: req.method,
-      path: req.path,
-      statusCode,
-      durationMs: duration,
-      ip: req.ip,
-      userAgent: req.get("user-agent") || undefined,
-      ...(isError && { error: true }),
-    };
-
-    if (isError) {
-      logger.warn(`${req.method} ${req.path}`, logData);
-    } else {
-      logger.debug(`${req.method} ${req.path}`, logData);
-    }
-  });
-
-  next();
-};
+import { Request, Response, NextFunction } from "express";
+import { logger } from "../utils/logger.ts";
+
+/**
+ * Request logging middleware
+ * Logs all HTTP requests with method, path, status, duration, and IP
+ */
+export const requestLogger = (
+  req: Request,
+  res: Response,
+  next: NextFunction,
+): void => {
+  const start = Date.now();
+
+  res.on("finish", () => {
+    const duration = Date.now() - start;
+    const statusCode = res.statusCode;
+    const isError = statusCode >= 400;
+
+    const logData = {
+      method: req.method,
+      path: req.path,
+      statusCode,
+      durationMs: duration,
+      ip: req.ip,
+      userAgent: req.get("user-agent") || undefined,
+      ...(isError && { error: true }),
+    };
+
+    if (isError) {
+      logger.warn(`${req.method} ${req.path}`, logData);
+    } else {
+      logger.debug(`${req.method} ${req.path}`, logData);
+    }
+  });
+
+  next();
+};

package/template/ts/src/middlewares/validateRequest.ts

@@ -1,46 +1,46 @@
-import { Request, Response, NextFunction } from "express";
-import { z, ZodError } from "zod";
-import { ValidationError } from "../utils/AppError.ts";
-
-/**
- * Request validation middleware
- *
- * Validates request body, query, and params against a Zod schema
- * Throws ValidationError if validation fails
- *
- * Example:
- * const schema = z.object({
- *   body: z.object({ name: z.string() }),
- *   query: z.object({ page: z.coerce.number().optional() }),
- * });
- *
- * router.post('/items', validateRequest(schema), handler)
- */
-export const validateRequest = (schema: z.AnyZodObject) => {
-  return async (
-    req: Request,
-    res: Response,
-    next: NextFunction,
-  ): Promise<void> => {
-    try {
-      const validated = await schema.parseAsync({
-        body: req.body,
-        query: req.query,
-        params: req.params,
-      });
-
-      req.validatedData = validated;
-      next();
-    } catch (error) {
-      if (error instanceof ZodError) {
-        const errors = error.errors.map((e) => ({
-          field: e.path.join("."),
-          message: e.message,
-          code: e.code,
-        }));
-        throw new ValidationError("Request validation failed", errors);
-      }
-      next(error);
-    }
-  };
-};
+import { Request, Response, NextFunction } from "express";
+import { z, ZodError } from "zod";
+import { ValidationError } from "../utils/AppError.ts";
+
+/**
+ * Request validation middleware
+ *
+ * Validates request body, query, and params against a Zod schema
+ * Throws ValidationError if validation fails
+ *
+ * Example:
+ * const schema = z.object({
+ *   body: z.object({ name: z.string() }),
+ *   query: z.object({ page: z.coerce.number().optional() }),
+ * });
+ *
+ * router.post('/items', validateRequest(schema), handler)
+ */
+export const validateRequest = (schema: z.AnyZodObject) => {
+  return async (
+    req: Request,
+    res: Response,
+    next: NextFunction,
+  ): Promise<void> => {
+    try {
+      const validated = await schema.parseAsync({
+        body: req.body,
+        query: req.query,
+        params: req.params,
+      });
+
+      req.validatedData = validated;
+      next();
+    } catch (error) {
+      if (error instanceof ZodError) {
+        const errors = error.errors.map((e) => ({
+          field: e.path.join("."),
+          message: e.message,
+          code: e.code,
+        }));
+        throw new ValidationError("Request validation failed", errors);
+      }
+      next(error);
+    }
+  };
+};

package/template/ts/src/modules/auth/auth.constants.ts

@@ -1,6 +1,6 @@
-export const USER_ROLES = ["user", "admin"] as const;
-
-export const AUTH_PROVIDERS = ["credentials"] as const;
-
-export type UserRole = (typeof USER_ROLES)[number];
-export type AuthProvider = (typeof AUTH_PROVIDERS)[number];
+export const USER_ROLES = ["user", "admin"] as const;
+
+export const AUTH_PROVIDERS = ["credentials"] as const;
+
+export type UserRole = (typeof USER_ROLES)[number];
+export type AuthProvider = (typeof AUTH_PROVIDERS)[number];

package/template/ts/src/modules/auth/auth.controller.ts

@@ -1,32 +1,32 @@
-import { AuthService } from "./auth.service.ts";
-import { Request, Response } from "express";
-
-export const AuthController = {
-  async register(req: Request, res: Response): Promise<void> {
-    try {
-      const user = await AuthService.register(
-        req.body,
-        req.app.locals.userRepo,
-      );
-
-      res.status(201).json({
-        message: "User registered successfully",
-        user,
-      });
-    } catch (err) {
-      const message = err instanceof Error ? err.message : "An error occurred";
-      res.status(400).json({ message });
-    }
-  },
-
-  async login(req: Request, res: Response): Promise<void> {
-    try {
-      const result = await AuthService.login(req.body, req.app.locals.userRepo);
-
-      res.json(result);
-    } catch (err) {
-      const message = err instanceof Error ? err.message : "An error occurred";
-      res.status(401).json({ message });
-    }
-  },
-};
+import { AuthService } from "./auth.service.ts";
+import { Request, Response } from "express";
+
+export const AuthController = {
+  async register(req: Request, res: Response): Promise<void> {
+    try {
+      const user = await AuthService.register(
+        req.body,
+        req.app.locals.userRepo,
+      );
+
+      res.status(201).json({
+        message: "User registered successfully",
+        user,
+      });
+    } catch (err) {
+      const message = err instanceof Error ? err.message : "An error occurred";
+      res.status(400).json({ message });
+    }
+  },
+
+  async login(req: Request, res: Response): Promise<void> {
+    try {
+      const result = await AuthService.login(req.body, req.app.locals.userRepo);
+
+      res.json(result);
+    } catch (err) {
+      const message = err instanceof Error ? err.message : "An error occurred";
+      res.status(401).json({ message });
+    }
+  },
+};