speedrun-cli 2.6.1

package/templates/orm/drizzle/src/modules/auth/auth.service.ts

@@ -0,0 +1,298 @@
+import {
+  Injectable,
+  UnauthorizedException,
+  ConflictException,
+  ForbiddenException,
+  NotFoundException,
+  Inject,
+} from '@nestjs/common';
+import { ConfigService } from '@nestjs/config';
+import { JwtService } from '@nestjs/jwt';
+import { eq, and } from 'drizzle-orm';
+import * as bcrypt from 'bcrypt';
+import { DRIZZLE } from '../../database/database.module';
+import { DrizzleDB } from '../../database/drizzle';
+import { users, refreshTokens, User, RefreshToken } from '../../database/schema';
+import { SignupDto } from './dtos/signup.dto';
+import { LoginDto } from './dtos/login.dto';
+
+const SALT_ROUNDS = 12;
+
+@Injectable()
+export class AuthService {
+  constructor(
+    @Inject(DRIZZLE) private db: DrizzleDB,
+    private jwtService: JwtService,
+    private configService: ConfigService,
+  ) {}
+
+  async signup(signupDto: SignupDto) {
+    const { fullName, email, password } = signupDto;
+
+    // Check if user already exists
+    const existingUser = await this.db.query.users.findFirst({
+      where: eq(users.email, email.toLowerCase()),
+    });
+
+    if (existingUser) {
+      throw new ConflictException('User with this email already exists');
+    }
+
+    // Hash password and create user
+    const passwordHash = await bcrypt.hash(password, SALT_ROUNDS);
+    
+    const [user] = await this.db
+      .insert(users)
+      .values({
+        fullName,
+        email: email.toLowerCase(),
+        passwordHash,
+        role: 'USER',
+        isActive: true,
+      })
+      .returning();
+
+    return {
+      id: user.id,
+      fullName: user.fullName,
+      email: user.email,
+      role: user.role,
+      isActive: user.isActive,
+    };
+  }
+
+  async login(loginDto: LoginDto, deviceInfo?: string, ipAddress?: string) {
+    const { email, password } = loginDto;
+
+    // Find user
+    const user = await this.db.query.users.findFirst({
+      where: eq(users.email, email.toLowerCase()),
+    });
+
+    if (!user) {
+      throw new UnauthorizedException('Invalid email or password');
+    }
+
+    // Check if user is active
+    if (!user.isActive) {
+      throw new UnauthorizedException('Account is deactivated');
+    }
+
+    // Verify password
+    const isPasswordValid = await bcrypt.compare(password, user.passwordHash);
+    if (!isPasswordValid) {
+      throw new UnauthorizedException('Invalid email or password');
+    }
+
+    // Generate tokens
+    const tokens = await this.generateTokens(user);
+
+    // Store refresh token in database
+    await this.storeRefreshToken(
+      tokens.refreshToken,
+      user.id,
+      deviceInfo || 'Unknown Device',
+      ipAddress || 'Unknown IP',
+    );
+
+    // Clean up expired tokens for this user
+    await this.cleanupExpiredTokens(user.id);
+
+    return {
+      user: {
+        id: user.id,
+        fullName: user.fullName,
+        email: user.email,
+        role: user.role,
+        isActive: user.isActive,
+      },
+      ...tokens,
+    };
+  }
+
+  async logout(userId: string, refreshToken?: string) {
+    if (refreshToken) {
+      // Find and revoke the specific refresh token by comparing hashes
+      const storedTokens = await this.db.query.refreshTokens.findMany({
+        where: eq(refreshTokens.userId, userId),
+      });
+
+      for (const storedToken of storedTokens) {
+        const matches = await bcrypt.compare(refreshToken, storedToken.token);
+        if (matches) {
+          await this.db
+            .update(refreshTokens)
+            .set({ isRevoked: true, updatedAt: new Date() })
+            .where(eq(refreshTokens.id, storedToken.id));
+          break;
+        }
+      }
+    } else {
+      // Logout from all devices - revoke all refresh tokens for this user
+      await this.db
+        .update(refreshTokens)
+        .set({ isRevoked: true, updatedAt: new Date() })
+        .where(and(eq(refreshTokens.userId, userId), eq(refreshTokens.isRevoked, false)));
+    }
+
+    return { message: 'Logged out successfully' };
+  }
+
+  async refreshToken(
+    userId: string,
+    rt: string,
+    deviceInfo?: string,
+    ipAddress?: string,
+  ) {
+    // Find the user
+    const user = await this.db.query.users.findFirst({
+      where: eq(users.id, userId),
+    });
+
+    if (!user) {
+      throw new ForbiddenException('Invalid refresh token');
+    }
+
+    // Find matching refresh token in database by comparing hashes
+    const storedTokens = await this.db.query.refreshTokens.findMany({
+      where: and(
+        eq(refreshTokens.userId, userId),
+        eq(refreshTokens.isRevoked, false),
+      ),
+    });
+
+    let validToken: RefreshToken | null = null;
+    for (const storedToken of storedTokens) {
+      if (new Date() < storedToken.expiresAt) {
+        const matches = await bcrypt.compare(rt, storedToken.token);
+        if (matches) {
+          validToken = storedToken;
+          break;
+        }
+      }
+    }
+
+    if (!validToken) {
+      throw new UnauthorizedException('Invalid refresh token');
+    }
+
+    // Revoke old refresh token (token rotation)
+    await this.db
+      .update(refreshTokens)
+      .set({ isRevoked: true, updatedAt: new Date() })
+      .where(eq(refreshTokens.id, validToken.id));
+
+    // Generate new tokens
+    const tokens = await this.generateTokens(user);
+
+    // Store new refresh token
+    await this.storeRefreshToken(
+      tokens.refreshToken,
+      user.id,
+      deviceInfo || 'Unknown Device',
+      ipAddress || 'Unknown IP',
+    );
+
+    return tokens;
+  }
+
+  async getMe(userId: string) {
+    const user = await this.db.query.users.findFirst({
+      where: eq(users.id, userId),
+    });
+
+    if (!user) {
+      throw new NotFoundException('User not found');
+    }
+
+    return {
+      id: user.id,
+      fullName: user.fullName,
+      email: user.email,
+      role: user.role,
+      isActive: user.isActive,
+    };
+  }
+
+  // Helper Methods
+
+  async hashData(data: string): Promise<string> {
+    return bcrypt.hash(data, SALT_ROUNDS);
+  }
+
+  async generateTokens(user: User): Promise<{ accessToken: string; refreshToken: string }> {
+    const payload = {
+      sub: user.id,
+      email: user.email,
+      role: user.role,
+    };
+
+    const [accessToken, refreshToken] = await Promise.all([
+      // @ts-expect-error - JWT library type definition issue with expiresIn accepting string
+      this.jwtService.signAsync(payload, {
+        secret: this.configService.get<string>('JWT_ACCESS_SECRET'),
+        expiresIn: this.configService.get<string>('JWT_ACCESS_EXPIRY') || '15m',
+      }),
+      // @ts-expect-error - JWT library type definition issue with expiresIn accepting string
+      this.jwtService.signAsync(payload, {
+        secret: this.configService.get<string>('JWT_REFRESH_SECRET'),
+        expiresIn: this.configService.get<string>('JWT_REFRESH_EXPIRY') || '7d',
+      }),
+    ]);
+
+    return { accessToken, refreshToken };
+  }
+
+  private async storeRefreshToken(
+    token: string,
+    userId: string,
+    userAgent: string,
+    ipAddress: string,
+  ) {
+    const expiresIn = this.configService.get<string>('JWT_REFRESH_EXPIRY') || '7d';
+    const expiresAt = this.calculateExpiry(expiresIn);
+
+    // Hash the refresh token before storing
+    const hashedToken = await this.hashData(token);
+
+    await this.db.insert(refreshTokens).values({
+      token: hashedToken,
+      userId,
+      userAgent,
+      ipAddress,
+      expiresAt,
+    });
+  }
+
+  private calculateExpiry(expiresIn: string): Date {
+    const match = expiresIn.match(/^(\d+)([smhd])$/);
+    if (!match) {
+      return new Date(Date.now() + 7 * 24 * 60 * 60 * 1000); // Default 7 days
+    }
+
+    const value = parseInt(match[1], 10);
+    const unit = match[2];
+
+    const multipliers: Record<string, number> = {
+      s: 1000,
+      m: 60 * 1000,
+      h: 60 * 60 * 1000,
+      d: 24 * 60 * 60 * 1000,
+    };
+
+    return new Date(Date.now() + value * multipliers[unit]);
+  }
+
+  private async cleanupExpiredTokens(userId: string) {
+    // Remove expired/revoked refresh tokens for this user
+    const expiredTokens = await this.db.query.refreshTokens.findMany({
+      where: eq(refreshTokens.userId, userId),
+    });
+
+    for (const token of expiredTokens) {
+      if (token.isRevoked || new Date() > token.expiresAt) {
+        await this.db.delete(refreshTokens).where(eq(refreshTokens.id, token.id));
+      }
+    }
+  }
+}

