@sn1006/common 1.0.10 → 1.0.14

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

@@ -1,9 +1,9 @@
-import NormalizedError from './normalized-error';
+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 normalized_error_1 = __importDefault(require("./normalized-error"));
-class BadRequestError extends normalized_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 NormalizedError from './normalized-error';
+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 normalized_error_1 = __importDefault(require("./normalized-error"));
-class DBError extends normalized_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/joi-validate-request.d.ts

@@ -0,0 +1,3 @@
+import { NextFunction, Request, Response } from "express";
+import Joi from "joi";
+export default function joiValidateRequest(schema: Joi.AnySchema, options?: Joi.ValidationOptions): (req: Request, res: Response, next: NextFunction) => any;

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

@@ -0,0 +1,18 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const validation_error_1 = __importDefault(require("./validation-error"));
+function joiValidateRequest(schema, options) {
+    return (req, res, next) => {
+        const { error } = schema.validate(req, options);
+        if (error) {
+            // normalized the error to be similar to express-validator error
+            const errors = error.details.map((err) => (Object.assign(Object.assign({}, err), { msg: err.message, path: err.path.join(".") })));
+            return next(new validation_error_1.default(errors));
+        }
+        return next();
+    };
+}
+exports.default = joiValidateRequest;

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

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

package/build/errors/normalized-error.js

@@ -1,5 +1,6 @@
 "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) {
@@ -7,4 +8,4 @@ class NormalizedError extends Error {
         Object.setPrototypeOf(this, NormalizedError.prototype);
     }
 }
-exports.default = NormalizedError;
+exports.NormalizedError = NormalizedError;

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

@@ -1,8 +1,8 @@
-import NormalizedError from './normalized-error';
+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 normalized_error_1 = __importDefault(require("./normalized-error"));
-class NotAuthorizedError extends normalized_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 NormalizedError from './normalized-error';
+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 normalized_error_1 = __importDefault(require("./normalized-error"));
-class NotFoundError extends normalized_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,11 +1,14 @@
-import NormalizedError from './normalized-error';
-import { ValidationError } from 'express-validator';
+import { NormalizedError } from './normalized-error';
+interface NonSerializedValidationError {
+    msg: string;
+    path: string;
+}
 declare class CustomValidationError extends NormalizedError {
-    errors: ValidationError[];
+    errors: NonSerializedValidationError[];
     status: number;
-    constructor(errors: ValidationError[]);
-    serializeError(): {
-        message: any;
+    constructor(errors: NonSerializedValidationError[]);
+    serializeErrors(): {
+        message: string;
         field: string;
     }[];
 }

package/build/errors/validation-error.js

@@ -1,20 +1,16 @@
 "use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
 Object.defineProperty(exports, "__esModule", { value: true });
-const normalized_error_1 = __importDefault(require("./normalized-error"));
-class CustomValidationError extends normalized_error_1.default {
+const normalized_error_1 = require("./normalized-error");
+class CustomValidationError extends normalized_error_1.NormalizedError {
     constructor(errors) {
         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 };
+            return { message: err.msg, field: err.path };
         });
     }
 }

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 normalized_error_1 = __importDefault(require("../errors/normalized-error"));
+const normalized_error_1 = require("../errors/normalized-error");
 const errorHandler = (err, req, res, next) => {
     console.log(err);
-    if (err instanceof normalized_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/build/middlewares/validate-request.js

@@ -7,9 +7,10 @@ exports.validateRequest = void 0;
 const express_validator_1 = require("express-validator");
 const validation_error_1 = __importDefault(require("../errors/validation-error"));
 const validateRequest = (req, res, next) => {
-    const errors = (0, express_validator_1.validationResult)(req);
-    if (!errors.isEmpty()) {
-        return next(new validation_error_1.default(errors.array()));
+    const error = (0, express_validator_1.validationResult)(req);
+    if (!error.isEmpty()) {
+        const errors = error.array();
+        return next(new validation_error_1.default(errors));
     }
     next();
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sn1006/common",
-  "version": "1.0.10",
+  "version": "1.0.14",
   "description": "",
   "main": "./build/index.js",
   "types": "./build/index.d.ts",
@@ -26,6 +26,7 @@
     "cookie-session": "^2.0.0",
     "express": "^4.18.2",
     "express-validator": "^7.0.1",
+    "joi": "^17.12.1",
     "jsonwebtoken": "^9.0.1"
   }
 }