@sn1006/common 1.0.9 → 1.0.12

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

@@ -1,9 +1,9 @@
-import CustomError from './custom-error';
-export declare class BadRequestError extends CustomError {
+import { NormalizedError } from './normalized-error';
+export declare class BadRequestError extends NormalizedError {
     message: string;
     status: number;
     constructor(message: string);
-    serializeError(): {
+    serializeErrors(): {
         message: string;
     }[];
 }

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

@@ -1,18 +1,15 @@
 "use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.BadRequestError = void 0;
-const custom_error_1 = __importDefault(require("./custom-error"));
-class BadRequestError extends custom_error_1.default {
+const normalized_error_1 = require("./normalized-error");
+class BadRequestError extends normalized_error_1.NormalizedError {
     constructor(message) {
         super(message);
         this.message = message;
         this.status = 400;
         Object.setPrototypeOf(this, BadRequestError.prototype);
     }
-    serializeError() {
+    serializeErrors() {
         return [{ message: this.message }];
     }
 }

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

@@ -1,8 +1,8 @@
-import CustomError from './custom-error';
-export default class DBError extends CustomError {
+import { NormalizedError } from './normalized-error';
+export default class DBError extends NormalizedError {
     status: number;
     constructor();
-    serializeError(): {
+    serializeErrors(): {
         message: string;
         field?: string | undefined;
     }[];

package/build/errors/db-error.js

@@ -1,16 +1,13 @@
 "use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
 Object.defineProperty(exports, "__esModule", { value: true });
-const custom_error_1 = __importDefault(require("./custom-error"));
-class DBError extends custom_error_1.default {
+const normalized_error_1 = require("./normalized-error");
+class DBError extends normalized_error_1.NormalizedError {
     constructor() {
         super('Error connecting to DB');
         this.status = 500;
         Object.setPrototypeOf(this, DBError.prototype);
     }
-    serializeError() {
+    serializeErrors() {
         return [{ message: this.message }];
     }
 }

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

@@ -0,0 +1,9 @@
+export declare abstract class NormalizedError extends Error {
+    abstract status: number;
+    constructor(message: string);
+    abstract serializeErrors(): SerializedError[];
+}
+export interface SerializedError {
+    message: string;
+    field?: string;
+}

package/build/errors/normalized-error.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NormalizedError = void 0;
+// the purpose of this class is to "normalize" errors between services
+class NormalizedError extends Error {
+    constructor(message) {
+        super(message);
+        Object.setPrototypeOf(this, NormalizedError.prototype);
+    }
+}
+exports.NormalizedError = NormalizedError;

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

@@ -1,8 +1,8 @@
-import CustomError from './custom-error';
-export declare class NotAuthorizedError extends CustomError {
+import { NormalizedError } from './normalized-error';
+export declare class NotAuthorizedError extends NormalizedError {
     status: number;
     constructor();
-    serializeError(): {
+    serializeErrors(): {
         message: string;
     }[];
 }

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

@@ -1,17 +1,14 @@
 "use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.NotAuthorizedError = void 0;
-const custom_error_1 = __importDefault(require("./custom-error"));
-class NotAuthorizedError extends custom_error_1.default {
+const normalized_error_1 = require("./normalized-error");
+class NotAuthorizedError extends normalized_error_1.NormalizedError {
     constructor() {
         super('Not authorized');
         this.status = 401;
         Object.setPrototypeOf(this, NotAuthorizedError.prototype);
     }
-    serializeError() {
+    serializeErrors() {
         return [{ message: this.message }];
     }
 }

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

@@ -1,8 +1,8 @@
-import CustomError from './custom-error';
-export declare class NotFoundError extends CustomError {
+import { NormalizedError } from './normalized-error';
+export declare class NotFoundError extends NormalizedError {
     status: number;
     constructor();
-    serializeError(): {
+    serializeErrors(): {
         message: string;
     }[];
 }

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

@@ -1,17 +1,14 @@
 "use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.NotFoundError = void 0;
-const custom_error_1 = __importDefault(require("./custom-error"));
-class NotFoundError extends custom_error_1.default {
+const normalized_error_1 = require("./normalized-error");
+class NotFoundError extends normalized_error_1.NormalizedError {
     constructor() {
         super("Resource not found");
         this.status = 404;
         Object.setPrototypeOf(this, NotFoundError.prototype);
     }
-    serializeError() {
+    serializeErrors() {
         return [{ message: this.message }];
     }
 }

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

@@ -1,10 +1,10 @@
-import CustomError from './custom-error';
+import { NormalizedError } from './normalized-error';
 import { ValidationError } from 'express-validator';
-declare class CustomValidationError extends CustomError {
+declare class CustomValidationError extends NormalizedError {
     errors: ValidationError[];
     status: number;
     constructor(errors: ValidationError[]);
-    serializeError(): {
+    serializeErrors(): {
         message: any;
         field: string;
     }[];

package/build/errors/validation-error.js

@@ -1,17 +1,14 @@
 "use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
 Object.defineProperty(exports, "__esModule", { value: true });
-const custom_error_1 = __importDefault(require("./custom-error"));
-class CustomValidationError extends custom_error_1.default {
+const normalized_error_1 = require("./normalized-error");
+class CustomValidationError extends normalized_error_1.NormalizedError {
     constructor(errors) {
-        super("Invalid username or password");
+        super("Validaton error");
         this.errors = errors;
         this.status = 400;
         Object.setPrototypeOf(this, CustomValidationError.prototype);
     }
-    serializeError() {
+    serializeErrors() {
         return this.errors.map(err => {
             const ferr = err;
             return { message: ferr.msg, field: ferr.path };

package/build/index.d.ts

@@ -1,5 +1,5 @@
 export * from './errors/bad-request-error';
-export * from './errors/custom-error';
+export * from './errors/normalized-error';
 export * from './errors/db-error';
 export * from './errors/validation-error';
 export * from './errors/not-authorized-error';

package/build/index.js

@@ -15,7 +15,7 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 __exportStar(require("./errors/bad-request-error"), exports);
-__exportStar(require("./errors/custom-error"), exports);
+__exportStar(require("./errors/normalized-error"), exports);
 __exportStar(require("./errors/db-error"), exports);
 __exportStar(require("./errors/validation-error"), exports);
 __exportStar(require("./errors/not-authorized-error"), exports);

package/build/middlewares/error-handler.js

@@ -1,14 +1,11 @@
 "use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.errorHandler = void 0;
-const custom_error_1 = __importDefault(require("../errors/custom-error"));
+const normalized_error_1 = require("../errors/normalized-error");
 const errorHandler = (err, req, res, next) => {
     console.log(err);
-    if (err instanceof custom_error_1.default) {
-        return res.status(err.status).send(err.serializeError());
+    if (err instanceof normalized_error_1.NormalizedError) {
+        return res.status(err.status).send(err.serializeErrors());
     }
     return res.status(400).send('Something went wrong');
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sn1006/common",
-  "version": "1.0.9",
+  "version": "1.0.12",
   "description": "",
   "main": "./build/index.js",
   "types": "./build/index.d.ts",

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

@@ -1,9 +0,0 @@
-declare abstract class CustomError extends Error {
-    abstract status: number;
-    constructor(message: string);
-    abstract serializeError(): {
-        message: string;
-        field?: string;
-    }[];
-}
-export default CustomError;

package/build/errors/custom-error.js

@@ -1,9 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-class CustomError extends Error {
-    constructor(message) {
-        super(message);
-        Object.setPrototypeOf(this, CustomError.prototype);
-    }
-}
-exports.default = CustomError;