@skillstew/common 1.0.26 → 1.0.27

package/build/index.d.ts

@@ -1,16 +1,5 @@
-export * from "./errors/AppError";
-export * from "./errors/JwtErrors";
-export * from "./errors/UnauthenticatedError";
-export * from "./errors/UnauthorizedError";
-export * from "./errors/codes/JwtErrorCodes";
-export * from "./errors/ForbiddenError";
-export * from "./jwt-utils/JwtHelper";
-export * from "./middlewares/authMiddleware";
-export * from "./middlewares/requireRole";
 export * from "./types/UserRoles";
 export * from "./constants/HttpStatus";
 export * from "./events/AppEvent";
 export * from "./events/schemas/userEventsSchema";
 export * from "./events/CreateEvent";
-export * from "./events/Consumer";
-export * from "./events/Producer";

package/build/index.js

@@ -14,18 +14,6 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
     for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-// Errors
-__exportStar(require("./errors/AppError"), exports);
-__exportStar(require("./errors/JwtErrors"), exports);
-__exportStar(require("./errors/UnauthenticatedError"), exports);
-__exportStar(require("./errors/UnauthorizedError"), exports);
-__exportStar(require("./errors/codes/JwtErrorCodes"), exports);
-__exportStar(require("./errors/ForbiddenError"), exports);
-// Helpers
-__exportStar(require("./jwt-utils/JwtHelper"), exports);
-// Middlewares
-__exportStar(require("./middlewares/authMiddleware"), exports);
-__exportStar(require("./middlewares/requireRole"), exports);
 // Types
 __exportStar(require("./types/UserRoles"), exports);
 // Constants
@@ -34,5 +22,3 @@ __exportStar(require("./constants/HttpStatus"), exports);
 __exportStar(require("./events/AppEvent"), exports);
 __exportStar(require("./events/schemas/userEventsSchema"), exports);
 __exportStar(require("./events/CreateEvent"), exports);
-__exportStar(require("./events/Consumer"), exports);
-__exportStar(require("./events/Producer"), exports);

package/package.json

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

package/src/index.ts

@@ -1,18 +1,3 @@
-// Errors
-export * from "./errors/AppError";
-export * from "./errors/JwtErrors";
-export * from "./errors/UnauthenticatedError";
-export * from "./errors/UnauthorizedError";
-export * from "./errors/codes/JwtErrorCodes";
-export * from "./errors/ForbiddenError";
-
-// Helpers
-export * from "./jwt-utils/JwtHelper";
-
-// Middlewares
-export * from "./middlewares/authMiddleware";
-export * from "./middlewares/requireRole";
-
 // Types
 export * from "./types/UserRoles";
 
@@ -23,5 +8,3 @@ export * from "./constants/HttpStatus";
 export * from "./events/AppEvent";
 export * from "./events/schemas/userEventsSchema";
 export * from "./events/CreateEvent";
-export * from "./events/Consumer";
-export * from "./events/Producer";

package/build/errors/AppError.d.ts

@@ -1,14 +0,0 @@
-export declare abstract class AppError extends Error {
-    readonly message: string;
-    readonly code: string;
-    readonly context?: Record<string, unknown> | undefined;
-    readonly name: string;
-    constructor(message: string, code: string, context?: Record<string, unknown> | undefined);
-    abstract toJSON(): object;
-}
-export declare abstract class DomainError extends AppError {
-}
-export declare abstract class InfrastructureError extends AppError {
-}
-export declare abstract class ApplicationError extends AppError {
-}

package/build/errors/AppError.js

@@ -1,23 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.ApplicationError = exports.InfrastructureError = exports.DomainError = exports.AppError = void 0;
-class AppError extends Error {
-    constructor(message, code, context) {
-        super(message);
-        this.message = message;
-        this.code = code;
-        this.context = context;
-        this.name = this.constructor.name;
-        Object.setPrototypeOf(this, new.target.prototype);
-    }
-}
-exports.AppError = AppError;
-class DomainError extends AppError {
-}
-exports.DomainError = DomainError;
-class InfrastructureError extends AppError {
-}
-exports.InfrastructureError = InfrastructureError;
-class ApplicationError extends AppError {
-}
-exports.ApplicationError = ApplicationError;

package/build/errors/ForbiddenError.d.ts

@@ -1,5 +0,0 @@
-import { ApplicationError } from "./AppError";
-export declare class ForbiddenError extends ApplicationError {
-    constructor();
-    toJSON(): object;
-}

package/build/errors/ForbiddenError.js

@@ -1,13 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.ForbiddenError = void 0;
-const AppError_1 = require("./AppError");
-class ForbiddenError extends AppError_1.ApplicationError {
-    constructor() {
-        super("Forbidden", "FORBIDDEN_ERROR");
-    }
-    toJSON() {
-        return { message: this.message, code: this.code };
-    }
-}
-exports.ForbiddenError = ForbiddenError;

