create-charcole 2.2.0 → 2.2.2

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

@@ -1,151 +1,151 @@
-import { z } from "zod";
-import { sendSuccess } from "../../utils/response.js";
-import { asyncHandler } from "../../middlewares/errorHandler.js";
-
-/**
- * @swagger
- * /api/health:
- *   get:
- *     summary: Health check endpoint
- *     description: Returns the health status of the API
- *     tags:
- *       - Health
- *     responses:
- *       200:
- *         description: Service is healthy
- *         content:
- *           application/json:
- *             schema:
- *               type: object
- *               properties:
- *                 success:
- *                   type: boolean
- *                   example: true
- *                 message:
- *                   type: string
- *                   example: Service is healthy
- *                 data:
- *                   type: object
- *                   properties:
- *                     status:
- *                       type: string
- *                       example: healthy
- *                     uptime:
- *                       type: number
- *                       example: 123.45
- *                     timestamp:
- *                       type: string
- *                       format: date-time
- */
-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(),
-  }),
-});
-
-/**
- * @swagger
- * /api/items:
- *   post:
- *     summary: Create a new item
- *     description: Example endpoint demonstrating validation with Zod
- *     tags:
- *       - Items
- *     requestBody:
- *       required: true
- *       content:
- *         application/json:
- *           schema:
- *             type: object
- *             required:
- *               - name
- *             properties:
- *               name:
- *                 type: string
- *                 minLength: 1
- *                 maxLength: 100
- *                 example: My Item
- *               description:
- *                 type: string
- *                 example: This is an example item
- *     responses:
- *       201:
- *         description: Item created successfully
- *         content:
- *           application/json:
- *             schema:
- *               type: object
- *               properties:
- *                 success:
- *                   type: boolean
- *                   example: true
- *                 message:
- *                   type: string
- *                   example: Item created successfully
- *                 data:
- *                   type: object
- *                   properties:
- *                     id:
- *                       type: string
- *                       example: abc123def
- *                     name:
- *                       type: string
- *                       example: My Item
- *                     description:
- *                       type: string
- *                       nullable: true
- *                       example: This is an example item
- *                     createdAt:
- *                       type: string
- *                       format: date-time
- *       400:
- *         description: Validation error
- *         content:
- *           application/json:
- *             schema:
- *               type: object
- *               properties:
- *                 success:
- *                   type: boolean
- *                   example: false
- *                 message:
- *                   type: string
- *                   example: Validation failed
- */
-export const createItem = asyncHandler(async (req, res) => {
-  const parsedData = createItemSchema.parse({ body: req.body });
-  const { name, description } = parsedData.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",
-  );
-});
+import { z } from "zod";
+import { sendSuccess } from "../../utils/response.js";
+import { asyncHandler } from "../../middlewares/errorHandler.js";
+
+/**
+ * @swagger
+ * /api/health:
+ *   get:
+ *     summary: Health check endpoint
+ *     description: Returns the health status of the API
+ *     tags:
+ *       - Health
+ *     responses:
+ *       200:
+ *         description: Service is healthy
+ *         content:
+ *           application/json:
+ *             schema:
+ *               type: object
+ *               properties:
+ *                 success:
+ *                   type: boolean
+ *                   example: true
+ *                 message:
+ *                   type: string
+ *                   example: Service is healthy
+ *                 data:
+ *                   type: object
+ *                   properties:
+ *                     status:
+ *                       type: string
+ *                       example: healthy
+ *                     uptime:
+ *                       type: number
+ *                       example: 123.45
+ *                     timestamp:
+ *                       type: string
+ *                       format: date-time
+ */
+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(),
+  }),
+});
+
+/**
+ * @swagger
+ * /api/items:
+ *   post:
+ *     summary: Create a new item
+ *     description: Example endpoint demonstrating validation with Zod
+ *     tags:
+ *       - Items
+ *     requestBody:
+ *       required: true
+ *       content:
+ *         application/json:
+ *           schema:
+ *             type: object
+ *             required:
+ *               - name
+ *             properties:
+ *               name:
+ *                 type: string
+ *                 minLength: 1
+ *                 maxLength: 100
+ *                 example: My Item
+ *               description:
+ *                 type: string
+ *                 example: This is an example item
+ *     responses:
+ *       201:
+ *         description: Item created successfully
+ *         content:
+ *           application/json:
+ *             schema:
+ *               type: object
+ *               properties:
+ *                 success:
+ *                   type: boolean
+ *                   example: true
+ *                 message:
+ *                   type: string
+ *                   example: Item created successfully
+ *                 data:
+ *                   type: object
+ *                   properties:
+ *                     id:
+ *                       type: string
+ *                       example: abc123def
+ *                     name:
+ *                       type: string
+ *                       example: My Item
+ *                     description:
+ *                       type: string
+ *                       nullable: true
+ *                       example: This is an example item
+ *                     createdAt:
+ *                       type: string
+ *                       format: date-time
+ *       400:
+ *         description: Validation error
+ *         content:
+ *           application/json:
+ *             schema:
+ *               type: object
+ *               properties:
+ *                 success:
+ *                   type: boolean
+ *                   example: false
+ *                 message:
+ *                   type: string
+ *                   example: Validation failed
+ */
+export const createItem = asyncHandler(async (req, res) => {
+  const parsedData = createItemSchema.parse({ body: req.body });
+  const { name, description } = parsedData.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/js/src/modules/swagger/package.json

@@ -1,5 +1,5 @@
-{
-  "dependencies": {
-    "@charcoles/swagger": "file:./charcole-swagger-1.0.0.tgz"
-  }
-}
+{
+  "dependencies": {
+    "@charcoles/swagger": "file:./charcole-swagger-1.0.1.tgz"
+  }
+}

package/template/js/src/repositories/user.repo.js

@@ -1,19 +1,19 @@
-import { randomUUID } from "crypto";
-
-const users = [];
-
-export const userRepo = {
-  async findByEmail(email) {
-    return users.find((u) => u.email === email);
-  },
-
-  async create(data) {
-    const user = {
-      id: randomUUID(),
-      role: "user",
-      ...data,
-    };
-    users.push(user);
-    return user;
-  },
-};
+import { randomUUID } from "crypto";
+
+const users = [];
+
+export const userRepo = {
+  async findByEmail(email) {
+    return users.find((u) => u.email === email);
+  },
+
+  async create(data) {
+    const user = {
+      id: randomUUID(),
+      role: "user",
+      ...data,
+    };
+    users.push(user);
+    return user;
+  },
+};

package/template/js/src/routes/index.js

@@ -1,25 +1,25 @@
-import { Router } from "express";
-import {
-  getHealth,
-  createItem,
-  createItemSchema,
-} from "../modules/health/controller.js";
-import { validateRequest } from "../middlewares/validateRequest.js";
-import { requireAuth } from "../modules/auth/auth.middlewares.js";
-import protectedRoutes from "./protected.js";
-import authRoutes from "../modules/auth/auth.routes.js";
-const router = Router();
-
-// Health check
-router.get("/health", getHealth);
-
-// Example: Create item with validation
-router.post("/items", validateRequest(createItemSchema), createItem);
-
-// 🔐 Auth routes
-router.use("/auth", authRoutes);
-
-// 🔐 Protected routes (REQUIRED BEARER TOKEN FOR THEM)
-router.use("/protected", protectedRoutes);
-
-export default router;
+import { Router } from "express";
+import {
+  getHealth,
+  createItem,
+  createItemSchema,
+} from "../modules/health/controller.js";
+import { validateRequest } from "../middlewares/validateRequest.js";
+import { requireAuth } from "../modules/auth/auth.middlewares.js";
+import protectedRoutes from "./protected.js";
+import authRoutes from "../modules/auth/auth.routes.js";
+const router = Router();
+
+// Health check
+router.get("/health", getHealth);
+
+// Example: Create item with validation
+router.post("/items", validateRequest(createItemSchema), createItem);
+
+// 🔐 Auth routes
+router.use("/auth", authRoutes);
+
+// 🔐 Protected routes (REQUIRED BEARER TOKEN FOR THEM)
+router.use("/protected", protectedRoutes);
+
+export default router;

package/template/js/src/routes/protected.js

@@ -1,57 +1,57 @@
-import { Router } from "express";
-import { requireAuth } from "../modules/auth/auth.middlewares.js";
-
-const router = Router();
-
-/**
- * @swagger
- * /api/protected/me:
- *   get:
- *     summary: Get current user profile
- *     description: Returns the authenticated user's information
- *     tags:
- *       - Protected
- *     security:
- *       - bearerAuth: []
- *     responses:
- *       200:
- *         description: User profile retrieved successfully
- *         content:
- *           application/json:
- *             schema:
- *               type: object
- *               properties:
- *                 message:
- *                   type: string
- *                   example: You are authenticated
- *                 user:
- *                   type: object
- *                   properties:
- *                     id:
- *                       type: string
- *                       example: user_123abc
- *                     email:
- *                       type: string
- *                       example: user@example.com
- *       401:
- *         description: Unauthorized - Invalid or missing token
- *         content:
- *           application/json:
- *             schema:
- *               type: object
- *               properties:
- *                 success:
- *                   type: boolean
- *                   example: false
- *                 message:
- *                   type: string
- *                   example: Unauthorized
- */
-router.get("/me", requireAuth, (req, res) => {
-  res.json({
-    message: "You are authenticated",
-    user: req.user,
-  });
-});
-
-export default router;
+import { Router } from "express";
+import { requireAuth } from "../modules/auth/auth.middlewares.js";
+
+const router = Router();
+
+/**
+ * @swagger
+ * /api/protected/me:
+ *   get:
+ *     summary: Get current user profile
+ *     description: Returns the authenticated user's information
+ *     tags:
+ *       - Protected
+ *     security:
+ *       - bearerAuth: []
+ *     responses:
+ *       200:
+ *         description: User profile retrieved successfully
+ *         content:
+ *           application/json:
+ *             schema:
+ *               type: object
+ *               properties:
+ *                 message:
+ *                   type: string
+ *                   example: You are authenticated
+ *                 user:
+ *                   type: object
+ *                   properties:
+ *                     id:
+ *                       type: string
+ *                       example: user_123abc
+ *                     email:
+ *                       type: string
+ *                       example: user@example.com
+ *       401:
+ *         description: Unauthorized - Invalid or missing token
+ *         content:
+ *           application/json:
+ *             schema:
+ *               type: object
+ *               properties:
+ *                 success:
+ *                   type: boolean
+ *                   example: false
+ *                 message:
+ *                   type: string
+ *                   example: Unauthorized
+ */
+router.get("/me", requireAuth, (req, res) => {
+  res.json({
+    message: "You are authenticated",
+    user: req.user,
+  });
+});
+
+export default router;

package/template/js/src/server.js

@@ -1,38 +1,38 @@
-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);
-});
+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);
+});