better-ts-stack 2.0.0 → 2.0.2

package/templates/modules/auth/express/src/middleware/requireAuth.ts.hbs

@@ -1,26 +1,26 @@
-import { NextFunction, Request, Response } from 'express';
-import { AuthTokenPayload, verifyToken } from '../lib/jwt';
-
-export interface AuthenticatedRequest extends Request {
-  user?: AuthTokenPayload;
-}
-
-export function requireAuth(req: AuthenticatedRequest, res: Response, next: NextFunction): void {
-  const authHeader = req.headers.authorization;
-
-  if (!authHeader || !authHeader.startsWith('Bearer ')) {
-    res.status(401).json({ error: 'Authorization header missing or invalid' });
-    return;
-  }
-
-  const token = authHeader.substring('Bearer '.length);
-
-  try {
-    const payload = verifyToken(token);
-    req.user = payload;
-    next();
-  } catch (error) {
-    console.error('JWT verification failed:', error);
-    res.status(401).json({ error: 'Invalid or expired token' });
-  }
-}
+import { NextFunction, Request, Response } from 'express';
+import { AuthTokenPayload, verifyToken } from '../lib/jwt';
+
+export interface AuthenticatedRequest extends Request {
+  user?: AuthTokenPayload;
+}
+
+export function requireAuth(req: AuthenticatedRequest, res: Response, next: NextFunction): void {
+  const authHeader = req.headers.authorization;
+
+  if (!authHeader || !authHeader.startsWith('Bearer ')) {
+    res.status(401).json({ error: 'Authorization header missing or invalid' });
+    return;
+  }
+
+  const token = authHeader.substring('Bearer '.length);
+
+  try {
+    const payload = verifyToken(token);
+    req.user = payload;
+    next();
+  } catch (error) {
+    console.error('JWT verification failed:', error);
+    res.status(401).json({ error: 'Invalid or expired token' });
+  }
+}

package/templates/modules/auth/express/src/services/userStore.ts.hbs

