nestjs-prisma-cli 1.0.9 → 1.0.11

package/README.md

@@ -14,6 +14,7 @@ A CLI tool to quickly scaffold a **NestJS + Prisma** project with built-in suppo
 - 📖 Swagger (OpenAPI) setup
 - 🔑 Authentication boilerplate
 - ☁️ AWS S3 integration
+- 📜 Logging via Winston (rotating logs and DB persistence)
 
 Compatible with **Node.js >=18** and **NestJS v10+**.
 
@@ -31,19 +32,20 @@ Once the CLI is installed, you can use the following commands:
 npm install -g nestjs-prisma-cli
 ```
 
-
 ### 2️⃣ Check CLI version
 
 ```bash
 nestgen -v
 ```
+
 # or
+
 ```bash
 nestgen --version
 ```
 
-
 ### 3️⃣ Generate a new project
+
 ```bash
 nestgen
 ```
@@ -61,31 +63,43 @@ Step 3: 🎉 Project ready! Next steps:
 ```
 
 ### Navigate into your project
+
 ```bash
 cd my-app
 ```
+
 ### Update .env
+
 ```bash
 DATABASE_URL="your_database_connection_string"
 ```
+
 ```bash
 npx prisma generate
 ```
+
 ### SQL Databases
+
 ### (PostgreSQL, MySQL, SQLite, CockroachDB, SQLServer)
+
 ```bash
 npx prisma migrate dev --name init
 ```
+
 ### NoSQL Database
+
 ### (MongoDB)
+
 ```bash
 npx prisma db push
 ```
+
 ### Then, follow this
+
 ```bash
 npx ts-node prisma/seed.ts
 ```
+
 ```bash
 npm run start:dev
 ```
-

package/bin/index.js

@@ -193,17 +193,17 @@ async function main() {
     sqlserver: `sqlserver://localhost:1433;database=${dbSafeName};user=sa;password=your_password;encrypt=false`,
   };
 
-  const envContent = `DATABASE_URL="${defaultUrlMap[database.toLowerCase()]}"
+  const envContent = `DATABASE_URL=${defaultUrlMap[database.toLowerCase()]}
 
-JWT_ACCESS_SECRET="JWT_ACCESS_SECRET"
-JWT_REFRESH_SECRET="JWT_REFRESH_SECRET"
-JWT_ACCESS_EXPIRATION_TIME="1d"
-JWT_REFRESH_EXPIRATION_TIME="30d"
+JWT_ACCESS_SECRET=JWT_ACCESS_SECRET
+JWT_REFRESH_SECRET=JWT_REFRESH_SECRET
+JWT_ACCESS_EXPIRATION_TIME=1d
+JWT_REFRESH_EXPIRATION_TIME=30d
 
-AWS_ACCESS_KEY_ID="AWS_ACCESS_KEY_ID"
-AWS_SECRET_ACCESS_KEY="AWS_SECRET_ACCESS_KEY"
+AWS_ACCESS_KEY_ID=AWS_ACCESS_KEY_ID
+AWS_SECRET_ACCESS_KEY=AWS_SECRET_ACCESS_KEY
 AWS_REGION=ap-southeast-1
-S3_BUCKET="S3_BUCKET"
+S3_BUCKET=S3_BUCKET
 
 NODE_ENV=dev
 PROJECT_NAME=${dbSafeName}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "nestjs-prisma-cli",
-  "version": "1.0.9",
+  "version": "1.0.11",
   "description": "A CLI to generate NestJS + Prisma project boilerplate with Swagger, Auth, and AWS S3 setup",
   "type": "module",
   "main": "bin/index.js",

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

@@ -4,84 +4,84 @@ import {
   Body,
   HttpCode,
   UnauthorizedException,
-} from '@nestjs/common';
-import { ApiBody, ApiTags } from '@nestjs/swagger';
-import { AuthService } from './auth.service';
-import { Public } from '../../common/decorator/public.decorator';
-import { JwtService } from '@nestjs/jwt';
-import { LoginDto } from './dto/login.dto';
+} from "@nestjs/common";
+import { ApiBody, ApiTags } from "@nestjs/swagger";
+import { AuthService } from "./auth.service";
+import { Public } from "../../common/decorator/public.decorator";
+import { JwtService } from "@nestjs/jwt";
+import { LoginDto } from "./dto/login.dto";
 