package/build/errors/JwtErrors.d.ts

@@ -1,24 +0,0 @@
-import { InfrastructureError } from "./AppError";
-import { JwtErrorCodes } from "./codes/JwtErrorCodes";
-export declare class JwtError extends InfrastructureError {
-    constructor(code: keyof typeof JwtErrorCodes);
-    toJSON(): object;
-}
-export declare class EmailVerificationJwtVerifyError extends JwtError {
-    constructor();
-}
-export declare class RefreshTokenVerifyError extends JwtError {
-    constructor();
-}
-export declare class AccessTokenVerifyError extends JwtError {
-    constructor();
-}
-export declare class InvalidTokenError extends JwtError {
-    constructor();
-}
-export declare class InvalidTokenRoleError extends JwtError {
-    constructor();
-}
-export declare class TokenRoleMismatchError extends JwtError {
-    constructor();
-}

package/build/errors/JwtErrors.js

@@ -1,50 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.TokenRoleMismatchError = exports.InvalidTokenRoleError = exports.InvalidTokenError = exports.AccessTokenVerifyError = exports.RefreshTokenVerifyError = exports.EmailVerificationJwtVerifyError = exports.JwtError = void 0;
-const AppError_1 = require("./AppError");
-const JwtErrorCodes_1 = require("./codes/JwtErrorCodes");
-class JwtError extends AppError_1.InfrastructureError {
-    constructor(code) {
-        super(JwtErrorCodes_1.JwtErrorCodes[code], code);
-    }
-    toJSON() {
-        return { error: this.name, message: this.message, code: this.code };
-    }
-}
-exports.JwtError = JwtError;
-class EmailVerificationJwtVerifyError extends JwtError {
-    constructor() {
-        super("EMAIL_VERIFICATION_JWT_VERIFY_ERROR");
-    }
-}
-exports.EmailVerificationJwtVerifyError = EmailVerificationJwtVerifyError;
-class RefreshTokenVerifyError extends JwtError {
-    constructor() {
-        super("REFRESH_TOKEN_VERIFY_ERROR");
-    }
-}
-exports.RefreshTokenVerifyError = RefreshTokenVerifyError;
-class AccessTokenVerifyError extends JwtError {
-    constructor() {
-        super("ACCESS_TOKEN_VERIFY_ERROR");
-    }
-}
-exports.AccessTokenVerifyError = AccessTokenVerifyError;
-class InvalidTokenError extends JwtError {
-    constructor() {
-        super("INVALID_TOKEN_ERROR");
-    }
-}
-exports.InvalidTokenError = InvalidTokenError;
-class InvalidTokenRoleError extends JwtError {
-    constructor() {
-        super("INVALID_TOKEN_ROLE_ERROR");
-    }
-}
-exports.InvalidTokenRoleError = InvalidTokenRoleError;
-class TokenRoleMismatchError extends JwtError {
-    constructor() {
-        super("TOKEN_ROLE_MISMATCH_ERROR");
-    }
-}
-exports.TokenRoleMismatchError = TokenRoleMismatchError;

package/build/errors/MessageQueueErrors.d.ts

@@ -1,18 +0,0 @@
-import { EventName } from "../events/EventMap";
-import { InfrastructureError } from "./AppError";
-export declare class InvalidEventPayloadError extends InfrastructureError {
-    constructor(eventName: EventName, errorString: string);
-    toJSON(): object;
-}
-export declare class UnknownEventError extends InfrastructureError {
-    constructor(eventName: string);
-    toJSON(): object;
-}
-export declare class ConsumerUsedBeforeInitializationError extends InfrastructureError {
-    constructor();
-    toJSON(): object;
-}
-export declare class ProducerUsedBeforeInitializationError extends InfrastructureError {
-    constructor();
-    toJSON(): object;
-}

package/build/errors/MessageQueueErrors.js

