[TM-1311] Implement password reset

apps/user-service/src/app.module.ts

@@ -7,16 +7,30 @@ import { CommonModule } from "@terramatch-microservices/common";
 import { HealthModule } from "./health/health.module";
 import { SentryGlobalFilter, SentryModule } from "@sentry/nestjs/setup";
 import { APP_FILTER } from "@nestjs/core";
+import { EmailModule } from "./email/email.module";
+import { ResetPasswordController } from "./auth/reset-password.controller";
+import { ResetPasswordService } from "./auth/reset-password.service";
+import { ConfigModule } from "@nestjs/config";
 
 @Module({
-  imports: [SentryModule.forRoot(), DatabaseModule, CommonModule, HealthModule],
-  controllers: [LoginController, UsersController],
+  imports: [
+    SentryModule.forRoot(),
+    DatabaseModule,
+    CommonModule,
+    HealthModule,
+    ConfigModule.forRoot({
+      isGlobal: true,
+    }),
+    EmailModule
+  ],
+  controllers: [LoginController, UsersController, ResetPasswordController],
   providers: [
     {
       provide: APP_FILTER,
       useClass: SentryGlobalFilter
     },
-    AuthService
+    AuthService,
+    ResetPasswordService,
   ]
 })
 export class AppModule {}

apps/user-service/src/auth/dto/reset-password-request.dto.ts

@@ -0,0 +1,14 @@
+import { ApiProperty } from "@nestjs/swagger";
+import { JsonApiDto } from "@terramatch-microservices/common/decorators";
+import { JsonApiAttributes } from "@terramatch-microservices/common/dto/json-api-attributes";
+
+
+@JsonApiDto({ type: 'logins', id: 'number' })
+export class RequestResetPasswordDto extends JsonApiAttributes<RequestResetPasswordDto> {
+  @ApiProperty({
+    description:
+      'User email',
+    example: '[email protected]',
+  })
+  emailAddress: string;
+}

apps/user-service/src/auth/dto/reset-password-response-operation.dto.ts

@@ -0,0 +1,13 @@
+import { JsonApiDto } from "@terramatch-microservices/common/decorators";
+import { JsonApiAttributes } from "@terramatch-microservices/common/dto/json-api-attributes";
+import { ApiProperty } from "@nestjs/swagger";
+
+@JsonApiDto({ type: 'logins', id: 'number' })
+export class ResetPasswordResponseOperationDto extends JsonApiAttributes<ResetPasswordResponseOperationDto> {
+  @ApiProperty({
+    description:
+      'User email',
+    example: '[email protected]',
+  })
+  message: string;
+}

apps/user-service/src/auth/dto/reset-password-response.dto.ts

@@ -0,0 +1,25 @@
+import { ApiProperty } from "@nestjs/swagger";
+import { JsonApiDto } from "@terramatch-microservices/common/decorators";
+import { JsonApiAttributes } from "@terramatch-microservices/common/dto/json-api-attributes";
+
+@JsonApiDto({ type: 'logins', id: 'number' })
+export class ResetPasswordResponseDto extends JsonApiAttributes<ResetPasswordResponseDto> {
+  @ApiProperty({
+    description: 'User id',
+    example: 'ac905c37-025c-4548-9851-f749ed15b5e1'
+  })
+  uuid: string;
+
+  @ApiProperty({
+    description:
+      'User email',
+    example: '[email protected]',
+  })
+  emailAddress: string;
+
+  @ApiProperty({
+    description: 'User Id',
+    example: '12345',
+  })
+  userId: number;
+}

apps/user-service/src/auth/dto/reset-password.dto.ts

@@ -0,0 +1,3 @@
+export class ResetPasswordDto {
+  newPassword: string;
+}

apps/user-service/src/auth/reset-password.controller.ts

