@vida-global/core 1.3.0 → 1.3.2

package/.github/workflows/npm-publish.yml

@@ -16,13 +16,23 @@ jobs:
   publish:
     runs-on: ubuntu-latest
     steps:
-      - uses: actions/checkout@v4
-      - uses: actions/setup-node@v4
+      - name: Checkout code
+        uses: actions/checkout@v4
+
+      - name: Setup Node
+        uses: actions/setup-node@v4
         with:
-          node-version: '24'
+          node-version: '20'
           registry-url: 'https://registry.npmjs.org'
-      - run: npm ci
-        env:
-          NODE_AUTH_TOKEN: ${{ secrets.NPM_READ_TOKEN }}
-      - run: npm test
-      - run: npm publish
+
+      - name: Update npm
+        run: npm install -g npm@latest
+
+      - name: Install dependencies
+        run: npm ci
+
+      - name: Run tests
+        run: npm test
+
+      - name: Publish
+        run: npm publish

package/.github/workflows/npm-test.yml

@@ -1,3 +1,6 @@
+# This workflow will run tests using node
+
+
 name: npm test
 
 on:
@@ -6,7 +9,6 @@ on:
 jobs:
   test:
     runs-on: ubuntu-latest
-
     steps:
       - name: Checkout code
         uses: actions/checkout@v4
@@ -14,8 +16,8 @@ jobs:
       - name: Setup Node
         uses: actions/setup-node@v4
         with:
-          node-version: 20
-          cache: 'npm'
+          node-version: '20'
+          registry-url: 'https://registry.npmjs.org'
 
       - name: Install dependencies
         run: npm ci

package/index.js

@@ -1,19 +1,14 @@
-const { HttpClient, HttpError } = require('./lib/http/client');
-const { AuthorizationError,
-        VidaServer,
-        VidaServerController }  = require('./lib/server');
-const { logger }                = require('./lib/logger');
-const   ActiveRecord            = require('./lib/activeRecord');
-const { redisClientFactory }    = require('./lib/redis');
+const   httpLibs     = require('./lib/http/client');
+const   serverLibs   = require('./lib/server');
+const { logger }     = require('./lib/logger');
+const   ActiveRecord = require('./lib/activeRecord');
+const   redisLibs    = require('./lib/redis');
 
 
 module.exports = {
     ActiveRecord,
-    AuthorizationError,
-    HttpClient,
-    HttpError,
+    ...httpLibs,
     logger,
-    redisClientFactory,
-    VidaServer,
-    VidaServerController,
+    ...redisLibs,
+    ...serverLibs
 };

package/lib/activeRecord/db/schema.js