@@ -1,45 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.ProducerUsedBeforeInitializationError = exports.ConsumerUsedBeforeInitializationError = exports.UnknownEventError = exports.InvalidEventPayloadError = void 0;
-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 });
-    }
-    toJSON() {
-        return {
-            message: this.message,
-            code: this.code,
-            error: this.context.zodErrorString,
-        };
-    }
-}
-exports.InvalidEventPayloadError = InvalidEventPayloadError;
-class UnknownEventError extends AppError_1.InfrastructureError {
-    constructor(eventName) {
-        super(MessageQueueErrorCodes_1.MessageQueueErrorCodes.UNKNOWN_EVENT + eventName, "UNKNOWN_EVENT");
-    }
-    toJSON() {
-        return { message: this.message, code: this.code };
-    }
-}
-exports.UnknownEventError = UnknownEventError;
-class ConsumerUsedBeforeInitializationError extends AppError_1.InfrastructureError {
-    constructor() {
-        super(MessageQueueErrorCodes_1.MessageQueueErrorCodes.CONSUMER_USED_BEFORE_INITIALIZATION, "CONSUMER_USED_BEFORE_INITIALIZATION");
-    }
-    toJSON() {
-        return { message: this.message, code: this.code };
-    }
-}
-exports.ConsumerUsedBeforeInitializationError = ConsumerUsedBeforeInitializationError;
-class ProducerUsedBeforeInitializationError extends AppError_1.InfrastructureError {
-    constructor() {
-        super(MessageQueueErrorCodes_1.MessageQueueErrorCodes.PRODUCER_USED_BEFORE_INITIALIZATION, "PRODUCER_USED_BEFORE_INITIALIZATION");
-    }
-    toJSON() {
-        return { message: this.message, code: this.code };
-    }
-}
-exports.ProducerUsedBeforeInitializationError = ProducerUsedBeforeInitializationError;

package/build/errors/UnauthenticatedError.d.ts

@@ -1,5 +0,0 @@
-import { ApplicationError } from "./AppError";
-export declare class UnauthenticatedError extends ApplicationError {
-    constructor();
-    toJSON(): object;
-}

package/build/errors/UnauthenticatedError.js

@@ -1,13 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.UnauthenticatedError = void 0;
-const AppError_1 = require("./AppError");
-class UnauthenticatedError extends AppError_1.ApplicationError {
-    constructor() {
-        super("Unauthenticated", "USER_UNAUTHENTICATED");
-    }
-    toJSON() {
-        return { name: this.name, message: this.message };
-    }
-}
-exports.UnauthenticatedError = UnauthenticatedError;

package/build/errors/UnauthorizedError.d.ts

@@ -1,5 +0,0 @@
-import { DomainError } from "./AppError";
-export declare class UnauthorizedError extends DomainError {
-    constructor();
-    toJSON(): object;
-}

package/build/errors/UnauthorizedError.js

@@ -1,13 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.UnauthorizedError = void 0;
-const AppError_1 = require("./AppError");
-class UnauthorizedError extends AppError_1.DomainError {
-    constructor() {
-        super("You are not authorized", "UNAUTHORIZED");
-    }
-    toJSON() {
-        return { error: this.name, message: this.message, code: this.code };
-    }
-}
-exports.UnauthorizedError = UnauthorizedError;

package/build/errors/codes/JwtErrorCodes.d.ts

@@ -1,8 +0,0 @@
-export declare enum JwtErrorCodes {
-    EMAIL_VERIFICATION_JWT_VERIFY_ERROR = "Invalid email verification jwt",
-    REFRESH_TOKEN_VERIFY_ERROR = "Invalid refresh token",
-    ACCESS_TOKEN_VERIFY_ERROR = "Invalid access token",
-    INVALID_TOKEN_ERROR = "Invalid token",
-    INVALID_TOKEN_ROLE_ERROR = "Invalid role identifier",
-    TOKEN_ROLE_MISMATCH_ERROR = "Role mismatch between payload and header"
-}

package/build/errors/codes/JwtErrorCodes.js

@@ -1,12 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.JwtErrorCodes = void 0;
-var JwtErrorCodes;
-(function (JwtErrorCodes) {
-    JwtErrorCodes["EMAIL_VERIFICATION_JWT_VERIFY_ERROR"] = "Invalid email verification jwt";
-    JwtErrorCodes["REFRESH_TOKEN_VERIFY_ERROR"] = "Invalid refresh token";
-    JwtErrorCodes["ACCESS_TOKEN_VERIFY_ERROR"] = "Invalid access token";
-    JwtErrorCodes["INVALID_TOKEN_ERROR"] = "Invalid token";
-    JwtErrorCodes["INVALID_TOKEN_ROLE_ERROR"] = "Invalid role identifier";
-    JwtErrorCodes["TOKEN_ROLE_MISMATCH_ERROR"] = "Role mismatch between payload and header";
-})(JwtErrorCodes || (exports.JwtErrorCodes = JwtErrorCodes = {}));

package/build/errors/codes/MessageQueueErrorCodes.d.ts

@@ -1,6 +0,0 @@
-export declare const MessageQueueErrorCodes: {
-    readonly PRODUCER_USED_BEFORE_INITIALIZATION: "Producer used before initialization!";
-    readonly CONSUMER_USED_BEFORE_INITIALIZATION: "Consumer used before initialization!";
-    readonly UNKNOWN_EVENT: "Unknown event type";
-    readonly INVALID_EVENT_PAYLOAD: "Invalid payload";
-};

