@vmbbtickets/common 1.0.3 → 1.0.5

package/package.json

@@ -1,18 +1,29 @@
 {
   "name": "@vmbbtickets/common",
-  "version": "1.0.3",
+  "version": "1.0.5",
   "main": "./build/index.js",
   "scripts": {
     "clean": "del ./build/*",
     "build": "npm run clean && tsc",
-    "pub": "git add . && git commit -m \"Updates\" && npm version patch && npm publish"
+    "pub": "git add . && git commit -m \"Updates\" && npm run build && npm version patch && npm publish"
   },
   "keywords": [],
   "author": "",
   "license": "ISC",
   "description": "",
   "devDependencies": {
+    "@types/express-session": "^1.19.0",
     "del-cli": "^7.0.0",
     "typescript": "^7.0.2"
+  },
+  "dependencies": {
+    "@types/cookie-session": "^2.0.49",
+    "@types/express": "5.0.0",
+    "@types/jsonwebtoken": "^9.0.10",
+    "cookie-session": "^2.1.1",
+    "express": "4.16.2",
+    "express-async-errors": "^3.1.1",
+    "express-validator": "^7.3.2",
+    "jsonwebtoken": "^9.0.3"
   }
 }

package/src/errors/bad-request-error.ts

@@ -0,0 +1,13 @@
+import { CustomError } from "./custom-error";
+
+export class BadRequestError extends CustomError {
+  statusCode = 400;
+
+  constructor(public message: string) {
+    super(message);
+  }
+
+  serializeErrors() {
+    return [{ message: this.message }];
+  }
+}

package/src/errors/custom-error.ts

@@ -0,0 +1,11 @@
+export abstract class CustomError extends Error {
+  abstract statusCode: number;
+  constructor(message: string) {
+    super(message);
+
+    // Ensure the prototype is set to the concrete subclass prototype so
+    // subclass methods (e.g. `serializeErrors`) remain available on `this`.
+    Object.setPrototypeOf(this, new.target.prototype);
+  }
+  abstract serializeErrors(): { message: string; field?: string }[];
+}

package/src/errors/database-connection-error.ts

@@ -0,0 +1,20 @@
+import { CustomError } from "./custom-error";
+
+export class DatabaseConnectionError extends CustomError {
+  statusCode = 500;
+  reason = "Unable to connect to database";
+
+  constructor() {
+    super("Database connection error");
+
+    Object.setPrototypeOf(this, DatabaseConnectionError.prototype);
+  }
+
+  serializeErrors() {
+    return [
+      {
+        message: this.reason,
+      },
+    ];
+  }
+}

package/src/errors/not-authorized-errors.ts

@@ -0,0 +1,15 @@
+import { CustomError } from "./custom-error";
+
+export class NotAuthorizedErrors extends CustomError {
+  statusCode: number = 401;
+
+  constructor(public message: string) {
+    super(message);
+
+    Object.setPrototypeOf(this, NotAuthorizedErrors.prototype);
+  }
+
+  serializeErrors(): { message: string; field?: string }[] {
+    return [{ message: this.message }];
+  }
+}

package/src/errors/not-found-error.ts

@@ -0,0 +1,13 @@
+import { CustomError } from "./custom-error";
+
+export class NotFoundError extends CustomError {
+  statusCode = 404;
+
+  constructor() {
+    super("Route not found");
+  }
+
+  serializeErrors() {
+    return [{ message: "Route not found" }];
+  }
+}

package/src/errors/request-validation-error.ts

@@ -0,0 +1,20 @@
+import { ValidationError } from "express-validator";
+import { CustomError } from "./custom-error";
+
+export class RequestValidationError extends CustomError {
+  statusCode = 400;
+
+  constructor(public errors: ValidationError[]) {
+    super("Validation errors");
+    Object.setPrototypeOf(this, RequestValidationError.prototype);
+  }
+
+  serializeErrors() {
+    return this.errors.map((error) => {
+      if (error.type === "field") {
+        return { message: error.msg, field: error.path };
+      }
+      return { message: error.msg };
+    });
+  }
+}

package/src/index.ts

@@ -1,17 +1,11 @@
-interface Color {
-  red: number;
-  blue: number;
-  green: number;
-  yellow: number;
-}
+export * from "./errors/bad-request-error";
+export * from "./errors/custom-error";
+export * from "./errors/database-connection-error";
+export * from "./errors/not-authorized-errors";
+export * from "./errors/not-found-error";
+export * from "./errors/request-validation-error";
 
-const color: Color = {
-  red: 10,
-  blue: 10,
-  green: 10,
-  yellow: 10,
-};
-
-console.log(color);
-
-export default color;
+export * from "./middleware/current-user";
+export * from "./middleware/error-handler";
+export * from "./middleware/require-auth";
+export * from "./middleware/validate-request";

package/src/middleware/current-user.ts

@@ -0,0 +1,35 @@
+import { Request, Response, NextFunction } from "express";
+import jwt from "jsonwebtoken";
+
+interface UserPayload {
+  id: string;
+  email: string;
+}
+
+declare global {
+  namespace Express {
+    interface Request {
+      currentUser?: UserPayload;
+    }
+  }
+}
+
+export const currentUser = (
+  req: Request,
+  res: Response,
+  next: NextFunction,
+) => {
+  if (!(req as any).session.jwt) {
+    next();
+  }
+
+  try {
+    const decoded = jwt.verify(
+      (req as any).session.jwt,
+      process.env.JWT_KEY!,
+    ) as UserPayload;
+    req.currentUser = decoded;
+  } catch (err) {}
+
+  next();
+};

package/src/middleware/error-handler.ts

@@ -0,0 +1,17 @@
+import { Response, Request, NextFunction } from "express";
+import { CustomError } from "../errors/custom-error";
+
+export const errorHandler = (
+  err: Error,
+  req: Request,
+  res: Response,
+  next: NextFunction,
+) => {
+  if (err instanceof CustomError) {
+    return res.status(err.statusCode).send({ errors: err.serializeErrors() });
+  }
+
+  res.status(500).send({
+    errors: [{ message: "Internal Server Error" }],
+  });
+};

package/src/middleware/require-auth.ts

@@ -0,0 +1,12 @@
+import { Request, Response, NextFunction } from "express";
+import { NotAuthorizedErrors } from "../errors/not-authorized-errors";
+
+export const requireAuth = (
+  req: Request,
+  res: Response,
+  next: NextFunction,
+) => {
+  if (!req.currentUser) {
+    throw new NotAuthorizedErrors("User is not authorized");
+  }
+};

package/src/middleware/validate-request.ts

@@ -0,0 +1,17 @@
+import { Response, Request, NextFunction } from "express";
+import { CustomError } from "../errors/custom-error";
+import { validationResult } from "express-validator";
+import { RequestValidationError } from "../errors/request-validation-error";
+
+export const validateRequest = (
+  req: Request,
+  res: Response,
+  next: NextFunction,
+) => {
+  const errors = validationResult(req);
+  if (!errors.isEmpty()) {
+    throw new RequestValidationError(errors.array());
+  }
+
+  next();
+};