speedrun-cli 2.6.1

package/templates/base/src/config/logger.config.ts

@@ -0,0 +1,109 @@
+import { Params } from 'nestjs-pino';
+import { IncomingMessage, ServerResponse } from 'http';
+
+export const loggerConfig: Params = {
+  pinoHttp: {
+    transport:
+      process.env.NODE_ENV !== 'production'
+        ? {
+            target: 'pino-pretty',
+            options: {
+              colorize: true,
+              translateTime: 'SYS:standard',
+              ignore: 'pid,hostname',
+              singleLine: false,
+              messageFormat: '[{context}] {msg}',
+            },
+          }
+        : undefined,
+
+    customProps: (req: unknown) => {
+      const request = req as { correlationId?: string };
+      return {
+        correlationId: request.correlationId,
+      };
+    },
+
+    // Customize log levels for different status codes
+    customLogLevel: (
+      _req: IncomingMessage,
+      res: ServerResponse<IncomingMessage>,
+      err: Error | undefined,
+    ) => {
+      if (res.statusCode >= 500 || err) {
+        return 'error';
+      }
+      if (res.statusCode >= 400) {
+        return 'warn';
+      }
+      return 'info';
+    },
+
+    // Customize success message
+    customSuccessMessage: (
+      req: IncomingMessage,
+      res: ServerResponse<IncomingMessage>,
+    ) => {
+      return `${req.method} ${req.url} - ${res.statusCode}`;
+    },
+
+    // Customize error message
+    customErrorMessage: (
+      req: IncomingMessage,
+      res: ServerResponse<IncomingMessage>,
+      err: Error,
+    ) => {
+      return `${req.method} ${req.url} - ${res.statusCode} - ${err.message}`;
+    },
+
+    // Redact sensitive information
+    redact: {
+      paths: [
+        'req.headers.authorization',
+        'req.headers.cookie',
+        'req.body.password',
+        'res.headers["set-cookie"]',
+      ],
+      censor: '[REDACTED]',
+    },
+
+    serializers: {
+      req: (req: {
+        id: string;
+        method: string;
+        url: string;
+        query: unknown;
+        params: unknown;
+        headers: Record<string, unknown>;
+        remoteAddress: string;
+        remotePort: number;
+      }) => ({
+        id: req.id,
+        method: req.method,
+        url: req.url,
+        query: req.query,
+        params: req.params,
+        headers: {
+          'user-agent': req.headers['user-agent'],
+          'content-type': req.headers['content-type'],
+        },
+        remoteAddress: req.remoteAddress,
+        remotePort: req.remotePort,
+      }),
+      res: (res: { statusCode: number; headers: Record<string, unknown> }) => ({
+        statusCode: res.statusCode,
+        headers: {
+          'content-type': res.headers['content-type'],
+        },
+      }),
+    },
+
+    level: process.env.LOG_LEVEL || 'info',
+
+    // Don't log health check endpoints
+    autoLogging: {
+      ignore: (req: IncomingMessage) =>
+        req.url === '/health' || req.url === '/api/v1/health',
+    },
+  },
+};

package/templates/base/src/main.ts

