create-charcole 2.0.4 → 2.1.0

package/template/ts/src/modules/health/controller.js

@@ -1,50 +0,0 @@
-import { z } from "zod";
-import { sendSuccess } from "../../utils/response.js";
-import { asyncHandler } from "../../middlewares/errorHandler.js";
-
-/**
- * Health check endpoint
- * Always returns healthy status (ping endpoint)
- */
-export const getHealth = asyncHandler(async (req, res) => {
-  sendSuccess(
-    res,
-    {
-      status: "healthy",
-      uptime: process.uptime(),
-      timestamp: new Date().toISOString(),
-    },
-    200,
-    "Service is healthy",
-  );
-});
-
-/**
- * Example POST endpoint with validation
- * Demonstrates proper error handling with Zod validation
- */
-export const createItemSchema = z.object({
-  body: z.object({
-    name: z.string().min(1, "Name is required").max(100),
-    description: z.string().optional(),
-  }),
-});
-
-export const createItem = asyncHandler(async (req, res) => {
-  const { name, description } = req.validatedData.body;
-
-  // Simulate some async work
-  await new Promise((resolve) => setTimeout(resolve, 10));
-
-  sendSuccess(
-    res,
-    {
-      id: Math.random().toString(36).substr(2, 9),
-      name,
-      description: description || null,
-      createdAt: new Date().toISOString(),
-    },
-    201,
-    "Item created successfully",
-  );
-});

package/template/ts/src/routes.js

@@ -1,17 +0,0 @@
-import { Router } from "express";
-import {
-  getHealth,
-  createItem,
-  createItemSchema,
-} from "./modules/health/controller.js";
-import { validateRequest } from "./middlewares/validateRequest.js";
-
-const router = Router();
-
-// Health check
-router.get("/health", getHealth);
-
-// Example: Create item with validation
-router.post("/items", validateRequest(createItemSchema), createItem);
-
-export default router;

package/template/ts/src/routes.ts

@@ -1,16 +0,0 @@
-import { Router } from "express";
-
-import {
-  getHealth,
-  createItem,
-  createItemSchema,
-} from "./modules/health/controller.js";
-import { validateRequest } from "./middlewares/validateRequest.js";
-
-const router = Router();
-
-router.get("/health", getHealth);
-
-router.post("/items", validateRequest(createItemSchema), createItem);
-
-export default router;

package/template/ts/src/server.js

@@ -1,38 +0,0 @@
-import "dotenv/config";
-
-import { app } from "./app.js";
-import { env } from "./config/env.js";
-import { logger } from "./utils/logger.js";
-
-const PORT = env.PORT;
-
-const server = app.listen(PORT, () => {
-  logger.info(`🔥 Server running in ${env.NODE_ENV} mode`, {
-    url: `http://localhost:${PORT}`,
-    port: PORT,
-  });
-});
-
-// Graceful shutdown
-const gracefulShutdown = (signal) => {
-  logger.warn(`${signal} signal received: closing HTTP server`);
-  server.close(() => {
-    logger.info("HTTP server closed");
-    process.exit(0);
-  });
-};
-
-process.on("SIGTERM", () => gracefulShutdown("SIGTERM"));
-process.on("SIGINT", () => gracefulShutdown("SIGINT"));
-
-// Unhandled promise rejections
-process.on("unhandledRejection", (reason, promise) => {
-  logger.error("Unhandled Rejection at:", { promise, reason });
-  process.exit(1);
-});
-
-// Uncaught exceptions
-process.on("uncaughtException", (error) => {
-  logger.error("Uncaught Exception:", { error: error.message });
-  process.exit(1);
-});

package/template/ts/src/utils/AppError.js

