@dip-university/common 3.0.8 → 3.0.9

package/build/errors/database-connection-error.d.ts

@@ -1,7 +1,5 @@
-import { httpError } from "./http-error";
-export declare class DatabaseConnectionError extends httpError {
-    statusCode: number;
-    reason: string;
+import { HttpError } from "./http-error";
+export declare class DatabaseConnectionError extends HttpError {
     constructor();
     serializeErrors(): {
         message: string;

package/build/errors/database-connection-error.js

@@ -2,15 +2,13 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.DatabaseConnectionError = void 0;
 const http_error_1 = require("./http-error");
-class DatabaseConnectionError extends http_error_1.httpError {
+class DatabaseConnectionError extends http_error_1.HttpError {
     constructor() {
-        super("Error connecting to db", 500);
-        this.statusCode = 500;
-        this.reason = "Error connecting to database";
+        super("Error connecting to database", 500);
         Object.setPrototypeOf(this, DatabaseConnectionError.prototype);
     }
     serializeErrors() {
-        return [{ message: this.reason }];
+        return [{ message: this.message }];
     }
 }
 exports.DatabaseConnectionError = DatabaseConnectionError;

package/build/errors/http-error.d.ts

@@ -1,4 +1,4 @@
-export declare class httpError extends Error {
+export declare class HttpError extends Error {
     statusCode: number;
     code?: string;
     constructor(message: string, statusCode?: number, code?: string);

package/build/errors/http-error.js

@@ -1,16 +1,16 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.httpError = void 0;
-class httpError extends Error {
+exports.HttpError = void 0;
+class HttpError extends Error {
     constructor(message, statusCode = 400, code) {
         super(message);
         this.statusCode = statusCode;
         if (code)
             this.code = code;
-        Object.setPrototypeOf(this, httpError.prototype);
+        Object.setPrototypeOf(this, HttpError.prototype);
     }
     serializeErrors() {
         return [{ message: this.message, code: this.code }];
     }
 }
-exports.httpError = httpError;
+exports.HttpError = HttpError;

package/build/errors/not-authorized-error.d.ts

@@ -0,0 +1,7 @@
+import { HttpError } from "./http-error";
+export declare class NotAuthorizedError extends HttpError {
+    constructor();
+    serializeErrors(): {
+        message: string;
+    }[];
+}

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

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NotAuthorizedError = void 0;
+const http_error_1 = require("./http-error");
+class NotAuthorizedError extends http_error_1.HttpError {
+    constructor() {
+        super("Not authorized", 401);
+        Object.setPrototypeOf(this, NotAuthorizedError.prototype);
+    }
+    serializeErrors() {
+        return [{ message: this.message }];
+    }
+}
+exports.NotAuthorizedError = NotAuthorizedError;

package/build/errors/not-found-error.d.ts

@@ -1,6 +1,5 @@
-import { httpError } from "./http-error";
-export declare class NotFoundError extends httpError {
-    statusCode: number;
+import { HttpError } from "./http-error";
+export declare class NotFoundError extends HttpError {
     constructor(message?: string);
     serializeErrors(): {
         message: string;

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

@@ -2,10 +2,9 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.NotFoundError = void 0;
 const http_error_1 = require("./http-error");
-class NotFoundError extends http_error_1.httpError {
+class NotFoundError extends http_error_1.HttpError {
     constructor(message = "Not Found") {
         super(message, 404);
-        this.statusCode = 404;
         Object.setPrototypeOf(this, NotFoundError.prototype);
     }
     serializeErrors() {

package/build/errors/request-validation-error.d.ts

@@ -1,12 +1,11 @@
-import { httpError } from "./http-error";
+import { HttpError } from "./http-error";
 interface ValidationErrorItem {
     msg: string;
     param?: string;
     location?: string;
 }
-export declare class RequestValidationError extends httpError {
+export declare class RequestValidationError extends HttpError {
     errors: ValidationErrorItem[];
-    statusCode: number;
     constructor(errors: ValidationErrorItem[]);
     serializeErrors(): {
         message: string;

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

@@ -2,15 +2,17 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.RequestValidationError = void 0;
 const http_error_1 = require("./http-error");
-class RequestValidationError extends http_error_1.httpError {
+class RequestValidationError extends http_error_1.HttpError {
     constructor(errors) {
         super("Invalid request parameters", 400);
         this.errors = errors;
-        this.statusCode = 400;
         Object.setPrototypeOf(this, RequestValidationError.prototype);
     }
     serializeErrors() {
-        return this.errors.map((err) => ({ message: err.msg, field: err.param }));
+        return this.errors.map((err) => ({
+            message: err.msg,
+            field: err.param,
+        }));
     }
 }
 exports.RequestValidationError = RequestValidationError;

package/build/middlewares/currentUser.js

@@ -27,7 +27,7 @@ const currentUser = (req, res, next) => __awaiter(void 0, void 0, void 0, functi
         next();
     }
     catch (err) {
-        throw new http_error_1.httpError("Invalid token", 401);
+        throw new http_error_1.HttpError("Invalid token", 401);
     }
 });
 exports.currentUser = currentUser;

package/build/middlewares/error-handler.js

@@ -3,7 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.errorHandler = void 0;
 const http_error_1 = require("../errors/http-error");
 const errorHandler = (err, req, res, next) => {
-    if (err instanceof http_error_1.httpError) {
+    if (err instanceof http_error_1.HttpError) {
         return res.status(err.statusCode).send({ errors: err.serializeErrors() });
     }
     console.error(err);

package/build/middlewares/requireAuth.js

@@ -1,10 +1,10 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.requireAuth = void 0;
-const http_error_1 = require("../errors/http-error");
+const not_authorized_error_1 = require("../errors/not-authorized-error");
 const requireAuth = (req, res, next) => {
     if (!req.currentUser) {
-        throw new http_error_1.httpError("Unauthorized", 401);
+        throw new not_authorized_error_1.NotAuthorizedError();
     }
     next();
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dip-university/common",
-  "version": "3.0.8",
+  "version": "3.0.9",
   "description": "Shared auth, errors, and middleware for microservices",
   "main": "./build/index.js",
   "types": "./build/index.d.ts",
@@ -10,8 +10,7 @@
   "scripts": {
     "clean": "del-cli build",
     "build": "npm run clean && tsc",
-    "release:patch": "npm version patch",
-    "publish:pkg": "npm run build && npm publish --access=public"
+    "publish": "npm run build && npm version patch &&npm publish --access=public"
   },
   "license": "ISC",
   "peerDependencies": {