create-charcole 2.2.0 → 2.2.2

package/template/js/src/middlewares/errorHandler.js

@@ -1,180 +1,180 @@
-import { ZodError } from "zod";
-import { HTTP_STATUS, ERROR_MESSAGES } from "../config/constants.js";
-import { logger } from "../utils/logger.js";
-import {
-  AppError,
-  ValidationError,
-  InternalServerError,
-} from "../utils/AppError.js";
-import { env } from "../config/env.js";
-
-/**
- * Normalize different error types to AppError
- */
-const normalizeError = (err) => {
-  // Already an AppError
-  if (err instanceof AppError) {
-    return err;
-  }
-
-  // Zod validation error
-  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);
-  }
-
-  // Syntax errors (programmer error)
-  if (err instanceof SyntaxError) {
-    return new InternalServerError("Syntax error in application code", err, {
-      type: "SyntaxError",
-    });
-  }
-
-  // Type errors (programmer error)
-  if (err instanceof TypeError) {
-    return new InternalServerError("Type error in application", err, {
-      type: "TypeError",
-    });
-  }
-
-  // Reference errors (programmer error)
-  if (err instanceof ReferenceError) {
-    return new InternalServerError("Reference error in application", err, {
-      type: "ReferenceError",
-    });
-  }
-
-  // Range errors
-  if (err instanceof RangeError) {
-    return new InternalServerError("Range error in application", err, {
-      type: "RangeError",
-    });
-  }
-
-  // Generic error (unknown)
-  return new InternalServerError(
-    err.message || ERROR_MESSAGES.SERVER_ERROR,
-    err,
-    { type: "UnknownError" },
-  );
-};
-
-/**
- * Log error based on type (operational vs programmer)
- */
-const logError = (appError, req) => {
-  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"),
-  };
-
-  // Operational errors: normal logging
-  if (appError.isOperational) {
-    logger.warn(`Operational Error: ${appError.code}`, errorDetails);
-  } else {
-    // Programmer errors: detailed logging with stack
-    logger.error(
-      `Programmer Error: ${appError.code}`,
-      errorDetails,
-      appError.stack,
-    );
-  }
-
-  // Log validation errors separately
-  if (appError instanceof ValidationError && appError.errors) {
-    logger.debug("Validation errors", { errors: appError.errors });
-  }
-
-  // Log cause if present
-  if (appError.cause) {
-    logger.debug("Error cause", { cause: appError.cause.message });
-  }
-};
-
-/**
- * Send error response
- */
-const sendErrorResponse = (res, appError) => {
-  const statusCode = appError.statusCode || HTTP_STATUS.INTERNAL_SERVER_ERROR;
-
-  // In production, hide internal details for programmer errors
-  if (!appError.isOperational && env.isProduction) {
-    return res.status(statusCode).json({
-      success: false,
-      message: ERROR_MESSAGES.SERVER_ERROR,
-      code: "INTERNAL_SERVER_ERROR",
-      timestamp: new Date().toISOString(),
-    });
-  }
-
-  // Return detailed error in development
-  const response = appError.toJSON
-    ? appError.toJSON()
-    : {
-        success: false,
-        message: appError.message,
-        code: appError.code,
-        statusCode,
-        timestamp: new Date().toISOString(),
-      };
-
-  return 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, req, res, next) => {
-  // Normalize the error
-  const appError = normalizeError(err);
-
-  // Log the error
-  logError(appError, req);
-
-  // Send response
-  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) => {
-  return (req, res, next) => {
-    return Promise.resolve(fn(req, res, next)).catch(next);
-  };
-};
-
-export {
-  AppError,
-  ValidationError,
-  InternalServerError,
-  AuthenticationError,
-  AuthorizationError,
-  NotFoundError,
-  ConflictError,
-  BadRequestError,
-} from "../utils/AppError.js";
+import { ZodError } from "zod";
+import { HTTP_STATUS, ERROR_MESSAGES } from "../config/constants.js";
+import { logger } from "../utils/logger.js";
+import {
+  AppError,
+  ValidationError,
+  InternalServerError,
+} from "../utils/AppError.js";
+import { env } from "../config/env.js";
+
+/**
+ * Normalize different error types to AppError
+ */
+const normalizeError = (err) => {
+  // Already an AppError
+  if (err instanceof AppError) {
+    return err;
+  }
+
+  // Zod validation error
+  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);
+  }
+
+  // Syntax errors (programmer error)
+  if (err instanceof SyntaxError) {
+    return new InternalServerError("Syntax error in application code", err, {
+      type: "SyntaxError",
+    });
+  }
+
+  // Type errors (programmer error)
+  if (err instanceof TypeError) {
+    return new InternalServerError("Type error in application", err, {
+      type: "TypeError",
+    });
+  }
+
+  // Reference errors (programmer error)
+  if (err instanceof ReferenceError) {
+    return new InternalServerError("Reference error in application", err, {
+      type: "ReferenceError",
+    });
+  }
+
+  // Range errors
+  if (err instanceof RangeError) {
+    return new InternalServerError("Range error in application", err, {
+      type: "RangeError",
+    });
+  }
+
+  // Generic error (unknown)
+  return new InternalServerError(
+    err.message || ERROR_MESSAGES.SERVER_ERROR,
+    err,
+    { type: "UnknownError" },
+  );
+};
+
+/**
+ * Log error based on type (operational vs programmer)
+ */
+const logError = (appError, req) => {
+  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"),
+  };
+
+  // Operational errors: normal logging
+  if (appError.isOperational) {
+    logger.warn(`Operational Error: ${appError.code}`, errorDetails);
+  } else {
+    // Programmer errors: detailed logging with stack
+    logger.error(
+      `Programmer Error: ${appError.code}`,
+      errorDetails,
+      appError.stack,
+    );
+  }
+
+  // Log validation errors separately
+  if (appError instanceof ValidationError && appError.errors) {
+    logger.debug("Validation errors", { errors: appError.errors });
+  }
+
+  // Log cause if present
+  if (appError.cause) {
+    logger.debug("Error cause", { cause: appError.cause.message });
+  }
+};
+
+/**
+ * Send error response
+ */
+const sendErrorResponse = (res, appError) => {
+  const statusCode = appError.statusCode || HTTP_STATUS.INTERNAL_SERVER_ERROR;
+
+  // In production, hide internal details for programmer errors
+  if (!appError.isOperational && env.isProduction) {
+    return res.status(statusCode).json({
+      success: false,
+      message: ERROR_MESSAGES.SERVER_ERROR,
+      code: "INTERNAL_SERVER_ERROR",
+      timestamp: new Date().toISOString(),
+    });
+  }
+
+  // Return detailed error in development
+  const response = appError.toJSON
+    ? appError.toJSON()
+    : {
+        success: false,
+        message: appError.message,
+        code: appError.code,
+        statusCode,
+        timestamp: new Date().toISOString(),
+      };
+
+  return 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, req, res, next) => {
+  // Normalize the error
+  const appError = normalizeError(err);
+
+  // Log the error
+  logError(appError, req);
+
+  // Send response
+  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) => {
+  return (req, res, next) => {
+    return Promise.resolve(fn(req, res, next)).catch(next);
+  };
+};
+
+export {
+  AppError,
+  ValidationError,
+  InternalServerError,
+  AuthenticationError,
+  AuthorizationError,
+  NotFoundError,
+  ConflictError,
+  BadRequestError,
+} from "../utils/AppError.js";

