create-charcole 2.2.0 → 2.2.2

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

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

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

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

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

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