@skillstew/common 1.0.17 → 1.0.19

package/build/errors/MessageQueueErrors.js

@@ -5,13 +5,13 @@ const AppError_1 = require("./AppError");
 const MessageQueueErrorCodes_1 = require("./codes/MessageQueueErrorCodes");
 class InvalidEventPayloadError extends AppError_1.InfrastructureError {
     constructor(eventName, errorString) {
-        super(MessageQueueErrorCodes_1.MessageQueueErrorCodes.INVALID_EVENT_PAYLOAD + `for ${eventName}`, "INVALID_EVENT_PAYLOAD", { zodErrorString: errorString });
+        super(MessageQueueErrorCodes_1.MessageQueueErrorCodes.INVALID_EVENT_PAYLOAD + ` for ${eventName}`, "INVALID_EVENT_PAYLOAD", { zodErrorString: errorString });
     }
     toJSON() {
         return {
             message: this.message,
             code: this.code,
-            error: this.context.zodErrorStrings,
+            error: this.context.zodErrorString,
         };
     }
 }

package/build/events/Consumer.d.ts

@@ -1,6 +1,7 @@
 import { Channel } from "amqplib";
 import { EventName } from "./EventMap";
 import { AppEvent } from "./AppEvent";
+type EventHandler<T extends EventName> = (event: AppEvent<T>) => Promise<HandlerResult>;
 export declare class Consumer {
     private _channel;
     private _exchange;
@@ -9,7 +10,7 @@ export declare class Consumer {
     constructor();
     init: (channel: Channel, exchange: string, serviceName: string, interestedEvents: (string | EventName)[]) => Promise<void>;
     private handleEvent;
-    registerHandler: <T extends EventName>(eventName: T, handler: (event: AppEvent<T>) => Promise<HandlerResult>) => void;
+    registerHandler: <T extends EventName>(eventName: T, handler: EventHandler<T>) => void;
 }
 interface HandlerResult {
     success: boolean;

package/build/middlewares/authMiddleware.js

@@ -3,9 +3,11 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.AuthMiddleware = void 0;
 const UnauthenticatedError_1 = require("../errors/UnauthenticatedError");
 const JwtHelper_1 = require("../jwt-utils/JwtHelper");
+const JwtErrors_1 = require("../errors/JwtErrors");
+const HttpStatus_1 = require("../constants/HttpStatus");
 class AuthMiddleware {
     constructor(userAccessTokenSecret, expertAccessTokenSecret, adminAccessTokenSecret) {
-        this.verify = (req, _res, next) => {
+        this.verify = (req, res, next) => {
             var _a;
             try {
                 const token = (_a = req.headers["authorization"]) === null || _a === void 0 ? void 0 : _a.split(" ")[1];
@@ -19,6 +21,24 @@ class AuthMiddleware {
                 next();
             }
             catch (err) {
+                if (err instanceof JwtErrors_1.AccessTokenVerifyError) {
+                    res
+                        .status(HttpStatus_1.HttpStatus.BAD_REQUEST)
+                        .json({ success: false, message: err.message, code: err.code });
+                    return;
+                }
+                else if (err instanceof JwtErrors_1.InvalidTokenError) {
+                    res
+                        .status(HttpStatus_1.HttpStatus.UNAUTHORIZED)
+                        .json({ success: false, message: err.message, code: err.code });
+                    return;
+                }
+                else if (err instanceof UnauthenticatedError_1.UnauthenticatedError) {
+                    res
+                        .status(HttpStatus_1.HttpStatus.UNAUTHORIZED)
+                        .json({ success: false, message: err.message, code: err.code });
+                    return;
+                }
                 next(err);
             }
         };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@skillstew/common",
-  "version": "1.0.17",
+  "version": "1.0.19",
   "main": "./build/index.js",
   "types": "./build/index.d.ts",
   "scripts": {

package/src/errors/MessageQueueErrors.ts

@@ -5,7 +5,7 @@ import { MessageQueueErrorCodes } from "./codes/MessageQueueErrorCodes";
 export class InvalidEventPayloadError extends InfrastructureError {
   constructor(eventName: EventName, errorString: string) {
     super(
-      MessageQueueErrorCodes.INVALID_EVENT_PAYLOAD + `for ${eventName}`,
+      MessageQueueErrorCodes.INVALID_EVENT_PAYLOAD + ` for ${eventName}`,
       "INVALID_EVENT_PAYLOAD",
       { zodErrorString: errorString },
     );
@@ -14,7 +14,7 @@ export class InvalidEventPayloadError extends InfrastructureError {
     return {
       message: this.message,
       code: this.code,
-      error: this.context!.zodErrorStrings,
+      error: this.context!.zodErrorString,
     };
   }
 }

package/src/events/Consumer.ts

@@ -8,13 +8,15 @@ import {
 } from "../errors/MessageQueueErrors";
 import z from "zod";
 
+type EventHandler<T extends EventName> = (event: AppEvent<T>) => Promise<HandlerResult>;
+
 export class Consumer {
   private _channel!: Channel;
   private _exchange!: string;
   private _initialized: boolean = false;
   private _handlers = new Map<
     EventName,
-    (event: any) => Promise<HandlerResult>
+  EventHandler<EventName>
   >();
   constructor() {}
 
@@ -93,12 +95,12 @@ export class Consumer {
 
   registerHandler = <T extends EventName>(
     eventName: T,
-    handler: (event: AppEvent<T>) => Promise<HandlerResult>,
+    handler: EventHandler<T>,
   ) => {
     if (!this._initialized) {
       throw new ConsumerUsedBeforeInitializationError();
     }
-    this._handlers.set(eventName, handler);
+    this._handlers.set(eventName, handler as EventHandler<EventName>);
   };
 }
 

package/src/middlewares/authMiddleware.ts

@@ -1,6 +1,8 @@
 import { RequestHandler } from "express";
 import { UnauthenticatedError } from "../errors/UnauthenticatedError";
 import { JwtHelper } from "../jwt-utils/JwtHelper";
+import { AccessTokenVerifyError, InvalidTokenError } from "../errors/JwtErrors";
+import { HttpStatus } from "../constants/HttpStatus";
 
 export class AuthMiddleware {
   private _jwtHelper: JwtHelper;
@@ -17,12 +19,13 @@ export class AuthMiddleware {
     });
   }
 
-  verify: RequestHandler = (req, _res, next) => {
+  verify: RequestHandler = (req, res, next) => {
     try {
       const token = req.headers["authorization"]?.split(" ")[1];
       if (!token) {
         throw new UnauthenticatedError();
       }
+
       const payload = this._jwtHelper.verifyAccessToken(token);
       req.user = {
         id: payload.userId,
@@ -33,6 +36,22 @@ export class AuthMiddleware {
       };
       next();
     } catch (err) {
+      if (err instanceof AccessTokenVerifyError) {
+        res
+          .status(HttpStatus.BAD_REQUEST)
+          .json({ success: false, message: err.message, code: err.code });
+        return;
+      } else if (err instanceof InvalidTokenError) {
+        res
+          .status(HttpStatus.UNAUTHORIZED)
+          .json({ success: false, message: err.message, code: err.code });
+        return;
+      } else if (err instanceof UnauthenticatedError) {
+        res
+          .status(HttpStatus.UNAUTHORIZED)
+          .json({ success: false, message: err.message, code: err.code });
+        return;
+      }
       next(err);
     }
   };