@tabletennisshop/common 1.0.0 → 1.0.2

package/{errors/custom-error.ts → build/errors/custom-error.js}

@@ -1,14 +1,16 @@
-export abstract class CustomError extends Error{
-    abstract statusCode: number;
-    constructor(message: string) {
-        super(message);
-        /*
-        Always use this line in subclasses
-        This will ensure that return true for "instanceof"
-            const error = new CustomError("message");
-            console.log(error instanceof CustomError);
-        */
-        Object.setPrototypeOf(this, CustomError.prototype);
-    }
-    abstract serializeErrors(): {message: string, details?: any}[];
-}
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CustomError = void 0;
+class CustomError extends Error {
+    constructor(message) {
+        super(message);
+        /*
+        Always use this line in subclasses
+        This will ensure that return true for "instanceof"
+            const error = new CustomError("message");
+            console.log(error instanceof CustomError);
+        */
+        Object.setPrototypeOf(this, CustomError.prototype);
+    }
+}
+exports.CustomError = CustomError;

package/build/errors/not-authorized-error.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NotAuthorizedError = void 0;
+const custom_error_1 = require("./custom-error");
+class NotAuthorizedError extends custom_error_1.CustomError {
+    constructor(message) {
+        super(message);
+        this.statusCode = 401;
+        Object.setPrototypeOf(this, NotAuthorizedError.prototype);
+    }
+    serializeErrors() {
+        return [{ message: this.message }];
+    }
+}
+exports.NotAuthorizedError = NotAuthorizedError;

package/build/errors/not-found-error.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NotFoundError = void 0;
+const custom_error_1 = require("./custom-error");
+class NotFoundError extends custom_error_1.CustomError {
+    constructor(message) {
+        super(message);
+        this.statusCode = 401;
+        Object.setPrototypeOf(this, NotFoundError.prototype);
+    }
+    serializeErrors() {
+        return [{ message: this.message }];
+    }
+}
+exports.NotFoundError = NotFoundError;

package/build/errors/request-validate-error.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RequestValidateError = void 0;
+const custom_error_1 = require("./custom-error");
+class RequestValidateError extends custom_error_1.CustomError {
+    constructor(errors) {
+        //Assign message to CustomError abstract class
+        super("Invalid request parameters");
+        this.statusCode = 400;
+        this.errors = errors;
+        Object.setPrototypeOf(this, RequestValidateError.prototype);
+    }
+    serializeErrors() {
+        return this.errors.map((err) => {
+            return { message: err.msg };
+        });
+    }
+}
+exports.RequestValidateError = RequestValidateError;

package/build/index.js

@@ -0,0 +1,23 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+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 });
+__exportStar(require("./errors/custom-error"), exports);
+__exportStar(require("./errors/not-authorized-error"), exports);
+__exportStar(require("./errors/not-found-error"), exports);
+__exportStar(require("./errors/request-validate-error"), exports);
+__exportStar(require("./middlewares/check-authorized-middleware"), exports);
+__exportStar(require("./middlewares/error-handler"), exports);
+__exportStar(require("./middlewares/validate-request-middleware"), exports);

package/build/middlewares/check-authorized-middleware.js

@@ -0,0 +1,25 @@
+"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());
+    });
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CheckAuthorized = void 0;
+const axios_1 = __importDefault(require("axios"));
+const not_authorized_error_1 = require("../errors/not-authorized-error");
+const CheckAuthorized = (req, res, next) => __awaiter(void 0, void 0, void 0, function* () {
+    const axiosRes = yield axios_1.default.get("localhost:3000/api/users/current-user");
+    if (axiosRes.status != 200) {
+        throw new not_authorized_error_1.NotAuthorizedError("Not Authorized");
+    }
+    next();
+});
+exports.CheckAuthorized = CheckAuthorized;

package/build/middlewares/error-handler.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.errorHandler = void 0;
+const custom_error_1 = require("../errors/custom-error");
+const errorHandler = (err, req, res, next) => {
+    if (err instanceof custom_error_1.CustomError) {
+        res.status(err.statusCode).send({ errors: err.serializeErrors() });
+        return;
+    }
+    res.status(400).send({ errors: [{ message: "Something is wrong" }] });
+    return;
+};
+exports.errorHandler = errorHandler;

package/build/middlewares/validate-request-middleware.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const express_validator_1 = require("express-validator");
+const request_validate_error_1 = require("../errors/request-validate-error");
+const validateRequestMiddleware = (req, res, next) => {
+    const errors = (0, express_validator_1.validationResult)(req);
+    if (!errors.isEmpty()) {
+        throw new request_validate_error_1.RequestValidateError(errors.array());
+    }
+    next();
+};
+exports.default = validateRequestMiddleware;

package/package.json

@@ -1,13 +1,27 @@
 {
   "name": "@tabletennisshop/common",
-  "version": "1.0.0",
+  "version": "1.0.2",
   "description": "",
-  "main": "index.js",
+  "main": "./build/index.js",
+  "types": "build/index.d.ts",
   "scripts": {
-    "test": "echo \"Error: no test specified\" && exit 1"
+    "clean": "del build",
+    "build": "npm run clean && tsc",
+    "pub": "npm version patch && npm run build && npm publish"
   },
+  "files": [
+    "build/**/*"
+  ],
   "keywords": [],
   "author": "",
   "license": "ISC",
-  "type": "commonjs"
+  "type": "commonjs",
+  "dependencies": {
+    "@tabletennisshop/common": "^1.0.1",
+    "@types/express": "^5.0.2",
+    "axios": "^1.9.0",
+    "express": "^5.1.0",
+    "express-validator": "^7.2.1",
+    "uninstall": "^0.0.0"
+  }
 }

package/errors/not-authorized-error.ts

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

package/errors/not-found-error.ts

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

package/errors/request-validate-error.ts

@@ -1,17 +0,0 @@
-import { CustomError } from './custom-error';
-import { ValidationError } from 'express-validator';
-export class RequestValidateError extends CustomError{
-    statusCode = 400;
-    private errors: ValidationError[];
-    constructor(errors: ValidationError[]){
-        //Assign message to CustomError abstract class
-        super("Invalid request parameters");
-        this.errors = errors;
-        Object.setPrototypeOf(this, RequestValidateError.prototype);
-    }
-    serializeErrors() {
-        return this.errors.map((err)=>{
-            return {message: err.msg};
-        });
-    }
-}

package/middlewares/check-authorized-middleware.ts

@@ -1,10 +0,0 @@
-import { NextFunction } from "express"
-import axios from "axios";
-import { NotAuthorizedError } from "../errors/not-authorized-error";
-export const CheckAuthorized= async (req: Request, res: Response, next: NextFunction)=>{
-    const axiosRes = await axios.get("localhost:3000/api/users/current-user");
-    if (axiosRes.status != 200){
-        throw new NotAuthorizedError("Not Authorized");
-    }
-    next();
-}

package/middlewares/error-handler.ts

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

package/middlewares/validate-request-middleware.ts

@@ -1,12 +0,0 @@
-import express, { NextFunction, Request, Response } from 'express';
-import { validationResult } from 'express-validator';
-import { RequestValidateError } from '../errors/request-validate-error';
-
-const validateRequestMiddleware = (req: Request, res: Response, next: NextFunction) => {
-    const errors = validationResult(req);
-    if (!errors.isEmpty()) {
-        throw new RequestValidateError(errors.array());
-    }
-    next();
-}
-export default validateRequestMiddleware;