biome autofix

Author: gugu

autoadmin-ws-server/src/constants/constants.js

@@ -19,7 +19,7 @@ export const CONSTANTS = Object.freeze({
 
   RES_CACHE_OPTIONS: {
     max: 5000,
-    dispose: function(key, n) {
+    dispose: (_key, n) => {
       n?.send('Connection was closed by timeout');
     },
     maxAge: 600000,

autoadmin-ws-server/src/index.js

@@ -3,12 +3,12 @@ import axios from 'axios';
 const app = express();
 import { createServer } from 'http';
 const httpServer = createServer(app);
-const wsServer = createServer((req, res) => {
+const wsServer = createServer((_req, res) => {
   res.writeHead(200);
   res.end();
 });
 import WebSocket, { WebSocketServer } from 'ws';
-const router = Router();
+const _router = Router();
 import commandRoute from './routes/command.js';
 import {
   getCacheWsConnection,
@@ -29,7 +29,7 @@ const tokenCacheResult = new LRUCache(CONSTANTS.TOKEN_RESULT_CACHE_OPTIONS);
 
 app.use(json());
 
-app.get('/', (req, res) => {
+app.get('/', (_req, res) => {
   res.json({ status: CONSTANTS.API_IS_RUNNING });
 });
 
@@ -42,7 +42,7 @@ wsServer.listen(wsPort, () => {
 const ws = new WebSocketServer({ server: wsServer });
 
 ws.on('connection', (connection, req) => {
-  const ip = req.socket.remoteAddress;
+  const _ip = req.socket.remoteAddress;
   // console.log(`Connected ${ip}`);
 
   connection.on('message', async (message) => {

backend/src/app.module.ts

@@ -1,7 +1,6 @@
 import { MiddlewareConsumer, Module, NestModule } from '@nestjs/common';
 import { APP_GUARD, APP_INTERCEPTOR } from '@nestjs/core';
 import { ScheduleModule } from '@nestjs/schedule';
-import { DataSource } from 'typeorm';
 import { AppController } from './app.controller.js';
 import { GlobalDatabaseContext } from './common/application/global-database-context.js';
 import { BaseType, UseCaseType } from './common/data-injection.tokens.js';
@@ -107,7 +106,6 @@ import { SignInAuditModule } from './entities/user-sign-in-audit/sign-in-audit.m
   ],
 })
 export class ApplicationModule implements NestModule {
-  constructor(private dataSource: DataSource) {}
   configure(consumer: MiddlewareConsumer): void {
     consumer.apply(AppLoggerMiddleware).forRoutes('*');
   }

backend/src/authorization/auth-with-api.middleware.ts

@@ -27,7 +27,7 @@ export class AuthWithApiMiddleware implements NestMiddleware {
     private readonly userRepository: Repository<UserEntity>,
   ) {}
 
-  async use(req: Request, res: Response, next: (err?: any, res?: any) => void): Promise<void> {
+  async use(req: Request, _res: Response, next: (err?: any, res?: any) => void): Promise<void> {
     try {
       await this.authenticateRequest(req);
       next();
@@ -61,11 +61,11 @@ export class AuthWithApiMiddleware implements NestMiddleware {
     try {
       const jwtSecret = process.env.JWT_SECRET;
       const data = jwt.verify(tokenFromCookie, jwtSecret);
-      const userId = data['id'];
+      const userId = data.id;
       if (!userId) {
         throw new UnauthorizedException('JWT verification failed');
       }
-      const addedScope: Array<JwtScopesEnum> = data['scope'];
+      const addedScope: Array<JwtScopesEnum> = data.scope;
       if (addedScope && addedScope.length > 0) {
         if (addedScope.includes(JwtScopesEnum.TWO_FA_ENABLE)) {
           throw new BadRequestException(Messages.TWO_FA_REQUIRED);
@@ -74,14 +74,14 @@ export class AuthWithApiMiddleware implements NestMiddleware {
 
       const payload = {
         sub: userId,
-        email: data['email'],
-        exp: data['exp'],
-        iat: data['iat'],
+        email: data.email,
+        exp: data.exp,
+        iat: data.iat,
       };
       if (!payload || isObjectEmpty(payload)) {
         throw new UnauthorizedException('JWT verification failed');
       }
-      req['decoded'] = payload;
+      req.decoded = payload;
     } catch (error) {
       Sentry.captureException(error);
       throw error;
@@ -106,7 +106,7 @@ export class AuthWithApiMiddleware implements NestMiddleware {
     if (!foundUserByApiKey) {
       throw new NotFoundException(Messages.NO_AUTH_KEYS_FOUND);
     }
-    req['decoded'] = {
+    req.decoded = {
       sub: foundUserByApiKey.id,
       email: foundUserByApiKey.email,
     };

backend/src/authorization/auth.middleware.ts

@@ -21,12 +21,11 @@ import { JwtScopesEnum } from '../entities/user/enums/jwt-scopes.enum.js';
 @Injectable()
 export class AuthMiddleware implements NestMiddleware {
   public constructor(
-    @InjectRepository(UserEntity)
-    private readonly userRepository: Repository<UserEntity>,
+    @InjectRepository(UserEntity)readonly _userRepository: Repository<UserEntity>,
     @InjectRepository(LogOutEntity)
     private readonly logOutRepository: Repository<LogOutEntity>,
   ) {}
-  async use(req: Request, res: Response, next: (err?: any, res?: any) => void): Promise<void> {
+  async use(req: Request, _res: Response, next: (err?: any, res?: any) => void): Promise<void> {
     let token: string;
     try {
       token = req.cookies[Constants.JWT_COOKIE_KEY_NAME];
@@ -48,11 +47,11 @@ export class AuthMiddleware implements NestMiddleware {
     try {
       const jwtSecret = process.env.JWT_SECRET;
       const data = jwt.verify(token, jwtSecret);
-      const userId = data['id'];
+      const userId = data.id;
       if (!userId) {
         throw new UnauthorizedException('JWT verification failed');
       }
-      const addedScope: Array<JwtScopesEnum> = data['scope'];
+      const addedScope: Array<JwtScopesEnum> = data.scope;
       if (addedScope && addedScope.length > 0) {
         if (addedScope.includes(JwtScopesEnum.TWO_FA_ENABLE)) {
           throw new BadRequestException(Messages.TWO_FA_REQUIRED);
@@ -61,14 +60,14 @@ export class AuthMiddleware implements NestMiddleware {
 
       const payload = {
         sub: userId,
-        email: data['email'],
-        exp: data['exp'],
-        iat: data['iat'],
+        email: data.email,
+        exp: data.exp,
+        iat: data.iat,
       };
       if (!payload || isObjectEmpty(payload)) {
         throw new UnauthorizedException('JWT verification failed');
       }
-      req['decoded'] = payload;
+      req.decoded = payload;
       next();
     } catch (e) {
       Sentry.captureException(e);

backend/src/authorization/basic-auth.middleware.ts

@@ -5,7 +5,7 @@ import { Messages } from '../exceptions/text/messages.js';
 
 @Injectable()
 export class BasicAuthMiddleware implements NestMiddleware {
-  use(req: Request, res: Response, next: (err?: any, res?: any) => void): void {
+  use(req: Request, _res: Response, next: (err?: any, res?: any) => void): void {
     const basicAuthLogin = process.env.BASIC_AUTH_LOGIN;
     const basicAuthPassword = process.env.BASIC_AUTH_PWD;
     const userCredentials = auth(req);

backend/src/authorization/non-scoped-auth.middleware.ts

@@ -21,7 +21,7 @@ export class NonScopedAuthMiddleware implements NestMiddleware {
     @InjectRepository(LogOutEntity)
     private readonly logOutRepository: Repository<LogOutEntity>,
   ) {}
-  async use(req: Request, res: Response, next: (err?: any, res?: any) => void): Promise<void> {
+  async use(req: Request, _res: Response, next: (err?: any, res?: any) => void): Promise<void> {
     console.log(`auth middleware triggered ->: ${new Date().toISOString()}`);
     let token: string;
     try {
@@ -44,21 +44,21 @@ export class NonScopedAuthMiddleware implements NestMiddleware {
     try {
       const jwtSecret = process.env.JWT_SECRET;
       const data = jwt.verify(token, jwtSecret);
-      const userId = data['id'];
+      const userId = data.id;
       if (!userId) {
         throw new UnauthorizedException('JWT verification failed');
       }
 
       const payload = {
         sub: userId,
-        email: data['email'],
-        exp: data['exp'],
-        iat: data['iat'],
+        email: data.email,
+        exp: data.exp,
+        iat: data.iat,
       };
       if (!payload || isObjectEmpty(payload)) {
         throw new UnauthorizedException('JWT verification failed');
       }
-      req['decoded'] = payload;
+      req.decoded = payload;
       next();
     } catch (e) {
       Sentry.captureException(e);

backend/src/authorization/saas-auth.middleware.ts

@@ -6,7 +6,7 @@ import { extractTokenFromHeader } from './utils/extract-token-from-header.js';
 
 @Injectable()
 export class SaaSAuthMiddleware implements NestMiddleware {
-  use(req: Request, res: Response, next: (err?: any, res?: any) => void): void {
+  use(req: Request, _res: Response, next: (err?: any, res?: any) => void): void {
     console.log(`saas auth middleware triggered ->: ${new Date().toISOString()}`);
     const token = extractTokenFromHeader(req);
     if (!token) {
@@ -15,13 +15,13 @@ export class SaaSAuthMiddleware implements NestMiddleware {
     try {
       const jwtSecret = process.env.MICROSERVICE_JWT_SECRET;
       const data = jwt.verify(token, jwtSecret);
-      const requestId = data['request_id'];
+      const requestId = data.request_id;
 
       if (!requestId) {
         throw new UnauthorizedException(Messages.AUTHORIZATION_REJECTED);
       }
 
-      req['decoded'] = data;
+      req.decoded = data;
       next();
     } catch (_e) {
       throw new UnauthorizedException(Messages.AUTHORIZATION_REJECTED);

backend/src/authorization/temporary-auth.middleware.ts

@@ -19,12 +19,11 @@ import { Constants } from '../helpers/constants/constants.js';
 @Injectable()
 export class TemporaryAuthMiddleware implements NestMiddleware {
   public constructor(
-    @InjectRepository(UserEntity)
-    private readonly userRepository: Repository<UserEntity>,
+    @InjectRepository(UserEntity)readonly _userRepository: Repository<UserEntity>,
     @InjectRepository(LogOutEntity)
     private readonly logOutRepository: Repository<LogOutEntity>,
   ) {}
-  async use(req: Request, res: Response, next: (err?: any, res?: any) => void): Promise<void> {
+  async use(req: Request, _res: Response, next: (err?: any, res?: any) => void): Promise<void> {
     console.log(`temporary auth middleware triggered ->: ${new Date().toISOString()}`);
     let token: string;
     try {
@@ -47,20 +46,20 @@ export class TemporaryAuthMiddleware implements NestMiddleware {
     try {
       const jwtSecret = process.env.TEMPORARY_JWT_SECRET;
       const data = jwt.verify(token, jwtSecret);
-      const userId = data['id'];
+      const userId = data.id;
       if (!userId) {
         throw new UnauthorizedException('JWT verification failed');
       }
       const payload = {
         sub: userId,
-        email: data['email'],
-        exp: data['exp'],
-        iat: data['iat'],
+        email: data.email,
+        exp: data.exp,
+        iat: data.iat,
       };
       if (!payload || isObjectEmpty(payload)) {
         throw new UnauthorizedException('JWT verification failed');
       }
-      req['decoded'] = payload;
+      req.decoded = payload;
       next();
     } catch (e) {
       Sentry.captureException(e);

backend/src/common/application/global-database-context.ts

@@ -391,11 +391,7 @@ export class GlobalDatabaseContext implements IGlobalDatabaseContext {
 
   public async commitTransaction(): Promise<void> {
     if (!this._queryRunner) return;
-    try {
       await this._queryRunner.commitTransaction();
-    } catch (e) {
-      throw e;
-    }
   }
 
   public async rollbackTransaction(): Promise<void> {