nestcraftx 0.3.0 → 1.0.0

package/utils/setups/setupAuth.js

@@ -17,11 +17,11 @@ async function setupAuth(inputs) {
   const installCmd = pkgManager === "yarn" || pkgManager === "pnpm" ? `${pkgManager} add` : "npm install";
 
   await runCommand(
-    `${installCmd} @nestjs/jwt @nestjs/passport passport passport-jwt bcrypt uuid`,
+    `${installCmd} @nestjs/jwt@^10.2.0 @nestjs/passport@^10.0.3 passport@^0.7.0 passport-jwt@^4.0.1 bcrypt@^5.1.1 uuid@^9.0.1`,
     "Erreur install deps auth",
   );
   await runCommand(
-    `${installCmd} -D @types/passport-jwt @types/bcrypt @types/uuid`,
+    `${installCmd} -D @types/passport-jwt@^4.0.1 @types/bcrypt@^5.0.2 @types/uuid@^9.0.8`,
     "Erreur install dev-deps auth",
   );
 
@@ -120,6 +120,109 @@ export class Session {
 }
 
 export const SessionSchema = SchemaFactory.createForClass(Session);
+`.trim(),
+    });
+
+    await createFile({
+      path: `${sessionSchemaPath}/password-reset.schema.ts`,
+      contente: `
+import { Prop, Schema, SchemaFactory } from '@nestjs/mongoose';
+import { Document } from 'mongoose';
+
+export type PasswordResetDocument = PasswordReset & Document;
+
+@Schema({ timestamps: true })
+export class PasswordReset {
+  @Prop({ required: true })
+  email: string;
+
+  @Prop({ required: true, unique: true })
+  token: string;
+
+  @Prop({ required: true })
+  expiresAt: Date;
+}
+
+export const PasswordResetSchema = SchemaFactory.createForClass(PasswordReset);
+`.trim(),
+    });
+
+    await createFile({
+      path: `${sessionSchemaPath}/otp.schema.ts`,
+      contente: `
+import { Prop, Schema, SchemaFactory } from '@nestjs/mongoose';
+import { Document } from 'mongoose';
+
+export type OtpDocument = Otp & Document;
+
+@Schema({ timestamps: true })
+export class Otp {
+  @Prop({ required: true })
+  email: string;
+
+  @Prop({ required: true })
+  otp: string;
+
+  @Prop({ required: true })
+  expiresAt: Date;
+}
+
+export const OtpSchema = SchemaFactory.createForClass(Otp);
+`.trim(),
+    });
+  }
+
+  // --- GÉNÉRATION DES ENTITÉS (Spécifique TypeORM) ---
+  if (dbConfig.orm === "typeorm") {
+    await createDirectory("src/entities");
+
+    await createFile({
+      path: `src/entities/PasswordReset.entity.ts`,
+      contente: `
+import { Entity, PrimaryGeneratedColumn, Column, CreateDateColumn } from 'typeorm';
+
+@Entity('password_reset')
+export class PasswordReset {
+  @PrimaryGeneratedColumn('uuid')
+  id: string;
+
+  @Column({ type: 'varchar' })
+  email: string;
+
+  @Column({ type: 'varchar', unique: true })
+  token: string;
+
+  @Column({ type: 'timestamp' })
+  expiresAt: Date;
+
+  @CreateDateColumn()
+  createdAt: Date;
+}
+`.trim(),
+    });
+
+    await createFile({
+      path: `src/entities/Otp.entity.ts`,
+      contente: `
+import { Entity, PrimaryGeneratedColumn, Column, CreateDateColumn } from 'typeorm';
+
+@Entity('otp')
+export class Otp {
+  @PrimaryGeneratedColumn('uuid')
+  id: string;
+
+  @Column({ type: 'varchar' })
+  email: string;
+
+  @Column({ type: 'varchar' })
+  otp: string;
+
+  @Column({ type: 'timestamp' })
+  expiresAt: Date;
+
+  @CreateDateColumn()
+  createdAt: Date;
+}
 `.trim(),
     });
   }
@@ -252,6 +355,8 @@ import { SendOtpDto } from '${paths.appDtos}/sendOtp.dto';
 import { VerifyOtpDto } from '${paths.appDtos}/verifyOtp.dto';
 import { ForgotPasswordDto } from '${paths.appDtos}/forgotPassword.dto';
 import { ResetPasswordDto } from '${paths.appDtos}/resetPassword.dto';
+import { OtpRepository } from '${paths.persistence}/otp.repository';
+import { PasswordResetRepository } from '${paths.persistence}/password-reset.repository';
 ${enumImport}
  ${
    mode === "light"
@@ -263,10 +368,11 @@ ${enumImport}
 
 @Injectable()
 export class AuthService {
-  private otps = new Map<string, string>();
   constructor(
     private readonly jwtService: JwtService,
     private readonly sessionService: SessionService,
+    private readonly otpRepository: OtpRepository,
+    private readonly passwordResetRepository: PasswordResetRepository,
   ${
     mode === "light"
       ? `private readonly userRepository: UserRepository,`
@@ -345,21 +451,26 @@ export class AuthService {
   }
 
   // 📲 Send OTP
-  sendOtp(dto: SendOtpDto) {
+  async sendOtp(dto: SendOtpDto) {
     const otp = Math.floor(100000 + Math.random() * 900000).toString();
-    this.otps.set(dto.email, otp);
+    const expiresAt = new Date();
+    expiresAt.setMinutes(expiresAt.getMinutes() + 5); // Valid for 5 mins
+
+    await this.otpRepository.deleteByEmail(dto.email);
+    await this.otpRepository.save({ email: dto.email, otp, expiresAt });
+
     console.log(\`[OTP] for \${dto.email} is \${otp}\`);
     return { message: 'OTP sent' };
   }
 
   // Verify OTP
-  verifyOtp(dto: VerifyOtpDto) {
-    const valid = this.otps.get(dto.email);
-    if (valid === dto.otp) {
-     this.otps.delete(dto.email);
-     return { message: 'OTP verified' };
+  async verifyOtp(dto: VerifyOtpDto) {
+    const record = await this.otpRepository.findLatestByEmail(dto.email);
+    if (record && record.otp === dto.otp && record.expiresAt > new Date()) {
+      await this.otpRepository.deleteByEmail(dto.email);
+      return { message: 'OTP verified' };
     }
-    throw new UnauthorizedException('Invalid OTP');
+    throw new UnauthorizedException('Invalid or expired OTP');
   }
 
    // 📬 Forgot Password
@@ -368,18 +479,31 @@ export class AuthService {
     if (!existingUser) throw new NotFoundException('User not found');
 
     const token = uuidv4();
+    const expiresAt = new Date();
+    expiresAt.setHours(expiresAt.getHours() + 1); // Valid for 1 hour
+
+    await this.passwordResetRepository.deleteByEmail(dto.email);
+    await this.passwordResetRepository.save({ email: dto.email, token, expiresAt });
+
     console.log(\`[ResetToken] for \${dto.email} is \${token}\`);
     return { message: 'Reset token sent' };
    }
 
    // 🔄 Reset Password
    async resetPassword(dto: ResetPasswordDto) {
+    const record = await this.passwordResetRepository.findByToken(dto.token);
+    if (!record || record.email !== dto.email || record.expiresAt < new Date()) {
+      throw new UnauthorizedException('Invalid or expired reset token');
+    }
+
     const existingUser = await this.userRepository.findByEmail(dto.email);
-    if (!existingUser) throw new UnauthorizedException('Invalid reset token');
+    if (!existingUser) throw new UnauthorizedException('User not found');
 
     const password = await this.hashPassword(dto.newPassword);
     await this.userRepository.update(existingUser.getId(), { password });
 
+    await this.passwordResetRepository.deleteByEmail(dto.email);
+
     return { message: 'Password reset successful' };
    }
 
@@ -566,6 +690,188 @@ export class SessionRepository ${implementsClause} {
     contente: repoContent.trim(),
   });
 
+  // --- PASSWORD RESET REPOSITORY ---
+  let resetRepoContent = "";
+  if (dbConfig.orm === "typeorm") {
+    resetRepoContent = `
+import { Injectable } from '@nestjs/common';
+import { InjectRepository } from '@nestjs/typeorm';
+import { Repository } from 'typeorm';
+import { PasswordReset as PasswordResetEntity } from 'src/entities/PasswordReset.entity';
+
+@Injectable()
+export class PasswordResetRepository {
+  constructor(
+    @InjectRepository(PasswordResetEntity)
+    private readonly repo: Repository<PasswordResetEntity>,
+  ) {}
+
+  async save(data: { email: string; token: string; expiresAt: Date }): Promise<PasswordResetEntity> {
+    return this.repo.save(data);
+  }
+
+  async findByToken(token: string): Promise<PasswordResetEntity | null> {
+    return this.repo.findOne({ where: { token } });
+  }
+
+  async deleteByEmail(email: string): Promise<void> {
+    await this.repo.delete({ email });
+  }
+}
+`.trim();
+  } else if (dbConfig.orm === "prisma") {
+    resetRepoContent = `
+import { Injectable } from '@nestjs/common';
+import { PrismaService } from 'src/prisma/prisma.service';
+
+@Injectable()
+export class PasswordResetRepository {
+  constructor(private readonly prisma: PrismaService) {}
+
+  async save(data: { email: string; token: string; expiresAt: Date }) {
+    return this.prisma.passwordReset.create({ data });
+  }
+
+  async findByToken(token: string) {
+    return this.prisma.passwordReset.findUnique({ where: { token } });
+  }
+
+  async deleteByEmail(email: string) {
+    await this.prisma.passwordReset.deleteMany({ where: { email } });
+  }
+}
+`.trim();
+  } else if (dbConfig.orm === "mongoose") {
+    const mongooseSchemaPath = isFull
+      ? "src/auth/infrastructure/persistence/mongoose"
+      : "src/auth/persistence";
+    resetRepoContent = `
+import { Injectable } from '@nestjs/common';
+import { InjectModel } from '@nestjs/mongoose';
+import { Model } from 'mongoose';
+import { PasswordReset, PasswordResetDocument } from '${mongooseSchemaPath}/password-reset.schema';
+
+@Injectable()
+export class PasswordResetRepository {
+  constructor(
+    @InjectModel(PasswordReset.name)
+    private readonly model: Model<PasswordResetDocument>,
+  ) {}
+
+  async save(data: { email: string; token: string; expiresAt: Date }) {
+    return new this.model(data).save();
+  }
+
+  async findByToken(token: string) {
+    return this.model.findOne({ token }).exec();
+  }
+
+  async deleteByEmail(email: string) {
+    await this.model.deleteMany({ email }).exec();
+  }
+}
+`.trim();
+  }
+
+  await createFile({
+    path: `${paths.persistence}/password-reset.repository.ts`,
+    contente: resetRepoContent,
+  });
+
+  // --- OTP REPOSITORY ---
+  let otpRepoContent = "";
+  if (dbConfig.orm === "typeorm") {
+    otpRepoContent = `
+import { Injectable } from '@nestjs/common';
+import { InjectRepository } from '@nestjs/typeorm';
+import { Repository } from 'typeorm';
+import { Otp as OtpEntity } from 'src/entities/Otp.entity';
+
+@Injectable()
+export class OtpRepository {
+  constructor(
+    @InjectRepository(OtpEntity)
+    private readonly repo: Repository<OtpEntity>,
+  ) {}
+
+  async save(data: { email: string; otp: string; expiresAt: Date }): Promise<OtpEntity> {
+    return this.repo.save(data);
+  }
+
+  async findLatestByEmail(email: string): Promise<OtpEntity | null> {
+    return this.repo.findOne({
+      where: { email },
+      order: { createdAt: 'DESC' }
+    });
+  }
+
+  async deleteByEmail(email: string): Promise<void> {
+    await this.repo.delete({ email });
+  }
+}
+`.trim();
+  } else if (dbConfig.orm === "prisma") {
+    otpRepoContent = `
+import { Injectable } from '@nestjs/common';
+import { PrismaService } from 'src/prisma/prisma.service';
+
+@Injectable()
+export class OtpRepository {
+  constructor(private readonly prisma: PrismaService) {}
+
+  async save(data: { email: string; otp: string; expiresAt: Date }) {
+    return this.prisma.otp.create({ data });
+  }
+
+  async findLatestByEmail(email: string) {
+    return this.prisma.otp.findFirst({
+      where: { email },
+      orderBy: { createdAt: 'desc' }
+    });
+  }
+
+  async deleteByEmail(email: string) {
+    await this.prisma.otp.deleteMany({ where: { email } });
+  }
+}
+`.trim();
+  } else if (dbConfig.orm === "mongoose") {
+    const mongooseSchemaPath = isFull
+      ? "src/auth/infrastructure/persistence/mongoose"
+      : "src/auth/persistence";
+    otpRepoContent = `
+import { Injectable } from '@nestjs/common';
+import { InjectModel } from '@nestjs/mongoose';
+import { Model } from 'mongoose';
+import { Otp, OtpDocument } from '${mongooseSchemaPath}/otp.schema';
+
+@Injectable()
+export class OtpRepository {
+  constructor(
+    @InjectModel(Otp.name)
+    private readonly model: Model<OtpDocument>,
+  ) {}
+
+  async save(data: { email: string; otp: string; expiresAt: Date }) {
+    return new this.model(data).save();
+  }
+
+  async findLatestByEmail(email: string) {
+    return this.model.findOne({ email }).sort({ createdAt: -1 }).exec();
+  }
+
+  async deleteByEmail(email: string) {
+    await this.model.deleteMany({ email }).exec();
+  }
+}
+`.trim();
+  }
+
+  await createFile({
+    path: `${paths.persistence}/otp.repository.ts`,
+    contente: otpRepoContent,
+  });
+
   // --- 6. INFRASTRUCTURE WEB (CONTROLLER, GUARD, STRATEGY) ---
 
   await createFile({
@@ -788,25 +1094,30 @@ export class JwtAuthGuard extends AuthGuard('jwt') {
   let dbProviders = "";
   if (dbConfig.orm === "typeorm") {
     dbImports =
-      "import { TypeOrmModule } from '@nestjs/typeorm';\nimport { Session as SessionEntity } from 'src/entities/Session.entity';";
-    dbProviders = "TypeOrmModule.forFeature([SessionEntity]),";
+      "import { TypeOrmModule } from '@nestjs/typeorm';\nimport { Session as SessionEntity } from 'src/entities/Session.entity';\nimport { PasswordReset as PasswordResetEntity } from 'src/entities/PasswordReset.entity';\nimport { Otp as OtpEntity } from 'src/entities/Otp.entity';";
+    dbProviders = "TypeOrmModule.forFeature([SessionEntity, PasswordResetEntity, OtpEntity]),";
   } else if (dbConfig.orm === "mongoose") {
     const schemaRelativePath = isFull
       ? "./infrastructure/persistence/mongoose/session.schema"
       : "./persistence/session.schema";
 
     dbImports = `import { MongooseModule } from '@nestjs/mongoose';
-import { Session, SessionSchema } from '${schemaRelativePath}';`;
-
-    dbProviders = `MongooseModule.forFeature([{ name: Session.name, schema: SessionSchema }]),`;
+import { Session, SessionSchema } from '${schemaRelativePath}';
+import { PasswordReset, PasswordResetSchema } from '${schemaRelativePath.replace("session.schema", "password-reset.schema")}';
+import { Otp, OtpSchema } from '${schemaRelativePath.replace("session.schema", "otp.schema")}';`;
+
+    dbProviders = `MongooseModule.forFeature([
+      { name: Session.name, schema: SessionSchema },
+      { name: PasswordReset.name, schema: PasswordResetSchema },
+      { name: Otp.name, schema: OtpSchema }
+    ]),`;
   } else if (dbConfig.orm === "prisma") {
     dbImports = "import { PrismaModule } from 'src/prisma/prisma.module';";
     dbProviders = "PrismaModule,";
   }
 
   if (inputs.mode == "full") {
-    dbImports =
-      +"import { ISessionRepositoryName } from '${paths.interfaces}/session.repository.interface';";
+    dbImports += `\nimport { ISessionRepositoryName } from '${paths.interfaces}/session.repository.interface';`;
   }
 
   await createFile({
@@ -823,6 +1134,8 @@ import { SessionService } from '${paths.services}/session.service';
 import { AuthController } from '${paths.controllers}/auth.controller';
 import { JwtStrategy } from '${paths.strategies}/jwt.strategy';
 import { SessionRepository } from '${paths.persistence}/session.repository';
+import { PasswordResetRepository } from '${paths.persistence}/password-reset.repository';
+import { OtpRepository } from '${paths.persistence}/otp.repository';
 
 @Module({
   imports: [
@@ -843,12 +1156,13 @@ import { SessionRepository } from '${paths.persistence}/session.repository';
     AuthService,
     SessionService,
     JwtStrategy,
+    PasswordResetRepository,
+    OtpRepository,
     ${
       isFull
         ? "{ provide: ISessionRepositoryName, useClass: SessionRepository }"
         : "SessionRepository"
     }
-
   ],
   exports: [AuthService, SessionService],
 })
@@ -901,6 +1215,7 @@ export class AuthModule {}`.trim(),
       name: "resetPassword",
       fields: [
         { name: "email", type: "string", swaggerExample: "user@example.com" },
+        { name: "token", type: "string", swaggerExample: "uuid-reset-token" },
         {
           name: "newPassword",
           type: "string",

package/utils/setups/setupDatabase.js

@@ -7,8 +7,11 @@ const { setupPrisma } = require("./setupPrisma");
 async function setupDatabase(inputs) {
   logInfo("🚀 Configuring the database...");
 
+  const pkgManager = inputs.packageManager || "npm";
+  const installCmd = pkgManager === "yarn" || pkgManager === "pnpm" ? `${pkgManager} add` : "npm install";
+
   await runCommand(
-    "npm install dotenv",
+    `${installCmd} dotenv`,
     "Error installing dotenv automatically, please run it manually now",
     { critical: false },
   );

package/utils/setups/setupHealth.js

@@ -0,0 +1,74 @@
+// utils/setups/setupHealth.js
+//
+// Script d'initialisation du Health Check.
+// Crée HealthController et HealthModule dans src/health
+// et met à jour app.module.ts de manière sécurisée et idempotente.
+
+const { createDirectory, createFile } = require("../userInput");
+const { safeUpdateAppModule } = require("../app-module.updater");
+const { logInfo } = require("../loggers/logInfo");
+const { logSuccess } = require("../loggers/logSuccess");
+
+/**
+ * Configure un module de Health Check natif sur la route /health.
+ */
+async function setupHealth() {
+  logInfo("Génération du module Health Check (/health)...");
+
+  const isDryRun = process.argv.includes("--dry-run");
+  if (isDryRun) {
+    console.log("[DRY-RUN] Simulated: create src/health directory, files and register in app.module.ts");
+    logSuccess(" Module Health Check configuré avec succès !");
+    return;
+  }
+
+  // 1. Créer le dossier src/health
+  await createDirectory("src/health");
+
+  // 2. Créer health.controller.ts
+  const controllerContent = `import { Controller, Get } from '@nestjs/common';
+import { ApiTags, ApiOperation, ApiResponse } from '@nestjs/swagger';
+
+@ApiTags('Health')
+@Controller('health')
+export class HealthController {
+  @Get()
+  @ApiOperation({ summary: 'Check application health status' })
+  @ApiResponse({ status: 200, description: 'Application is healthy and running.' })
+  check() {
+    return {
+      status: 'ok',
+      timestamp: new Date().toISOString(),
+      uptime: process.uptime(),
+    };
+  }
+}
+`;
+
+  await createFile({
+    path: "src/health/health.controller.ts",
+    contente: controllerContent,
+  });
+
+  // 3. Créer health.module.ts
+  const moduleContent = `import { Module } from '@nestjs/common';
+import { HealthController } from './health.controller';
+
+@Module({
+  controllers: [HealthController],
+})
+export class HealthModule {}
+`;
+
+  await createFile({
+    path: "src/health/health.module.ts",
+    contente: moduleContent,
+  });
+
+  // 4. Mettre à jour app.module.ts
+  await safeUpdateAppModule("health");
+
+  logSuccess(" Module Health Check configuré avec succès !");
+}
+
+module.exports = { setupHealth };