@meaptickets/common 1.0.0 → 1.0.3

package/package.json

@@ -1,12 +1,33 @@
 {
   "name": "@meaptickets/common",
-  "version": "1.0.0",
+  "version": "1.0.3",
   "description": "",
-  "main": "index.js",
+  "main": "./build/index.js",
+  "types": "./build/index.d.ts",
+  "file": [
+    "build/**/*"
+  ],
   "scripts": {
-    "test": "echo \"Error: no test specified\" && exit 1"
+    "clean": "rimraf build",
+    "build": "npm run clean && tsc",
+    "pub": "git add . && git commit -m \"Updates\" && npm version patch && npm run build &&  npm publish --access public"
   },
   "keywords": [],
   "author": "",
-  "license": "ISC"
+  "license": "ISC",
+  "dependencies": {
+    "@types/cookie-session": "^2.0.49",
+    "@types/express": "^5.0.6",
+    "@types/jsonwebtoken": "^9.0.10",
+    "cookie-session": "^2.1.1",
+    "express": "^5.2.1",
+    "express-validator": "^7.3.1",
+    "jsonwebtoken": "^9.0.3",
+    "ts-node": "^10.9.2"
+  },
+  "devDependencies": {
+    "del-cli": "^7.0.0",
+    "rimraf": "^6.1.2",
+    "typescript": "^5.9.3"
+  }
 }

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

@@ -0,0 +1,15 @@
+import { CustomError } from "./custom-error";
+
+export class BadRequestError extends CustomError {
+    statusCode = 400;
+
+    constructor(public message: string) {
+        super(message);
+
+        Object.setPrototypeOf(this, BadRequestError.prototype);
+    }
+
+    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);
+
+        Object.setPrototypeOf(this, CustomError.prototype);
+    }
+
+    abstract serializeErrors(): { message: string, field?: string }[];
+}

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

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

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

@@ -0,0 +1,15 @@
+import { CustomError } from "./custom-error";
+
+export class NotAuthorizedError extends CustomError {
+    statusCode = 401;
+
+    constructor() {
+        super('Not authorized');
+
+        Object.setPrototypeOf(this, NotAuthorizedError.prototype);
+    }
+
+    serializeErrors() {
+        return [{ message: 'Not authorized' }];
+    }
+}

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

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

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

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

package/src/index.ts

@@ -0,0 +1,11 @@
+export * from './errors/bad-request-error';
+export * from './errors/custom-error';
+export * from './errors/database-connection-error';
+export * from './errors/not-authorized-error';
+export * from './errors/not-found-error';
+export * from './errors/request-validation-error';
+
+export * from './middlewares/current-user';
+export * from './middlewares/error-handler';
+export * from './middlewares/require-auth';
+export * from './middlewares/validate-request';

package/src/middlewares/current-user.ts

@@ -0,0 +1,35 @@
+import { Request, Response, NextFunction } from "express";
+import jwt from 'jsonwebtoken';
+import 'cookie-session';
+
+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.session?.jwt) {
+        return next();
+    }
+
+    try {
+        const payload = jwt.verify(req.session.jwt, process.env.JWT_KEY!) as UserPayload;
+        req.currentUser = payload;
+    } catch (err) {
+
+    }
+
+    next();
+};

package/src/middlewares/error-handler.ts

@@ -0,0 +1,17 @@
+import { Request, Response, 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(400).send({
+        errors: [{ message: 'Something went wrong' }]
+    });
+};

package/src/middlewares/require-auth.ts

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

package/src/middlewares/validate-request.ts

@@ -0,0 +1,17 @@
+import { Request, Response, NextFunction } from "express";
+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();
+}

package/tsconfig.json

@@ -0,0 +1,44 @@
+{
+  // Visit https://aka.ms/tsconfig to read more about this file
+  "compilerOptions": {
+    // File Layout
+    // "rootDir": "./src",
+    "outDir": "./build",
+
+    // Environment Settings
+    // See also https://aka.ms/tsconfig/module
+    "module": "nodenext",
+    "target": "esnext",
+    "types": [],
+    // For nodejs:
+    // "lib": ["esnext"],
+    // "types": ["node"],
+    // and npm install -D @types/node
+
+    // Other Outputs
+    "sourceMap": true,
+    "declaration": true,
+    "declarationMap": true,
+
+    // Stricter Typechecking Options
+    "noUncheckedIndexedAccess": true,
+    "exactOptionalPropertyTypes": true,
+
+    // Style Options
+    // "noImplicitReturns": true,
+    // "noImplicitOverride": true,
+    // "noUnusedLocals": true,
+    // "noUnusedParameters": true,
+    // "noFallthroughCasesInSwitch": true,
+    // "noPropertyAccessFromIndexSignature": true,
+
+    // Recommended Options
+    "strict": true,
+    "jsx": "react-jsx",
+    "verbatimModuleSyntax": false,
+    "isolatedModules": true,
+    "noUncheckedSideEffectImports": true,
+    "moduleDetection": "force",
+    "skipLibCheck": true,
+  }
+}