package/template/js/src/middlewares/requestLogger.js

@@ -1,33 +1,33 @@
-import { logger } from "../utils/logger.js";
-
-/**
- * Request logging middleware
- * Logs all HTTP requests with method, path, status, duration, and IP
- */
-export const requestLogger = (req, res, next) => {
-  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"),
-      ...(isError && { error: true }),
-    };
-
-    if (isError) {
-      logger.warn(`${req.method} ${req.path}`, logData);
-    } else {
-      logger.debug(`${req.method} ${req.path}`, logData);
-    }
-  });
-
-  next();
-};
+import { logger } from "../utils/logger.js";
+
+/**
+ * Request logging middleware
+ * Logs all HTTP requests with method, path, status, duration, and IP
+ */
+export const requestLogger = (req, res, next) => {
+  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"),
+      ...(isError && { error: true }),
+    };
+
+    if (isError) {
+      logger.warn(`${req.method} ${req.path}`, logData);
+    } else {
+      logger.debug(`${req.method} ${req.path}`, logData);
+    }
+  });
+
+  next();
+};

package/template/js/src/middlewares/validateRequest.js

@@ -1,42 +1,42 @@
-import { ValidationError } from "../utils/AppError.js";
-
-/**
- * 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) => {
-  return async (req, res, next) => {
-    try {
-      // Validate request
-      const validated = await schema.parseAsync({
-        body: req.body,
-        query: req.query,
-        params: req.params,
-      });
-
-      // Attach validated data
-      req.validatedData = validated;
-      next();
-    } catch (error) {
-      if (error.name === "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 { ValidationError } from "../utils/AppError.js";
+
+/**
+ * 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) => {
+  return async (req, res, next) => {
+    try {
+      // Validate request
+      const validated = await schema.parseAsync({
+        body: req.body,
+        query: req.query,
+        params: req.params,
+      });
+
+      // Attach validated data
+      req.validatedData = validated;
+      next();
+    } catch (error) {
+      if (error.name === "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/js/src/modules/auth/auth.constants.js

@@ -1,3 +1,3 @@
-export const USER_ROLES = ["user", "admin"];
-
-export const AUTH_PROVIDERS = ["credentials"];
+export const USER_ROLES = ["user", "admin"];
+
+export const AUTH_PROVIDERS = ["credentials"];

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

@@ -1,29 +1,29 @@
-import { AuthService } from "./auth.service.js";
-
-export const AuthController = {
-  async register(req, res) {
-    try {
-      const user = await AuthService.register(
-        req.body,
-        req.app.locals.userRepo,
-      );
-
-      res.status(201).json({
-        message: "User registered successfully",
-        user,
-      });
-    } catch (err) {
-      res.status(400).json({ message: err.message });
-    }
-  },
-
-  async login(req, res) {
-    try {
-      const result = await AuthService.login(req.body, req.app.locals.userRepo);
-
-      res.json(result);
-    } catch (err) {
-      res.status(401).json({ message: err.message });
-    }
-  },
-};
+import { AuthService } from "./auth.service.js";
+
+export const AuthController = {
+  async register(req, res) {
+    try {
+      const user = await AuthService.register(
+        req.body,
+        req.app.locals.userRepo,
+      );
+
+      res.status(201).json({
+        message: "User registered successfully",
+        user,
+      });
+    } catch (err) {
+      res.status(400).json({ message: err.message });
+    }
+  },
+
+  async login(req, res) {
+    try {
+      const result = await AuthService.login(req.body, req.app.locals.userRepo);
+
+      res.json(result);
+    } catch (err) {
+      res.status(401).json({ message: err.message });
+    }
+  },
+};

package/template/js/src/modules/auth/auth.middlewares.js

@@ -1,19 +1,19 @@
-import jwt from "jsonwebtoken";
-
-export const requireAuth = (req, res, next) => {
-  const authHeader = req.headers.authorization;
-
-  if (!authHeader?.startsWith("Bearer ")) {
-    return res.status(401).json({ message: "Unauthorized" });
-  }
-
-  const token = authHeader.split(" ")[1];
-
-  try {
-    const payload = jwt.verify(token, process.env.JWT_SECRET);
-    req.user = payload;
-    next();
-  } catch {
-    res.status(401).json({ message: "Invalid token" });
-  }
-};
+import jwt from "jsonwebtoken";
+
+export const requireAuth = (req, res, next) => {
+  const authHeader = req.headers.authorization;
+
+  if (!authHeader?.startsWith("Bearer ")) {
+    return res.status(401).json({ message: "Unauthorized" });
+  }
+
+  const token = authHeader.split(" ")[1];
+
+  try {
+    const payload = jwt.verify(token, process.env.JWT_SECRET);
+    req.user = payload;
+    next();
+  } catch {
+    res.status(401).json({ message: "Invalid token" });
+  }
+};