@vida-global/core 1.4.1 → 1.4.3

package/index.js

@@ -5,10 +5,22 @@ const   ActiveRecord = require('./lib/activeRecord');
 const   redisLibs    = require('./lib/redis');
 
 
+const {
+  AbstractServerError,
+  ApiDocsGenerator,
+  VidaServer,
+  VidaServerController,
+} = serverLibs;
+const serverErrorsToExport = Object.values(serverLibs).filter(obj => obj.prototype instanceof AbstractServerError);
+
+
 module.exports = {
     ActiveRecord,
     ...httpLibs,
     logger,
     ...redisLibs,
-    ...serverLibs
+    ...serverErrorsToExport,
+    ApiDocsGenerator,
+    VidaServer,
+    VidaServerController,
 };

package/lib/server/errors.js

@@ -1,16 +1,58 @@
-class ServerError extends Error {
+const Statuses = {
+    BadRequest:           400,
+    Unauthorized:         401,
+    PaymentRequired:      402,
+    Forbidden:            403,
+    NotFound:             404,
+    MethodNotAllowed:     405,
+    RequestTimeout:       408,
+    Conflict:             409,
+    Gone:                 410,
+    ContentTooLarge:      413,
+    UnsupportedMediaType: 415,
+    UnprocessableContent: 422,
+    Locked:               423,
+    TooManyRequests:      429,
+    Server:               500,
+    NotImplemented:       501,
+    BadGateway:           502,
+    ServiceUnavailable:   503,
+    GatewayTimeout:       504,
+}
+
+
+const classNameForErrorType = (type) => `${type}Error`;
+
+
+
+class AbstractServerError extends Error {
     #message;
-    constructor(message) {
+    #body;
+    constructor(message, body) {
         super();
         this.#message = message;
+        this.#body    = body || null;
     }
     get message() { return this.#message; }; 
+    get body()    { return this.#body; }; 
+    get type()    { 
+        const clsName = this.constructor.name;
+        return clsName == 'ServerError' ? 'ServerError' : clsName.replace('Error', '')
+    }
 }
-class AuthorizationError extends ServerError {}
-class ConflictError      extends ServerError {}
-class ForbiddenError     extends ServerError {}
-class NotFoundError      extends ServerError {}
-class ValidationError    extends ServerError {
+
+
+const ErrorClasses = {};
+for (const [type, statusCode] of Object.entries(Statuses)) {
+    const clsName         = classNameForErrorType(type);
+    const cls             = class extends AbstractServerError {};
+    ErrorClasses[clsName] = cls
+    Object.defineProperty(cls, 'name',       { value: clsName });
+    Object.defineProperty(cls, 'statusCode', { value: statusCode });
+}
+
+
+class ValidationError extends AbstractServerError {
     #fields;
     constructor(message, fields) {
         super(message);
@@ -20,11 +62,22 @@ class ValidationError    extends ServerError {
 }
 
 
+function errorForStatusCode(code) {
+    for (const [type, aCode] of Object.entries(Statuses)) {
+        if (code == aCode) {
+            return ErrorClasses[classNameForErrorType(type)];
+        }
+    }
+    return null;
+}
+
+
+
 module.exports = {
-    AuthorizationError,
-    ConflictError,
-    ForbiddenError,
-    NotFoundError,
-    ServerError,
+    ...ErrorClasses,
+    AuthorizationError: ErrorClasses.UnauthorizedError, // Deprecated
+    errorForStatusCode,
+    AbstractServerError,
+    Statuses, 
     ValidationError
 }

package/lib/server/index.js

@@ -1,11 +1,12 @@
 const { VidaServer }           = require('./server');
 const { VidaServerController } = require('./serverController');
-const   ERRORS                 = require('./errors');
+const   Errors                 = require('./errors');
 const { ApiDocsGenerator }    = require('./apiDocsGenerator');
 
+
 module.exports = {
     ApiDocsGenerator,
-    ...ERRORS,
+    ...Errors,
     VidaServer,
     VidaServerController,
 }

package/lib/server/serverController.js

@@ -1,22 +1,19 @@
 const { logger }                 = require('../logger');
 const { camelize, singularize }  = require('inflection');
-const{ AuthorizationError,
-       ConflictError,
-       ForbiddenError,
-       NotFoundError,
-       ServerError,
-       ValidationError }         = require('./errors');
+const   Errors                   = require('./errors');
 
 
 const AUTH_CALLBACK_NAME = 'authenticateRequest';
 
 
 class VidaServerController {
-    #afterCallbacks  = [];
-    #beforeCallbacks = [];
-    #callbacksSetUp  = false;
+    #afterCallbacks        = [];
+    #afterCallbacksToSkip  = [];
+    #beforeCallbacks       = [];
+    #beforeCallbacksToSkip = [];
+    #callbacksSetUp        = false;
     #params;
-    #rendered        = false;
+    #rendered              = false;
     #request;
     #response;
 
@@ -122,25 +119,22 @@ class VidaServerController {
 
 
     async #handleError(err) {
-        if (err instanceof AuthorizationError) {
-            await this.renderUnauthorized(err.message);
+        if (err instanceof Errors.AuthorizationError) {
+            await this.renderUnauthorized(err.message, err.body);
 
-        } else if (err instanceof ConflictError) {
-            await this.renderConflict(err.message);
-
-        } else if (err instanceof ForbiddenError) {
-            await this.renderForbidden(err.message);
-
-        } else if (err instanceof NotFoundError) {
-            await this.renderNotFound(err.message);
-
-        } else if (err instanceof ValidationError) {
+        } else if (err instanceof Errors.ValidationError) {
             await this.renderErrors(err.message, err.fields);
 
+        } else if (err instanceof Errors.AbstractServerError) {
+            const renderer = `render${err.type}`;
+            await this[renderer](err.message, err.body);
+
         } else {
             this._response.error = err;
-            let message;
-            if (typeof err == 'string') {
+            let message = null;
+            if (process.env.NODE_ENV != 'development') {
+                // don't show error details outside of development
+            } else if (typeof err == 'string') {
                 message = err;
             } else {
                 message = err.message;
@@ -170,8 +164,6 @@ class VidaServerController {
 
 
     async renderErrors(message, fields) {
-        this.statusCode = 400;
-
         const errors = {message: null, fields: {}};
 
         if (message && !fields && typeof message == 'object') {
@@ -179,7 +171,6 @@ class VidaServerController {
             message = null;
         }
 
-        if (message) errors.message = message;
         if (fields) {
           for (const [field, values] of Object.entries(fields)) {
               if (!Array.isArray(values)) fields[field] = [values];
@@ -187,15 +178,7 @@ class VidaServerController {
           errors.fields = fields;
         }
 
-        await this.render({ errors });
-    }
-
-
-    async renderServerError(message=null) {
-        if (process.env.NODE_ENV != 'development') {
-            message = null;
-        }
-        return await this.#renderError(500, message);
+        await this.renderBadRequest(message, { errors });
     }
 
 
@@ -213,6 +196,8 @@ class VidaServerController {
         if (body === undefined)               return null;
         if (!body || typeof body != 'object') return body;
 
+        body = structuredClone(body);
+
         if (body.toApiResponse) {
             const formattedBody = await body.toApiResponse(options);
             return await this.processJSONBody(formattedBody, options);
@@ -285,27 +270,19 @@ class VidaServerController {
                 return 'too many requests';
             case 500:
                 return 'server error';
+            case 501:
+                return 'not implemented';
+            case 502:
+                return 'bad gateway';
+            case 503:
+                return 'service unavailable';
+            case 504:
+                return 'gateway timeout';
         }
     }
 
 
     #setupStatusRenderers() {
-      const errorStatuses = {
-        Unauthorized:         401,
-        PaymentRequired:      402,
-        Forbidden:            403,
-        NotFound:             404,
-        MethodNotAllowed:     405,
-        RequestTimeout:       408,
-        Conflict:             409,
-        Gone:                 410,
-        ContentTooLarge:      413,
-        UnsupportedMediaType: 415,
-        UnprocessableContent: 422,
-        Locked:               423,
-        TooManyRequests:      429,
-       }
-
       const successStatuses = {
         CreationSuccessful: 201,
         Accepted:           202,
@@ -317,23 +294,26 @@ class VidaServerController {
         PermanentRedirect:  308,
       }
 
-      for (const [method, statusCode] of Object.entries(errorStatuses)) {
-        this[`render${method}`] = async function(message=null) {
-            return await this.#renderError(statusCode, message);
+      for (let [type, statusCode] of Object.entries(Errors.Statuses)) {
+        if (type == 'Server') type = 'ServerError';
+        this[`render${type}`] = async function(message=null, body=null) {
+            return await this.#renderError(statusCode, message, body);
         }
       }
 
-      for (const [method, statusCode] of Object.entries(successStatuses)) {
-        this[`render${method}`] = async function(message=null) {
-            return await this.#renderSuccess(statusCode, message);
+      for (let [type, statusCode] of Object.entries(successStatuses)) {
+        this[`render${type}`] = async function(body=null) {
+            return await this.#renderSuccess(statusCode, body);
         }
       }
     }
 
 
-    async #renderError(statusCode, message) {
+    async #renderError(statusCode, message, body) {
         this.statusCode = statusCode;
-        const body = {errors: {message: message || null}};
+        body        = structuredClone(body || {});
+        body.errors = body.errors || {};
+        body.errors.message = message || null;
         return await this.render(body);
     }
 
@@ -413,24 +393,40 @@ class VidaServerController {
     }
 
 
+    skipBeforeCallback(callback, options={}) {
+        this.#addCallback(callback, options, this.#beforeCallbacksToSkip);
+    }
+
+
+    skipAfterCallback(callback, options={}) {
+        this.#addCallback(callback, options, this.#afterCallbacksToSkip);
+    }
+
+
     #addCallback(callback, options, callbacksList) {
         callbacksList.push({ callback, options });
     }
 
 
     async runBeforeCallbacks(actionName) {
-        return await this.#runCallbacks(this.#beforeCallbacks, actionName);
+        return await this.#runCallbacks(this.#beforeCallbacks, this.#beforeCallbacksToSkip, actionName);
     }
 
 
     async runAfterCallbacks(actionName) {
-        return await this.#runCallbacks(this.#afterCallbacks, actionName);
+        return await this.#runCallbacks(this.#afterCallbacks, this.#afterCallbacksToSkip, actionName);
     }
 
 
-    async #runCallbacks(callbacksList, actionName) {
+    async #runCallbacks(callbacksList, callbacksToSkipList, actionName) {
+        let toSkip = callbacksToSkipList.filter(({ callback, options }) => {
+            return this.#shouldRunCallback(actionName, options);
+        });
+        toSkip = toSkip.map(({ callback }) => callback);
+
         for (const  { callback, options } of callbacksList) {
             if (!this.#shouldRunCallback(actionName, options)) continue;
+            if (toSkip.includes(callback))                     continue;
             const result = await this.#runCallback(callback)
             if (result === false) return false;
         }
@@ -470,7 +466,7 @@ class VidaServerController {
             if (parameterErrors.length) errors[parameterName] = parameterErrors;
         }
 
-        if (Object.keys(errors).length) throw new ValidationError('', errors);
+        if (Object.keys(errors).length) throw new Errors.ValidationError('', errors);
     }
 
 
@@ -677,14 +673,10 @@ class VidaServerController {
 }
 
 
-VidaServerController.prototype.Errors = {
-    Authorization: AuthorizationError,
-    Conflict:      ConflictError,
-    Forbidden:     ForbiddenError,
-    NotFound:      NotFoundError,
-    Server:        ServerError,
-    Validation:    ValidationError
-}
+const errorClasses = Object.values(Errors).filter(cls => cls == Errors.ServerError || cls.prototype instanceof Errors.AbstractServerError);
+VidaServerController.prototype.Errors = Object.fromEntries(errorClasses.map(cls => {
+    return [cls.name.replace('Error', ''), cls]
+}));
 
 
 module.exports = { 

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@vida-global/core",
-    "version": "1.4.1",
+    "version": "1.4.3",
     "description": "Core libraries for supporting Vida development",
     "author": "",
     "license": "ISC",

package/test/server/errors.test.js

@@ -0,0 +1,54 @@
+const Errors = require('../../lib/server/errors');
+
+
+const Statuses = [
+    ['BadRequest',           400],
+    ['Unauthorized',         401],
+    ['PaymentRequired',      402],
+    ['Forbidden',            403],
+    ['NotFound',             404],
+    ['MethodNotAllowed',     405],
+    ['RequestTimeout',       408],
+    ['Conflict',             409],
+    ['Gone',                 410],
+    ['ContentTooLarge',      413],
+    ['UnsupportedMediaType', 415],
+    ['UnprocessableContent', 422],
+    ['Locked',               423],
+    ['TooManyRequests',      429],
+    ['Server',               500],
+    ['NotImplemented',       501],
+    ['BadGateway',           502],
+    ['ServiceUnavailable',   503],
+    ['GatewayTimeout',       504],
+];
+
+
+describe.each(Statuses)('describe %s', (type, statusCode) => {
+    const cls = Errors.errorForStatusCode(statusCode);
+
+    describe('statusCode', () => {
+        it (`equals ${statusCode}`, () => {
+            expect(cls.statusCode).toEqual(statusCode);
+        });
+    });
+
+
+    describe('type', () => {
+        const typeStr = type == 'Server' ? 'ServerError' : type;
+        it (`equals ${typeStr}`, () => {
+            expect(new cls().type).toEqual(typeStr);
+        });
+    });
+
+});
+
+
+describe('errorForStatusCode', () => {
+    it.each(Statuses)('returns a %sError for %s', (type, statusCode) => {
+        const clsName = `${type}Error`;
+        const cls     = Errors[clsName];
+        expect(Errors.errorForStatusCode(statusCode)).toEqual(cls);
+
+    });
+});

package/test/server/serverController.test.js

@@ -464,17 +464,39 @@ describe('VidaServerController', () => {
 
     describe('#performRequest', () => {
         const errorHandlers = [
-            ['renderUnauthorized', 'AuthorizationError'],
-            ['renderConflict',     'ConflictError'],
-            ['renderForbidden',    'ForbiddenError'],
-            ['renderNotFound',     'NotFoundError'],
-            ['renderErrors',       'ValidationError'],
-        ]
+            ['renderUnauthorized',         'AuthorizationError'],
+            ['renderErrors',               'ValidationError'],
+            ['renderBadRequest',           'BadRequestError'],
+            ['renderUnauthorized',         'UnauthorizedError'],
+            ['renderPaymentRequired',      'PaymentRequiredError'],
+            ['renderForbidden',            'ForbiddenError'],
+            ['renderNotFound',             'NotFoundError'],
+            ['renderMethodNotAllowed',     'MethodNotAllowedError'],
+            ['renderRequestTimeout',       'RequestTimeoutError'],
+            ['renderConflict',             'ConflictError'],
+            ['renderGone',                 'GoneError'],
+            ['renderContentTooLarge',      'ContentTooLargeError'],
+            ['renderUnsupportedMediaType', 'UnsupportedMediaTypeError'],
+            ['renderUnprocessableContent', 'UnprocessableContentError'],
+            ['renderLocked',               'LockedError'],
+            ['renderTooManyRequests',      'TooManyRequestsError'],
+            ['renderServerError',          'ServerError'],
+            ['renderNotImplemented',       'NotImplementedError'],
+            ['renderBadGateway',           'BadGatewayError'],
+            ['renderServiceUnavailable',   'ServiceUnavailableError'],
+            ['renderGatewayTimeout',       'GatewayTimeoutError'],
+        ];
 
         it.each(errorHandlers)('calls %s when %s is thrown', async (handlerName, errorClsName) => {
             const controller = new FooController({}, {});
+            const key        = TestHelpers.Faker.Text.randomString();
+            const value      = TestHelpers.Faker.Text.randomString();
+            const body       = {[key]: value};
             const message    = TestHelpers.Faker.Text.randomString();
-            const error      = new Errors[errorClsName](message);
+
+          if (!Errors[errorClsName]) console.log(errorClsName);
+
+            const error      = new Errors[errorClsName](message, body);
             if (handlerName == 'renderErrors') error.errors = randomPayload();
 
             controller[handlerName] = jest.fn();
@@ -485,7 +507,7 @@ describe('VidaServerController', () => {
             if (handlerName == 'renderErrors') {
                 expect(controller[handlerName]).toHaveBeenCalledWith(message, error.fields);
             } else {
-                expect(controller[handlerName]).toHaveBeenCalledWith(message);
+                expect(controller[handlerName]).toHaveBeenCalledWith(message, body);
             }
         });
 
@@ -611,6 +633,11 @@ describe('VidaServerController', () => {
             ['renderUnprocessableContent', 422],
             ['renderLocked',               423],
             ['renderTooManyRequests',      429],
+            ['renderServerError',          500],
+            ['renderNotImplemented',       501],
+            ['renderBadGateway',           502],
+            ['renderServiceUnavailable',   503],
+            ['renderGatewayTimeout',       504],
         ]
 
         describe.each(errorHandlers)('#%s', (handlerName, statusCode) => {
@@ -631,6 +658,17 @@ describe('VidaServerController', () => {
                 expect(controller.render).toHaveBeenCalledTimes(1);
                 expect(controller.render).toHaveBeenCalledWith({errors: {message: msg}});
             });
+
+            it ('includes a provided body and message', async () => {
+                const key      = TestHelpers.Faker.Text.randomString();
+                const val      = TestHelpers.Faker.Text.randomString();
+                const body     = {[key]: val};
+                const msg      = TestHelpers.Faker.Text.randomString();
+                const expected = {...body, errors: {message: msg}};
+                await controller[handlerName](msg, body);
+                expect(controller.render).toHaveBeenCalledTimes(1);
+                expect(controller.render).toHaveBeenCalledWith(expected);
+            });
         });
     });