create-charcole 2.2.0 → 2.2.2

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

@@ -1,80 +1,80 @@
-import { Request, Response } from "express";
-import { z } from "zod";
-import { sendSuccess } from "../../utils/response.ts";
-import { asyncHandler } from "../../middlewares/errorHandler.ts";
-
-/**
- * @swagger
- * /api/health:
- *   get:
- *     summary: Health check endpoint
- *     description: Returns the health status of the API
- *     tags:
- *       - Health
- *     responses:
- *       200:
- *         $ref: '#/components/responses/Success'
- */
-export const getHealth = asyncHandler(async (req: Request, res: Response) => {
-  sendSuccess(
-    res,
-    {
-      status: "healthy" as const,
-      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:
- *             $ref: '#/components/schemas/createItemSchema'
- *     responses:
- *       201:
- *         $ref: '#/components/responses/Success'
- *       400:
- *         $ref: '#/components/responses/ValidationError'
- */
-export const createItem = asyncHandler(async (req: Request, res: Response) => {
-  const parsed = createItemSchema.parse({ body: req.body });
-  const { name, description } = parsed.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 { Request, Response } from "express";
+import { z } from "zod";
+import { sendSuccess } from "../../utils/response.ts";
+import { asyncHandler } from "../../middlewares/errorHandler.ts";
+
+/**
+ * @swagger
+ * /api/health:
+ *   get:
+ *     summary: Health check endpoint
+ *     description: Returns the health status of the API
+ *     tags:
+ *       - Health
+ *     responses:
+ *       200:
+ *         $ref: '#/components/responses/Success'
+ */
+export const getHealth = asyncHandler(async (req: Request, res: Response) => {
+  sendSuccess(
+    res,
+    {
+      status: "healthy" as const,
+      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:
+ *             $ref: '#/components/schemas/createItemSchema'
+ *     responses:
+ *       201:
+ *         $ref: '#/components/responses/Success'
+ *       400:
+ *         $ref: '#/components/responses/ValidationError'
+ */
+export const createItem = asyncHandler(async (req: Request, res: Response) => {
+  const parsed = createItemSchema.parse({ body: req.body });
+  const { name, description } = parsed.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/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/ts/src/repositories/user.repo.ts

@@ -1,33 +1,33 @@
-import { randomUUID } from "crypto";
-import type { User } from "../modules/auth/auth.schemas.ts";
-
-const users: User[] = [];
-
-type CreateUserData = {
-  email: string;
-  name: string;
-  passwordHash: string;
-};
-
-export const userRepo = {
-  async findByEmail(email: string): Promise<User | undefined> {
-    return users.find((u) => u.email === email);
-  },
-
-  async create(data: CreateUserData): Promise<User> {
-    const user: User = {
-      id: randomUUID(),
-      email: data.email,
-      name: data.name,
-      passwordHash: data.passwordHash,
-      role: "user",
-      provider: "credentials",
-      isEmailVerified: false,
-      createdAt: new Date(),
-      updatedAt: new Date(),
-    };
-
-    users.push(user);
-    return user;
-  },
-};
+import { randomUUID } from "crypto";
+import type { User } from "../modules/auth/auth.schemas.ts";
+
+const users: User[] = [];
+
+type CreateUserData = {
+  email: string;
+  name: string;
+  passwordHash: string;
+};
+
+export const userRepo = {
+  async findByEmail(email: string): Promise<User | undefined> {
+    return users.find((u) => u.email === email);
+  },
+
+  async create(data: CreateUserData): Promise<User> {
+    const user: User = {
+      id: randomUUID(),
+      email: data.email,
+      name: data.name,
+      passwordHash: data.passwordHash,
+      role: "user",
+      provider: "credentials",
+      isEmailVerified: false,
+      createdAt: new Date(),
+      updatedAt: new Date(),
+    };
+
+    users.push(user);
+    return user;
+  },
+};

package/template/ts/src/routes/index.ts

@@ -1,24 +1,24 @@
-import { Router } from "express";
-import {
-  getHealth,
-  createItem,
-  createItemSchema,
-} from "../modules/health/controller.ts";
-import { validateRequest } from "../middlewares/validateRequest.ts";
-import protectedRoutes from "./protected.ts";
-import authRoutes from "../modules/auth/auth.routes.ts";
-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.ts";
+import { validateRequest } from "../middlewares/validateRequest.ts";
+import protectedRoutes from "./protected.ts";
+import authRoutes from "../modules/auth/auth.routes.ts";
+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/ts/src/routes/protected.ts

@@ -1,46 +1,46 @@
-import { Router } from "express";
-import { requireAuth } from "../modules/auth/auth.middlewares.ts";
-
-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
- */
-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.ts";
+
+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
+ */
+router.get("/me", requireAuth, (req, res) => {
+  res.json({
+    message: "You are authenticated",
+    user: req.user,
+  });
+});
+
+export default router;

package/template/ts/src/server.ts

@@ -1,41 +1,41 @@
-import "dotenv/config";
-import { app } from "./app.ts";
-import { env } from "./config/env.ts";
-import { logger } from "./utils/logger.ts";
-
-const PORT = env.PORT;
-
-const server = app.listen(PORT, () => {
-  logger.info(`🔥 Server running in ${env.NODE_ENV} mode`, {
-    url: `http://localhost:${PORT}`,
-    port: PORT,
-  });
-});
-
-const gracefulShutdown = (signal: string): void => {
-  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"));
-
-process.on(
-  "unhandledRejection",
-  (reason: unknown, promise: Promise<unknown>) => {
-    logger.error("Unhandled Rejection at:", { promise, reason });
-    process.exit(1);
-  },
-);
-
-process.on("uncaughtException", (error: Error) => {
-  logger.error("Uncaught Exception:", {
-    message: error.message,
-    stack: error.stack,
-  });
-  process.exit(1);
-});
+import "dotenv/config";
+import { app } from "./app.ts";
+import { env } from "./config/env.ts";
+import { logger } from "./utils/logger.ts";
+
+const PORT = env.PORT;
+
+const server = app.listen(PORT, () => {
+  logger.info(`🔥 Server running in ${env.NODE_ENV} mode`, {
+    url: `http://localhost:${PORT}`,
+    port: PORT,
+  });
+});
+
+const gracefulShutdown = (signal: string): void => {
+  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"));
+
+process.on(
+  "unhandledRejection",
+  (reason: unknown, promise: Promise<unknown>) => {
+    logger.error("Unhandled Rejection at:", { promise, reason });
+    process.exit(1);
+  },
+);
+
+process.on("uncaughtException", (error: Error) => {
+  logger.error("Uncaught Exception:", {
+    message: error.message,
+    stack: error.stack,
+  });
+  process.exit(1);
+});

package/template/ts/src/types/express.d.ts

@@ -1,9 +1,9 @@
-import { Request } from "express";
-
-declare global {
-  namespace Express {
-    interface Request {
-      validatedData?: Record<string, any>;
-    }
-  }
-}
+import { Request } from "express";
+
+declare global {
+  namespace Express {
+    interface Request {
+      validatedData?: Record<string, any>;
+    }
+  }
+}