package/templates/orm/drizzle/src/modules/health/health.controller.ts

@@ -0,0 +1,34 @@
+import { Controller, Get, Inject } from '@nestjs/common';
+import { Pool } from 'pg';
+import { DRIZZLE } from '../../database/database.module';
+import { Public } from '../../common/decorators/public.decorator';
+
+@Controller('health')
+export class HealthController {
+  constructor(@Inject(DRIZZLE) private db: any) {}
+
+  @Public()
+  @Get()
+  async check() {
+    let dbStatus = 'unhealthy';
+
+    try {
+      // Try to execute a simple query
+      await this.db.execute('SELECT 1');
+      dbStatus = 'healthy';
+    } catch (error) {
+      dbStatus = 'unhealthy';
+    }
+
+    return {
+      status: dbStatus === 'healthy' ? 'ok' : 'error',
+      timestamp: new Date().toISOString(),
+      services: {
+        database: {
+          status: dbStatus,
+          type: 'postgresql',
+        },
+      },
+    };
+  }
+}

package/templates/orm/drizzle/src/modules/health/health.module.ts

@@ -0,0 +1,7 @@
+import { Module } from '@nestjs/common';
+import { HealthController } from './health.controller';
+
+@Module({
+  controllers: [HealthController],
+})
+export class HealthModule {}

