better-ts-stack 2.0.0 → 2.0.2

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

@@ -1,70 +1,70 @@
-import {
-  ConflictException,
-  Injectable,
-  UnauthorizedException,
-} from "@nestjs/common";
-import bcrypt from "bcrypt";
-
-import type { LoginInput, RegisterInput } from "./auth.schemas.js";
-import { signToken } from "./jwt.js";
-import {
-  type AuthUser,
-  isDuplicateEmailError,
-  UsersService,
-} from "./users.service.js";
-
-const SALT_ROUNDS = 10;
-
-export interface AuthResponse {
-  user: Omit<AuthUser, "password">;
-  token: string;
-}
-
-@Injectable()
-export class AuthService {
-  constructor(private readonly usersService: UsersService) {}
-
-  async register({
-    email,
-    password,
-    name = null,
-  }: RegisterInput): Promise<AuthResponse> {
-    if (await this.usersService.findByEmail(email)) {
-      throw new ConflictException("User already exists");
-    }
-
-    const hashedPassword = await bcrypt.hash(password, SALT_ROUNDS);
-
-    try {
-      const user = await this.usersService.create({
-        email,
-        name,
-        password: hashedPassword,
-      });
-      return this.toAuthResponse(user);
-    } catch (error) {
-      // A concurrent request registered the same email after the check above
-      if (isDuplicateEmailError(error)) {
-        throw new ConflictException("User already exists");
-      }
-      throw error;
-    }
-  }
-
-  async login({ email, password }: LoginInput): Promise<AuthResponse> {
-    const user = await this.usersService.findByEmail(email);
-
-    if (!user || !(await bcrypt.compare(password, user.password))) {
-      throw new UnauthorizedException("Invalid credentials");
-    }
-
-    return this.toAuthResponse(user);
-  }
-
-  private toAuthResponse({ id, email, name }: AuthUser): AuthResponse {
-    return {
-      user: { id, email, name },
-      token: signToken({ sub: id, email, name }),
-    };
-  }
-}
+import {
+  ConflictException,
+  Injectable,
+  UnauthorizedException,
+} from "@nestjs/common";
+import bcrypt from "bcrypt";
+
+import type { LoginInput, RegisterInput } from "./auth.schemas.js";
+import { signToken } from "./jwt.js";
+import {
+  type AuthUser,
+  isDuplicateEmailError,
+  UsersService,
+} from "./users.service.js";
+
+const SALT_ROUNDS = 10;
+
+export interface AuthResponse {
+  user: Omit<AuthUser, "password">;
+  token: string;
+}
+
+@Injectable()
+export class AuthService {
+  constructor(private readonly usersService: UsersService) {}
+
+  async register({
+    email,
+    password,
+    name = null,
+  }: RegisterInput): Promise<AuthResponse> {
+    if (await this.usersService.findByEmail(email)) {
+      throw new ConflictException("User already exists");
+    }
+
+    const hashedPassword = await bcrypt.hash(password, SALT_ROUNDS);
+
+    try {
+      const user = await this.usersService.create({
+        email,
+        name,
+        password: hashedPassword,
+      });
+      return this.toAuthResponse(user);
+    } catch (error) {
+      // A concurrent request registered the same email after the check above
+      if (isDuplicateEmailError(error)) {
+        throw new ConflictException("User already exists");
+      }
+      throw error;
+    }
+  }
+
+  async login({ email, password }: LoginInput): Promise<AuthResponse> {
+    const user = await this.usersService.findByEmail(email);
+
+    if (!user || !(await bcrypt.compare(password, user.password))) {
+      throw new UnauthorizedException("Invalid credentials");
+    }
+
+    return this.toAuthResponse(user);
+  }
+
+  private toAuthResponse({ id, email, name }: AuthUser): AuthResponse {
+    return {
+      user: { id, email, name },
+      token: signToken({ sub: id, email, name }),
+    };
+  }
+}

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

@@ -1,27 +1,27 @@
-import jwt, { type SignOptions } from "jsonwebtoken";
-
-export interface AuthTokenPayload {
-  sub: string;
-  email: string;
-  name?: string | null;
-}
-
-const { JWT_SECRET, JWT_EXPIRES_IN } = process.env;
-
-function ensureSecret(): string {
-  if (!JWT_SECRET) {
-    throw new Error("JWT_SECRET is not set");
-  }
-  return JWT_SECRET;
-}
-
-export function signToken(payload: AuthTokenPayload): string {
-  const secret = ensureSecret();
-  const expiresIn = JWT_EXPIRES_IN || "1h";
-  return jwt.sign(payload, secret, { expiresIn } as SignOptions);
-}
-
-export function verifyToken(token: string): AuthTokenPayload {
-  const secret = ensureSecret();
-  return jwt.verify(token, secret) as AuthTokenPayload;
-}
+import jwt, { type SignOptions } from "jsonwebtoken";
+
+export interface AuthTokenPayload {
+  sub: string;
+  email: string;
+  name?: string | null;
+}
+
+const { JWT_SECRET, JWT_EXPIRES_IN } = process.env;
+
+function ensureSecret(): string {
+  if (!JWT_SECRET) {
+    throw new Error("JWT_SECRET is not set");
+  }
+  return JWT_SECRET;
+}
+
+export function signToken(payload: AuthTokenPayload): string {
+  const secret = ensureSecret();
+  const expiresIn = JWT_EXPIRES_IN || "1h";
+  return jwt.sign(payload, secret, { expiresIn } as SignOptions);
+}
+
+export function verifyToken(token: string): AuthTokenPayload {
+  const secret = ensureSecret();
+  return jwt.verify(token, secret) as AuthTokenPayload;
+}