@@ -0,0 +1,55 @@
+import {
+  Controller,
+  Body,
+  Post,
+  HttpStatus,
+  BadRequestException,
+  Param,
+} from '@nestjs/common';
+import { ResetPasswordService } from './reset-password.service';
+import { ApiOperation } from '@nestjs/swagger';
+import { JsonApiResponse } from '@terramatch-microservices/common/decorators';
+import { buildJsonApi, JsonApiDocument } from '@terramatch-microservices/common/util';
+import { ApiException } from '@nanogiants/nestjs-swagger-api-exception-decorator';
+import { RequestResetPasswordDto } from './dto/reset-password-request.dto';
+import { ResetPasswordDto } from './dto/reset-password.dto';
+import { NoBearerAuth } from '@terramatch-microservices/common/guards';
+import { ResetPasswordResponseOperationDto } from "./dto/reset-password-response-operation.dto";
+
+@Controller('auth/v3/reset-password')
+export class ResetPasswordController {
+  constructor(private readonly resetPasswordService: ResetPasswordService) {}
+
+  @Post('request')
+  @NoBearerAuth
+  @ApiOperation({
+    operationId: 'requestPasswordReset',
+    description: 'Send password reset email with a token',
+  })
+  @JsonApiResponse({ status: HttpStatus.CREATED, data: { type: RequestResetPasswordDto } })
+  @ApiException(() => BadRequestException, { description: 'Invalid request or email.' })
+  async requestReset(@Body() { emailAddress }: RequestResetPasswordDto): Promise<JsonApiDocument> {
+    const response = await this.resetPasswordService.sendResetPasswordEmail(emailAddress);
+    return buildJsonApi()
+      .addData(`${response.userId}`, response)
+      .document.serialize();
+  }
+
+  @Post('reset/:token')
+  @NoBearerAuth
+  @ApiOperation({
+    operationId: 'resetPassword',
+    description: 'Reset password using the provided token',
+  })
+  @JsonApiResponse({ status: HttpStatus.OK, data: { type: ResetPasswordResponseOperationDto } })
+  @ApiException(() => BadRequestException, { description: 'Invalid or expired token.' })
+  async resetPassword(
+    @Param('token') token: string,
+    @Body() { newPassword }: ResetPasswordDto
+  ): Promise<JsonApiDocument> {
+    const response = await this.resetPasswordService.resetPassword(token, newPassword);
+    return buildJsonApi()
+      .addData('sads',response)
+      .document.serialize();
+  }
+}

apps/user-service/src/auth/reset-password.service.ts

@@ -0,0 +1,72 @@
+import { Injectable, NotFoundException, BadRequestException } from '@nestjs/common';
+import bcrypt from 'bcryptjs';
+import { JwtService } from '@nestjs/jwt';
+import { User, LocalizationKeys } from '@terramatch-microservices/database/entities';
+import { ResetPasswordDto } from './dto/reset-password.dto';
+import { RequestResetPasswordDto } from './dto/reset-password-request.dto';
+import { ResetPasswordResponseDto } from './dto/reset-password-response.dto';
+import { EmailService } from '../email/email.service';
+import {ConfigService} from "@nestjs/config";
+import { ResetPasswordResponseOperationDto } from "./dto/reset-password-response-operation.dto";
+
+@Injectable()
+export class ResetPasswordService {
+  constructor(
+    private readonly jwtService: JwtService,
+    private readonly emailService: EmailService,
+    private readonly configService: ConfigService,
+    //private readonly userService: UserService  // Assuming you have a User service to interact with the database
+  ) {}
+
+  async sendResetPasswordEmail(emailAddress: string) {
+    const user = await User.findOne({ where: { emailAddress } });
+    if (!user) {
+      throw new NotFoundException('User not found');
+    }
+
+    const resetToken = await this.jwtService.signAsync(
+      { sub: user.uuid }, // user id as the subject
+      { expiresIn: '1h', secret: 'reset_password_secret' } // token expires in 1 hour
+    );
+
+    const localizationKeys = await LocalizationKeys.findOne({where: { key: 'reset-password.body'}});
+
+    if (!localizationKeys) {
+      throw new NotFoundException('Localization body not found');
+    }
+    const url = this.configService.get('TERRAMATCH_WEBSITE_URL');
+    const resetLink =  `${url}/auth/reset-password/${resetToken}`;
+    const bodyEmail = localizationKeys.value.replace('link', `<a href="${resetLink}">link</a>`);
+    await this.emailService.sendEmail(
+      user.emailAddress,
+      'Reset Password',
+      bodyEmail,
+    );
+
+    return  new ResetPasswordResponseDto({emailAddress: user.emailAddress, uuid: user.uuid, userId: user.id});
+  }
+
+  async resetPassword(resetToken: string, newPassword: string) {
+    console.log(" token: ", resetToken)
+    let userId;
+    try {
+      const payload = await this.jwtService.verifyAsync(resetToken, {
+        secret: 'reset_password_secret',
+      });
+      userId = payload.sub;
+    } catch (error) {
+      console.log(error)
+      throw new BadRequestException('Invalid or provide token is expired');
+    }
+
+    const user = await User.findOne({ where: { id: userId } });
+    if (!user) {
+      throw new NotFoundException('User not found');
+    }
+
+    const hashedPassword = await bcrypt.hash(newPassword, 10);
+    await User.update({ password: hashedPassword }, { where: { id: userId } });
+
+    return new ResetPasswordResponseOperationDto({ message: 'Password successfully reset' });
+  }
+}