package/templates/orm/drizzle/src/modules/users/users.module.ts

@@ -0,0 +1,10 @@
+import { Module } from '@nestjs/common';
+import { UsersController } from './users.controller';
+import { UsersService } from './users.service';
+
+@Module({
+  controllers: [UsersController],
+  providers: [UsersService],
+  exports: [UsersService],
+})
+export class UsersModule {}

package/templates/orm/drizzle/src/modules/users/users.service.ts

@@ -0,0 +1,152 @@
+import {
+  Injectable,
+  NotFoundException,
+  ConflictException,
+  Inject,
+} from '@nestjs/common';
+import { eq, ne, and, desc, count } from 'drizzle-orm';
+import * as bcrypt from 'bcrypt';
+import { DRIZZLE } from '../../database/database.module';
+import { DrizzleDB } from '../../database/drizzle';
+import { users, refreshTokens, UserRole } from '../../database/schema';
+import { UpdateProfileDto } from './dtos/update-profile.dto';
+import { UpdateUserDto } from './dtos/update-user.dto';
+
+const SALT_ROUNDS = 12;
+
+@Injectable()
+export class UsersService {
+  constructor(@Inject(DRIZZLE) private db: DrizzleDB) {}
+
+  async getProfile(userId: string) {
+    const user = await this.db.query.users.findFirst({
+      where: eq(users.id, userId),
+    });
+
+    if (!user) {
+      throw new NotFoundException('User not found');
+    }
+
+    return this.sanitizeUser(user);
+  }
+
+  async updateProfile(userId: string, updateProfileDto: UpdateProfileDto) {
+    const user = await this.db.query.users.findFirst({
+      where: eq(users.id, userId),
+    });
+
+    if (!user) {
+      throw new NotFoundException('User not found');
+    }
+
+    const updateData: Record<string, any> = { updatedAt: new Date() };
+    if (updateProfileDto.fullName) updateData.fullName = updateProfileDto.fullName;
+
+    const [updatedUser] = await this.db
+      .update(users)
+      .set(updateData)
+      .where(eq(users.id, userId))
+      .returning();
+
+    return this.sanitizeUser(updatedUser);
+  }
+
+  // Admin methods
+
+  async getAllUsers(page: number = 1, limit: number = 10) {
+    const offset = (page - 1) * limit;
+
+    const [userList, totalResult] = await Promise.all([
+      this.db.query.users.findMany({
+        offset,
+        limit,
+        orderBy: [desc(users.createdAt)],
+      }),
+      this.db.select({ count: count() }).from(users),
+    ]);
+
+    const total = totalResult[0].count;
+    const totalPages = Math.ceil(total / limit);
+
+    return {
+      data: userList.map((user) => this.sanitizeUser(user)),
+      meta: {
+        total,
+        page,
+        limit,
+        totalPages,
+        hasNext: page < totalPages,
+        hasPrevious: page > 1,
+      },
+    };
+  }
+
+  async getUserById(userId: string) {
+    if (!userId) {
+      return null;
+    }
+
+    const user = await this.db.query.users.findFirst({
+      where: eq(users.id, userId),
+    });
+
+    if (!user) {
+      return null;
+    }
+
+    return this.sanitizeUser(user);
+  }
+
+  async updateUserById(userId: string, updateUserDto: UpdateUserDto) {
+    // Check if user exists
+    const user = await this.db.query.users.findFirst({
+      where: eq(users.id, userId),
+    });
+
+    if (!user) {
+      throw new NotFoundException('User not found');
+    }
+
+    const updateData: Record<string, any> = { updatedAt: new Date() };
+    if (updateUserDto.fullName) updateData.fullName = updateUserDto.fullName;
+    if (updateUserDto.role) updateData.role = updateUserDto.role as UserRole;
+    if (updateUserDto.isActive !== undefined) updateData.isActive = updateUserDto.isActive;
+
+    const [updatedUser] = await this.db
+      .update(users)
+      .set(updateData)
+      .where(eq(users.id, userId))
+      .returning();
+
+    return this.sanitizeUser(updatedUser);
+  }
+
+  async deleteUserById(userId: string) {
+    const user = await this.db.query.users.findFirst({
+      where: eq(users.id, userId),
+    });
+
+    if (!user) {
+      throw new NotFoundException('User not found');
+    }
+
+    // Delete user's refresh tokens first
+    await this.db.delete(refreshTokens).where(eq(refreshTokens.userId, userId));
+
+    // Delete user
+    await this.db.delete(users).where(eq(users.id, userId));
+
+    return { message: 'User deleted successfully' };
+  }
+
+  // Utils
+
+  private sanitizeUser(user: any) {
+    if (!user) {
+      return null;
+    }
+
+    const { passwordHash, ...safeUser } = user;
+    return safeUser;
+  }
+}

