biome autofix (#1478)

* biome autofix

* types fix

* remove unused imports

* frontend tsc

* fix ts type

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

@@ -19,6 +19,7 @@ import jwt from 'jsonwebtoken';
 import Sentry from '@sentry/minimal';
 import { Encryptor } from '../helpers/encryption/encryptor.js';
 import { EncryptionAlgorithmEnum } from '../enums/encryption-algorithm.enum.js';
+import { IRequestWithCognitoInfo } from './cognito-decoded.interface.js';
 
 @Injectable()
 export class AuthWithApiMiddleware implements NestMiddleware {
@@ -27,7 +28,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: IRequestWithCognitoInfo, _res: Response, next: (err?: any, res?: any) => void): Promise<void> {
     try {
       await this.authenticateRequest(req);
       next();
@@ -37,7 +38,7 @@ export class AuthWithApiMiddleware implements NestMiddleware {
     }
   }
 
-  private async authenticateRequest(req: Request): Promise<void> {
+  private async authenticateRequest(req: IRequestWithCognitoInfo): Promise<void> {
     const tokenFromCookie = this.getTokenFromCookie(req);
     if (tokenFromCookie) {
       await this.authenticateWithToken(tokenFromCookie, req);
@@ -57,15 +58,15 @@ export class AuthWithApiMiddleware implements NestMiddleware {
     throw new InternalServerErrorException(Messages.AUTHORIZATION_REJECTED);
   }
 
-  private async authenticateWithToken(tokenFromCookie: string, req: Request): Promise<void> {
+  private async authenticateWithToken(tokenFromCookie: string, req: IRequestWithCognitoInfo): Promise<void> {
     try {
       const jwtSecret = process.env.JWT_SECRET;
-      const data = jwt.verify(tokenFromCookie, jwtSecret);
-      const userId = data['id'];
+      const data = jwt.verify(tokenFromCookie, jwtSecret) as jwt.JwtPayload;
+      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,21 +75,21 @@ 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;
     }
   }
 
-  private async authenticateWithApiKey(req: Request): Promise<void> {
+  private async authenticateWithApiKey(req: IRequestWithCognitoInfo): Promise<void> {
     let apiKey = req.headers?.['x-api-key'];
     if (Array.isArray(apiKey)) {
       apiKey = apiKey[0];
@@ -106,7 +107,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

@@ -7,7 +7,7 @@ import {
   UnauthorizedException,
 } from '@nestjs/common';
 import { InjectRepository } from '@nestjs/typeorm';
-import { Request, Response } from 'express';
+import { Response } from 'express';
 import jwt from 'jsonwebtoken';
 import { Repository } from 'typeorm';
 import { LogOutEntity } from '../entities/log-out/log-out.entity.js';
@@ -17,16 +17,16 @@ import { isObjectEmpty } from '../helpers/index.js';
 import { Constants } from '../helpers/constants/constants.js';
 import Sentry from '@sentry/minimal';
 import { JwtScopesEnum } from '../entities/user/enums/jwt-scopes.enum.js';
+import { IRequestWithCognitoInfo } from './cognito-decoded.interface.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: IRequestWithCognitoInfo, _res: Response, next: (err?: any, res?: any) => void): Promise<void> {
     let token: string;
     try {
       token = req.cookies[Constants.JWT_COOKIE_KEY_NAME];
@@ -47,12 +47,12 @@ export class AuthMiddleware implements NestMiddleware {
 
     try {
       const jwtSecret = process.env.JWT_SECRET;
-      const data = jwt.verify(token, jwtSecret);
-      const userId = data['id'];
+      const data = jwt.verify(token, jwtSecret) as jwt.JwtPayload;
+      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 +61,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/cognito-decoded.interface.ts

@@ -1,7 +1,8 @@
+import type { Request } from 'express';
 export interface ICognitoDecodedData {
   at_hash: string;
   sub: string;
-  aud: string;
+  aud: string | string[];
   email_verified: boolean;
   event_id: string;
   token_use: string;
@@ -15,6 +16,6 @@ export interface ICognitoDecodedData {
 
 export interface IRequestWithCognitoInfo extends Request {
   query: any;
-  decoded: ICognitoDecodedData;
+  decoded: Partial<ICognitoDecodedData>;
   params: any;
 }

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

@@ -6,22 +6,23 @@ import {
   UnauthorizedException,
 } from '@nestjs/common';
 import { InjectRepository } from '@nestjs/typeorm';
-import { Request, Response } from 'express';
+import { Response } from 'express';
 import jwt from 'jsonwebtoken';
 import { Repository } from 'typeorm';
 import { LogOutEntity } from '../entities/log-out/log-out.entity.js';
 import { Messages } from '../exceptions/text/messages.js';
 import { isObjectEmpty } from '../helpers/index.js';
 import { Constants } from '../helpers/constants/constants.js';
 import Sentry from '@sentry/minimal';
+import { IRequestWithCognitoInfo } from './cognito-decoded.interface.js';
 
 @Injectable()
 export class NonScopedAuthMiddleware implements NestMiddleware {
   public constructor(
     @InjectRepository(LogOutEntity)
     private readonly logOutRepository: Repository<LogOutEntity>,
   ) {}
-  async use(req: Request, res: Response, next: (err?: any, res?: any) => void): Promise<void> {
+  async use(req: IRequestWithCognitoInfo, _res: Response, next: (err?: any, res?: any) => void): Promise<void> {
     console.log(`auth middleware triggered ->: ${new Date().toISOString()}`);
     let token: string;
     try {
@@ -43,22 +44,22 @@ export class NonScopedAuthMiddleware implements NestMiddleware {
 
     try {
       const jwtSecret = process.env.JWT_SECRET;
-      const data = jwt.verify(token, jwtSecret);
-      const userId = data['id'];
+      const data = jwt.verify(token, jwtSecret) as jwt.JwtPayload;
+      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

@@ -1,27 +1,28 @@
 import { Injectable, NestMiddleware, UnauthorizedException } from '@nestjs/common';
-import { Request, Response } from 'express';
+import { Response } from 'express';
 import jwt from 'jsonwebtoken';
 import { Messages } from '../exceptions/text/messages.js';
 import { extractTokenFromHeader } from './utils/extract-token-from-header.js';
+import { IRequestWithCognitoInfo } from './cognito-decoded.interface.js';
 
 @Injectable()
 export class SaaSAuthMiddleware implements NestMiddleware {
-  use(req: Request, res: Response, next: (err?: any, res?: any) => void): void {
+  use(req: IRequestWithCognitoInfo, _res: Response, next: (err?: any, res?: any) => void): void {
     console.log(`saas auth middleware triggered ->: ${new Date().toISOString()}`);
     const token = extractTokenFromHeader(req);
     if (!token) {
       throw new UnauthorizedException('Token is missing');
     }
     try {
       const jwtSecret = process.env.MICROSERVICE_JWT_SECRET;
-      const data = jwt.verify(token, jwtSecret);
-      const requestId = data['request_id'];
+      const data = jwt.verify(token, jwtSecret) as jwt.JwtPayload;
+      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

@@ -6,7 +6,7 @@ import {
   UnauthorizedException,
 } from '@nestjs/common';
 import { InjectRepository } from '@nestjs/typeorm';
-import { Request, Response } from 'express';
+import { Response } from 'express';
 import jwt from 'jsonwebtoken';
 import { Repository } from 'typeorm';
 import { LogOutEntity } from '../entities/log-out/log-out.entity.js';
@@ -15,16 +15,16 @@ import { Messages } from '../exceptions/text/messages.js';
 import { isObjectEmpty } from '../helpers/index.js';
 import Sentry from '@sentry/minimal';
 import { Constants } from '../helpers/constants/constants.js';
+import { IRequestWithCognitoInfo } from './cognito-decoded.interface.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: IRequestWithCognitoInfo, _res: Response, next: (err?: any, res?: any) => void): Promise<void> {
     console.log(`temporary auth middleware triggered ->: ${new Date().toISOString()}`);
     let token: string;
     try {
@@ -46,21 +46,21 @@ export class TemporaryAuthMiddleware implements NestMiddleware {
 
     try {
       const jwtSecret = process.env.TEMPORARY_JWT_SECRET;
-      const data = jwt.verify(token, jwtSecret);
-      const userId = data['id'];
+      const data = jwt.verify(token, jwtSecret) as jwt.JwtPayload;
+      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);