create-charcole 2.0.4 → 2.2.0

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

@@ -0,0 +1,52 @@
+import { Router } from "express";
+import { AuthController } from "./auth.controller.ts";
+
+const router = Router();
+
+/**
+ * @swagger
+ * /api/auth/register:
+ *   post:
+ *     summary: Register a new user
+ *     description: Create a new user account with email and password
+ *     tags:
+ *       - Authentication
+ *     requestBody:
+ *       required: true
+ *       content:
+ *         application/json:
+ *           schema:
+ *             $ref: '#/components/schemas/registerSchema'
+ *     responses:
+ *       201:
+ *         $ref: '#/components/responses/Success'
+ *       400:
+ *         $ref: '#/components/responses/ValidationError'
+ */
+router.post("/register", AuthController.register);
+
+/**
+ * @swagger
+ * /api/auth/login:
+ *   post:
+ *     summary: Login user
+ *     description: Authenticate user with email and password
+ *     tags:
+ *       - Authentication
+ *     requestBody:
+ *       required: true
+ *       content:
+ *         application/json:
+ *           schema:
+ *             $ref: '#/components/schemas/loginSchema'
+ *     responses:
+ *       200:
+ *         $ref: '#/components/responses/Success'
+ *       401:
+ *         $ref: '#/components/responses/Unauthorized'
+ *       400:
+ *         $ref: '#/components/responses/ValidationError'
+ */
+router.post("/login", AuthController.login);
+
+export default router;

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

@@ -0,0 +1,73 @@
+import { z } from "zod";
+import { USER_ROLES, AUTH_PROVIDERS } from "./auth.constants.ts";
+
+export const emailSchema = z
+  .string()
+  .email("Invalid email address")
+  .toLowerCase();
+
+export const passwordSchema = z
+  .string()
+  .min(8, "Password must be at least 8 characters")
+  .max(72, "Password too long");
+
+export const userSchema = z.object({
+  id: z.string().uuid(),
+  email: emailSchema,
+  name: z.string().min(1).max(100),
+  role: z.enum(USER_ROLES).default("user"),
+  provider: z.enum(AUTH_PROVIDERS).default("credentials"),
+
+  passwordHash: z.string().optional(), // credentials only
+  isEmailVerified: z.boolean().default(false),
+
+  createdAt: z.date(),
+  updatedAt: z.date(),
+});
+
+export const registerSchema = z.object({
+  name: z.string().min(1, "Name is required"),
+  email: emailSchema,
+  password: passwordSchema,
+});
+
+export const loginSchema = z.object({
+  email: emailSchema,
+  password: z.string().min(1, "Password is required"),
+});
+
+export const jwtPayloadSchema = z.object({
+  sub: z.string().uuid(), // user id
+  email: emailSchema,
+  role: z.enum(USER_ROLES),
+});
+
+export const forgotPasswordSchema = z.object({
+  email: emailSchema,
+});
+
+export const resetPasswordSchema = z.object({
+  token: z.string().min(1),
+  newPassword: passwordSchema,
+});
+
+export const publicUserSchema = userSchema.omit({
+  passwordHash: true,
+});
+
+// Generic validate function with proper typing
+export const validate = <T extends z.ZodTypeAny>(
+  schema: T,
+  data: unknown,
+): z.infer<T> => {
+  return schema.parse(data);
+};
+
+// Export inferred types for use in other files
+export type User = z.infer<typeof userSchema>;
+export type RegisterInput = z.infer<typeof registerSchema>;
+export type LoginInput = z.infer<typeof loginSchema>;
+export type JwtPayload = z.infer<typeof jwtPayloadSchema>;
+export type ForgotPasswordInput = z.infer<typeof forgotPasswordSchema>;
+export type ResetPasswordInput = z.infer<typeof resetPasswordSchema>;
+export type PublicUser = z.infer<typeof publicUserSchema>;

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

