fixes as per eslint

Author: janishar

.eslintrc

@@ -1,5 +1,4 @@
 {
-  "plugins": ["react-hooks"],
   "rules": {
     "semi": ["error", "always"],
     "@typescript-eslint/ban-ts-ignore": "off",

src/app.ts

@@ -24,6 +24,7 @@ app.use('/v1', routesV1);
 app.use((req, res, next) => next(new NotFoundError()));
 
 // Middleware Error Handler
+// eslint-disable-next-line @typescript-eslint/no-unused-vars
 app.use((err: Error, req: Request, res: Response, next: NextFunction) => {
   if (err instanceof ApiError) {
     ApiError.handle(err, res);

src/auth/authUtils.ts

@@ -55,8 +55,8 @@ export const createTokens = async (
 
   if (!refreshToken) throw new InternalError();
 
-  return <Tokens>{
+  return {
     accessToken: accessToken,
     refreshToken: refreshToken,
-  };
+  } as Tokens;
 };

src/auth/authentication.ts

@@ -1,5 +1,5 @@
 import express from 'express';
-import { ProtectedRequest, Tokens } from 'app-request';
+import { ProtectedRequest } from 'app-request';
 import UserRepo from '../database/repository/UserRepo';
 import { AuthFailureError, AccessTokenError, TokenExpiredError } from '../core/ApiError';
 import JWT from '../core/JWT';

src/core/ApiError.ts

@@ -56,61 +56,61 @@ export abstract class ApiError extends Error {
 }
 
 export class AuthFailureError extends ApiError {
-  constructor(message: string = 'Invalid Credentials') {
+  constructor(message = 'Invalid Credentials') {
     super(ErrorType.UNAUTHORIZED, message);
   }
 }
 
 export class InternalError extends ApiError {
-  constructor(message: string = 'Internal error') {
+  constructor(message = 'Internal error') {
     super(ErrorType.INTERNAL, message);
   }
 }
 
 export class BadRequestError extends ApiError {
-  constructor(message: string = 'Bad Request') {
+  constructor(message = 'Bad Request') {
     super(ErrorType.BAD_REQUEST, message);
   }
 }
 
 export class NotFoundError extends ApiError {
-  constructor(message: string = 'Not Found') {
+  constructor(message = 'Not Found') {
     super(ErrorType.NOT_FOUND, message);
   }
 }
 
 export class ForbiddenError extends ApiError {
-  constructor(message: string = 'Permission denied') {
+  constructor(message = 'Permission denied') {
     super(ErrorType.FORBIDDEN, message);
   }
 }
 
 export class NoEntryError extends ApiError {
-  constructor(message: string = "Entry don't exists") {
+  constructor(message = "Entry don't exists") {
     super(ErrorType.NO_ENTRY, message);
   }
 }
 
 export class BadTokenError extends ApiError {
-  constructor(message: string = 'Token is not valid') {
+  constructor(message = 'Token is not valid') {
     super(ErrorType.BAD_TOKEN, message);
   }
 }
 
 export class TokenExpiredError extends ApiError {
-  constructor(message: string = 'Token is expired') {
+  constructor(message = 'Token is expired') {
     super(ErrorType.TOKEN_EXPIRED, message);
   }
 }
 
 export class NoDataError extends ApiError {
-  constructor(message: string = 'No data available') {
+  constructor(message = 'No data available') {
     super(ErrorType.NO_DATA, message);
   }
 }
 
 export class AccessTokenError extends ApiError {
-  constructor(message: string = 'Invalid access token') {
+  constructor(message = 'Invalid access token') {
     super(ErrorType.ACCESS_TOKEN, message);
   }
 }

src/core/ApiResponse.ts

@@ -33,7 +33,7 @@ abstract class ApiResponse {
   }
 
   private static sanitize<T extends ApiResponse>(response: T): T {
-    const clone: T = <T>{};
+    const clone: T = {} as T;
     Object.assign(clone, response);
     // delete {some_field};
     delete clone.status;
@@ -43,15 +43,15 @@ abstract class ApiResponse {
 }
 
 export class AuthFailureResponse extends ApiResponse {
-  constructor(message: string = 'Authentication Failure') {
+  constructor(message = 'Authentication Failure') {
     super(StatusCode.FAILURE, ResponseStatus.UNAUTHORIZED, message);
   }
 }
 
 export class NotFoundResponse extends ApiResponse {
   private url: string;
 
-  constructor(message: string = 'Not Found') {
+  constructor(message = 'Not Found') {
     super(StatusCode.FAILURE, ResponseStatus.NOT_FOUND, message);
   }
 
@@ -62,19 +62,19 @@ export class NotFoundResponse extends ApiResponse {
 }
 
 export class ForbiddenResponse extends ApiResponse {
-  constructor(message: string = 'Forbidden') {
+  constructor(message = 'Forbidden') {
     super(StatusCode.FAILURE, ResponseStatus.FORBIDDEN, message);
   }
 }
 
 export class BadRequestResponse extends ApiResponse {
-  constructor(message: string = 'Bad Parameters') {
+  constructor(message = 'Bad Parameters') {
     super(StatusCode.FAILURE, ResponseStatus.BAD_REQUEST, message);
   }
 }
 
 export class InternalErrorResponse extends ApiResponse {
-  constructor(message: string = 'Internal Error') {
+  constructor(message = 'Internal Error') {
     super(StatusCode.FAILURE, ResponseStatus.INTERNAL_ERROR, message);
   }
 }
@@ -104,7 +104,7 @@ export class SuccessResponse<T> extends ApiResponse {
 export class AccessTokenErrorResponse extends ApiResponse {
   private instruction = 'refresh_token';
 
-  constructor(message: string = 'Access token invalid') {
+  constructor(message = 'Access token invalid') {
     super(StatusCode.INVALID_ACCESS_TOKEN, ResponseStatus.UNAUTHORIZED, message);
   }
 

src/core/JWT.ts

@@ -1,7 +1,7 @@
 import path from 'path';
 import { readFile } from 'fs';
 import { promisify } from 'util';
-import { sign, verify, decode } from 'jsonwebtoken';
+import { sign, verify } from 'jsonwebtoken';
 import { InternalError, BadTokenError, TokenExpiredError } from './ApiError';
 import Logger from './Logger';
 
@@ -36,7 +36,7 @@ export default class JWT {
     const cert = await this.readPublicKey();
     try {
       // @ts-ignore
-      return <JwtPayload>await promisify(verify)(token, cert);
+      return (await promisify(verify)(token, cert)) as JwtPayload;
     } catch (e) {
       Logger.debug(e);
       if (e && e.name === 'TokenExpiredError') throw new TokenExpiredError();
@@ -52,7 +52,7 @@ export default class JWT {
     const cert = await this.readPublicKey();
     try {
       // @ts-ignore
-      return <JwtPayload>await promisify(verify)(token, cert, { ignoreExpiration: true });
+      return (await promisify(verify)(token, cert, { ignoreExpiration: true })) as JwtPayload;
     } catch (e) {
       Logger.debug(e);
       throw new BadTokenError();

src/database/model/ApiKey.ts

@@ -1,4 +1,4 @@
-import { Schema, model, Document, Types } from 'mongoose';
+import { Schema, model, Document } from 'mongoose';
 
 export const DOCUMENT_NAME = 'ApiKey';
 export const COLLECTION_NAME = 'api_keys';

src/database/model/User.ts

@@ -1,4 +1,4 @@
-import { model, Schema, Document, Types } from 'mongoose';
+import { model, Schema, Document } from 'mongoose';
 import Role from './Role';
 
 export const DOCUMENT_NAME = 'User';

src/database/repository/BlogRepo.ts

@@ -112,7 +112,7 @@ export default class BlogRepo {
     return this.findDetailedBlogs({ author: user, status: true, isDraft: true });
   }
 
-  private static findDetailedBlogs(query: Object): Promise<Blog[]> {
+  private static findDetailedBlogs(query: object): Promise<Blog[]> {
     return BlogModel.find(query)
       .select(this.BLOG_INFO_ADDITIONAL)
       .populate('author', this.AUTHOR_DETAIL)