@vida-global/core 1.3.3 → 1.4.1

package/lib/logger/index.js

@@ -1,7 +1,10 @@
 const pino = require('pino');
 
 const config = {
-    level: process.env.LOG_LEVEL || 'info'
+    level: process.env.LOG_LEVEL || 'info',
+    customLevels: {
+      test: 1000
+    }
 };
 
 if (!process.env.ENV_VERCEL) {

package/lib/server/README.md

@@ -118,9 +118,34 @@ Additional options can be passed to `toApiResponse` by explicitly calling `rende
 await this.render(response, {includeTitle: true});
 ```
 
+### Other Status Codes
+There is no need to set `statusCode` directly as there are helper methods for all statuses.
+```
+201 - this.renderCreationSuccessful
+202 - this.renderAccepted
+204 - this.renderNoConent
+301 - this.renderMovedPermanently
+302 - this.renderFound
+304 - this.renderNotModified
+307 - this.renderTemporaryRedirect
+308 - this.renderPermanentRedirect
+401 - this.renderUnauthorizedResponse
+402 - this.renderPaymentRequired
+403 - this.renderForbiddenResponse
+404 - this.renderNotFoundResponse
+405 - this.renderMethodNotAllowed
+408 - this.renderRequestTimeout
+409 - this.renderConflictResponse
+410 - this.renderGone
+413 - this.renderContentTooLarge
+415 - this.renderUnsupportedMediaType
+422 - this.renderUnprocessableContent
+423 - this.renderLocked
+429 - this.renderTooManyRequests
+```
+
 
 ## Error handling
-There is no need to set `statusCode` directly as there are helper methods for all statuses.
 HTTP 400
 ```
 await this.renderErrors("Something bad happened", {password: ['must be > 8 characters', 'must include numbers']})
@@ -134,19 +159,16 @@ await this.renderErrors({password: ['must be > 8 characters', 'must include numb
 ```
 HTTP 401
 ```
-await this.renderUnauthorizedResponse("Nope")
+await this.renderUnauthorized("Nope")
 // renders {data: {message: "Nope"}, status: "unauthorized"}
 ```
 HTTP 403
 ```
-await this.renderForbiddenResponse("You shall not pass")
+await this.renderForbidden("You shall not pass")
 // renders {data: {message: "You shall not pass"}, status: "forbidden"}
 ```
-HTTP 404
-```
-await this.renderNotFoundResponse("Whoops")
-// renders {data: {message: "Whoops"}, status: "not found"}
-```
+* _Other statuses detailed above._
+
 Throwing any of `this.Errors.Authorization(msg)`, `this.Errors.Forbidden(msg)`, `this.Errors.NotFound(msg)`, `this.Errors.Validation(msg, errors)` from anywhere in the code will trigger the corresponding error handler. All other errors will generate a 500 error.
 
 

package/lib/server/errors.js

@@ -7,6 +7,7 @@ class ServerError extends Error {
     get message() { return this.#message; }; 
 }
 class AuthorizationError extends ServerError {}
+class ConflictError      extends ServerError {}
 class ForbiddenError     extends ServerError {}
 class NotFoundError      extends ServerError {}
 class ValidationError    extends ServerError {
@@ -21,6 +22,7 @@ class ValidationError    extends ServerError {
 
 module.exports = {
     AuthorizationError,
+    ConflictError,
     ForbiddenError,
     NotFoundError,
     ServerError,

package/lib/server/serverController.js

@@ -1,6 +1,7 @@
 const { logger }                 = require('../logger');
 const { camelize, singularize }  = require('inflection');
 const{ AuthorizationError,
+       ConflictError,
        ForbiddenError,
        NotFoundError,
        ServerError,
@@ -28,6 +29,7 @@ class VidaServerController {
         this.#response = response;
 
         this.#applyCallbacks();
+        this.#setupStatusRenderers();
     }
 
 
@@ -121,13 +123,16 @@ class VidaServerController {
 
     async #handleError(err) {
         if (err instanceof AuthorizationError) {
-            await this.renderUnauthorizedResponse(err.message);
+            await this.renderUnauthorized(err.message);
+
+        } else if (err instanceof ConflictError) {
+            await this.renderConflict(err.message);
 
         } else if (err instanceof ForbiddenError) {
-            await this.renderForbiddenResponse(err.message);
+            await this.renderForbidden(err.message);
 
         } else if (err instanceof NotFoundError) {
-            await this.renderNotFoundResponse(err.message);
+            await this.renderNotFound(err.message);
 
         } else if (err instanceof ValidationError) {
             await this.renderErrors(err.message, err.fields);
@@ -140,7 +145,7 @@ class VidaServerController {
             } else {
                 message = err.message;
             }
-            await this.renderServerErrorResponse(message);
+            await this.renderServerError(message);
         }
     }
 
@@ -186,33 +191,14 @@ class VidaServerController {
     }
 
 
-    async renderUnauthorizedResponse(message=null) {
-        return await this.#renderError(401, message);
-    }
-
-
-    async renderForbiddenResponse(message=null) {
-        return await this.#renderError(403, message);
-    }
-
-
-    async renderNotFoundResponse(message=null) {
-        return await this.#renderError(404, message);
-    }
-
-
-    async renderServerErrorResponse(message=null) {
+    async renderServerError(message=null) {
+        if (process.env.NODE_ENV != 'development') {
+            message = null;
+        }
         return await this.#renderError(500, message);
     }
 
 
-    async #renderError(statusCode, message) {
-        this.statusCode = statusCode;
-        const body = {errors: {message: message || null}};
-        return await this.render(body);
-    }
-
-
     formatJSONBody(body, errors, options) {
         if (options.standardize === false) return body;
 
@@ -253,26 +239,118 @@ class VidaServerController {
         switch(this.statusCode) {
             case 200:
                 return 'ok';
+            case 201:
+                return 'created';
+            case 202:
+                return 'accepted';
+            case 204:
+                return 'no content';
+            case 301:
+              return 'moved permanently';
+            case 302:
+              return 'found';
+            case 304:
+              return 'not modified';
+            case 307:
+              return 'temporary redirect';
+            case 308:
+              return 'permanent redirect';
             case 400:
                 return 'bad request'
             case 401:
                 return 'unauthorized';
+            case 402:
+                return 'payment required';
             case 403:
                 return 'forbidden';
             case 404:
                 return 'not found';
+            case 405:
+                return 'method not allowed';
+            case 408:
+                return 'request timeout';
+            case 409:
+                return 'conflict';
+            case 410:
+                return 'gone';
+            case 413:
+                return 'content too large';
+            case 415:
+                return 'unsupported media type';
+            case 422:
+                return 'unprocessable content';
+            case 423:
+                return 'locked';
+            case 429:
+                return 'too many requests';
             case 500:
                 return 'server error';
         }
     }
 
 
+    #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,
+        NoConent:           204,
+        MovedPermanently:   301,
+        Found:              302,
+        NotModified:        304,
+        TemporaryRedirect:  307,
+        PermanentRedirect:  308,
+      }
+
+      for (const [method, statusCode] of Object.entries(errorStatuses)) {
+        this[`render${method}`] = async function(message=null) {
+            return await this.#renderError(statusCode, message);
+        }
+      }
+
+      for (const [method, statusCode] of Object.entries(successStatuses)) {
+        this[`render${method}`] = async function(message=null) {
+            return await this.#renderSuccess(statusCode, message);
+        }
+      }
+    }
+
+
+    async #renderError(statusCode, message) {
+        this.statusCode = statusCode;
+        const body = {errors: {message: message || null}};
+        return await this.render(body);
+    }
+
+
+    async #renderSuccess(statusCode, body) {
+      this.statusCode = statusCode;
+      return await this.render(body);
+    }
+
+
     /***********************************************************************************************
     * HELPERS
     ***********************************************************************************************/
     static autoLoadHelpers() {
-        const { InstanceMethods, Accessors } = this._autoLoadModule(this.autoLoadHelperPath);
+        const { StaticMethods, InstanceMethods, Accessors } = this._autoLoadModule(this.autoLoadHelperPath);
 
+        if (StaticMethods)   Object.assign(this, StaticMethods);
         if (InstanceMethods) Object.assign(this.prototype, InstanceMethods);
 
         if (Accessors) {
@@ -385,10 +463,10 @@ class VidaServerController {
     /***********************************************************************************************
     * VALIDATIONS
     ***********************************************************************************************/
-    validateParameters(validations) {
+    async validateParameters(validations) {
         const errors = {};
         for (const [parameterName, parameterValidations] of Object.entries(validations)) {
-            const parameterErrors = this.validateParameter(this.params[parameterName], parameterValidations);
+            const parameterErrors = await this.validateParameter(this.params[parameterName], parameterValidations);
             if (parameterErrors.length) errors[parameterName] = parameterErrors;
         }
 
@@ -396,7 +474,7 @@ class VidaServerController {
     }
 
 
-    validateParameter(value, parameterValidations) {
+    async validateParameter(value, parameterValidations) {
         const errors = [];
 
         if (parameterValidations?.optional && value === undefined) return errors;
@@ -404,7 +482,7 @@ class VidaServerController {
         for (const [validationType, validationOptions] of Object.entries(parameterValidations)) {
             const validationMethod = `validate${camelize(validationType)}`;
             if (!this[validationMethod]) continue;
-            const error = this[validationMethod](value, validationOptions);
+            const error = await this[validationMethod](value, validationOptions);
             if (error) errors.push(error);
         }
 
@@ -457,8 +535,8 @@ class VidaServerController {
     }
 
 
-    validateFunction(value, fnc) {
-        const error = fnc(value);
+    async validateFunction(value, fnc) {
+        const error = await fnc.call(this, value);
         if (error) return error;
     }
 
@@ -601,6 +679,7 @@ class VidaServerController {
 
 VidaServerController.prototype.Errors = {
     Authorization: AuthorizationError,
+    Conflict:      ConflictError,
     Forbidden:     ForbiddenError,
     NotFound:      NotFoundError,
     Server:        ServerError,

package/package.json

@@ -1,12 +1,12 @@
 {
     "name": "@vida-global/core",
-    "version": "1.3.3",
+    "version": "1.4.1",
     "description": "Core libraries for supporting Vida development",
     "author": "",
     "license": "ISC",
     "main": "index.js",
     "scripts": {
-        "test": "NODE_NO_WARNINGS=1 node --experimental-vm-modules node_modules/jest/bin/jest.js",
+        "test": "LOG_LEVEL=test NODE_NO_WARNINGS=1 node --experimental-vm-modules node_modules/jest/bin/jest.js",
         "release": "node node_modules/@vida-global/release/scripts/release.js",
         "develop": "node node_modules/@vida-global/release/scripts/release.js develop"
     },

package/test/server/serverController.test.js

@@ -155,8 +155,8 @@ describe('VidaServerController', () => {
             [paramName2]: {[validationType1]: options2}
         };
 
-        it ('runs validation checkers based on inputs', () => {
-            controller.validateParameters(validations);
+        it ('runs validation checkers based on inputs', async () => {
+            await controller.validateParameters(validations);
             expect(validator1).toHaveBeenCalledTimes(2);
             expect(validator1).toHaveBeenCalledWith(value1, options1);
             expect(validator1).toHaveBeenCalledWith(value2, options2);
@@ -165,52 +165,44 @@ describe('VidaServerController', () => {
             expect(validator2).toHaveBeenCalledWith(value1, options2);
         });
 
-        it ('throws a `ValidationError` when there\'s an error', () => {
+        it ('throws a `ValidationError` when there\'s an error', async () => {
             validator1.mockImplementation(() => error1);
-            expect(() => {
-                controller.validateParameters(validations);
-            }).toThrow(Errors.ValidationError);
+            await expect(controller.validateParameters(validations)).rejects.toThrow();
         });
 
-        it ('throws a `ValidationError` when there are multiple errors', () => {
+        it ('throws a `ValidationError` when there are multiple errors', async () => {
             validator1.mockImplementation(() => error1);
             validator2.mockImplementation(() => error2);
 
-            expect(() => {
-                controller.validateParameters(validations);
-            }).toThrow(Errors.ValidationError);
+            await expect(controller.validateParameters(validations)).rejects.toThrow(Errors.ValidationError);
         });
 
-        it ('sets nothing when there is no error', () => {
-            controller.validateParameters(validations);
+        it ('sets nothing when there is no error', async () => {
+            await controller.validateParameters(validations);
             expect(controller.render).toHaveBeenCalledTimes(0);
             expect(response.statusCode).toEqual(200);
         });
 
-        it ('ignores details where there is no validator', () => {
+        it ('ignores details where there is no validator', async () => {
             const validations = {
                 [paramName2]: {[validationType1]: options2, 'foo': true}
             };
-            controller.validateParameters(validations);
+            await controller.validateParameters(validations);
 
             expect(validator1).toHaveBeenCalledTimes(1);
             expect(validator1).toHaveBeenCalledWith(value2, options2);
         });
 
-        it ('does not error when optional parameters are not included', () => {
+        it ('does not error when optional parameters are not included', async () => {
             const validations = {foo: {isString: true, optional: true}};
-            expect(() => {
-                controller.validateParameters(validations);
-            }).not.toThrow();
+            expect(controller.validateParameters(validations)).resolves.not.toThrow();
         });
 
-        it ('does  error when optional parameters are invalid', () => {
+        it ('does  error when optional parameters are invalid', async () => {
             const validations = {foo: {isString: {length: {gte: 2}}, optional: true}};
             params.foo = '';
 
-            expect(() => {
-                controller.validateParameters(validations);
-            }).toThrow(Errors.ValidationError);
+            await expect(controller.validateParameters(validations)).rejects.toThrow(Errors.ValidationError);
 
             delete params.foo;
         });
@@ -458,13 +450,13 @@ describe('VidaServerController', () => {
         const error        = TestHelpers.Faker.Text.randomString();
         const validator    = (value) => value == correctValue ? undefined : error;
 
-        it ('returns undefiend when passed a valid value', () => {
-            const result = controller.validateFunction(correctValue, validator);
+        it ('returns undefiend when passed a valid value', async () => {
+            const result = await controller.validateFunction(correctValue, validator);
             expect(result).toBe(undefined);
         });
 
-        it ('returns an error when the function returns an error', () => {
-            const result = controller.validateFunction(Math.random(), validator);
+        it ('returns an error when the function returns an error', async () => {
+            const result = await controller.validateFunction(Math.random(), validator);
             expect(result).toBe(error);
         });
     });
@@ -472,10 +464,11 @@ describe('VidaServerController', () => {
 
     describe('#performRequest', () => {
         const errorHandlers = [
-            ['renderUnauthorizedResponse', 'AuthorizationError'],
-            ['renderForbiddenResponse',    'ForbiddenError'],
-            ['renderNotFoundResponse',     'NotFoundError'],
-            ['renderErrors',               'ValidationError'],
+            ['renderUnauthorized', 'AuthorizationError'],
+            ['renderConflict',     'ConflictError'],
+            ['renderForbidden',    'ForbiddenError'],
+            ['renderNotFound',     'NotFoundError'],
+            ['renderErrors',       'ValidationError'],
         ]
 
         it.each(errorHandlers)('calls %s when %s is thrown', async (handlerName, errorClsName) => {
@@ -505,7 +498,7 @@ describe('VidaServerController', () => {
             await controller.performRequest('testAction');
 
             expect(controller.statusCode).toEqual(500);
-            expect(controller.render).toHaveBeenCalledWith({errors: { message }});
+            expect(controller.render).toHaveBeenCalledWith({errors: {message: null}});
         });
     });
 
@@ -519,7 +512,6 @@ describe('VidaServerController', () => {
             controller.render = jest.fn();
         });
 
-        
         describe('#renderErrors', () => {
             it ('returns a 400 response', async () => {
                 await controller.renderErrors();
@@ -576,64 +568,66 @@ describe('VidaServerController', () => {
             });
         });
 
-        
-        describe('#renderUnauthorizedResponse', () => {
-            it ('returns a 401 response', async () => {
-                await controller.renderUnauthorizedResponse();
-                expect(response.statusCode).toBe(401);
-            })
-
-            it ('includes a blank message by default', async () => {
-                await controller.renderUnauthorizedResponse();
-                expect(controller.render).toHaveBeenCalledTimes(1);
-                expect(controller.render).toHaveBeenCalledWith({errors: {message: null}});
-            })
 
-            it ('includes a provided message', async () => {
-                const msg = TestHelpers.Faker.Text.randomString();
-                await controller.renderUnauthorizedResponse(msg);
-                expect(controller.render).toHaveBeenCalledTimes(1);
-                expect(controller.render).toHaveBeenCalledWith({errors: {message: msg}});
-            });
-        });
-
-        
-        describe('#renderForbiddenResponse', () => {
-            it ('returns a 403 response', async () => {
-                await controller.renderForbiddenResponse();
-                expect(response.statusCode).toBe(403);
+        const successHandlers = [
+            ['renderCreationSuccessful', 201],
+            ['renderAccepted',           202],
+            ['renderNoConent',           204],
+            ['renderMovedPermanently',   301],
+            ['renderFound',              302],
+            ['renderNotModified',        304],
+            ['renderTemporaryRedirect',  307],
+            ['renderPermanentRedirect',  308],
+        ]
+        describe.each(successHandlers)('#%s', (handlerName, statusCode) => {
+            it (`returns a ${statusCode} response`, async () => {
+                await (controller[handlerName]());
+                expect(response.statusCode).toBe(statusCode);
             })
 
-            it ('includes a blank message by default', async () => {
-                await controller.renderForbiddenResponse();
-                expect(controller.render).toHaveBeenCalledTimes(1);
-                expect(controller.render).toHaveBeenCalledWith({errors: {message: null}});
-            })
+            it ('includes the provided body', async () => {
+                const key   = TestHelpers.Faker.Text.randomString();
+                const value = TestHelpers.Faker.Text.randomString();
+                const body  = {[key]: value};
+                await (controller[handlerName](body));
 
-            it ('includes a provided message', async () => {
-                const msg = TestHelpers.Faker.Text.randomString();
-                await controller.renderForbiddenResponse(msg);
                 expect(controller.render).toHaveBeenCalledTimes(1);
-                expect(controller.render).toHaveBeenCalledWith({errors: {message: msg}});
+                expect(controller.render).toHaveBeenCalledWith(body);
             });
         });
 
+        
+        const errorHandlers = [
+            ['renderUnauthorized',         401],
+            ['renderPaymentRequired',      402],
+            ['renderForbidden',            403],
+            ['renderNotFound',             404],
+            ['renderMethodNotAllowed',     405],
+            ['renderRequestTimeout',       408],
+            ['renderConflict',             409],
+            ['renderGone',                 410],
+            ['renderContentTooLarge',      413],
+            ['renderUnsupportedMediaType', 415],
+            ['renderUnprocessableContent', 422],
+            ['renderLocked',               423],
+            ['renderTooManyRequests',      429],
+        ]
 
-        describe('#renderNotFoundResponse', () => {
-            it ('returns a 404 response', async () => {
-                await controller.renderNotFoundResponse();
-                expect(response.statusCode).toBe(404);
+        describe.each(errorHandlers)('#%s', (handlerName, statusCode) => {
+            it (`returns a ${statusCode} response`, async () => {
+                await (controller[handlerName]());
+                expect(response.statusCode).toBe(statusCode);
             })
 
             it ('includes a blank message by default', async () => {
-                await controller.renderNotFoundResponse();
+                await controller[handlerName]();
                 expect(controller.render).toHaveBeenCalledTimes(1);
                 expect(controller.render).toHaveBeenCalledWith({errors: {message: null}});
             })
 
             it ('includes a provided message', async () => {
                 const msg = TestHelpers.Faker.Text.randomString();
-                await controller.renderNotFoundResponse(msg);
+                await controller[handlerName](msg);
                 expect(controller.render).toHaveBeenCalledTimes(1);
                 expect(controller.render).toHaveBeenCalledWith({errors: {message: msg}});
             });