package/templates/modules/auth/nestjs/src/auth/users.service.ts.hbs

@@ -1,144 +1,144 @@
-{{#if (eq database 'drizzle')}}
-import { Inject, Injectable } from "@nestjs/common";
-import { eq } from "drizzle-orm";
-
-import { type Database, DRIZZLE } from "../database/database.module.js";
-import { users } from "../database/schema.js";
-{{/if}}
-{{#if (eq database 'prisma')}}
-import { Injectable } from "@nestjs/common";
-
-import { PrismaService } from "../prisma/prisma.service.js";
-{{/if}}
-{{#if (eq database 'mongoose')}}
-import { Injectable } from "@nestjs/common";
-import { InjectModel } from "@nestjs/mongoose";
-import type { Model } from "mongoose";
-
-import { User } from "../users/user.schema.js";
-{{/if}}
-{{#if (eq database 'none')}}
-import { Injectable } from "@nestjs/common";
-import { randomUUID } from "node:crypto";
-{{/if}}
-
-export interface AuthUser {
-  id: string;
-  email: string;
-  name?: string | null;
-  password: string;
-}
-
-export interface CreateUserInput {
-  email: string;
-  name?: string | null;
-  password: string;
-}
-
-@Injectable()
-export class UsersService {
-  {{#if (eq database 'drizzle')}}
-  constructor(@Inject(DRIZZLE) private readonly db: Database) {}
-
-  async findByEmail(email: string): Promise<AuthUser | null> {
-    const [user] = await this.db
-      .select()
-      .from(users)
-      .where(eq(users.email, email))
-      .limit(1);
-    return user ?? null;
-  }
-
-  async create(data: CreateUserInput): Promise<AuthUser> {
-    const [user] = await this.db.insert(users).values(data).returning();
-    return user;
-  }
-  {{/if}}
-  {{#if (eq database 'prisma')}}
-  constructor(private readonly prisma: PrismaService) {}
-
-  findByEmail(email: string): Promise<AuthUser | null> {
-    return this.prisma.user.findUnique({ where: { email } });
-  }
-
-  create(data: CreateUserInput): Promise<AuthUser> {
-    return this.prisma.user.create({ data });
-  }
-  {{/if}}
-  {{#if (eq database 'mongoose')}}
-  constructor(
-    @InjectModel(User.name) private readonly userModel: Model<User>
-  ) {}
-
-  async findByEmail(email: string): Promise<AuthUser | null> {
-    const user = await this.userModel.findOne({ email }).exec();
-    if (!user) return null;
-    return {
-      id: user._id.toString(),
-      email: user.email,
-      name: user.name,
-      password: user.password,
-    };
-  }
-
-  async create(data: CreateUserInput): Promise<AuthUser> {
-    const user = await this.userModel.create(data);
-    return {
-      id: user._id.toString(),
-      email: user.email,
-      name: user.name,
-      password: user.password,
-    };
-  }
-  {{/if}}
-  {{#if (eq database 'none')}}
-  // In-memory store for trying the API out: users are lost on restart, so add
-  // a database before going to production
-  private readonly users: AuthUser[] = [];
-
-  findByEmail(email: string): Promise<AuthUser | null> {
-    const user = this.users.find((candidate) => candidate.email === email);
-    return Promise.resolve(user ?? null);
-  }
-
-  create(data: CreateUserInput): Promise<AuthUser> {
-    // Enforce unique emails like a database constraint would, so a sign-up that
-    // raced past the findByEmail check is rejected instead of duplicated
-    if (this.users.some((candidate) => candidate.email === data.email)) {
-      return Promise.reject(
-        Object.assign(new Error("User already exists"), {
-          code: "DUPLICATE_EMAIL",
-        })
-      );
-    }
-
-    const user: AuthUser = { id: randomUUID(), ...data };
-    this.users.push(user);
-    return Promise.resolve(user);
-  }
-  {{/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;
-}
+{{#if (eq database 'drizzle')}}
+import { Inject, Injectable } from "@nestjs/common";
+import { eq } from "drizzle-orm";
+
+import { type Database, DRIZZLE } from "../database/database.module.js";
+import { users } from "../database/schema.js";
+{{/if}}
+{{#if (eq database 'prisma')}}
+import { Injectable } from "@nestjs/common";
+
+import { PrismaService } from "../prisma/prisma.service.js";
+{{/if}}
+{{#if (eq database 'mongoose')}}
+import { Injectable } from "@nestjs/common";
+import { InjectModel } from "@nestjs/mongoose";
+import type { Model } from "mongoose";
+
+import { User } from "../users/user.schema.js";
+{{/if}}
+{{#if (eq database 'none')}}
+import { Injectable } from "@nestjs/common";
+import { randomUUID } from "node:crypto";
+{{/if}}
+
+export interface AuthUser {
+  id: string;
+  email: string;
+  name?: string | null;
+  password: string;
+}
+
+export interface CreateUserInput {
+  email: string;
+  name?: string | null;
+  password: string;
+}
+
+@Injectable()
+export class UsersService {
+  {{#if (eq database 'drizzle')}}
+  constructor(@Inject(DRIZZLE) private readonly db: Database) {}
+
+  async findByEmail(email: string): Promise<AuthUser | null> {
+    const [user] = await this.db
+      .select()
+      .from(users)
+      .where(eq(users.email, email))
+      .limit(1);
+    return user ?? null;
+  }
+
+  async create(data: CreateUserInput): Promise<AuthUser> {
+    const [user] = await this.db.insert(users).values(data).returning();
+    return user;
+  }
+  {{/if}}
+  {{#if (eq database 'prisma')}}
+  constructor(private readonly prisma: PrismaService) {}
+
+  findByEmail(email: string): Promise<AuthUser | null> {
+    return this.prisma.user.findUnique({ where: { email } });
+  }
+
+  create(data: CreateUserInput): Promise<AuthUser> {
+    return this.prisma.user.create({ data });
+  }
+  {{/if}}
+  {{#if (eq database 'mongoose')}}
+  constructor(
+    @InjectModel(User.name) private readonly userModel: Model<User>
+  ) {}
+
+  async findByEmail(email: string): Promise<AuthUser | null> {
+    const user = await this.userModel.findOne({ email }).exec();
+    if (!user) return null;
+    return {
+      id: user._id.toString(),
+      email: user.email,
+      name: user.name,
+      password: user.password,
+    };
+  }
+
+  async create(data: CreateUserInput): Promise<AuthUser> {
+    const user = await this.userModel.create(data);
+    return {
+      id: user._id.toString(),
+      email: user.email,
+      name: user.name,
+      password: user.password,
+    };
+  }
+  {{/if}}
+  {{#if (eq database 'none')}}
+  // In-memory store for trying the API out: users are lost on restart, so add
+  // a database before going to production
+  private readonly users: AuthUser[] = [];
+
+  findByEmail(email: string): Promise<AuthUser | null> {
+    const user = this.users.find((candidate) => candidate.email === email);
+    return Promise.resolve(user ?? null);
+  }
+
+  create(data: CreateUserInput): Promise<AuthUser> {
+    // Enforce unique emails like a database constraint would, so a sign-up that
+    // raced past the findByEmail check is rejected instead of duplicated
+    if (this.users.some((candidate) => candidate.email === data.email)) {
+      return Promise.reject(
+        Object.assign(new Error("User already exists"), {
+          code: "DUPLICATE_EMAIL",
+        })
+      );
+    }
+
+    const user: AuthUser = { id: randomUUID(), ...data };
+    this.users.push(user);
+    return Promise.resolve(user);
+  }
+  {{/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;
+}

package/templates/modules/auth/nestjs/src/auth/zod-validation.pipe.ts

@@ -1,16 +1,16 @@
-import { BadRequestException, type PipeTransform } from "@nestjs/common";
-import type { ZodType } from "zod";
-
-// Validates a request body against a Zod schema and returns the parsed value
-export class ZodValidationPipe<T> implements PipeTransform<unknown, T> {
-  constructor(private readonly schema: ZodType<T>) {}
-
-  transform(value: unknown): T {
-    // The body is undefined when the request has none
-    const result = this.schema.safeParse(value ?? {});
-    if (!result.success) {
-      throw new BadRequestException(result.error.issues[0].message);
-    }
-    return result.data;
-  }
-}
+import { BadRequestException, type PipeTransform } from "@nestjs/common";
+import type { ZodType } from "zod";
+
+// Validates a request body against a Zod schema and returns the parsed value
+export class ZodValidationPipe<T> implements PipeTransform<unknown, T> {
+  constructor(private readonly schema: ZodType<T>) {}
+
+  transform(value: unknown): T {
+    // The body is undefined when the request has none
+    const result = this.schema.safeParse(value ?? {});
+    if (!result.success) {
+      throw new BadRequestException(result.error.issues[0].message);
+    }
+    return result.data;
+  }
+}