@@ -1,117 +1,117 @@
-{{#if (eq database 'drizzle')}}
-import { eq } from "drizzle-orm";
-import { db } from "../lib/db";
-import { users } from "../lib/schema";
-{{/if}}
-{{#if (eq database 'none')}}
-import crypto from 'crypto';
-{{/if}}
-{{#if (eq database 'prisma')}}
-import { prisma } from '../lib/prisma';
-{{/if}}
-{{#if (eq database 'mongoose')}}
-import UserModel from '../models/User';
-{{/if}}
-
-export interface AuthUser {
-  id: string;
-  email: string;
-  name?: string | null;
-  password: string;
-}
-
-export interface CreateUserInput {
-  email: string;
-  name?: string | null;
-  password: string;
-}
-
-{{#if (eq database 'none')}}
-const users: AuthUser[] = [];
-{{/if}}
-
-export {{#unless (eq database 'none')}}async {{/unless}}function findUserByEmail(email: string): Promise<AuthUser | null> {
-  {{#if (eq database 'drizzle')}}
-  const [user] = await db.select().from(users).where(eq(users.email, email)).limit(1);
-  return user ?? null;
-  {{/if}}
-  {{#if (eq database 'prisma')}}
-  return await prisma.user.findUnique({ where: { email } });
-  {{/if}}
-
-  {{#if (eq database 'mongoose')}}
-  const user = await UserModel.findOne({ email }).exec();
-  if (!user) return null;
-  return {
-    id: String(user._id),
-    email: user.email,
-    name: user.name,
-    password: user.password,
-  };
-  {{/if}}
-
-  {{#if (eq database 'none')}}
-  const user = users.find((candidate) => candidate.email === email);
-  return Promise.resolve(user ?? null);
-  {{/if}}
-}
-
-export {{#unless (eq database 'none')}}async {{/unless}}function createUser(data: CreateUserInput): Promise<AuthUser> {
-  {{#if (eq database 'drizzle')}}
-  const [user] = await db.insert(users).values(data).returning();
-  return user;
-  {{/if}}
-  {{#if (eq database 'prisma')}}
-  return await prisma.user.create({ data });
-  {{/if}}
-
-  {{#if (eq database 'mongoose')}}
-  const user = await UserModel.create(data);
-
-  return {
-    id: String(user._id),
-    email: user.email,
-    name: user.name,
-    password: user.password,
-  };
-  {{/if}}
-
-  {{#if (eq database 'none')}}
-  // Enforce unique emails like a database constraint would, so a sign-up that
-  // raced past the findUserByEmail check is rejected instead of duplicated
-  if (users.some((candidate) => candidate.email === data.email)) {
-    return Promise.reject(
-      Object.assign(new Error('User already exists'), { code: 'DUPLICATE_EMAIL' }),
-    );
-  }
-
-  const newUser: AuthUser = {
-    id: crypto.randomUUID(),
-    email: data.email,
-    name: data.name,
-    password: data.password,
-  };
-
-  users.push(newUser);
-  return Promise.resolve(newUser);
-  {{/if}}
-}
-
-// Unique-constraint error codes: Prisma, PostgreSQL (Drizzle wraps it in `cause`),
-// MongoDB, and the in-memory store
-const DUPLICATE_KEY_CODES = new Set<unknown>(['P2002', '23505', 11000, 'DUPLICATE_EMAIL']);
-
-// True when an insert failed because the email is already taken (e.g. concurrent sign-ups)
-export function isDuplicateEmailError(error: unknown): boolean {
-  let current = error;
-  for (let depth = 0; depth < 5 && current && typeof current === 'object'; depth++) {
-    if (DUPLICATE_KEY_CODES.has((current as { code?: unknown }).code)) return true;
-    current = (current as { cause?: unknown }).cause;
-  }
-  return false;
-}
-
-export function toPublicUser(user: AuthUser): Omit<AuthUser, 'password'> {
-  const { id, email, name } = user;
-  return { id, email, name };
-}
+{{#if (eq database 'drizzle')}}
+import { eq } from "drizzle-orm";
+import { db } from "../lib/db";
+import { users } from "../lib/schema";
+{{/if}}
+{{#if (eq database 'none')}}
+import crypto from 'crypto';
+{{/if}}
+{{#if (eq database 'prisma')}}
+import { prisma } from '../lib/prisma';
+{{/if}}
+{{#if (eq database 'mongoose')}}
+import UserModel from '../models/User';
+{{/if}}
+
+export interface AuthUser {
+  id: string;
+  email: string;
+  name?: string | null;
+  password: string;
+}
+
+export interface CreateUserInput {
+  email: string;
+  name?: string | null;
+  password: string;
+}
+
+{{#if (eq database 'none')}}
+const users: AuthUser[] = [];
+{{/if}}
+
+export {{#unless (eq database 'none')}}async {{/unless}}function findUserByEmail(email: string): Promise<AuthUser | null> {
+  {{#if (eq database 'drizzle')}}
+  const [user] = await db.select().from(users).where(eq(users.email, email)).limit(1);
+  return user ?? null;
+  {{/if}}
+  {{#if (eq database 'prisma')}}
+  return await prisma.user.findUnique({ where: { email } });
+  {{/if}}
+
+  {{#if (eq database 'mongoose')}}
+  const user = await UserModel.findOne({ email }).exec();
+  if (!user) return null;
+  return {
+    id: String(user._id),
+    email: user.email,
+    name: user.name,
+    password: user.password,
+  };
+  {{/if}}
+
+  {{#if (eq database 'none')}}
+  const user = users.find((candidate) => candidate.email === email);
+  return Promise.resolve(user ?? null);
+  {{/if}}
+}
+
+export {{#unless (eq database 'none')}}async {{/unless}}function createUser(data: CreateUserInput): Promise<AuthUser> {
+  {{#if (eq database 'drizzle')}}
+  const [user] = await db.insert(users).values(data).returning();
+  return user;
+  {{/if}}
+  {{#if (eq database 'prisma')}}
+  return await prisma.user.create({ data });
+  {{/if}}
+
+  {{#if (eq database 'mongoose')}}
+  const user = await UserModel.create(data);
+
+  return {
+    id: String(user._id),
+    email: user.email,
+    name: user.name,
+    password: user.password,
+  };
+  {{/if}}
+
+  {{#if (eq database 'none')}}
+  // Enforce unique emails like a database constraint would, so a sign-up that
+  // raced past the findUserByEmail check is rejected instead of duplicated
+  if (users.some((candidate) => candidate.email === data.email)) {
+    return Promise.reject(
+      Object.assign(new Error('User already exists'), { code: 'DUPLICATE_EMAIL' }),
+    );
+  }
+
+  const newUser: AuthUser = {
+    id: crypto.randomUUID(),
+    email: data.email,
+    name: data.name,
+    password: data.password,
+  };
+
+  users.push(newUser);
+  return Promise.resolve(newUser);
+  {{/if}}
+}
+
+// Unique-constraint error codes: Prisma, PostgreSQL (Drizzle wraps it in `cause`),
+// MongoDB, and the in-memory store
+const DUPLICATE_KEY_CODES = new Set<unknown>(['P2002', '23505', 11000, 'DUPLICATE_EMAIL']);
+
+// True when an insert failed because the email is already taken (e.g. concurrent sign-ups)
+export function isDuplicateEmailError(error: unknown): boolean {
+  let current = error;
+  for (let depth = 0; depth < 5 && current && typeof current === 'object'; depth++) {
+    if (DUPLICATE_KEY_CODES.has((current as { code?: unknown }).code)) return true;
+    current = (current as { cause?: unknown }).cause;
+  }
+  return false;
+}
+
+export function toPublicUser(user: AuthUser): Omit<AuthUser, 'password'> {
+  const { id, email, name } = user;
+  return { id, email, name };
+}

package/templates/modules/auth/nestjs/config.json

@@ -16,9 +16,5 @@
   "envVars": {
     "JWT_SECRET": "please-change-me",
     "JWT_EXPIRES_IN": "1h"
-  },
-  "templateFiles": [
-    "src/auth/auth.module.ts.hbs",
-    "src/auth/users.service.ts.hbs"
-  ]
+  }
 }

package/templates/modules/auth/nestjs/src/auth/auth.controller.ts

@@ -1,46 +1,46 @@
-import {
-  Body,
-  Controller,
-  Get,
-  HttpCode,
-  Post,
-  Req,
-  UseGuards,
-} from "@nestjs/common";
-
-import { type AuthenticatedRequest, AuthGuard } from "./auth.guard.js";
-import {
-  type LoginInput,
-  loginSchema,
-  type RegisterInput,
-  registerSchema,
-} from "./auth.schemas.js";
-import { type AuthResponse, AuthService } from "./auth.service.js";
-import type { AuthTokenPayload } from "./jwt.js";
-import { ZodValidationPipe } from "./zod-validation.pipe.js";
-
-@Controller("auth")
-export class AuthController {
-  constructor(private readonly authService: AuthService) {}
-
-  @Post("register")
-  register(
-    @Body(new ZodValidationPipe(registerSchema)) body: RegisterInput
-  ): Promise<AuthResponse> {
-    return this.authService.register(body);
-  }
-
-  @Post("login")
-  @HttpCode(200)
-  login(
-    @Body(new ZodValidationPipe(loginSchema)) body: LoginInput
-  ): Promise<AuthResponse> {
-    return this.authService.login(body);
-  }
-
-  @Get("me")
-  @UseGuards(AuthGuard)
-  me(@Req() request: AuthenticatedRequest): { user?: AuthTokenPayload } {
-    return { user: request.user };
-  }
-}
+import {
+  Body,
+  Controller,
+  Get,
+  HttpCode,
+  Post,
+  Req,
+  UseGuards,
+} from "@nestjs/common";
+
+import { type AuthenticatedRequest, AuthGuard } from "./auth.guard.js";
+import {
+  type LoginInput,
+  loginSchema,
+  type RegisterInput,
+  registerSchema,
+} from "./auth.schemas.js";
+import { type AuthResponse, AuthService } from "./auth.service.js";
+import type { AuthTokenPayload } from "./jwt.js";
+import { ZodValidationPipe } from "./zod-validation.pipe.js";
+
+@Controller("auth")
+export class AuthController {
+  constructor(private readonly authService: AuthService) {}
+
+  @Post("register")
+  register(
+    @Body(new ZodValidationPipe(registerSchema)) body: RegisterInput
+  ): Promise<AuthResponse> {
+    return this.authService.register(body);
+  }
+
+  @Post("login")
+  @HttpCode(200)
+  login(
+    @Body(new ZodValidationPipe(loginSchema)) body: LoginInput
+  ): Promise<AuthResponse> {
+    return this.authService.login(body);
+  }
+
+  @Get("me")
+  @UseGuards(AuthGuard)
+  me(@Req() request: AuthenticatedRequest): { user?: AuthTokenPayload } {
+    return { user: request.user };
+  }
+}

package/templates/modules/auth/nestjs/src/auth/auth.guard.ts

@@ -1,36 +1,36 @@
-import {
-  type CanActivate,
-  type ExecutionContext,
-  Injectable,
-  UnauthorizedException,
-} from "@nestjs/common";
-import type { Request } from "express";
-
-import { type AuthTokenPayload, verifyToken } from "./jwt.js";
-
-export interface AuthenticatedRequest extends Request {
-  user?: AuthTokenPayload;
-}
-
-// Requires a valid "Authorization: Bearer <token>" header and sets request.user
-@Injectable()
-export class AuthGuard implements CanActivate {
-  canActivate(context: ExecutionContext): boolean {
-    const request = context.switchToHttp().getRequest<AuthenticatedRequest>();
-    const authHeader = request.headers.authorization;
-
-    if (!authHeader?.startsWith("Bearer ")) {
-      throw new UnauthorizedException(
-        "Authorization header missing or invalid"
-      );
-    }
-
-    try {
-      request.user = verifyToken(authHeader.substring("Bearer ".length));
-    } catch {
-      throw new UnauthorizedException("Invalid or expired token");
-    }
-
-    return true;
-  }
-}
+import {
+  type CanActivate,
+  type ExecutionContext,
+  Injectable,
+  UnauthorizedException,
+} from "@nestjs/common";
+import type { Request } from "express";
+
+import { type AuthTokenPayload, verifyToken } from "./jwt.js";
+
+export interface AuthenticatedRequest extends Request {
+  user?: AuthTokenPayload;
+}
+
+// Requires a valid "Authorization: Bearer <token>" header and sets request.user
+@Injectable()
+export class AuthGuard implements CanActivate {
+  canActivate(context: ExecutionContext): boolean {
+    const request = context.switchToHttp().getRequest<AuthenticatedRequest>();
+    const authHeader = request.headers.authorization;
+
+    if (!authHeader?.startsWith("Bearer ")) {
+      throw new UnauthorizedException(
+        "Authorization header missing or invalid"
+      );
+    }
+
+    try {
+      request.user = verifyToken(authHeader.substring("Bearer ".length));
+    } catch {
+      throw new UnauthorizedException("Invalid or expired token");
+    }
+
+    return true;
+  }
+}

package/templates/modules/auth/nestjs/src/auth/auth.module.ts.hbs

@@ -1,22 +1,22 @@
-import { Module } from "@nestjs/common";
-{{#if (eq database 'mongoose')}}
-import { MongooseModule } from "@nestjs/mongoose";
-{{/if}}
-
-{{#if (eq database 'mongoose')}}
-import { User, UserSchema } from "../users/user.schema.js";
-{{/if}}
-import { AuthController } from "./auth.controller.js";
-import { AuthService } from "./auth.service.js";
-import { UsersService } from "./users.service.js";
-
-@Module({
-  {{#if (eq database 'mongoose')}}
-  imports: [
-    MongooseModule.forFeature([{ name: User.name, schema: UserSchema }]),
-  ],
-  {{/if}}
-  controllers: [AuthController],
-  providers: [AuthService, UsersService],
-})
-export class AuthModule {}
+import { Module } from "@nestjs/common";
+{{#if (eq database 'mongoose')}}
+import { MongooseModule } from "@nestjs/mongoose";
+{{/if}}
+
+{{#if (eq database 'mongoose')}}
+import { User, UserSchema } from "../users/user.schema.js";
+{{/if}}
+import { AuthController } from "./auth.controller.js";
+import { AuthService } from "./auth.service.js";
+import { UsersService } from "./users.service.js";
+
+@Module({
+  {{#if (eq database 'mongoose')}}
+  imports: [
+    MongooseModule.forFeature([{ name: User.name, schema: UserSchema }]),
+  ],
+  {{/if}}
+  controllers: [AuthController],
+  providers: [AuthService, UsersService],
+})
+export class AuthModule {}

package/templates/modules/auth/nestjs/src/auth/auth.schemas.ts

@@ -1,35 +1,35 @@
-import { z } from "zod";
-
-const MIN_PASSWORD_LENGTH = 8;
-// bcrypt ignores bytes beyond 72, so longer passwords would be silently truncated
-const MAX_PASSWORD_BYTES = 72;
-
-// Emails are trimmed and lowercased so sign-in is case-insensitive
-const emailSchema = z
-  .string("Email and password are required")
-  .trim()
-  .toLowerCase()
-  .pipe(z.email("Email must be a valid email address"));
-
-export const registerSchema = z.object({
-  email: emailSchema,
-  password: z
-    .string("Email and password are required")
-    .min(
-      MIN_PASSWORD_LENGTH,
-      `Password must be at least ${MIN_PASSWORD_LENGTH} characters`
-    )
-    .refine(
-      (password) => Buffer.byteLength(password, "utf8") <= MAX_PASSWORD_BYTES,
-      `Password must be at most ${MAX_PASSWORD_BYTES} bytes`
-    ),
-  name: z.string("Name must be a string").nullish(),
-});
-
-export const loginSchema = z.object({
-  email: emailSchema,
-  password: z.string("Email and password are required").min(1),
-});
-
-export type RegisterInput = z.infer<typeof registerSchema>;
-export type LoginInput = z.infer<typeof loginSchema>;
+import { z } from "zod";
+
+const MIN_PASSWORD_LENGTH = 8;
+// bcrypt ignores bytes beyond 72, so longer passwords would be silently truncated
+const MAX_PASSWORD_BYTES = 72;
+
+// Emails are trimmed and lowercased so sign-in is case-insensitive
+const emailSchema = z
+  .string("Email and password are required")
+  .trim()
+  .toLowerCase()
+  .pipe(z.email("Email must be a valid email address"));
+
+export const registerSchema = z.object({
+  email: emailSchema,
+  password: z
+    .string("Email and password are required")
+    .min(
+      MIN_PASSWORD_LENGTH,
+      `Password must be at least ${MIN_PASSWORD_LENGTH} characters`
+    )
+    .refine(
+      (password) => Buffer.byteLength(password, "utf8") <= MAX_PASSWORD_BYTES,
+      `Password must be at most ${MAX_PASSWORD_BYTES} bytes`
+    ),
+  name: z.string("Name must be a string").nullish(),
+});
+
+export const loginSchema = z.object({
+  email: emailSchema,
+  password: z.string("Email and password are required").min(1),
+});
+
+export type RegisterInput = z.infer<typeof registerSchema>;
+export type LoginInput = z.infer<typeof loginSchema>;