package/build/errors/codes/MessageQueueErrorCodes.js

@@ -1,9 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.MessageQueueErrorCodes = void 0;
-exports.MessageQueueErrorCodes = {
-    PRODUCER_USED_BEFORE_INITIALIZATION: "Producer used before initialization!",
-    CONSUMER_USED_BEFORE_INITIALIZATION: "Consumer used before initialization!",
-    UNKNOWN_EVENT: "Unknown event type",
-    INVALID_EVENT_PAYLOAD: "Invalid payload",
-};

package/build/events/Consumer.d.ts

@@ -1,19 +0,0 @@
-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;
-    private _initialized;
-    private _handlers;
-    constructor();
-    init: (channel: Channel, exchange: string, serviceName: string, interestedEvents: (string | EventName)[]) => Promise<void>;
-    private handleEvent;
-    registerHandler: <T extends EventName>(eventName: T, handler: EventHandler<T>) => void;
-}
-interface HandlerResult {
-    success: boolean;
-    retryable?: boolean;
-}
-export {};

package/build/events/Consumer.js

@@ -1,78 +0,0 @@
-"use strict";
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.Consumer = void 0;
-const EventMap_1 = require("./EventMap");
-const MessageQueueErrors_1 = require("../errors/MessageQueueErrors");
-class Consumer {
-    constructor() {
-        this._initialized = false;
-        this._handlers = new Map();
-        this.init = (channel, exchange, serviceName, interestedEvents) => __awaiter(this, void 0, void 0, function* () {
-            this._channel = channel;
-            this._exchange = exchange;
-            yield this._channel.assertExchange(this._exchange, "topic", {
-                durable: true,
-            });
-            const queue = yield this._channel.assertQueue(`${serviceName}_queue`, {
-                durable: true,
-            });
-            yield Promise.all(interestedEvents.map((eventName) => this._channel.bindQueue(queue.queue, this._exchange, eventName)));
-            this._channel.consume(queue.queue, this.handleEvent, { noAck: false });
-            this._initialized = true;
-        });
-        this.handleEvent = (msg) => __awaiter(this, void 0, void 0, function* () {
-            if (!msg) {
-                return;
-            }
-            const event = JSON.parse(msg.content.toString());
-            const eventName = event.eventName;
-            // validate using schema
-            const schema = EventMap_1.EventSchemas[eventName];
-            if (!schema) {
-                throw new MessageQueueErrors_1.UnknownEventError(eventName);
-            }
-            const parseResult = schema.safeParse(event.data);
-            if (!parseResult.success) {
-                this._channel.nack(msg, false, false);
-                return;
-            }
-            // create typed app event
-            const appEvent = Object.assign(Object.assign({}, event), { data: parseResult.data });
-            try {
-                const handler = this._handlers.get(eventName);
-                if (!handler) {
-                    this._channel.ack(msg); // ack if no handler
-                    return;
-                }
-                const result = yield handler(appEvent);
-                if (result.success) {
-                    this._channel.ack(msg);
-                }
-                else {
-                    const requeue = result.retryable;
-                    this._channel.nack(msg, false, requeue);
-                }
-            }
-            catch (err) {
-                console.log(err);
-                this._channel.nack(msg, false, false);
-            }
-        });
-        this.registerHandler = (eventName, handler) => {
-            if (!this._initialized) {
-                throw new MessageQueueErrors_1.ConsumerUsedBeforeInitializationError();
-            }
-            this._handlers.set(eventName, handler);
-        };
-    }
-}
-exports.Consumer = Consumer;

package/build/events/Producer.d.ts

@@ -1,10 +0,0 @@
-import { Channel } from "amqplib";
-import { AnyAppEvent } from "./AppEvent";
-export declare class Producer {
-    private _channel;
-    private _exchange;
-    private _initialized;
-    constructor();
-    init: (channel: Channel, exchange: string) => Promise<void>;
-    publish: (event: AnyAppEvent) => void;
-}

package/build/events/Producer.js

@@ -1,37 +0,0 @@
-"use strict";
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.Producer = void 0;
-const MessageQueueErrors_1 = require("../errors/MessageQueueErrors");
-class Producer {
-    constructor() {
-        this._initialized = false;
-        this.init = (channel, exchange) => __awaiter(this, void 0, void 0, function* () {
-            this._channel = channel;
-            this._exchange = exchange;
-            yield this._channel.assertExchange(this._exchange, "topic", {
-                durable: true,
-            });
-            this._initialized = true;
-        });
-        this.publish = (event) => {
-            if (!this._initialized) {
-                throw new MessageQueueErrors_1.ProducerUsedBeforeInitializationError();
-            }
-            const routingKey = event.eventName;
-            const message = Buffer.from(JSON.stringify(event));
-            this._channel.publish(this._exchange, routingKey, message, {
-                persistent: true,
-            });
-        };
-    }
-}
-exports.Producer = Producer;

