create-charcole 2.0.4 → 2.1.0

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

@@ -0,0 +1,60 @@
+import { z } from "zod";
+import { USER_ROLES, AUTH_PROVIDERS } from "./auth.constants.js";
+
+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,
+});
+
+export const validate = (schema, data) => {
+  return schema.parse(data);
+};

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

@@ -0,0 +1,67 @@
+import bcrypt from "bcryptjs";
+import jwt from "jsonwebtoken";
+import { registerSchema, loginSchema } from "./auth.schemas.js";
+
+const SALT_ROUNDS = 10;
+const JWT_EXPIRES_IN = "7d";
+
+export const AuthService = {
+  async hashPassword(password) {
+    return bcrypt.hash(password, SALT_ROUNDS);
+  },
+
+  async comparePassword(password, hash) {
+    return bcrypt.compare(password, hash);
+  },
+
+  signToken(payload) {
+    return jwt.sign(payload, process.env.JWT_SECRET, {
+      expiresIn: JWT_EXPIRES_IN,
+    });
+  },
+
+  async register(data, userRepo) {
+    const input = 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, userRepo) {
+    const input = 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/js/src/modules/auth/package.json

@@ -0,0 +1,6 @@
+{
+  "dependencies": {
+    "bcryptjs": "^3.0.3",
+    "jsonwebtoken": "^9.0.3"
+  }
+}

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

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

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

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

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

@@ -0,0 +1,13 @@
+import { Router } from "express";
+import { requireAuth } from "../modules/auth/auth.middlewares.js";
+
+const router = Router();
+
+router.get("/me", requireAuth, (req, res) => {
+  res.json({
+    message: "You are authenticated",
+    user: req.user,
+  });
+});
+
+export default router;

package/template/ts/.env.example

@@ -1,8 +1,16 @@
+# Server Configuration
 NODE_ENV=development
 PORT=3000
 
+# Logging
 LOG_LEVEL=info
 
+# CORS
 CORS_ORIGIN=*
 
+# Request
 REQUEST_TIMEOUT=30000
+
+
+# Authentication
+JWT_SECRET=your-secret-key-here

package/template/ts/basePackage.json

@@ -1,32 +1,36 @@
 {
   "name": "charcole",
-  "version": "2.0.4",
+  "version": "2.1.0",
   "description": "Production-grade Node.js Express API",
-  "main": "src/server.js",
+  "main": "dist/server.js",
+  "type": "module",
   "scripts": {
-    "start": "node src/server.js",
-    "dev": "nodemon src/server.js",
-    "lint": "echo 'Add linting here'",
-    "test": "echo 'Add tests here'"
+    "start": "node dist/server.js",
+    "dev": "tsx watch src/server.ts",
+    "build": "node build.js",
+    "clean": "rimraf dist",
+    "prebuild": "npm run clean",
+    "lint": "echo \"Add linting here\"",
+    "test": "echo \"Add tests here\""
   },
   "engines": {
     "node": ">=18.0.0"
   },
-  "keywords": [],
-  "author": "",
-  "license": "ISC",
-  "type": "module",
   "dependencies": {
+    "express": "^4.18.2",
     "cors": "^2.8.5",
     "dotenv": "^16.3.1",
-    "express": "^4.18.2",
-    "zod": "^3.22.4"
+    "zod": "^3.25.76"
   },
   "devDependencies": {
+    "@types/cors": "^2.8.19",
     "@types/express": "^4.17.21",
     "@types/node": "^25.0.10",
-    "nodemon": "^3.0.2",
-    "ts-node-dev": "^2.0.0",
+    "esbuild": "^0.24.2",
+    "rimraf": "^6.0.1",
+    "tsc-alias": "^1.8.8",
+    "tsx": "^4.19.2",
     "typescript": "^5.9.3"
-  }
+  },
+  "license": "ISC"
 }

package/template/ts/build.js

@@ -0,0 +1,46 @@
+import { build } from "esbuild";
+import { glob } from "glob";
+import fs from "fs";
+import path from "path";
+
+const entryPoints = await glob("src/**/*.ts");
+
+// Custom plugin to rewrite .ts imports to .js
+const rewriteImportsPlugin = {
+  name: "rewrite-imports",
+  setup(build) {
+    build.onLoad({ filter: /\.ts$/ }, async (args) => {
+      const contents = await fs.promises.readFile(args.path, "utf8");
+
+      // Replace .ts extensions with .js in imports
+      const modifiedContents = contents
+        .replace(/from\s+['"]([^'"]+)\.ts['"]/g, 'from "$1.js"')
+        .replace(/import\s+['"]([^'"]+)\.ts['"]/g, 'import "$1.js"');
+
+      return {
+        contents: modifiedContents,
+        loader: "ts",
+      };
+    });
+  },
+};
+
+await build({
+  entryPoints,
+  outdir: "dist",
+  bundle: false,
+  platform: "node",
+  format: "esm",
+  target: "es2020",
+  sourcemap: true,
+  outExtension: { ".js": ".js" },
+  packages: "external",
+  plugins: [rewriteImportsPlugin],
+})
+  .then(() => {
+    console.log("✅ Build completed successfully!");
+  })
+  .catch((error) => {
+    console.error("❌ Build failed:", error);
+    process.exit(1);
+  });

package/template/ts/src/app.ts

@@ -1,8 +1,8 @@
 import express, { Request, Response, NextFunction } from "express";
 import cors from "cors";
-
-import { env } from "./config/env.js";
-import { requestLogger } from "./middlewares/requestLogger.js";
+import { userRepo } from "./repositories/user.repo.ts";
+import { env } from "./config/env.ts";
+import { requestLogger } from "./middlewares/requestLogger.ts";
 import {
   errorHandler,
   asyncHandler,
@@ -10,7 +10,7 @@ import {
 } from "./middlewares/errorHandler.js";
 import { sendSuccess } from "./utils/response.js";
 import { logger } from "./utils/logger.js";
-import routes from "./routes.js";
+import routes from "./routes/index.js";
 
 export const app = express();
 
@@ -64,3 +64,4 @@ app.use((req: Request) => {
 app.use(errorHandler);
 
 logger.info("Express app configured successfully");
+app.locals.userRepo = userRepo;

package/template/ts/src/middlewares/errorHandler.ts

@@ -1,6 +1,6 @@
 import { ZodError } from "zod";
-import { HTTP_STATUS, ERROR_MESSAGES } from "../config/constants.js";
-import { logger } from "../utils/logger.js";
+import { HTTP_STATUS, ERROR_MESSAGES } from "../config/constants.ts";
+import { logger } from "../utils/logger.ts";
 import {
   AppError,
   ValidationError,
@@ -10,9 +10,16 @@ import {
   NotFoundError,
   ConflictError,
   BadRequestError,
-} from "../utils/AppError.js";
-import { env } from "../config/env.js";
-import { Request, Response, NextFunction, RequestHandler } from "express";
+} from "../utils/AppError.ts";
+import { env } from "../config/env.ts";
+import { Request, Response, NextFunction } from "express";
+
+// Custom type for async route handlers
+type AsyncRequestHandler = (
+  req: Request,
+  res: Response,
+  next: NextFunction,
+) => Promise<any> | any;
 
 const normalizeError = (err: unknown): AppError => {
   if (err instanceof AppError) {
@@ -176,24 +183,9 @@ export const errorHandler = (
  * Example:
  * router.get('/users/:id', asyncHandler(getUserHandler))
  */
-export const asyncHandler = (fn: RequestHandler): RequestHandler => {
-  return (req: Request, res: Response, next: NextFunction): any => {
-    try {
-      const result = fn(req, res, next);
-
-      if (
-        result &&
-        typeof result === "object" &&
-        "then" in result &&
-        typeof result.then === "function"
-      ) {
-        return (result as Promise<any>).catch(next);
-      }
-
-      return result;
-    } catch (err) {
-      return next(err);
-    }
+export const asyncHandler = (fn: AsyncRequestHandler) => {
+  return (req: Request, res: Response, next: NextFunction): void => {
+    Promise.resolve(fn(req, res, next)).catch(next);
   };
 };
 

package/template/ts/src/middlewares/requestLogger.ts

@@ -1,5 +1,5 @@
 import { Request, Response, NextFunction } from "express";
-import { logger } from "../utils/logger.js";
+import { logger } from "../utils/logger.ts";
 
 /**
  * Request logging middleware

package/template/ts/src/middlewares/validateRequest.ts

@@ -1,6 +1,6 @@
 import { Request, Response, NextFunction } from "express";
 import { z, ZodError } from "zod";
-import { ValidationError } from "../utils/AppError.js";
+import { ValidationError } from "../utils/AppError.ts";
 
 /**
  * Request validation middleware

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

@@ -0,0 +1,6 @@
+export const USER_ROLES = ["user", "admin"] as const;
+
+export const AUTH_PROVIDERS = ["credentials"] as const;
+
+export type UserRole = (typeof USER_ROLES)[number];
+export type AuthProvider = (typeof AUTH_PROVIDERS)[number];

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

@@ -0,0 +1,32 @@
+import { AuthService } from "./auth.service.ts";
+import { Request, Response } from "express";
+
+export const AuthController = {
+  async register(req: Request, res: Response): Promise<void> {
+    try {
+      const user = await AuthService.register(
+        req.body,
+        req.app.locals.userRepo,
+      );
+
+      res.status(201).json({
+        message: "User registered successfully",
+        user,
+      });
+    } catch (err) {
+      const message = err instanceof Error ? err.message : "An error occurred";
+      res.status(400).json({ message });
+    }
+  },
+
+  async login(req: Request, res: Response): Promise<void> {
+    try {
+      const result = await AuthService.login(req.body, req.app.locals.userRepo);
+
+      res.json(result);
+    } catch (err) {
+      const message = err instanceof Error ? err.message : "An error occurred";
+      res.status(401).json({ message });
+    }
+  },
+};

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

@@ -0,0 +1,46 @@
+import jwt from "jsonwebtoken";
+import { Request, Response, NextFunction } from "express";
+
+type JwtPayload = {
+  sub: string;
+  email: string;
+  role: string;
+};
+
+// Extend Express Request type to include user property
+declare global {
+  namespace Express {
+    interface Request {
+      user?: JwtPayload;
+    }
+  }
+}
+
+export const requireAuth = (
+  req: Request,
+  res: Response,
+  next: NextFunction,
+): void => {
+  const authHeader = req.headers.authorization;
+
+  if (!authHeader?.startsWith("Bearer ")) {
+    res.status(401).json({ message: "Unauthorized" });
+    return;
+  }
+
+  const token = authHeader.split(" ")[1];
+
+  try {
+    const secret = process.env.JWT_SECRET;
+
+    if (!secret) {
+      throw new Error("JWT_SECRET environment variable is not defined");
+    }
+
+    const payload = jwt.verify(token, secret) as JwtPayload;
+    req.user = payload;
+    next();
+  } catch {
+    res.status(401).json({ message: "Invalid token" });
+  }
+};

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

@@ -0,0 +1,9 @@
+import { Router } from "express";
+import { AuthController } from "./auth.controller.ts";
+
+const router = Router();
+
+router.post("/register", AuthController.register);
+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 };
+  },
+};