@@ -59,7 +59,7 @@ function resolveAutoIncrementColumns(details) {
     if (!details.defaultValue) return;
 
     const regExp = /^nextval\(\w+_seq::regclass\)$/;
-    if (details.defaultValue.match(regExp)) {
+    if (regExp.test(details.defaultValue)) {
         delete details.defaultValue;
         delete details.allowNull;
         details.autoIncrement = true;

package/lib/redis/index.js

@@ -1,5 +1,5 @@
 const { redisClientFactory } = require('./redisClient');
 
 module.exports = {
-  redisClientFactory
+    redisClientFactory
 }

package/lib/server/README.md

@@ -194,5 +194,5 @@ titleUniqueness(title) {
 - `{isInteger: true}`, `{isInteger: {gte: 0, lte: 100}}`
 - `{isDateTime}`
 - `{isEnum: {enums: [a, b, c]}}`
-- `{regex: /foo/}`
+- `{isString: true}`, `{isString: {length: {gte: 10, lte: 100}, regex: /foo/}}
 - `{function: someFunction}` If the function returns a string, that is considered an error and returned as the validation message

package/lib/server/apiDocsGenerator.js

@@ -0,0 +1,86 @@
+const { ControllerImporter } = require('./controllerImporter');
+
+
+class ApiDocsGenerator {
+    #controllerDirectories
+    #controllerClasses;
+    #docs = {};
+    
+    constructor(server) {
+        this.#controllerDirectories = server.controllerDirectories;
+    }
+
+
+    generateDocs() {
+console.log("\n\n");
+        this.controllerClasses.forEach(controllerClass => {
+            controllerClass.actions.forEach(action => {
+                this.generateDocsForAction(action, controllerClass);
+            });
+        });
+console.log("\n");
+    }
+
+
+    generateDocsForAction(action, controllerClass) {
+        const documentationDetails = controllerClass.documentationForAction(action.action);
+        if (!documentationDetails?.description) return;
+
+        const components = this.collectComponents(controllerClass, documentationDetails, action);
+
+        const endpoint       = components.endpoint;
+        this.#docs[endpoint] = this.#docs[endpoint] || {};
+        const actionDocs     = this.#docs[endpoint][action.method.toLowerCase()] = {};
+
+    }
+
+
+    collectComponents(controllerClass, documentationDetails, action) {
+        const components    = {...documentationDetails};
+        components.endpoint = this.formatEndpoint(action);
+        components.method   = action.method;
+
+        const pathParamNames = components.endpoint.match(/{[^}]+}/g).map(p => {
+            return p.replace(/[{}]/g, '')
+        });
+
+        const parameters  = Object.entries(controllerClass.parametersForAction(action.action));
+        const pathParams  = parameters.filter(([param, _]) => pathParamNames.includes(param));
+        const otherParams = parameters.filter(([param, _]) => !pathParamNames.includes(param));
+        console.log(components.endpoint);
+        console.log(pathParams);
+        console.log(components.method);
+        console.log(parameters);
+        console.log(components.description);
+        console.log(components.summary);
+      console.log("\n");
+        //const auth       = controllerClass.authenticationDocumentation(action.action);
+        //const method     = action.method;
+
+        return components;
+    }
+
+
+    get controllerClasses() {
+        if (!this.#controllerClasses) {
+            const controllerImporter = new ControllerImporter(this.#controllerDirectories);
+            this.#controllerClasses  = controllerImporter.controllerClasses;
+        }
+        return [...this.#controllerClasses];
+    }
+
+
+    /***********************************************************************************************
+    * OPENAPI COMPONENTS
+    ***********************************************************************************************/
+    formatEndpoint(action) {
+        const endpoint = action.path.replace(/:([^/]+)/g, '{$1}');
+        return endpoint;
+    }
+
+}
+
+
+module.exports = {
+    ApiDocsGenerator
+}

package/lib/server/controllerImporter.js

@@ -0,0 +1,64 @@
+const   fs                     = require('fs');
+const { VidaServerController } = require('./serverController');
+
+
+class ControllerImporter {
+    #controllerDirectories;
+    #controllerClasses;
+
+
+    constructor(controllerDirectories) {
+        if (!Array.isArray(controllerDirectories)) {
+            controllerDirectories = [controllerDirectories];
+        }
+        this.#controllerDirectories = controllerDirectories;
+    }
+
+
+    get controllerClasses() {
+        if (!this.#controllerClasses) {
+            this.#importControllerClasses();
+        }
+        return this.#controllerClasses;
+    }
+
+
+    #importControllerClasses() {
+        this.#controllerClasses = [];
+        this.#controllerDirectories.forEach(dir => {
+            this.#importDirectory(dir, dir);
+        });
+    }
+
+
+    #importDirectory(dir, topLevelDirectory) {
+        fs.readdirSync(dir).forEach((f => {
+            const filePath = `${dir}/${f}`;
+            if (fs.lstatSync(filePath).isDirectory()) {
+                this.#importDirectory(filePath, topLevelDirectory);
+            } else if (f.endsWith('.js')) {
+                this.#importFromFile(filePath, dir, topLevelDirectory);
+            }
+        }).bind(this));
+    }
+
+
+    #importFromFile(filePath, dir, topLevelDirectory) {
+        const exports = Object.values(require(filePath));
+        exports.forEach(_export => {
+            if (_export.prototype instanceof VidaServerController) {
+                const directoryPrefix   = dir.replace(topLevelDirectory, '');
+                _export.directoryPrefix = directoryPrefix;
+                _export.autoLoadHelpers();
+                _export.autoLoadDocumentation();
+                this.#controllerClasses.push(_export);
+            }
+        });
+    }
+
+}
+
+
+module.exports = {
+    ControllerImporter
+}

package/lib/server/index.js

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

package/lib/server/server.js

@@ -1,5 +1,5 @@
+const { ControllerImporter }   = require('./controllerImporter');
 const   express                = require('express');
-const   fs                     = require('fs');
 const   httpLogger             = require('pino-http')
 const { logger }               = require('../logger');
 const   mustacheExpress        = require('mustache-express');
@@ -8,11 +8,6 @@ const   responseTime           = require('response-time');
 const   IoServer               = require("socket.io")
 const { Server }               = require('http');
 const { SystemController }     = require('./systemController');
-const { AuthorizationError,
-        ForbiddenError,
-        NotFoundError,
-        ValidationError,
-        VidaServerController } = require('./serverController');
 
 
 class VidaServer {
@@ -32,11 +27,12 @@ class VidaServer {
     }
 
 
-    async listen() {
+    async listen(callback) {
         await this.registerControllers();
 
         this.#httpServer.listen(this.#port, this.#host, () => {
             this.logger.info(`Server is running on port ${this.#port}`);
+            if (callback) callback();
         });
     }
 
@@ -75,6 +71,7 @@ class VidaServer {
     ***********************************************************************************************/
     setupMiddleware() {
         this.use(this.jsonParsingMiddleware);
+        this.use(this.octetStreamParsingMiddleware);
         this.use(responseTime())
         this.use(express.static('public'))
         this.use(this.loggingMiddleware);
@@ -97,6 +94,16 @@ class VidaServer {
     }
 
 
+    get octetStreamParsingMiddleware() {
+        return express.raw({ type: 'application/octet-stream', limit: this.octetStreamLimit });
+    }
+
+
+    get octetStreamLimit() {
+        return '128mb';
+    }
+
+
     get loggingMiddleware() {
         return httpLogger({
             logger: this.middlewareLogger,
@@ -193,7 +200,6 @@ class VidaServer {
 
 
     #registerController(controllerCls) {
-        controllerCls.autoLoadHelpers();
         controllerCls.actions.forEach((action => {
             this.#registerAction(action, controllerCls)
         }).bind(this));
@@ -215,6 +221,7 @@ class VidaServer {
     _put()    { this.#expressServer.put(...arguments); }
     _delete() { this.#expressServer.delete(...arguments); }
     _patch()  { this.#expressServer.patch(...arguments); }
+    _head()   { this.#expressServer.head(...arguments); }
 
 
     requestHandler(action, controllerCls) {
@@ -232,41 +239,15 @@ class VidaServer {
 
 
     get controllerClasses() {
-        if (this.#controllerClasses) return this.#controllerClasses;
-        this.#controllerClasses = [];
-
-        this.controllerDirectories.forEach(dir => {
-          this.#importControllers(dir, dir);
-        });
+        if (!this.#controllerClasses) {
+            const controllerImporter = new ControllerImporter(this.controllerDirectories);
+            this.#controllerClasses  = controllerImporter.controllerClasses;
+        }
 
         return this.#controllerClasses;
     }
 
 
-    #importControllers(dir, topLevelDirectory) {
-        fs.readdirSync(dir).forEach((f => {
-            const filePath = `${dir}/${f}`;
-            if (fs.lstatSync(filePath).isDirectory()) {
-                this.#importControllers(filePath, topLevelDirectory);
-            } else if (f.endsWith('.js')) {
-                this.#importControllersFromFile(filePath, dir, topLevelDirectory);
-            }
-        }).bind(this));
-    }
-
-    
-    #importControllersFromFile(filePath, dir, topLevelDirectory) {
-        const exports     = Object.values(require(filePath));
-        exports.forEach(_export => {
-            if (_export.prototype instanceof VidaServerController) {
-                const directoryPrefix   = dir.replace(topLevelDirectory, '');
-                _export.directoryPrefix = directoryPrefix;
-                this.#controllerClasses.push(_export);
-            }
-        });
-    }
-
-
     get controllerDirectories() {
         return [`${process.cwd()}/controllers`];
     }
@@ -291,6 +272,7 @@ class VidaServer {
     post()   { this.handleDeprecatedRoutingCall('post',   arguments); }
     put()    { this.handleDeprecatedRoutingCall('put',    arguments); }
     patch()  { this.handleDeprecatedRoutingCall('patch',  arguments); }
+    head()   { this.handleDeprecatedRoutingCall('head',   arguments); }
     delete() { this.handleDeprecatedRoutingCall('delete', arguments); }
 
 

package/lib/server/serverController.js

@@ -7,14 +7,16 @@ const{ AuthorizationError,
        ValidationError }         = require('./errors');
 
 
+const AUTH_CALLBACK_NAME = 'authenticateRequest';
+
+
 class VidaServerController {
     #afterCallbacks  = [];
     #beforeCallbacks = [];
+    #callbacksSetUp  = false;
     #params;
     #rendered        = false;
     #request;
-    #requestBody;
-    #requestQuery;
     #response;
 
 
@@ -24,6 +26,8 @@ class VidaServerController {
         }
         this.#request  = request;
         this.#response = response;
+
+        this.#applyCallbacks();
     }
 
 
@@ -32,15 +36,15 @@ class VidaServerController {
 
     get params()          { 
         if (!this.#params) {
-            const body   = this.#processRequestData('body');
-            const query  = this.#processRequestData('query');
-            this.#params = {...this._request.params, ...body, ...query};
+            const body   = Buffer.isBuffer(this._request.body) ? {} : this.#processRequestData('body');
+            this.#params = {...this._request.params, ...this._request.query, ...body};
         }
         return structuredClone(this.#params);
     }
 
     get requestHeaders()  { return structuredClone(this._request.headers || {}); }
     get responseHeaders() { return this._response.headers; };
+    get requestBody()     { return this._request.body; }
     get contentType()     { return this.requestHeaders['content-type']; }
     get logger()          { return logger; }
     get rendered()        { return this.#rendered }
@@ -51,23 +55,20 @@ class VidaServerController {
 
 
     #processRequestData(key) {
-        const instanceVarKey  = key.charAt(0).toUpperCase() + key.slice(1);
-        const instanceVarName = `#request${instanceVarKey}`;
-        const data            = this._request[key] || {};
-        if (this[instanceVarName] === undefined) {
-            const processedData = {};
-            this[instanceVarName] = processedData;
-            for (let [paramName, paramValue] of Object.entries(data)) {
-                processedData[paramName] = this.#processedRequestDataValue(paramValue)
-            }
+        const data          = this._request[key] || {};
+        const processedData = {};
+        for (let [paramName, paramValue] of Object.entries(data)) {
+            processedData[paramName] = this.#processedRequestDataValue(paramValue)
         }
 
-        return structuredClone(this[instanceVarName]);
+        return processedData;
     }
 
 
     #processedRequestDataValue(value) {
+      return value;
         try {
+            if (!/^\[|{/.test(value)) return value;
             return JSON.parse(value);
         } catch(err) {
             return value;
@@ -95,8 +96,6 @@ class VidaServerController {
             return;
         }
 
-        this.setupCallbacks();
-
         const responseBody = await this.#performAction(action);
 
         if (!this.rendered) {
@@ -109,6 +108,10 @@ class VidaServerController {
 
     async #performAction(action) {
         if (await this.runBeforeCallbacks(action) === false) return false;
+
+        const parameters = this.constructor.parametersForAction(action);
+        if (parameters) await this.validateParameters(parameters);
+
         const responseBody = await this[action]();
         if (await this.runAfterCallbacks(action) === false)  return false;
 
@@ -127,7 +130,7 @@ class VidaServerController {
             await this.renderNotFoundResponse(err.message);
 
         } else if (err instanceof ValidationError) {
-            await this.renderErrors(err.message, err.errors);
+            await this.renderErrors(err.message, err.fields);
 
         } else {
             this.statusCode = 500;
@@ -144,7 +147,8 @@ class VidaServerController {
         if (typeof body == 'string') {
             this._response.send(body);
         } else {
-            body = await this.formatJSONBody(body, options);
+            body = await this.processJSONBody(body, options);
+            body = this.formatJSONBody(body, options);
             this._response.json(body);
         }
         this.#rendered = true;
@@ -191,24 +195,23 @@ class VidaServerController {
     }
 
 
-    async formatJSONBody(body, options) {
-        body = await this._formatJSONBody(body, options);
+    formatJSONBody(body, options) {
         if (options.standardize === false) return body;
         return {data: body, status: this.statusText};
     }
 
 
-    async _formatJSONBody(body, options) {
+    async processJSONBody(body, options) {
         if (body === undefined)               return null;
         if (!body || typeof body != 'object') return body;
 
         if (body.toApiResponse) {
             const formattedBody = await body.toApiResponse(options);
-            return await this._formatJSONBody(formattedBody, options);
+            return await this.processJSONBody(formattedBody, options);
 
         } else if (Array.isArray(body)) {
             for (const idx in body) {
-                body[idx] = await this._formatJSONBody(body[idx], options);
+                body[idx] = await this.processJSONBody(body[idx], options);
             }
 
         } else if (body.constructor == Date) {
@@ -216,7 +219,7 @@ class VidaServerController {
 
         } else {
             for (let [key, val] of Object.entries(body)) {
-                body[key] = await this._formatJSONBody(val, options);
+                body[key] = await this.processJSONBody(val, options);
             }
         }
 
@@ -246,17 +249,7 @@ class VidaServerController {
     * HELPERS
     ***********************************************************************************************/
     static autoLoadHelpers() {
-        try {
-            this._autoLoadHelpers()
-        } catch(err) {
-            if (err.message.includes(`Cannot find module '${this.autoLoadHelperPath}'`)) return;
-            throw err;
-        }
-    }
-
-
-    static _autoLoadHelpers() {
-        const { InstanceMethods, Accessors } = require(this.autoLoadHelperPath);
+        const { InstanceMethods, Accessors } = this._autoLoadModule(this.autoLoadHelperPath);
 
         if (InstanceMethods) Object.assign(this.prototype, InstanceMethods);
 
@@ -268,11 +261,34 @@ class VidaServerController {
     }
 
 
+    static autoLoadDocumentation() {
+        const docs = this._autoLoadModule(this.autoLoadDocumentationPath);
+        Object.assign(this, docs);
+    }
+
+
+    static _autoLoadModule(path) {
+        try {
+            return require(path);
+        } catch(err) {
+            const errorText = `Cannot find module '${path}'`;
+            if (!err.message.includes(errorText)) throw err;
+        }
+
+        return {};
+    }
+
+
     static get autoLoadHelperPath() {
         return `${process.cwd()}/lib/controllers${this.routePrefix}Controller.js`;
     }
 
 
+    static get autoLoadDocumentationPath() {
+        return `${process.cwd()}/lib/controllers/_docs${this.routePrefix}Controller.js`;
+    }
+
+
     /***********************************************************************************************
     * CALLBACKS
     ***********************************************************************************************/
@@ -280,6 +296,13 @@ class VidaServerController {
     setupCallbacks() {}
 
 
+    #applyCallbacks() {
+        // set up the callbacks when the instance is constructed and prevent it from being called again
+        this.setupCallbacks();
+        this.setupCallbacks = undefined;
+    }
+
+
     beforeCallback(callback, options={}) {
         this.#addCallback(callback, options, this.#beforeCallbacks);
     }
@@ -340,7 +363,7 @@ class VidaServerController {
     /***********************************************************************************************
     * VALIDATIONS
     ***********************************************************************************************/
-    async validateParameters(validations) {
+    validateParameters(validations) {
         const errors = {};
         for (const [parameterName, parameterValidations] of Object.entries(validations)) {
             const parameterErrors = this.validateParameter(this.params[parameterName], parameterValidations);
@@ -353,8 +376,12 @@ class VidaServerController {
 
     validateParameter(value, parameterValidations) {
         const errors = [];
+
+        if (parameterValidations?.optional && value === undefined) return errors;
+
         for (const [validationType, validationOptions] of Object.entries(parameterValidations)) {
             const validationMethod = `validate${camelize(validationType)}`;
+            if (!this[validationMethod]) continue;
             const error = this[validationMethod](value, validationOptions);
             if (error) errors.push(error);
         }
@@ -370,10 +397,29 @@ class VidaServerController {
 
     validateIsInteger(value, options) {
         const num = parseFloat(value);
-        if (/\D/.test(value) || isNaN(num) || !Number.isInteger(num)) return 'must be an integer';
-        if (options && options.gte !== undefined) {
+        if (!/^-?\d+$/.test(value) || isNaN(num) || !Number.isInteger(num)) return 'must be an integer';
+
+        if (options?.gte !== undefined) {
             if (num < options.gte) return `must be greater than or equal to ${options.gte}`;
         }
+        if (options?.lte !== undefined) {
+            if (num > options.lte) return `must be less than or equal to ${options.lte}`;
+        }
+    }
+
+
+    validateIsString(value, options) {
+        if (typeof value !== 'string') return 'must be a string';
+
+        if (options?.length?.gte !== undefined) {
+            if (value.length < options.length.gte) return `must be greater than or equal to ${options.length.gte} characters`;
+        }
+        if (options?.length?.lte !== undefined) {
+            if (value.length > options.length.lte) return `must be fewer than or equal to ${options.length.lte} characters`;
+        }
+        if (options?.regex !== undefined) {
+            if (!options.regex.test(value)) return `must match ${options.regex}`;
+        }
     }
 
 
@@ -389,11 +435,6 @@ class VidaServerController {
     }
 
 
-    validateRegex(value, regex) {
-        if (!regex.test(value)) return `must match the pattern ${regex}`;
-    }
-
-
     validateFunction(value, fnc) {
         const error = fnc(value);
         if (error) return error;
@@ -482,7 +523,56 @@ class VidaServerController {
 
 
     static get actionRegExp() {
-        return new RegExp(/^(?<method>get|post|put|delete|patch)(?<path>[A-Z][a-zA-Z]+)$/);
+        return new RegExp(/^(?<method>get|post|put|delete|patch|head)(?<path>[A-Z][a-zA-Z]+)$/);
+    }
+
+
+    /***********************************************************************************************
+    * DOCUMENTATION
+    ***********************************************************************************************/
+    static parametersForAction(actionName) {
+        const methodName = this.parametersMethodForAction(actionName);
+        if (this[methodName]) return this[methodName]();
+        return null;
+    }
+
+
+    static parametersMethodForAction(actionName) {
+        return `parametersFor${camelize(actionName)}`;
+    }
+
+
+    static documentationForAction(actionName) {
+        const methodName = this.documentationMethodForAction(actionName);
+        if (this[methodName]) return this[methodName]();
+        return null;
+    }
+
+
+    static documentationMethodForAction(actionName) {
+        return `document${camelize(actionName)}`;
+    }
+
+
+    isAuthenticatedAction(actionName) {
+        const { options } = this.#beforeCallbacks.find(({ callback, options }) => callback == AUTH_CALLBACK_NAME)
+        return Boolean(options) && this.#shouldRunCallback(actionName, options);
+    }
+
+
+    static isAuthenticatedAction(actionName) {
+        const controller = new this();
+        return controller.isAuthenticatedAction(actionName);
+    }
+
+
+    static _authenticationDocumentation(actionName) {
+        if (!this.isAuthenticatedAction(actionName)) return undefined;
+    }
+
+
+    static authenticationDocumentation(actionName) {
+        return {apiKeyAuth: []};
     }
 }
 

package/package.json

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

package/test/server/server.test.js

@@ -8,12 +8,14 @@ const { VidaServer }    = require('../../lib/server');
 
 
 jest.mock('express', () => {
+    const express      = require('jest-express');
     const { Response } = require('jest-express/lib/response');
 
-    // missing functions in mock Response
-    Response.prototype.on   = jest.fn();
+    // missing functions in mock express
+    Response.prototype.on = jest.fn();
+    express.raw           = jest.fn();
 
-    return require('jest-express');
+    return express;
 });
 
 

package/test/server/serverController.test.js

@@ -165,20 +165,20 @@ describe('VidaServerController', () => {
             expect(validator2).toHaveBeenCalledWith(value1, options2);
         });
 
-        it ('throws a `ValidationError` when there\'s an error', async () => {
+        it ('throws a `ValidationError` when there\'s an error', () => {
             validator1.mockImplementation(() => error1);
-            await expect(async () => {
-                await controller.validateParameters(validations);
-            }).rejects.toThrow(Errors.ValidationError);
+            expect(() => {
+                controller.validateParameters(validations);
+            }).toThrow(Errors.ValidationError);
         });
 
-        it ('throws a `ValidationError` when there are multiple errors', async () => {
+        it ('throws a `ValidationError` when there are multiple errors', () => {
             validator1.mockImplementation(() => error1);
             validator2.mockImplementation(() => error2);
 
-            await expect(async () => {
-                await controller.validateParameters(validations);
-            }).rejects.toThrow(Errors.ValidationError);
+            expect(() => {
+                controller.validateParameters(validations);
+            }).toThrow(Errors.ValidationError);
         });
 
         it ('sets nothing when there is no error', () => {
@@ -186,6 +186,34 @@ describe('VidaServerController', () => {
             expect(controller.render).toHaveBeenCalledTimes(0);
             expect(response.statusCode).toEqual(200);
         });
+
+        it ('ignores details where there is no validator', () => {
+            const validations = {
+                [paramName2]: {[validationType1]: options2, 'foo': true}
+            };
+            controller.validateParameters(validations);
+
+            expect(validator1).toHaveBeenCalledTimes(1);
+            expect(validator1).toHaveBeenCalledWith(value2, options2);
+        });
+
+        it ('does not error when optional parameters are not included', () => {
+            const validations = {foo: {isString: true, optional: true}};
+            expect(() => {
+                controller.validateParameters(validations);
+            }).not.toThrow();
+        });
+
+        it ('does  error when optional parameters are invalid', () => {
+            const validations = {foo: {isString: {length: {gte: 2}}, optional: true}};
+            params.foo = '';
+
+            expect(() => {
+                controller.validateParameters(validations);
+            }).toThrow(Errors.ValidationError);
+
+            delete params.foo;
+        });
     });
 
 
@@ -230,6 +258,21 @@ describe('VidaServerController', () => {
             expect(result).toEqual('must be an integer');
         });
 
+        it ('returns an error when the value is null', () => {
+            const result = controller.validateIsInteger(null)
+            expect(result).toEqual('must be an integer');
+        });
+
+        it ('returns an error when the value is undefined', () => {
+            const result = controller.validateIsInteger(undefined)
+            expect(result).toEqual('must be an integer');
+        });
+
+        it ('returns an error when the value is an object', () => {
+            const result = controller.validateIsInteger({})
+            expect(result).toEqual('must be an integer');
+        });
+
         it ('returns an error when the number is less than the gte option', () => {
             const result = controller.validateIsInteger(1, {gte: 2});
             expect(result).toEqual('must be greater than or equal to 2');
@@ -244,6 +287,112 @@ describe('VidaServerController', () => {
             const result = controller.validateIsInteger(2, {gte: 2});
             expect(result).toEqual(undefined);
         });
+
+        it ('returns an error when the number is greater than the lte option', () => {
+            const result = controller.validateIsInteger(3, {lte: 2});
+            expect(result).toEqual('must be less than or equal to 2');
+        });
+
+        it ('returns undefined when the number is less than the lte option', () => {
+            const result = controller.validateIsInteger(1, {lte: 2});
+            expect(result).toEqual(undefined);
+        });
+
+        it ('returns undefined when the number is equal to the lte option', () => {
+            const result = controller.validateIsInteger(2, {lte: 2});
+            expect(result).toEqual(undefined);
+        });
+
+        it ('supports both the lte and gte options', () => {
+            let result = controller.validateIsInteger(1, {lte: 2, gte: 0});
+            expect(result).toEqual(undefined);
+
+            result = controller.validateIsInteger(-1, {lte: 2, gte: 0});
+            expect(result).toEqual('must be greater than or equal to 0');
+
+            result = controller.validateIsInteger(3, {lte: 2, gte: 0});
+            expect(result).toEqual('must be less than or equal to 2');
+        });
+    });
+
+
+    describe('VidaServerController.validateIsString', () => {
+        const controller = new FooController({}, {});
+        it ('returns undefined when there is an string', () => {
+            const result = controller.validateIsString('')
+            expect(result).toEqual(undefined);
+        });
+
+        it ('returns an error when there is a number', () => {
+            const result = controller.validateIsString(Math.random());
+            expect(result).toEqual('must be a string');
+        });
+
+        it ('returns an error when the value is null', () => {
+            const result = controller.validateIsString(null)
+            expect(result).toEqual('must be a string');
+        });
+
+        it ('returns an error when the value is undefined', () => {
+            const result = controller.validateIsString(undefined)
+            expect(result).toEqual('must be a string');
+        });
+
+        it ('returns an error when the value is an object', () => {
+            const result = controller.validateIsString({})
+            expect(result).toEqual('must be a string');
+        });
+
+        it ('returns an error when the length is fewer than the gte option', () => {
+            const result = controller.validateIsString('f', {length: {gte: 2}});
+            expect(result).toEqual('must be greater than or equal to 2 characters');
+        });
+
+        it ('returns undefined when the length is greater than the gte option', () => {
+            const result = controller.validateIsString('foo', {length: {gte: 2}});
+            expect(result).toEqual(undefined);
+        });
+
+        it ('returns undefined when the length is equal to the gte option', () => {
+            const result = controller.validateIsString('fo', {length: {gte: 2}});
+            expect(result).toEqual(undefined);
+        });
+
+        it ('returns an error when the length is greater than the lte option', () => {
+            const result = controller.validateIsString('foo', {length: {lte: 2}});
+            expect(result).toEqual('must be fewer than or equal to 2 characters');
+        });
+
+        it ('returns undefined when the length is fewer than the lte option', () => {
+            const result = controller.validateIsString('f', {length: {lte: 2}});
+            expect(result).toEqual(undefined);
+        });
+
+        it ('returns undefined when the length is equal to the lte option', () => {
+            const result = controller.validateIsString('fo', {length: {lte: 2}});
+            expect(result).toEqual(undefined);
+        });
+
+        it ('supports both the lte and gte options', () => {
+            let result = controller.validateIsString('fo', {length: {lte: 3, gte: 1}});
+            expect(result).toEqual(undefined);
+
+            result = controller.validateIsString('', {length: {lte: 3, gte: 1}});
+            expect(result).toEqual('must be greater than or equal to 1 characters');
+
+            result = controller.validateIsString('foobar', {length: {lte: 3, gte: 1}});
+            expect(result).toEqual('must be fewer than or equal to 3 characters');
+        });
+
+        it ('returns undefined when the value matches the pattern', () => {
+            const result = controller.validateIsString('foo', {regex: /oo/})
+            expect(result).toBe(undefined);
+        });
+
+        it ('returns an error when the value does not match the pattern', () => {
+            const result = controller.validateIsString('bar', {regex: /oo/})
+            expect(result).toBe(`must match /oo/`);
+        });
     });
 
 
@@ -321,36 +470,6 @@ describe('VidaServerController', () => {
     });
 
 
-    describe('VidaServerController.validateRegex', () => {
-        const controller = new FooController({}, {});
-
-        it ('returns undefined when the value matches the pattern', () => {
-            const result = controller.validateRegex('foo', /oo/)
-            expect(result).toBe(undefined);
-        });
-
-        it ('returns an error when the value does not match the pattern', () => {
-            const result = controller.validateRegex('bar', /oo/)
-            expect(result).toBe(`must match the pattern /oo/`);
-        });
-
-        it ('returns an error when the value is null', () => {
-            const result = controller.validateRegex(null, /oo/)
-            expect(result).toBe(`must match the pattern /oo/`);
-        });
-
-        it ('returns an error when the value is undefined', () => {
-            const result = controller.validateRegex(undefined, /oo/)
-            expect(result).toBe(`must match the pattern /oo/`);
-        });
-
-        it ('returns an error when the value is an object', () => {
-            const result = controller.validateRegex({}, /oo/)
-            expect(result).toBe(`must match the pattern /oo/`);
-        });
-    });
-
-
     describe('VidaServerController#performRequest', () => {
         const errorHandlers = [
             ['renderUnauthorizedResponse', 'AuthorizationError'],
@@ -371,7 +490,7 @@ describe('VidaServerController', () => {
 
             expect(controller[handlerName]).toHaveBeenCalledTimes(1);
             if (handlerName == 'renderErrors') {
-                expect(controller[handlerName]).toHaveBeenCalledWith(message, error.errors);
+                expect(controller[handlerName]).toHaveBeenCalledWith(message, error.fields);
             } else {
                 expect(controller[handlerName]).toHaveBeenCalledWith(message);
             }
@@ -594,4 +713,21 @@ describe('VidaServerController', () => {
             });
         });
     });
+
+
+    describe('ServerController#setupCallbacks', () => {
+        it ('is only called once', () => {
+            class CallbacksTestController extends VidaServerController {}
+            CallbacksTestController.prototype.setupCallbacks = jest.fn();
+            const controller = new CallbacksTestController({}, {});
+
+            expect(CallbacksTestController.prototype.setupCallbacks).toHaveBeenCalledTimes(1);
+            expect(controller.setupCallbacks).toBe(undefined);
+
+        });
+    });
+
+
+    describe('Request Properties', () => {
+    });
 });