package/build/jwt-utils/JwtHelper.d.ts

@@ -1,23 +0,0 @@
-import { UserRoles } from "../types/UserRoles";
-export type tokenBody = {
-    userId: string;
-    email: string;
-    role: Exclude<UserRoles, "ADMIN">;
-} | {
-    userId: string;
-    username: string;
-    role: "ADMIN";
-};
-export type JWTPayload = tokenBody & {
-    iat: number;
-    exp: number;
-};
-export declare class JwtHelper {
-    private _AccessSecrets;
-    constructor({ userAccessTokenSecret, expertAccessTokenSecret, adminAccessTokenSecret, }: {
-        userAccessTokenSecret: string;
-        expertAccessTokenSecret: string;
-        adminAccessTokenSecret: string;
-    });
-    verifyAccessToken: (jwtToken: string) => JWTPayload;
-}

package/build/jwt-utils/JwtHelper.js

@@ -1,43 +0,0 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.JwtHelper = void 0;
-const jsonwebtoken_1 = __importDefault(require("jsonwebtoken"));
-const JwtErrors_1 = require("../errors/JwtErrors");
-function isUserRole(role) {
-    return ["ADMIN", "EXPERT", "USER"].includes(role);
-}
-class JwtHelper {
-    constructor({ userAccessTokenSecret, expertAccessTokenSecret, adminAccessTokenSecret, }) {
-        this.verifyAccessToken = (jwtToken) => {
-            const decoded = jsonwebtoken_1.default.decode(jwtToken, { complete: true });
-            if (!decoded || !decoded.header) {
-                throw new JwtErrors_1.InvalidTokenError();
-            }
-            const header = decoded.header;
-            const role = header.kid;
-            if (!role || !isUserRole(role)) {
-                throw new JwtErrors_1.InvalidTokenRoleError();
-            }
-            let payload;
-            try {
-                payload = jsonwebtoken_1.default.verify(jwtToken, this._AccessSecrets[role]);
-            }
-            catch (err) {
-                throw new JwtErrors_1.AccessTokenVerifyError();
-            }
-            if (!(role === payload.role)) {
-                throw new JwtErrors_1.TokenRoleMismatchError();
-            }
-            return payload;
-        };
-        this._AccessSecrets = {
-            USER: userAccessTokenSecret,
-            ADMIN: adminAccessTokenSecret,
-            EXPERT: expertAccessTokenSecret,
-        };
-    }
-}
-exports.JwtHelper = JwtHelper;

package/build/middlewares/authMiddleware.d.ts

@@ -1,6 +0,0 @@
-import { RequestHandler } from "express";
-export declare class AuthMiddleware {
-    private _jwtHelper;
-    constructor(userAccessTokenSecret: string, expertAccessTokenSecret: string, adminAccessTokenSecret: string);
-    verify: RequestHandler;
-}

package/build/middlewares/authMiddleware.js

@@ -1,52 +0,0 @@
-"use strict";
-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) => {
-            var _a;
-            try {
-                const token = (_a = req.headers["authorization"]) === null || _a === void 0 ? void 0 : _a.split(" ")[1];
-                if (!token) {
-                    throw new UnauthenticatedError_1.UnauthenticatedError();
-                }
-                const payload = this._jwtHelper.verifyAccessToken(token);
-                req.user = Object.assign(Object.assign({ id: payload.userId }, (payload.role === "ADMIN"
-                    ? { userame: payload.username }
-                    : { email: payload.email })), { role: payload.role });
-                next();
-            }
-            catch (err) {
-                if (err instanceof JwtErrors_1.AccessTokenVerifyError) {
-                    res
-                        .status(HttpStatus_1.HttpStatus.UNAUTHORIZED)
-                        .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);
-            }
-        };
-        this._jwtHelper = new JwtHelper_1.JwtHelper({
-            userAccessTokenSecret,
-            expertAccessTokenSecret,
-            adminAccessTokenSecret,
-        });
-    }
-}
-exports.AuthMiddleware = AuthMiddleware;

package/build/middlewares/requireRole.d.ts

@@ -1,3 +0,0 @@
-import { NextFunction, Request, Response } from "express";
-import { UserRoles } from "../types/UserRoles";
-export declare const requireRole: (...roles: UserRoles[]) => (req: Request, _res: Response, next: NextFunction) => void;

package/build/middlewares/requireRole.js