apps/user-service/src/email/email.module.ts

@@ -0,0 +1,10 @@
+import { Module } from '@nestjs/common';
+import { ConfigModule } from '@nestjs/config';
+import { EmailService } from './email.service';
+
+@Module({
+  imports: [ConfigModule],
+  providers: [EmailService],
+  exports: [EmailService],
+})
+export class EmailModule {}

apps/user-service/src/email/email.service.ts

@@ -0,0 +1,31 @@
+import { Injectable } from '@nestjs/common';
+import * as nodemailer from 'nodemailer';
+import { ConfigService } from '@nestjs/config';
+
+@Injectable()
+export class EmailService {
+  private transporter: nodemailer.Transporter;
+
+  constructor(private readonly configService: ConfigService) {
+    this.transporter = nodemailer.createTransport({
+      host: this.configService.get<string>('MAIL_HOST'),
+      port: this.configService.get<number>('MAIL_PORT'),
+      secure: false, // true for 465, false for other ports
+      auth: {
+        user: this.configService.get<string>('MAIL_USERNAME'),
+        pass: this.configService.get<string>('MAIL_PASSWORD'),
+      },
+    });
+  }
+
+  async sendEmail(to: string, subject: string, body: string): Promise<void> {
+    const mailOptions = {
+      from: this.configService.get<string>('MAIL_FROM_ADDRESS'),
+      to,
+      subject,
+      html: body,
+    };
+
+    await this.transporter.sendMail(mailOptions);
+  }
+}

libs/common/src/lib/dto/json-api-attributes.ts

@@ -58,14 +58,16 @@ export function pickApiProperties<Source, DTO>(source: Source, dtoClass: Type<DT
   return pick(source, fields) as Common<Source | DTO>;
 }
 
+export type JsonApiAttributesInput<DTO> = Omit<DTO, "type">;
+
 /**
  * A simple class to make it easy to create a typed attributes DTO with new()
  *
  * See users.controller.ts findOne and user.dto.ts for a complex example.
  * See auth.controller.ts login for a simple example.
  */
 export class JsonApiAttributes<DTO> {
-  constructor(source: Omit<DTO, "type">) {
+  constructor(source: JsonApiAttributesInput<DTO>) {
     Object.assign(this, pickApiProperties(source, this.constructor as Type<DTO>));
   }
 }

libs/database/src/lib/entities/index.ts

@@ -29,3 +29,4 @@ export * from "./tree-species.entity";
 export * from "./tree-species-research.entity";
 export * from "./user.entity";
 export * from "./workday.entity";
+export * from "./localization-keys.entity";

libs/database/src/lib/entities/localization-keys.entity.ts

@@ -0,0 +1,35 @@
+import {
+  AllowNull,
+  AutoIncrement,
+  Column,
+  Model,
+  PrimaryKey,
+  Table,
+  Unique
+} from "sequelize-typescript";
+import { BIGINT, NUMBER, STRING } from "sequelize";
+
+
+
+@Table({ tableName: "localization_keys", underscored: true, paranoid: false })
+export class LocalizationKeys extends Model<LocalizationKeys> {
+
+  @PrimaryKey
+  @AutoIncrement
+  @Column(BIGINT.UNSIGNED)
+  override id: number;
+
+  @AllowNull
+  @Column(STRING)
+  key: string | null;
+
+  @AllowNull
+  @Column(STRING)
+  value: string | null;
+
+  @AllowNull
+  @Unique
+  @Column(NUMBER)
+  valueId: number;
+
+}

package.json

@@ -35,6 +35,7 @@
     "mariadb": "^3.3.2",
     "mysql2": "^3.11.2",
     "nestjs-request-context": "^3.0.0",
+    "nodemailer": "^6.9.16",
     "reflect-metadata": "^0.1.14",
     "rxjs": "^7.8.0",
     "sequelize": "^6.37.3",