-@ApiTags('Authentication')
+@ApiTags("Authentication")
 @Controller()
 export class AuthController {
   constructor(
     private readonly authService: AuthService,
-    private readonly jwtService: JwtService,
+    private readonly jwtService: JwtService
   ) {}
 
   @Public()
-  @Post('login')
-  @ApiBody({ description: 'Login credentials', type: LoginDto })
+  @Post("login")
+  @ApiBody({ description: "Login credentials", type: LoginDto })
   async login(@Body() body: LoginDto) {
     if (!body || !body.userId || !body.password) {
-      throw new UnauthorizedException('Missing login credentials');
+      throw new UnauthorizedException("Missing login credentials");
     }
 
     const user = await this.authService.validateUser(
       body.userId,
-      body.password,
+      body.password
     );
     return this.authService.login(user);
   }
 
   @Public()
-  @Post('refresh')
+  @Post("refresh")
   @ApiBody({
-    description: 'Provide your userId and refreshToken',
+    description: "Provide your userId and refreshToken",
     schema: {
-      type: 'object',
+      type: "object",
       properties: {
-        userId: { type: 'string', example: 'USER_20250815001' },
-        refreshToken: { type: 'string', example: 'xxxx.yyyy.zzzz' },
+        userId: { type: "string", example: "USER_20250815001" },
+        refreshToken: { type: "string", example: "xxxx.yyyy.zzzz" },
       },
-      required: ['userId', 'refreshToken'],
+      required: ["userId", "refreshToken"],
     },
   })
   async refresh(@Body() body: { userId: string; refreshToken: string }) {
     if (!body || !body.userId || !body.refreshToken) {
-      throw new UnauthorizedException('Missing login credentials');
+      throw new UnauthorizedException("Missing login credentials");
     }
 
     let payload: any;
-    const modifiedUserId = body.userId.replace(/\s+/g, '');
+    const modifiedUserId = body.userId.replace(/\s+/g, "");
 
     try {
       payload = this.jwtService.verify(body.refreshToken, {
         secret: process.env.JWT_REFRESH_SECRET,
       });
     } catch (err) {
-      if (err.name === 'TokenExpiredError') {
-        throw new UnauthorizedException('Refresh Token expired');
+      if (err.name === "TokenExpiredError") {
+        throw new UnauthorizedException("Refresh Token expired");
       }
-      throw new UnauthorizedException('Invalid refresh token');
+      throw new UnauthorizedException("Invalid refresh token");
     }
 
     if (String(payload.userId).trim() !== modifiedUserId) {
-      throw new UnauthorizedException('Unauthorized access');
+      throw new UnauthorizedException("Unauthorized access");
     }
 
     const user = await this.authService.getUserByUserId(modifiedUserId);
 
     if (!user) {
-      throw new UnauthorizedException('User not found');
+      throw new UnauthorizedException("User not found");
     }
 
     const newAccessToken = this.jwtService.sign(
       { sub: user.id, userId: user.userId },
       {
         secret: process.env.JWT_ACCESS_SECRET,
-        expiresIn: process.env.JWT_ACCESS_EXPIRATION_TIME,
-      },
+        expiresIn: process.env.JWT_ACCESS_EXPIRATION_TIME as any,
+      }
     );
 
     return {
@@ -91,16 +91,16 @@ export class AuthController {
   }
 
   @Public()
-  @Post('validate')
+  @Post("validate")
   @HttpCode(200)
   @ApiBody({
-    description: 'Provide the access token to validate',
+    description: "Provide the access token to validate",
     schema: {
-      type: 'object',
+      type: "object",
       properties: {
-        token: { type: 'string', example: 'xxxx.yyyy.zzzz' },
+        token: { type: "string", example: "xxxx.yyyy.zzzz" },
       },
-      required: ['token'],
+      required: ["token"],
     },
   })
   async validate(@Body() body: { token: string }) {
@@ -110,10 +110,10 @@ export class AuthController {
       });
       return payload;
     } catch (err) {
-      if (err.name === 'TokenExpiredError') {
-        throw new UnauthorizedException('Token expired');
+      if (err.name === "TokenExpiredError") {
+        throw new UnauthorizedException("Token expired");
       }
-      throw new UnauthorizedException('Invalid token');
+      throw new UnauthorizedException("Invalid token");
     }
   }
 }

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

@@ -1,7 +1,7 @@
 import { Module } from '@nestjs/common';
 import { AuthController } from './auth.controller';
 import { AuthService } from './auth.service';
-import { JwtModule } from '@nestjs/jwt';
+import { JwtModule, JwtModuleOptions } from '@nestjs/jwt';
 import { JwtStrategy } from './jwt/jwt.strategy';
 import { ConfigModule, ConfigService } from '@nestjs/config';
 
@@ -11,12 +11,21 @@ import { ConfigModule, ConfigService } from '@nestjs/config';
     JwtModule.registerAsync({
       imports: [ConfigModule],
       inject: [ConfigService],
-      useFactory: async (configService: ConfigService) => ({
-        secret: configService.get<string>('JWT_ACCESS_SECRET'),
-        signOptions: {
-          expiresIn: configService.get<string>('JWT_ACCESS_EXPIRATION_TIME'),
-        },
-      }),
+      useFactory: async (configService: ConfigService): Promise<JwtModuleOptions> => {
+        const secret = configService.get<string>('JWT_ACCESS_SECRET');
+        const expiresIn = configService.get<string>('JWT_ACCESS_EXPIRATION_TIME');
+
+        if (!secret || !expiresIn) {
+          throw new Error('Missing JWT environment variables');
+        }
+
+        return {
+          secret,
+          signOptions: {
+            expiresIn: expiresIn as any, 
+          },
+        };
+      },
     }),
   ],
   controllers: [AuthController],

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

@@ -36,12 +36,12 @@ export class AuthService {
 
     const accessToken = this.jwtService.sign(payload, {
       secret: process.env.JWT_ACCESS_SECRET,
-      expiresIn: process.env.JWT_ACCESS_EXPIRATION_TIME,
+      expiresIn: process.env.JWT_ACCESS_EXPIRATION_TIME as any,
     });
 
     const refreshToken = this.jwtService.sign(payload, {
       secret: process.env.JWT_REFRESH_SECRET,
-      expiresIn: process.env.JWT_REFRESH_EXPIRATION_TIME,
+      expiresIn: process.env.JWT_REFRESH_EXPIRATION_TIME as any,
     });
 
     return {