@@ -0,0 +1,106 @@
+import bcrypt from "bcryptjs";
+import jwt from "jsonwebtoken";
+import { registerSchema, loginSchema } from "./auth.schemas.ts";
+import type { z } from "zod";
+
+const SALT_ROUNDS = 10;
+const JWT_EXPIRES_IN = "7d";
+
+// Type definitions
+type RegisterInput = z.infer<typeof registerSchema>;
+type LoginInput = z.infer<typeof loginSchema>;
+
+type User = {
+  id: string;
+  email: string;
+  name: string;
+  passwordHash: string;
+  role: string;
+};
+
+type UserRepo = {
+  findByEmail(email: string): Promise<User | null>;
+  create(data: {
+    email: string;
+    name: string;
+    passwordHash: string;
+  }): Promise<User>;
+};
+
+type JwtPayload = {
+  sub: string;
+  email: string;
+  role: string;
+};
+
+type LoginResult = {
+  user: User;
+  token: string;
+};
+
+export const AuthService = {
+  async hashPassword(password: string): Promise<string> {
+    return bcrypt.hash(password, SALT_ROUNDS);
+  },
+
+  async comparePassword(password: string, hash: string): Promise<boolean> {
+    return bcrypt.compare(password, hash);
+  },
+
+  signToken(payload: JwtPayload): string {
+    const secret = process.env.JWT_SECRET;
+
+    if (!secret) {
+      throw new Error("JWT_SECRET environment variable is not defined");
+    }
+
+    return jwt.sign(payload, secret, {
+      expiresIn: JWT_EXPIRES_IN,
+    });
+  },
+
+  async register(data: unknown, userRepo: UserRepo): Promise<User> {
+    const input: RegisterInput = registerSchema.parse(data);
+
+    const existingUser = await userRepo.findByEmail(input.email);
+    if (existingUser) {
+      throw new Error("Email already in use");
+    }
+
+    const passwordHash = await this.hashPassword(input.password);
+
+    const user = await userRepo.create({
+      email: input.email,
+      name: input.name,
+      passwordHash,
+    });
+
+    return user;
+  },
+
+  async login(data: unknown, userRepo: UserRepo): Promise<LoginResult> {
+    const input: LoginInput = loginSchema.parse(data);
+
+    const user = await userRepo.findByEmail(input.email);
+    if (!user || !user.passwordHash) {
+      throw new Error("Invalid credentials");
+    }
+
+    const isValid = await this.comparePassword(
+      input.password,
+      user.passwordHash,
+    );
+
+    if (!isValid) {
+      throw new Error("Invalid credentials");
+    }
+
+    const token = this.signToken({
+      sub: user.id,
+      email: user.email,
+      role: user.role,
+    });
+
+    return { user, token };
+  },
+};

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

@@ -0,0 +1,10 @@
+{
+  "dependencies": {
+    "bcryptjs": "^3.0.3",
+    "jsonwebtoken": "^9.0.3"
+  },
+  "devDependencies": {
+    "@types/bcryptjs": "^2.4.6",
+    "@types/jsonwebtoken": "^9.0.10"
+  }
+}

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

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

package/template/ts/src/modules/swagger/package.json

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

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

@@ -0,0 +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;
+  },
+};

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

@@ -0,0 +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;

package/template/ts/src/routes/protected.ts

@@ -0,0 +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;

package/template/ts/src/server.ts

@@ -1,8 +1,7 @@
 import "dotenv/config";
-
-import { app } from "./app.js";
-import { env } from "./config/env.js";
-import { logger } from "./utils/logger.js";
+import { app } from "./app.ts";
+import { env } from "./config/env.ts";
+import { logger } from "./utils/logger.ts";
 
 const PORT = env.PORT;
 

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

@@ -1,4 +1,4 @@
-import { env } from "../config/env.js";
+import { env } from "../config/env.ts";
 
 type LogLevel = "debug" | "info" | "warn" | "error" | "fatal";
 

package/template/ts/tsconfig.json

@@ -2,18 +2,25 @@
   "compilerOptions": {
     "target": "ES2020",
     "module": "ESNext",
-    "rootDir": "src",
-    "outDir": "dist",
+    "moduleResolution": "bundler",
+    "rootDir": "./src",
+    "outDir": "./dist",
     "strict": true,
     "esModuleInterop": true,
     "forceConsistentCasingInFileNames": true,
     "skipLibCheck": true,
-    "moduleResolution": "node",
     "resolveJsonModule": true,
     "allowJs": false,
-    "noEmitOnError": true,
-    "sourceMap": true
+    "noEmitOnError": false,
+    "sourceMap": true,
+    "declaration": false,
+    "allowImportingTsExtensions": true,
+    "noEmit": true
   },
-  "include": ["src/**/*.ts"],
-  "exclude": ["node_modules", "dist"]
+  "include": ["src/**/*"],
+  "exclude": ["node_modules", "dist"],
+  "ts-node": {
+    "esm": true,
+    "experimentalSpecifierResolution": "node"
+  }
 }

package/tmpclaude-1049-cwd

@@ -0,0 +1 @@
+/e/SAFEZONE/charcole

package/tmpclaude-3e37-cwd

@@ -0,0 +1 @@
+/e/SAFEZONE/charcole

package/tmpclaude-4d73-cwd

@@ -0,0 +1 @@
+/e/SAFEZONE/charcole

package/tmpclaude-8a8e-cwd

@@ -0,0 +1 @@
+/e/SAFEZONE/charcole