@@ -1,20 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.requireRole = void 0;
-const ForbiddenError_1 = require("../errors/ForbiddenError");
-const requireRole = (...roles) => {
-    return (req, _res, next) => {
-        try {
-            if (!req.user || !roles.includes(req.user.role)) {
-                throw new ForbiddenError_1.ForbiddenError();
-            }
-            else {
-                next();
-            }
-        }
-        catch (err) {
-            next(err);
-        }
-    };
-};
-exports.requireRole = requireRole;

package/src/errors/AppError.ts

@@ -1,20 +0,0 @@
-export abstract class AppError extends Error {
-  public readonly name: string;
-  constructor(
-    public readonly message: string,
-    public readonly code: string,
-    public readonly context?: Record<string, unknown>,
-  ) {
-    super(message);
-    this.name = this.constructor.name;
-    Object.setPrototypeOf(this, new.target.prototype);
-  }
-
-  abstract toJSON(): object;
-}
-
-export abstract class DomainError extends AppError {}
-
-export abstract class InfrastructureError extends AppError {}
-
-export abstract class ApplicationError extends AppError {}

package/src/errors/ForbiddenError.ts

@@ -1,10 +0,0 @@
-import { ApplicationError } from "./AppError";
-
-export class ForbiddenError extends ApplicationError {
-  constructor() {
-    super("Forbidden", "FORBIDDEN_ERROR");
-  }
-  toJSON(): object {
-    return { message: this.message, code: this.code };
-  }
-}

package/src/errors/JwtErrors.ts

@@ -1,47 +0,0 @@
-import { InfrastructureError } from "./AppError";
-import { JwtErrorCodes } from "./codes/JwtErrorCodes";
-
-export class JwtError extends InfrastructureError {
-  constructor(code: keyof typeof JwtErrorCodes) {
-    super(JwtErrorCodes[code], code);
-  }
-  toJSON(): object {
-    return { error: this.name, message: this.message, code: this.code };
-  }
-}
-
-export class EmailVerificationJwtVerifyError extends JwtError {
-  constructor() {
-    super("EMAIL_VERIFICATION_JWT_VERIFY_ERROR");
-  }
-}
-
-export class RefreshTokenVerifyError extends JwtError {
-  constructor() {
-    super("REFRESH_TOKEN_VERIFY_ERROR");
-  }
-}
-
-export class AccessTokenVerifyError extends JwtError {
-  constructor() {
-    super("ACCESS_TOKEN_VERIFY_ERROR");
-  }
-}
-
-export class InvalidTokenError extends JwtError {
-  constructor() {
-    super("INVALID_TOKEN_ERROR");
-  }
-}
-
-export class InvalidTokenRoleError extends JwtError {
-  constructor() {
-    super("INVALID_TOKEN_ROLE_ERROR");
-  }
-}
-
-export class TokenRoleMismatchError extends JwtError {
-  constructor() {
-    super("TOKEN_ROLE_MISMATCH_ERROR");
-  }
-}

package/src/errors/MessageQueueErrors.ts

@@ -1,53 +0,0 @@
-import { EventName } from "../events/EventMap";
-import { InfrastructureError } from "./AppError";
-import { MessageQueueErrorCodes } from "./codes/MessageQueueErrorCodes";
-
-export class InvalidEventPayloadError extends InfrastructureError {
-  constructor(eventName: EventName, errorString: string) {
-    super(
-      MessageQueueErrorCodes.INVALID_EVENT_PAYLOAD + ` for ${eventName}`,
-      "INVALID_EVENT_PAYLOAD",
-      { zodErrorString: errorString },
-    );
-  }
-  toJSON(): object {
-    return {
-      message: this.message,
-      code: this.code,
-      error: this.context!.zodErrorString,
-    };
-  }
-}
-
-export class UnknownEventError extends InfrastructureError {
-  constructor(eventName: string) {
-    super(MessageQueueErrorCodes.UNKNOWN_EVENT + eventName, "UNKNOWN_EVENT");
-  }
-  toJSON(): object {
-    return { message: this.message, code: this.code };
-  }
-}
-
-export class ConsumerUsedBeforeInitializationError extends InfrastructureError {
-  constructor() {
-    super(
-      MessageQueueErrorCodes.CONSUMER_USED_BEFORE_INITIALIZATION,
-      "CONSUMER_USED_BEFORE_INITIALIZATION",
-    );
-  }
-  toJSON(): object {
-    return { message: this.message, code: this.code };
-  }
-}
-
-export class ProducerUsedBeforeInitializationError extends InfrastructureError {
-  constructor() {
-    super(
-      MessageQueueErrorCodes.PRODUCER_USED_BEFORE_INITIALIZATION,
-      "PRODUCER_USED_BEFORE_INITIALIZATION",
-    );
-  }
-  toJSON(): object {
-    return { message: this.message, code: this.code };
-  }
-}

package/src/errors/UnauthenticatedError.ts