@@ -1,182 +0,0 @@
-/**
- * Operational Error Class
- *
- * Use for expected errors that can be handled gracefully
- * Examples: validation errors, resource not found, auth failures
- *
- * These errors are logged and sent back to client as JSON
- */
-export class AppError extends Error {
-  constructor(
-    message,
-    statusCode = 500,
-    { isOperational = true, code = null, context = null, cause = null } = {},
-  ) {
-    super(message);
-
-    // Operational or Programmer error
-    this.isOperational = isOperational;
-
-    // HTTP status code
-    this.statusCode = statusCode;
-
-    // Error code for client handling (e.g., 'INVALID_EMAIL', 'USER_NOT_FOUND')
-    this.code = code;
-
-    // Additional context data
-    this.context = context || {};
-
-    // Original error that caused this
-    this.cause = cause;
-
-    // Timestamp
-    this.timestamp = new Date().toISOString();
-
-    // Preserve stack trace
-    Error.captureStackTrace(this, this.constructor);
-  }
-
-  /**
-   * Convert to JSON response format
-   */
-  toJSON() {
-    return {
-      success: false,
-      message: this.message,
-      code: this.code,
-      statusCode: this.statusCode,
-      ...(Object.keys(this.context).length > 0 && { context: this.context }),
-      timestamp: this.timestamp,
-    };
-  }
-
-  /**
-   * Get full error details for logging
-   */
-  getFullDetails() {
-    return {
-      message: this.message,
-      statusCode: this.statusCode,
-      code: this.code,
-      isOperational: this.isOperational,
-      context: this.context,
-      cause: this.cause?.message || null,
-      stack: this.stack,
-      timestamp: this.timestamp,
-    };
-  }
-}
-
-/**
- * Validation Error - extends AppError
- * Use for input validation failures
- */
-export class ValidationError extends AppError {
-  constructor(message, errors = [], context = null) {
-    super(message, 422, {
-      isOperational: true,
-      code: "VALIDATION_ERROR",
-      context,
-    });
-    this.errors = errors;
-    this.name = "ValidationError";
-  }
-
-  toJSON() {
-    return {
-      ...super.toJSON(),
-      errors: this.errors,
-    };
-  }
-}
-
-/**
- * Authentication Error
- * Use for auth/permission failures
- */
-export class AuthenticationError extends AppError {
-  constructor(message = "Unauthorized", context = null) {
-    super(message, 401, {
-      isOperational: true,
-      code: "AUTHENTICATION_ERROR",
-      context,
-    });
-    this.name = "AuthenticationError";
-  }
-}
-
-/**
- * Authorization Error
- * Use for permission denied scenarios
- */
-export class AuthorizationError extends AppError {
-  constructor(message = "Forbidden", context = null) {
-    super(message, 403, {
-      isOperational: true,
-      code: "AUTHORIZATION_ERROR",
-      context,
-    });
-    this.name = "AuthorizationError";
-  }
-}
-
-/**
- * Not Found Error
- * Use when resource doesn't exist
- */
-export class NotFoundError extends AppError {
-  constructor(resource = "Resource", context = null) {
-    super(`${resource} not found`, 404, {
-      isOperational: true,
-      code: "NOT_FOUND",
-      context,
-    });
-    this.name = "NotFoundError";
-  }
-}
-
-/**
- * Conflict Error
- * Use for duplicate resources, business logic conflicts
- */
-export class ConflictError extends AppError {
-  constructor(message, context = null) {
-    super(message, 409, {
-      isOperational: true,
-      code: "CONFLICT",
-      context,
-    });
-    this.name = "ConflictError";
-  }
-}
-
-/**
- * Bad Request Error
- * Use for malformed requests
- */
-export class BadRequestError extends AppError {
-  constructor(message, context = null) {
-    super(message, 400, {
-      isOperational: true,
-      code: "BAD_REQUEST",
-      context,
-    });
-    this.name = "BadRequestError";
-  }
-}
-
-/**
- * Internal Server Error
- * Use for unexpected server-side errors (programmer errors)
- */
-export class InternalServerError extends AppError {
-  constructor(message = "Internal server error", cause = null, context = null) {
-    super(message, 500, {
-      isOperational: false,
-      code: "INTERNAL_SERVER_ERROR",
-      cause,
-      context,
-    });
-    this.name = "InternalServerError";
-  }
-}

package/template/ts/src/utils/logger.js

@@ -1,73 +0,0 @@
-import { env } from "../config/env.js";
-
-const COLORS = {
-  reset: "\x1b[0m",
-  red: "\x1b[31m",
-  yellow: "\x1b[33m",
-  green: "\x1b[32m",
-  blue: "\x1b[36m",
-  gray: "\x1b[90m",
-  magenta: "\x1b[35m",
-};
-
-const LOG_LEVELS = {
-  debug: 0,
-  info: 1,
-  warn: 2,
-  error: 3,
-};
-
-const getCurrentLogLevel = () => LOG_LEVELS[env.LOG_LEVEL] || LOG_LEVELS.info;
-
-const formatLog = (level, message, data) => {
-  const timestamp = new Date().toISOString();
-  const dataStr = data ? ` ${JSON.stringify(data)}` : "";
-  return `[${timestamp}] ${level}:${dataStr ? " " + message + dataStr : " " + message}`;
-};
-
-const formatStack = (stack) => {
-  if (!stack) return "";
-  return `\n${stack}`;
-};
-
-export const logger = {
-  debug: (message, data) => {
-    if (getCurrentLogLevel() <= LOG_LEVELS.debug) {
-      console.log(
-        `${COLORS.gray}${formatLog("DEBUG", message, data)}${COLORS.reset}`,
-      );
-    }
-  },
-
-  info: (message, data) => {
-    if (getCurrentLogLevel() <= LOG_LEVELS.info) {
-      console.log(
-        `${COLORS.blue}${formatLog("INFO", message, data)}${COLORS.reset}`,
-      );
-    }
-  },
-
-  warn: (message, data) => {
-    if (getCurrentLogLevel() <= LOG_LEVELS.warn) {
-      console.warn(
-        `${COLORS.yellow}${formatLog("WARN", message, data)}${COLORS.reset}`,
-      );
-    }
-  },
-
-  error: (message, data, stack) => {
-    if (getCurrentLogLevel() <= LOG_LEVELS.error) {
-      const stackTrace = formatStack(stack);
-      console.error(
-        `${COLORS.red}${formatLog("ERROR", message, data)}${stackTrace}${COLORS.reset}`,
-      );
-    }
-  },
-
-  fatal: (message, data, stack) => {
-    const stackTrace = formatStack(stack);
-    console.error(
-      `${COLORS.red}${COLORS.magenta}${formatLog("FATAL", message, data)}${stackTrace}${COLORS.reset}`,
-    );
-  },
-};