package/templates/orm/mongoose/.env.example

@@ -0,0 +1,22 @@
+# Database Configuration (MongoDB)
+DATABASE_URL=mongodb://user:password@localhost:27017/database_name
+
+# JWT Configuration
+JWT_ACCESS_SECRET=your_jwt_access_secret_key_here_minimum_32_characters
+JWT_REFRESH_SECRET=your_jwt_refresh_secret_key_here_minimum_32_characters
+# Token expiration (format: {number}{unit} where unit = s|m|h|d)
+JWT_ACCESS_EXPIRY=60m
+JWT_REFRESH_EXPIRY=30d
+
+# Server Configuration
+PORT=8080
+NODE_ENV=development
+
+# CORS Configuration
+# Single origin: http://localhost:3000
+# Multiple origins: http://localhost:3000,https://app.example.com
+# Wildcard (use with caution): *
+CORS_ORIGIN=http://localhost:3000
+
+# Logging
+LOG_LEVEL=info

package/templates/orm/mongoose/package.json

@@ -0,0 +1,86 @@
+{
+  "name": "nestjs-auth-mongoose",
+  "version": "0.0.1",
+  "description": "NestJS Authentication API with Mongoose & MongoDB",
+  "author": "",
+  "private": true,
+  "license": "MIT",
+  "scripts": {
+    "build": "nest build",
+    "format": "prettier --write \"src/**/*.ts\" \"test/**/*.ts\"",
+    "start": "nest start",
+    "start:dev": "nest start --watch",
+    "start:debug": "nest start --debug --watch",
+    "start:prod": "node dist/main",
+    "lint": "eslint \"{src,apps,libs,test}/**/*.ts\" --fix",
+    "test": "jest",
+    "test:watch": "jest --watch",
+    "test:cov": "jest --coverage",
+    "test:debug": "node --inspect-brk -r tsconfig-paths/register -r ts-node/register node_modules/.bin/jest --runInBand",
+    "test:e2e": "jest --config ./test/jest-e2e.json",
+    "db:seed": "ts-node src/database/seed.ts"
+  },
+  "dependencies": {
+    "@nestjs/common": "^11.0.0",
+    "@nestjs/config": "^4.0.0",
+    "@nestjs/core": "^11.0.0",
+    "@nestjs/jwt": "^11.0.0",
+    "@nestjs/mongoose": "^11.0.0",
+    "@nestjs/platform-express": "^11.0.0",
+    "@nestjs/throttler": "^6.4.0",
+    "bcrypt": "^6.0.0",
+    "class-transformer": "^0.5.1",
+    "class-validator": "^0.14.2",
+    "cookie-parser": "^1.4.7",
+    "helmet": "^8.1.0",
+    "zod": "^4.1.12",
+    "mongoose": "^8.9.0",
+    "nestjs-pino": "^4.2.0",
+    "pino-http": "^10.4.0",
+    "pino-pretty": "^13.0.0",
+    "reflect-metadata": "^0.2.2",
+    "rxjs": "^7.8.1"
+  },
+  "devDependencies": {
+    "@nestjs/cli": "^11.0.0",
+    "@nestjs/schematics": "^11.0.0",
+    "@nestjs/testing": "^11.0.0",
+    "@types/bcrypt": "^6.0.0",
+    "@types/cookie-parser": "^1.4.10",
+    "@types/express": "^5.0.0",
+    "@types/jest": "^30.0.0",
+    "@types/node": "^22.10.0",
+    "@types/supertest": "^6.0.2",
+    "dotenv": "^16.4.7",
+    "eslint": "^9.16.0",
+    "eslint-config-prettier": "^10.0.0",
+    "eslint-plugin-prettier": "^5.2.2",
+    "jest": "^30.0.0",
+    "prettier": "^3.4.2",
+    "source-map-support": "^0.5.21",
+    "supertest": "^7.0.0",
+    "ts-jest": "^29.2.5",
+    "ts-loader": "^9.5.1",
+    "ts-node": "^10.9.2",
+    "tsconfig-paths": "^4.2.0",
+    "typescript": "^5.7.2",
+    "typescript-eslint": "^8.18.0"
+  },
+  "jest": {
+    "moduleFileExtensions": [
+      "js",
+      "json",
+      "ts"
+    ],
+    "rootDir": "src",
+    "testRegex": ".*\\.spec\\.ts$",
+    "transform": {
+      "^.+\\.(t|j)s$": "ts-jest"
+    },
+    "collectCoverageFrom": [
+      "**/*.(t|j)s"
+    ],
+    "coverageDirectory": "../coverage",
+    "testEnvironment": "node"
+  }
+}