@@ -1,10 +0,0 @@
-import { ApplicationError } from "./AppError";
-
-export class UnauthenticatedError extends ApplicationError {
-  constructor() {
-    super("Unauthenticated", "USER_UNAUTHENTICATED");
-  }
-  toJSON(): object {
-    return { name: this.name, message: this.message };
-  }
-}

package/src/errors/UnauthorizedError.ts

@@ -1,10 +0,0 @@
-import { DomainError } from "./AppError";
-
-export class UnauthorizedError extends DomainError {
-  constructor() {
-    super("You are not authorized", "UNAUTHORIZED");
-  }
-  toJSON(): object {
-    return { error: this.name, message: this.message, code: this.code };
-  }
-}

package/src/errors/codes/JwtErrorCodes.ts

@@ -1,8 +0,0 @@
-export enum JwtErrorCodes {
-  EMAIL_VERIFICATION_JWT_VERIFY_ERROR = "Invalid email verification jwt",
-  REFRESH_TOKEN_VERIFY_ERROR = "Invalid refresh token",
-  ACCESS_TOKEN_VERIFY_ERROR = "Invalid access token",
-  INVALID_TOKEN_ERROR = "Invalid token",
-  INVALID_TOKEN_ROLE_ERROR = "Invalid role identifier",
-  TOKEN_ROLE_MISMATCH_ERROR = "Role mismatch between payload and header",
-}

package/src/errors/codes/MessageQueueErrorCodes.ts

@@ -1,6 +0,0 @@
-export const MessageQueueErrorCodes = {
-  PRODUCER_USED_BEFORE_INITIALIZATION: "Producer used before initialization!",
-  CONSUMER_USED_BEFORE_INITIALIZATION: "Consumer used before initialization!",
-  UNKNOWN_EVENT: "Unknown event type",
-  INVALID_EVENT_PAYLOAD: "Invalid payload",
-} as const;

package/src/events/Consumer.ts

@@ -1,106 +0,0 @@
-import { Channel, ConsumeMessage } from "amqplib";
-import { EventName, EventSchemas } from "./EventMap";
-import { AnyAppEvent, AppEvent } from "./AppEvent";
-import {
-  ConsumerUsedBeforeInitializationError,
-  UnknownEventError,
-} from "../errors/MessageQueueErrors";
-
-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, EventHandler<EventName>>();
-  constructor() {}
-
-  init = async (
-    channel: Channel,
-    exchange: string,
-    serviceName: string,
-    interestedEvents: (string | EventName)[], // ex: user.#, payments.subscribed
-  ) => {
-    this._channel = channel;
-    this._exchange = exchange;
-    await this._channel.assertExchange(this._exchange, "topic", {
-      durable: true,
-    });
-
-    const queue = await this._channel.assertQueue(`${serviceName}_queue`, {
-      durable: true,
-    });
-
-    await Promise.all(
-      interestedEvents.map((eventName) =>
-        this._channel.bindQueue(queue.queue, this._exchange, eventName),
-      ),
-    );
-
-    this._channel.consume(queue.queue, this.handleEvent, { noAck: false });
-
-    this._initialized = true;
-  };
-
-  private handleEvent = async (msg: ConsumeMessage | null) => {
-    if (!msg) {
-      return;
-    }
-    const event = JSON.parse(msg.content.toString()) as AnyAppEvent;
-    const eventName = event.eventName;
-
-    // validate using schema
-    const schema = EventSchemas[eventName];
-    if (!schema) {
-      throw new UnknownEventError(eventName);
-    }
-    const parseResult = schema.safeParse(event.data);
-    if (!parseResult.success) {
-      this._channel.nack(msg, false, false);
-      return;
-    }
-
-    // create typed app event
-    const appEvent: AppEvent<typeof eventName> = {
-      ...event,
-      data: parseResult.data,
-    };
-
-    try {
-      const handler = this._handlers.get(eventName);
-      if (!handler) {
-        this._channel.ack(msg); // ack if no handler
-        return;
-      }
-
-      const result = await handler(appEvent);
-
-      if (result.success) {
-        this._channel.ack(msg);
-      } else {
-        const requeue = result.retryable;
-        this._channel.nack(msg, false, requeue);
-      }
-    } catch (err) {
-      console.log(err);
-      this._channel.nack(msg, false, false);
-    }
-  };
-
-  registerHandler = <T extends EventName>(
-    eventName: T,
-    handler: EventHandler<T>,
-  ) => {
-    if (!this._initialized) {
-      throw new ConsumerUsedBeforeInitializationError();
-    }
-    this._handlers.set(eventName, handler as EventHandler<EventName>);
-  };
-}
-
-interface HandlerResult {
-  success: boolean;
-  retryable?: boolean;
-}