package/template/ts/src/utils/response.js

@@ -1,51 +0,0 @@
-/**
- * Send success response
- *
- * @param {Response} res - Express response object
- * @param {*} data - Response data
- * @param {number} statusCode - HTTP status code (default: 200)
- * @param {string} message - Success message (default: 'Success')
- */
-export const sendSuccess = (
-  res,
-  data,
-  statusCode = 200,
-  message = "Success",
-) => {
-  return res.status(statusCode).json({
-    success: true,
-    message,
-    data,
-    timestamp: new Date().toISOString(),
-  });
-};
-
-/**
- * Send error response (DEPRECATED - use AppError instead)
- * This is kept for backward compatibility
- */
-export const sendError = (res, message, statusCode = 500, errors = null) => {
-  return res.status(statusCode).json({
-    success: false,
-    message,
-    ...(errors && { errors }),
-    timestamp: new Date().toISOString(),
-  });
-};
-
-/**
- * Send validation error response (DEPRECATED - use ValidationError instead)
- * This is kept for backward compatibility
- */
-export const sendValidationError = (res, errors, statusCode = 422) => {
-  return res.status(statusCode).json({
-    success: false,
-    message: "Validation failed",
-    errors: errors.map((err) => ({
-      field: err.path.join("."),
-      message: err.message,
-      code: err.code,
-    })),
-    timestamp: new Date().toISOString(),
-  });
-};

package/template/ts/test-api.js

@@ -1,100 +0,0 @@
-#!/usr/bin/env node
-
-import http from "http";
-
-const tests = [
-  {
-    name: "Test 1: GET / (root)",
-    method: "GET",
-    path: "/",
-    body: null,
-  },
-  {
-    name: "Test 2: GET /api/health",
-    method: "GET",
-    path: "/api/health",
-    body: null,
-  },
-  {
-    name: "Test 3: POST /api/items (valid)",
-    method: "POST",
-    path: "/api/items",
-    body: JSON.stringify({ name: "Test Item", description: "A test item" }),
-  },
-  {
-    name: "Test 4: POST /api/items (invalid - missing name)",
-    method: "POST",
-    path: "/api/items",
-    body: JSON.stringify({ description: "No name" }),
-  },
-  {
-    name: "Test 5: GET /api/nonexistent (404)",
-    method: "GET",
-    path: "/api/nonexistent",
-    body: null,
-  },
-];
-
-const runTest = (test) => {
-  return new Promise((resolve) => {
-    const options = {
-      hostname: "localhost",
-      port: 3000,
-      path: test.path,
-      method: test.method,
-      headers: {
-        "Content-Type": "application/json",
-      },
-    };
-
-    const req = http.request(options, (res) => {
-      let data = "";
-
-      res.on("data", (chunk) => {
-        data += chunk;
-      });
-
-      res.on("end", () => {
-        try {
-          const json = JSON.parse(data);
-          console.log(`\n✅ ${test.name}`);
-          console.log(`   Status: ${res.statusCode}`);
-          console.log(`   Response:`, JSON.stringify(json, null, 2));
-        } catch (error) {
-          console.log(`\n✅ ${test.name}`);
-          console.log(`   Status: ${res.statusCode}`);
-          console.log(`   Response:`, data);
-        }
-        resolve();
-      });
-    });
-
-    req.on("error", (error) => {
-      console.error(`\n❌ ${test.name}`);
-      console.error(`   Error: ${error.message}`);
-      resolve();
-    });
-
-    if (test.body) {
-      req.write(test.body);
-    }
-    req.end();
-  });
-};
-
-const runTests = async () => {
-  console.log("🚀 Testing Charcole API Error Handling\n");
-  console.log("=".repeat(60));
-
-  for (const test of tests) {
-    await runTest(test);
-    await new Promise((r) => setTimeout(r, 200));
-  }
-
-  console.log("\n" + "=".repeat(60));
-  console.log("\n✅ All tests completed!");
-  process.exit(0);
-};
-
-// Wait for server to be ready
-setTimeout(runTests, 1000);