@@ -0,0 +1,84 @@
+import { NestFactory } from '@nestjs/core';
+import { AppModule } from './app.module';
+import cookieParser from 'cookie-parser';
+import helmet from 'helmet';
+import { ValidationPipe } from '@nestjs/common';
+import { ConfigService } from '@nestjs/config';
+import { ResponseInterceptor } from './common/interceptors/response.interceptor';
+import { HttpExceptionFilter } from './common/filters/http-exception.filter';
+import { Logger } from 'nestjs-pino';
+
+async function bootstrap() {
+  const app = await NestFactory.create(AppModule, { bufferLogs: true });
+
+  // Use Pino logger
+  app.useLogger(app.get(Logger));
+
+  app.setGlobalPrefix('api/v1');
+
+  const configService = app.get(ConfigService);
+
+  const port = configService.get<number>('PORT');
+  const corsOrigins = configService.get<string>('CORS_ORIGIN')?.split(',');
+
+  app.enableCors({
+    origins: corsOrigins,
+    credentials: true,
+  });
+
+  app.use(cookieParser());
+
+  // Configure Helmet with strict security headers
+  app.use(
+    helmet({
+      contentSecurityPolicy: {
+        directives: {
+          defaultSrc: ["'self'"],
+          styleSrc: ["'self'", "'unsafe-inline'"],
+          scriptSrc: ["'self'"],
+          imgSrc: ["'self'", 'data:', 'https:'],
+        },
+      },
+      crossOriginEmbedderPolicy: true,
+      crossOriginOpenerPolicy: { policy: 'same-origin' },
+      crossOriginResourcePolicy: { policy: 'same-origin' },
+      dnsPrefetchControl: { allow: false },
+      frameguard: { action: 'deny' },
+      hidePoweredBy: true,
+      hsts: {
+        maxAge: 31536000,
+        includeSubDomains: true,
+        preload: true,
+      },
+      ieNoOpen: true,
+      noSniff: true,
+      referrerPolicy: { policy: 'strict-origin-when-cross-origin' },
+      xssFilter: true,
+    }),
+  );
+
+  app.useGlobalPipes(
+    new ValidationPipe({
+      whitelist: true,
+      forbidNonWhitelisted: true,
+      transform: true,
+    }),
+  );
+
+  // Get logger instance
+  const logger = app.get(Logger);
+
+  // Global response interceptor for standard API responses
+  app.useGlobalInterceptors(new ResponseInterceptor());
+
+  // Global exception filter for standard error responses
+  app.useGlobalFilters(new HttpExceptionFilter(logger));
+
+  await app.listen(port || 8080);
+
+  logger.log(
+    `🚀 Application is running on: http://localhost:${port || 8080}/api/v1`,
+    'Bootstrap',
+  );
+}
+void bootstrap();

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

@@ -0,0 +1,133 @@
+import {
+  Body,
+  Controller,
+  Get,
+  Post,
+  Req,
+  Res,
+  UseGuards,
+} from '@nestjs/common';
+import { AuthService } from './auth.service';
+import { Request, Response } from 'express';
+import { RefreshTokenGuard } from 'src/common/guards/refresh-token.guard';
+import { GetUser } from 'src/common/decorators/get-user.decorator';
+import { Public } from 'src/common/decorators/public.decorator';
+import { SignupDto } from './dtos/signup.dto';
+import { LoginDto } from './dtos/login.dto';
+import { Throttle, SkipThrottle } from '@nestjs/throttler';
+import { COOKIE_CONFIG } from 'src/common/constants/cookie.config';
+import { CookieOptions } from 'express';
+
+@Controller('auth')
+export class AuthController {
+  constructor(private readonly authService: AuthService) {}
+
+  @Throttle({ strict: { ttl: 60000, limit: 3 } })
+  @Public()
+  @Post('/signup')
+  async signup(@Body() signupDto: SignupDto) {
+    return this.authService.signup(signupDto);
+  }
+
+  @Throttle({ strict: { ttl: 60000, limit: 5 } })
+  @Public()
+  @Post('/login')
+  async login(
+    @Body() loginDto: LoginDto,
+    @Req() req: Request,
+    @Res({ passthrough: true }) res: Response,
+  ) {
+    const deviceInfo = req.headers['user-agent'] || 'Unknown Device';
+    const ipAddress =
+      (req.headers['x-forwarded-for'] as string)?.split(',')[0] ||
+      req.ip ||
+      'Unknown IP';
+
+    const data = await this.authService.login(loginDto, deviceInfo, ipAddress);
+
+    res.cookie(
+      COOKIE_CONFIG.ACCESS_TOKEN.name,
+      data.accessToken,
+      COOKIE_CONFIG.ACCESS_TOKEN.options as CookieOptions,
+    );
+    res.cookie(
+      COOKIE_CONFIG.REFRESH_TOKEN.name,
+      data.refreshToken,
+      COOKIE_CONFIG.REFRESH_TOKEN.options as CookieOptions,
+    );
+
+    return {
+      user: data.user,
+    };
+  }
+
+  @Throttle({ default: { ttl: 60000, limit: 10 } })
+  @Public()
+  @UseGuards(RefreshTokenGuard)
+  @Post('/refresh')
+  async refreshToken(
+    @GetUser('sub') userId: string,
+    @Req() req: Request,
+    @Res({ passthrough: true }) res: Response,
+  ) {
+    const rt = req.cookies[COOKIE_CONFIG.REFRESH_TOKEN.name] as string;
+    const deviceInfo = req.headers['user-agent'] || 'Unknown Device';
+    const ipAddress =
+      (req.headers['x-forwarded-for'] as string)?.split(',')[0] ||
+      req.ip ||
+      'Unknown IP';
+
+    const { accessToken, refreshToken } = await this.authService.refreshToken(
+      userId,
+      rt,
+      deviceInfo,
+      ipAddress,
+    );
+
+    res.cookie(
+      COOKIE_CONFIG.ACCESS_TOKEN.name,
+      accessToken,
+      COOKIE_CONFIG.ACCESS_TOKEN.options as CookieOptions,
+    );
+    res.cookie(
+      COOKIE_CONFIG.REFRESH_TOKEN.name,
+      refreshToken,
+      COOKIE_CONFIG.REFRESH_TOKEN.options as CookieOptions,
+    );
+
+    return {
+      message: 'Tokens refreshed successfully',
+    };
+  }
+
+  @Public()
+  @UseGuards(RefreshTokenGuard)
+  @Post('/logout')
+  async logout(
+    @GetUser('sub') userId: string,
+    @Req() req: Request,
+    @Res({ passthrough: true }) res: Response,
+  ) {
+    const rt = req.cookies[COOKIE_CONFIG.REFRESH_TOKEN.name] as string | undefined;
+    await this.authService.logout(userId, rt);
+
+    res.clearCookie(
+      COOKIE_CONFIG.ACCESS_TOKEN.name,
+      COOKIE_CONFIG.ACCESS_TOKEN.options as CookieOptions | undefined,
+    );
+    res.clearCookie(
+      COOKIE_CONFIG.REFRESH_TOKEN.name,
+      COOKIE_CONFIG.REFRESH_TOKEN.options as CookieOptions | undefined,
+    );
+
+    return {
+      message: 'Logged out successfully',
+    };
+  }
+
+  @SkipThrottle()
+  @Get('/me')
+  async getMe(@GetUser('sub') userId: string) {
+    return this.authService.getMe(userId);
+  }
+}

