fix: update config and import

backend/.env.example

@@ -3,4 +3,5 @@ DB_PORT=5432
 DB_USER='pbl6_jw8s_user'
 DB_PASSWORD=''
 DB_NAME='pbl6_jw8s'
-JWT_KEY = ''
+JWT_KEY= ''
+DB_SSL_ENABLED=true # default is true to connect with remote database

backend/src/app.module.ts

@@ -9,10 +9,7 @@ import { AppLoggerMiddleware } from './common/middlewares/app-logger.middleware.
 import { DeviceInfoMiddleware } from './common/middlewares/device-info.middleware.js';
 import { UserModule } from './modules/user/user.module.js';
 import { BranchModule } from './modules/branch/branch.module.js';
-import { AuthenticationModule } from './modules/authentication/authentication.module';
-import {AccessControlModule, ACGuard} from 'nest-access-control'
-import { APP_GUARD } from '@nestjs/core';
-
+import { AuthenticationModule } from './modules/authentication/authentication.module.js';
 @Module({
   imports: [
     ConfigModule.forRoot({

backend/src/config/config.ts

@@ -7,5 +7,6 @@ export const configuration = () => {
     'db.password': process.env.DB_PASSWORD,
     'db.name': process.env.DB_NAME,
     'db.slow_limit': Number(process.env.DB_SLOW_LIMIT) || 500, // ms
+    'db.ssl_enabled': process.env.DB_SSL_ENABLED,
   };
 };

backend/src/config/database.ts

@@ -13,6 +13,7 @@ export class DatabaseConfigService implements TypeOrmOptionsFactory {
   constructor(private readonly configService: ConfigService) {}
 
   createTypeOrmOptions(): TypeOrmModuleOptions {
+    const isSslEnabled = this.configService.get('db.ssl_enabled') !== 'false';
     return {
       type: 'postgres',
       host: this.configService.get('db.host'),
@@ -21,9 +22,11 @@ export class DatabaseConfigService implements TypeOrmOptionsFactory {
       database: this.configService.get('db.name'),
       password: this.configService.get('db.password'),
       entities: [path.join(__dirname, '../**/*.entity{.ts,.js}')],
-      ssl: {
-        rejectUnauthorized: false,
-      },
+      ssl: isSslEnabled
+        ? {
+            rejectUnauthorized: false,
+          }
+        : false,
       maxQueryExecutionTime: this.configService.get('db.slow_limit'),
     };
   }

backend/src/config/typeorm.ts

@@ -9,6 +9,8 @@ const __dirname = path.dirname(__filename);
 
 const migrationsPath = 'src/migrations/*.ts';
 
+const isSslEnabled = process.env.DB_SSL_ENABLED !== 'false';
+
 export default new DataSource({
   type: 'postgres',
   host: process.env.DB_HOST,
@@ -17,8 +19,10 @@ export default new DataSource({
   username: process.env.DB_USER,
   password: process.env.DB_PASSWORD,
   entities: [path.join(__dirname, '../**/*.entity{.ts,.js}')],
-  ssl: {
-    rejectUnauthorized: false,
-  },
+  ssl: isSslEnabled
+    ? {
+        rejectUnauthorized: false,
+      }
+    : false,
   migrations: [migrationsPath],
 });

backend/src/modules/authentication/authentication.controller.spec.ts

@@ -1,20 +0,0 @@
-import { Test, TestingModule } from '@nestjs/testing';
-import { AuthenticationController } from './authentication.controller';
-import { AuthenticationService } from './authentication.service';
-
-describe('AuthenticationController', () => {
-  let controller: AuthenticationController;
-
-  beforeEach(async () => {
-    const module: TestingModule = await Test.createTestingModule({
-      controllers: [AuthenticationController],
-      providers: [AuthenticationService],
-    }).compile();
-
-    controller = module.get<AuthenticationController>(AuthenticationController);
-  });
-
-  it('should be defined', () => {
-    expect(controller).toBeDefined();
-  });
-});

backend/src/modules/authentication/authentication.controller.ts

@@ -1,4 +1,3 @@
-
 import {
   Body,
   Controller,
@@ -7,11 +6,10 @@ import {
   HttpStatus,
   Post,
   Request,
-  UseGuards
 } from '@nestjs/common';
-import { AuthenticationGuard } from './authentication.guard';
-import { AuthenticationService } from './authentication.service';
-import { Public } from './authentication.decorator';
+import { AuthenticationService } from './authentication.service.js';
+import { Public } from './authentication.decorator.js';
+
 @Controller('authentication')
 export class AuthenticationController {
   constructor(private AuthenticationService: AuthenticationService) {}
@@ -20,7 +18,10 @@ export class AuthenticationController {
   @HttpCode(HttpStatus.OK)
   @Post('login')
   signIn(@Body() signInDto: Record<string, any>) {
-    return this.AuthenticationService.signIn(signInDto.username, signInDto.password);
+    return this.AuthenticationService.signIn(
+      signInDto.username,
+      signInDto.password,
+    );
   }
 
   // @UseGuards(AuthenticationGuard)

backend/src/modules/authentication/authentication.guard.ts

@@ -1,49 +1,51 @@
-
 import {
-    CanActivate,
-    ExecutionContext,
-    Injectable,
-    UnauthorizedException,
-  } from '@nestjs/common';
-  import { JwtService } from '@nestjs/jwt';
-  import { jwtConstants } from './constants';
-  import { Request } from 'express';
-  import { Reflector } from '@nestjs/core';
-  import { IS_PUBLIC_KEY } from './authentication.decorator';
-  @Injectable()
-  export class AuthenticationGuard implements CanActivate {
-    constructor(private jwtService: JwtService, private reflector: Reflector) {}
-  
-    async canActivate(context: ExecutionContext): Promise<boolean> {
-      const isPublic = this.reflector.getAllAndOverride<boolean>(IS_PUBLIC_KEY, [
-        context.getHandler(),
-        context.getClass(),
-      ]);
-      if (isPublic) {
-        // 💡 See this condition
-        return true;
-      }
-  
-      const request = context.switchToHttp().getRequest();
-      const token = this.extractTokenFromHeader(request);
-      if (!token) {
-        throw new UnauthorizedException();
-      }
-      try {
-        const payload = await this.jwtService.verifyAsync(token, {
-          secret: jwtConstants.secret,
-        });
-        // 💡 We're assigning the payload to the request object here
-        // so that we can access it in our route handlers
-        request['user'] = payload;
-      } catch {
-        throw new UnauthorizedException();
-      }
+  CanActivate,
+  ExecutionContext,
+  Injectable,
+  UnauthorizedException,
+} from '@nestjs/common';
+import { JwtService } from '@nestjs/jwt';
+import { jwtConstants } from './constants.js';
+import { Request } from 'express';
+import { Reflector } from '@nestjs/core';
+import { IS_PUBLIC_KEY } from './authentication.decorator.js';
+@Injectable()
+export class AuthenticationGuard implements CanActivate {
+  constructor(
+    private jwtService: JwtService,
+    private reflector: Reflector,
+  ) {}
+
+  async canActivate(context: ExecutionContext): Promise<boolean> {
+    const isPublic = this.reflector.getAllAndOverride<boolean>(IS_PUBLIC_KEY, [
+      context.getHandler(),
+      context.getClass(),
+    ]);
+    if (isPublic) {
+      // 💡 See this condition
       return true;
     }
-  
-    private extractTokenFromHeader(request: Request): string | undefined {
-      const [type, token] = request.headers.authorization?.split(' ') ?? [];
-      return type === 'Bearer' ? token : undefined;
+
+    const request = context.switchToHttp().getRequest();
+    const token = this.extractTokenFromHeader(request);
+    if (!token) {
+      throw new UnauthorizedException();
     }
-  }
+    try {
+      const payload = await this.jwtService.verifyAsync(token, {
+        secret: jwtConstants.secret,
+      });
+      // 💡 We're assigning the payload to the request object here
+      // so that we can access it in our route handlers
+      request['user'] = payload;
+    } catch {
+      throw new UnauthorizedException();
+    }
+    return true;
+  }
+
+  private extractTokenFromHeader(request: Request): string | undefined {
+    const [type, token] = request.headers.authorization?.split(' ') ?? [];
+    return type === 'Bearer' ? token : undefined;
+  }
+}

backend/src/modules/authentication/authentication.module.ts

@@ -1,11 +1,10 @@
-
 import { Module } from '@nestjs/common';
-import { AuthenticationService } from './authentication.service';
-import { UserModule } from '../user/user.module';
+import { AuthenticationService } from './authentication.service.js';
+import { UserModule } from '../user/user.module.js';
 import { JwtModule } from '@nestjs/jwt';
-import { AuthenticationController } from './authentication.controller';
-import { jwtConstants } from './constants';
-import { AuthenticationGuard } from './authentication.guard';
+import { AuthenticationController } from './authentication.controller.js';
+import { jwtConstants } from './constants.js';
+import { AuthenticationGuard } from './authentication.guard.js';
 import { APP_GUARD } from '@nestjs/core';
 @Module({
   imports: [
@@ -21,7 +20,7 @@ import { APP_GUARD } from '@nestjs/core';
     {
       provide: APP_GUARD,
       useClass: AuthenticationGuard,
-    }
+    },
   ],
   controllers: [AuthenticationController],
   exports: [AuthenticationService],

backend/src/modules/authentication/authentication.service.spec.ts

@@ -1,18 +0,0 @@
-import { Test, TestingModule } from '@nestjs/testing';
-import { AuthenticationService } from './authentication.service';
-
-describe('AuthenticationService', () => {
-  let service: AuthenticationService;
-
-  beforeEach(async () => {
-    const module: TestingModule = await Test.createTestingModule({
-      providers: [AuthenticationService],
-    }).compile();
-
-    service = module.get<AuthenticationService>(AuthenticationService);
-  });
-
-  it('should be defined', () => {
-    expect(service).toBeDefined();
-  });
-});

backend/src/modules/authentication/authentication.service.ts

@@ -1,23 +1,23 @@
-
 import { Injectable, UnauthorizedException } from '@nestjs/common';
-import { UserService } from '../user/user.service';
+import { UserService } from '../user/user.service.js';
 import * as bcrypt from 'bcrypt';
 import { JwtService } from '@nestjs/jwt';
 @Injectable()
 export class AuthenticationService {
   constructor(
     private usersService: UserService,
-    private jwtService: JwtService
+    private jwtService: JwtService,
   ) {}
 
-  async signIn(username: string, pass: string): Promise<{access_token: string}> {
+  async signIn(
+    username: string,
+    pass: string,
+  ): Promise<{ access_token: string }> {
     const user = await this.usersService.findOne(username);
-    if (!user || await !bcrypt.compare(pass, user.hash_password)) {
+    if (!user || (await !bcrypt.compare(pass, user.hash_password))) {
       throw new UnauthorizedException();
     }
     const payload = { sub: user.id, username: user.id };
-    // TODO: Generate a JWT and return it here
-    // instead of the user object
     return {
       access_token: await this.jwtService.signAsync(payload),
     };

backend/src/modules/user/user.controller.ts

@@ -1,13 +1,15 @@
 import { Controller, Get, Param } from '@nestjs/common';
-import { UserService } from './user.service';
-import { UserEntity } from 'src/entities/user.entity';
+import { UserService } from './user.service.js';
+import { UserEntity } from 'src/entities/user.entity.js';
 
 @Controller('users')
 export class UsersController {
   constructor(private readonly usersService: UserService) {}
 
   @Get(':username')
-  async getUser(@Param('username') username: string): Promise<UserEntity | undefined> {
+  async getUser(
+    @Param('username') username: string,
+  ): Promise<UserEntity | undefined> {
     return this.usersService.findOne(username);
   }
 }

backend/src/modules/user/user.module.ts

@@ -1,5 +1,5 @@
 import { Module } from '@nestjs/common';
-import { UserService } from './user.service';
+import { UserService } from './user.service.js';
 
 @Module({
   providers: [UserService],

backend/src/modules/user/user.service.ts

@@ -1,18 +1,15 @@
 import { Injectable } from '@nestjs/common';
 import { InjectRepository } from '@nestjs/typeorm';
 import { Repository } from 'typeorm';
-import { UserEntity } from 'src/entities/user.entity'
-// This should be a real class/interface representing a user entity
+import { UserEntity } from '../../entities/user.entity.js';
+
 export type User = any;
 
 @Injectable()
 export class UserService {
-  constructor(
-    @InjectRepository(UserEntity)
-    private usersRepository: Repository<UserEntity>,
-  ) {}
+  constructor() {}
 
   async findOne(username: string): Promise<UserEntity | undefined> {
-    return this.usersRepository.findOne({ where: { id: username } });
+    return UserEntity.findOne({ where: { id: username } });
   }
 }