package/src/events/Producer.ts

@@ -1,30 +0,0 @@
-import { Channel } from "amqplib";
-import { AnyAppEvent } from "./AppEvent";
-import { ProducerUsedBeforeInitializationError } from "../errors/MessageQueueErrors";
-
-export class Producer {
-  private _channel!: Channel;
-  private _exchange!: string;
-  private _initialized: boolean = false;
-  constructor() {}
-
-  init = async (channel: Channel, exchange: string) => {
-    this._channel = channel;
-    this._exchange = exchange;
-    await this._channel.assertExchange(this._exchange, "topic", {
-      durable: true,
-    });
-    this._initialized = true;
-  };
-
-  publish = (event: AnyAppEvent) => {
-    if (!this._initialized) {
-      throw new ProducerUsedBeforeInitializationError();
-    }
-    const routingKey = event.eventName;
-    const message = Buffer.from(JSON.stringify(event));
-    this._channel.publish(this._exchange, routingKey, message, {
-      persistent: true,
-    });
-  };
-}

package/src/jwt-utils/JwtHelper.ts

@@ -1,74 +0,0 @@
-import jwt, { JwtHeader } from "jsonwebtoken";
-import { UserRoles } from "../types/UserRoles";
-import {
-  AccessTokenVerifyError,
-  InvalidTokenError,
-  InvalidTokenRoleError,
-  TokenRoleMismatchError,
-} from "../errors/JwtErrors";
-
-function isUserRole(role: string): role is UserRoles {
-  return ["ADMIN", "EXPERT", "USER"].includes(role);
-}
-
-export type tokenBody =
-  | {
-      userId: string;
-      email: string;
-      role: Exclude<UserRoles, "ADMIN">;
-    }
-  | {
-      userId: string;
-      username: string;
-      role: "ADMIN";
-    };
-
-export type JWTPayload = tokenBody & {
-  iat: number;
-  exp: number;
-};
-
-export class JwtHelper {
-  private _AccessSecrets: Record<UserRoles, string>;
-  constructor({
-    userAccessTokenSecret,
-    expertAccessTokenSecret,
-    adminAccessTokenSecret,
-  }: {
-    userAccessTokenSecret: string;
-    expertAccessTokenSecret: string;
-    adminAccessTokenSecret: string;
-  }) {
-    this._AccessSecrets = {
-      USER: userAccessTokenSecret,
-      ADMIN: adminAccessTokenSecret,
-      EXPERT: expertAccessTokenSecret,
-    };
-  }
-
-  verifyAccessToken = (jwtToken: string) => {
-    const decoded = jwt.decode(jwtToken, { complete: true }) as any;
-    if (!decoded || !decoded.header) {
-      throw new InvalidTokenError();
-    }
-
-    const header = decoded.header as JwtHeader & { kid?: string };
-    const role = header.kid as UserRoles | undefined;
-
-    if (!role || !isUserRole(role)) {
-      throw new InvalidTokenRoleError();
-    }
-    let payload: JWTPayload;
-    try {
-      payload = <JWTPayload>jwt.verify(jwtToken, this._AccessSecrets[role]);
-    } catch (err) {
-      throw new AccessTokenVerifyError();
-    }
-
-    if (!(role === payload.role)) {
-      throw new TokenRoleMismatchError();
-    }
-
-    return payload;
-  };
-}

package/src/middlewares/authMiddleware.ts

@@ -1,58 +0,0 @@
-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;
-
-  constructor(
-    userAccessTokenSecret: string,
-    expertAccessTokenSecret: string,
-    adminAccessTokenSecret: string,
-  ) {
-    this._jwtHelper = new JwtHelper({
-      userAccessTokenSecret,
-      expertAccessTokenSecret,
-      adminAccessTokenSecret,
-    });
-  }
-
-  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,
-        ...(payload.role === "ADMIN"
-          ? { userame: payload.username }
-          : { email: payload.email }),
-        role: payload.role,
-      };
-      next();
-    } catch (err) {
-      if (err instanceof AccessTokenVerifyError) {
-        res
-          .status(HttpStatus.UNAUTHORIZED)
-          .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);
-    }
-  };
-}

package/src/middlewares/requireRole.ts

@@ -1,17 +0,0 @@
-import { NextFunction, Request, Response } from "express";
-import { UserRoles } from "../types/UserRoles";
-import { ForbiddenError } from "../errors/ForbiddenError";
-
-export const requireRole = (...roles: UserRoles[]) => {
-  return (req: Request, _res: Response, next: NextFunction) => {
-    try {
-      if (!req.user || !roles.includes(req.user.role)) {
-        throw new ForbiddenError();
-      } else {
-        next();
-      }
-    } catch (err) {
-      next(err);
-    }
-  };
-};