package/templates/base/src/modules/auth/dtos/login.dto.ts

@@ -0,0 +1,11 @@
+import { IsEmail, IsString } from 'class-validator';
+import { IsStrongPassword } from 'src/common/validators/password.validator';
+
+export class LoginDto {
+  @IsEmail()
+  email: string;
+
+  @IsString()
+  @IsStrongPassword()
+  password: string;
+}

package/templates/base/src/modules/auth/dtos/signup.dto.ts

@@ -0,0 +1,8 @@
+import { IsString, MinLength } from 'class-validator';
+import { LoginDto } from './login.dto';
+
+export class SignupDto extends LoginDto {
+  @IsString()
+  @MinLength(2)
+  fullName: string;
+}

package/templates/base/src/modules/health/health.controller.ts

@@ -0,0 +1,20 @@
+import { Controller, Get } from '@nestjs/common';
+import { Public } from '../../common/decorators/public.decorator';
+
+@Controller('health')
+export class HealthController {
+  @Public()
+  @Get()
+  check() {
+    return {
+      status: 'ok',
+      timestamp: new Date().toISOString(),
+      services: {
+        application: {
+          status: 'healthy',
+          uptime: process.uptime(),
+        },
+      },
+    };
+  }
+}

package/templates/base/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/base/src/modules/users/dtos/update-profile.dto.ts

@@ -0,0 +1,12 @@
+import { IsOptional, IsString, MaxLength, MinLength } from 'class-validator';
+
+export class UpdateProfileDto {
+  @IsOptional()
+  @IsString()
+  @MinLength(2)
+  @MaxLength(100)
+  fullName?: string;
+
+  // Email update removed - requires separate verification flow for security
+  // Implement email change in a dedicated endpoint with verification
+}

package/templates/base/src/modules/users/dtos/update-user.dto.ts

@@ -0,0 +1,13 @@
+import { IsBoolean, IsEnum, IsOptional } from 'class-validator';
+import { UpdateProfileDto } from './update-profile.dto';
+import { UserRole } from 'src/common/guards/roles.guard';
+
+export class UpdateUserDto extends UpdateProfileDto {
+  @IsOptional()
+  @IsEnum(UserRole, { message: 'Role must be a valid UserRole' })
+  role?: UserRole;
+
+  @IsOptional()
+  @IsBoolean()
+  isActive?: boolean;
+}

package/templates/base/src/modules/users/users.controller.ts