package/templates/orm/mongoose/src/app.module.ts

@@ -0,0 +1,73 @@
+import { Module } from '@nestjs/common';
+import { ConfigModule } from '@nestjs/config';
+import { APP_FILTER, APP_GUARD, APP_INTERCEPTOR } from '@nestjs/core';
+import { ThrottlerModule, ThrottlerGuard } from '@nestjs/throttler';
+import { LoggerModule } from 'nestjs-pino';
+
+import { loggerConfig } from './config/logger.config';
+import { validate } from './config/env.validation';
+import { DatabaseModule } from './database/database.module';
+import { AuthModule } from './modules/auth/auth.module';
+import { UsersModule } from './modules/users/users.module';
+import { HealthModule } from './modules/health/health.module';
+import { AuthGuard } from './common/guards/auth.guard';
+import { RolesGuard } from './common/guards/roles.guard';
+import { HttpExceptionFilter } from './common/filters/http-exception.filter';
+import { ResponseInterceptor } from './common/interceptors/response.interceptor';
+
+@Module({
+  imports: [
+    // Configuration
+    ConfigModule.forRoot({
+      isGlobal: true,
+      validate,
+    }),
+
+    // Logging
+    LoggerModule.forRoot(loggerConfig),
+
+    // Rate limiting
+    ThrottlerModule.forRoot([
+      {
+        ttl: 60000, // 1 minute
+        limit: 100, // 100 requests per minute
+      },
+    ]),
+
+    // Database (MongoDB via Mongoose)
+    DatabaseModule,
+
+    // Feature modules
+    AuthModule,
+    UsersModule,
+    HealthModule,
+  ],
+  providers: [
+    // Global exception filter
+    {
+      provide: APP_FILTER,
+      useClass: HttpExceptionFilter,
+    },
+    // Global response interceptor
+    {
+      provide: APP_INTERCEPTOR,
+      useClass: ResponseInterceptor,
+    },
+    // Global rate limiter
+    {
+      provide: APP_GUARD,
+      useClass: ThrottlerGuard,
+    },
+    // Global auth guard
+    {
+      provide: APP_GUARD,
+      useClass: AuthGuard,
+    },
+    // Global roles guard
+    {
+      provide: APP_GUARD,
+      useClass: RolesGuard,
+    },
+  ],
+})
+export class AppModule {}