@@ -0,0 +1,65 @@
+import {
+  Body,
+  Controller,
+  Delete,
+  Get,
+  Param,
+  Patch,
+  Query,
+} from '@nestjs/common';
+import { UsersService } from './users.service';
+import { GetUser } from 'src/common/decorators/get-user.decorator';
+import { Roles } from 'src/common/decorators/roles.decorator';
+import { UserRole } from 'src/common/guards/roles.guard';
+import { UpdateUserDto } from './dtos/update-user.dto';
+import { UpdateProfileDto } from './dtos/update-profile.dto';
+import { PaginationDto } from 'src/common/dtos/pagination.dto';
+
+@Controller('users')
+export class UsersController {
+  constructor(private readonly usersService: UsersService) {}
+
+  // profile routes
+  @Get('/profile')
+  async getProfile(@GetUser('sub') userId: string) {
+    return this.usersService.getProfile(userId);
+  }
+
+  @Patch('/profile')
+  async updateProfile(
+    @GetUser('sub') userId: string,
+    @Body() updateProfileDto: UpdateProfileDto,
+  ) {
+    return this.usersService.updateProfile(userId, updateProfileDto);
+  }
+
+  // admin routes
+  @Roles(UserRole.ADMIN)
+  @Get('/')
+  async getAllUsers(@Query() paginationDto: PaginationDto) {
+    const { page = 1, limit = 10 } = paginationDto;
+    return this.usersService.getAllUsers(page, limit);
+  }
+
+  @Roles(UserRole.ADMIN)
+  @Get('/:id')
+  async getUserById(@Param('id') id: string) {
+    return this.usersService.getUserById(id);
+  }
+
+  @Roles(UserRole.ADMIN)
+  @Patch('/:id')
+  async updateUserById(
+    @Param('id') id: string,
+    @Body() updateUserDto: UpdateUserDto,
+  ) {
+    return this.usersService.updateUserById(id, updateUserDto);
+  }
+
+  //this soft deletes a user by setting isActive to false
+  @Roles(UserRole.ADMIN)
+  @Delete('/:id')
+  async deleteUserById(@Param('id') id: string) {
+    return this.usersService.deleteUserById(id);
+  }
+}

package/templates/base/test/app.e2e-spec.ts

@@ -0,0 +1,24 @@
+import { Test, TestingModule } from '@nestjs/testing';
+import { INestApplication } from '@nestjs/common';
+import request from 'supertest';
+import { AppModule } from './../src/app.module';
+
+describe('AppController (e2e)', () => {
+  let app: INestApplication;
+
+  beforeEach(async () => {
+    const moduleFixture: TestingModule = await Test.createTestingModule({
+      imports: [AppModule],
+    }).compile();
+
+    app = moduleFixture.createNestApplication();
+    await app.init();
+  });
+
+  it('/ (GET)', async () => {
+    // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
+    const server = app.getHttpServer();
+    // eslint-disable-next-line @typescript-eslint/no-unsafe-argument
+    await request(server).get('/').expect(404);
+  });
+});

package/templates/base/test/jest-e2e.json

@@ -0,0 +1,9 @@
+{
+  "moduleFileExtensions": ["js", "json", "ts"],
+  "rootDir": ".",
+  "testEnvironment": "node",
+  "testRegex": ".e2e-spec.ts$",
+  "transform": {
+    "^.+\\.(t|j)s$": "ts-jest"
+  }
+}

package/templates/base/tsconfig.build.json

@@ -0,0 +1,4 @@
+{
+  "extends": "./tsconfig.json",
+  "exclude": ["node_modules", "test", "dist", "**/*spec.ts"]
+}

package/templates/base/tsconfig.json

@@ -0,0 +1,24 @@
+{
+  "compilerOptions": {
+    "module": "commonjs",
+    "moduleResolution": "node",
+    "esModuleInterop": true,
+    "isolatedModules": true,
+    "declaration": true,
+    "removeComments": true,
+    "emitDecoratorMetadata": true,
+    "experimentalDecorators": true,
+    "allowSyntheticDefaultImports": true,
+    "target": "ES2022",
+    "sourceMap": true,
+    "outDir": "./dist",
+    "baseUrl": "./",
+    "incremental": true,
+    "skipLibCheck": true,
+    "strictNullChecks": true,
+    "forceConsistentCasingInFileNames": true,
+    "noImplicitAny": false,
+    "strictBindCallApply": false,
+    "noFallthroughCasesInSwitch": false
+  }
+}