@vida-global/core 2.0.0 → 2.0.3

package/lib/server/serverController.js

@@ -1,27 +1,16 @@
-const   APM                      = require('../apm');
-const { camelize, singularize }  = require('inflection');
-const   Errors                   = require('./errors');
-const { logger }                 = require('../logger');
-const   nodeUtil                 = require('util');
-
-
-const AUTH_CALLBACK_NAME = 'authenticateRequest';
-const actionStore        = new WeakMap();
+const   APM        = require('../apm');
+const { camelize } = require('inflection');
+const   crypto     = require('node:crypto');
+const   Errors     = require('./errors');
+const { logger }   = require('../logger');
 
 
 class VidaServerController {
-    #afterCallbacks        = [];
-    #afterCallbacksToSkip  = [];
-    #beforeCallbacks       = [];
-    #beforeCallbacksToSkip = [];
-    #callbacksSetUp        = false;
-    #isStreaming           = false;
     #logger;
     #params;
-    #rendered              = false;
+    #rendered = false;
     #request;
     #response;
-    #streamAbortController;
 
 
     constructor(request, response, serverLogger) {
@@ -32,75 +21,18 @@ class VidaServerController {
         this.#response = response;
         this.#logger   = (serverLogger || logger).child(this.requestId);
 
-        this.#applyCallbacks();
-        this.#setupStatusRenderers();
-    }
-
-
-    get _request()        { return this.#request  };
-    get _response()       { return this.#response };
-
-    get params()          { 
-        if (!this.#params) {
-            const body   = Buffer.isBuffer(this._request.body) ? {} : this.#processRequestData('body');
-            this.#params = {...this._request.params, ...this._request.query, ...body};
-        }
-        return structuredClone(this.#params);
-    }
-
-    get requestId()       { return this._request.id; }
-    get requestHeaders()  { return structuredClone(this._request.headers || {}); }
-    get responseHeaders() { return this._response.headers; };
-    get requestBody()     { return this._request.body; }
-    get requestMethod()   { return this._request.method; }
-    get requestIp()       { return this._request.ip; }
-    get url()             { return this._request.originalUrl; }
-    get contentType()     { return this.requestHeaders['content-type']; }
-    get userAgent()       { return this.requestHeaders['user-agent']; }
-
-    get statusCode()        { return this._response.statusCode; }
-    set statusCode(_status) { this._response.statusCode = _status; }
-
-
-    get logger() {
-        return this.#logger;
-    }
-
-
-    get bearerToken() {
-      const auth = this.requestHeaders.authorization;
-      if (!auth) return null;
-
-      const match = /^\s*bearer\s+(.+)$/i.exec(auth);
-      if (!match) return null;
-      return match[1].trim();
-    }
-
-
-    #processRequestData(key) {
-        const data          = this._request[key] || {};
-        const processedData = {};
-        for (let [paramName, paramValue] of Object.entries(data)) {
-            processedData[paramName] = this.#processedRequestDataValue(paramValue)
-        }
-
-        return processedData;
+        this._applyCallbacks();
+        this._setupStatusRenderers();
     }
 
 
-    #processedRequestDataValue(value) {
-      return value;
-        try {
-            if (!/^\[|{/.test(value)) return value;
-            return JSON.parse(value);
-        } catch(err) {
-            return value;
-        }
-    }
+    get _request()  { return this.#request  }
+    get _response() { return this.#response }
+    get logger()    { return this.#logger   }
 
 
     /***********************************************************************************************
-    * PERFORM ACTION
+    * PERFORM REQUEST
     ***********************************************************************************************/
     async performRequest(action) {
         try {
@@ -113,32 +45,30 @@ class VidaServerController {
 
 
     async #performRequest(action) {
-        await APM.startSegment('setupRequestState', true, () => this.setupRequestState());
-
-        if (this.rendered) {
-            this.#response.end();
-            return;
-        }
+        await this.#setupRequestState()
+        if (this.rendered) return this.#response.end();
 
         const responseBody = await this.#performAction(action);
 
-        if (!this.rendered) {
-            await APM.startSegment('render', true, () => this.render(responseBody || {}));
-        }
+        if (!this.rendered) await this.render(responseBody || {});
 
         this.#response.end();
     }
 
 
+    async #setupRequestState() {
+        return await APM.startSegment('setupRequestState', true, () => this.setupRequestState?.());
+    }
+
+
     async #performAction(action) {
-        if (await APM.startSegment('beforeCallbacks', true, () => this.runBeforeCallbacks(action)) === false) return false;
+        if (!await this._runCallbacks('before', action)) return false;
 
-        const parameters = this.constructor.parametersForAction(action);
-        if (parameters) await APM.startSegment('validateParameters', true, () => this.validateParameters(parameters));
+        await APM.startSegment('validateParameters', true, () => this.validateAction(action));
 
         const responseBody = await APM.startSegment(`action:${action}`, true, () => this[action]());
 
-        if (await APM.startSegment('afterCallbacks', true, () => this.runAfterCallbacks(action)) === false) return false;
+        if (!await this._runCallbacks('after', action)) return false;
 
         return responseBody;
     }
@@ -172,287 +102,41 @@ class VidaServerController {
     }
 
 
-    reportError(err) {
-        APM.reportError(err);
-    }
-
-
-    /***********************************************************************************************
-    * RESPONSE RENDERING
-    ***********************************************************************************************/
-    async render(body, options={}) {
-        if (this.rendered) return;
-        if (this.#isStreaming) return;
-
-        if (typeof body == 'string') {
-            this._response.send(body);
-        } else {
-            body = await this.processJSONBody(body, options);
-
-            const  errors = body.errors || null;
-            delete body.errors;
-
-            body = this.formatJSONBody(body, errors, options);
-            this._response.json(body);
-        }
-        this.markRendered();
-    }
-
-
-    async renderErrors(message, fields) {
-        const errors = {message: null, fields: {}};
-
-        if (message && !fields && typeof message == 'object') {
-            fields  = message;
-            message = null;
-        }
-
-        if (fields) {
-          for (const [field, values] of Object.entries(fields)) {
-              if (!Array.isArray(values)) fields[field] = [values];
-          }
-          errors.fields = fields;
-        }
-
-        await this.renderBadRequest(message, { errors });
-    }
-
-
-    formatJSONBody(body, errors, options) {
-        if (options.standardize === false) return body;
-
-        const response = {data: body, status: this.statusText};
-        if (errors) response.errors = errors;
-
-        return response;
-    }
-
-
-    async processJSONBody(body, options) {
-        if (body === undefined)               return null;
-        if (!body || typeof body != 'object') return body;
-
-        let processedBody;
-
-        if (body.toApiResponse) {
-            const formattedBody = await body.toApiResponse(options);
-            return await this.processJSONBody(formattedBody, options);
-
-        } else if (Array.isArray(body)) {
-            const processed = [];
-            for (const idx in body) {
-                processed.push(await this.processJSONBody(body[idx], options));
-            }
-            return processed;
-
-        } else if (body.constructor == Date) {
-            return body.getTime();
-
-        } else {
-            const processed = {};
-            for (let [key, val] of Object.entries(body)) {
-                processed[key] = await this.processJSONBody(val, options);
-            }
-            return processed;
-        }
-    }
-
-
-    get statusText() {
-        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';
-            case 501:
-                return 'not implemented';
-            case 502:
-                return 'bad gateway';
-            case 503:
-                return 'service unavailable';
-            case 504:
-                return 'gateway timeout';
-        }
-    }
-
-
-    #setupStatusRenderers() {
-      const successStatuses = {
-        CreationSuccessful: 201,
-        Accepted:           202,
-        NoConent:           204,
-        MovedPermanently:   301,
-        Found:              302,
-        NotModified:        304,
-        TemporaryRedirect:  307,
-        PermanentRedirect:  308,
-      }
-
-      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 (let [type, statusCode] of Object.entries(successStatuses)) {
-        this[`render${type}`] = async function(body=null) {
-            return await this.#renderSuccess(statusCode, body);
-        }
-      }
-    }
-
-
-    async #renderError(statusCode, message, body) {
-        this.statusCode = statusCode;
-        body        = structuredClone(body || {});
-        body.errors = body.errors || {};
-        body.errors.message = message || null;
-        return await this.render(body);
-    }
-
-
-    async #renderSuccess(statusCode, body) {
-      this.statusCode = statusCode;
-      return await this.render(body);
-    }
-
-
-    setHeader(header, value) {
-        this.#response.setHeader(header, value);
-    }
-
-
-    flushHeaders() {
-      this.#response.flushHeaders();
-    }
-
-
     get rendered()      { return this.#rendered; }
     markRendered()      { this.#rendered = true; }
     get writableEnded() { return this.#response.writableEnded; }
+    get isStreaming()   { return Boolean(this._isStreaming); }
 
 
     /***********************************************************************************************
-    * STREAM
+    * MIXINS
     ***********************************************************************************************/
-    async streamSseResponse(handler, errorHandler, abortController=null) {
-        if (this.#isStreaming) throw new StreamInProgressError();
-        this.#isStreaming = true;
-
-        let closeHandler;
-        if (abortController) {
-            this.#streamAbortController = abortController;
-            closeHandler = () => abortController.abort();
-            this.#request.on('close', closeHandler);
-        }
-
-        this.#setSseHeaders();
-        this.markRendered();
-        try {
-            await handler.bind(this)();
-        } catch(err) {
-          await errorHandler(err);
-          throw err;
-        } finally {
-            this.writeStreamEvent(null, '[DONE]');
-            this.#response.end();
-
-            this.#isStreaming           = false;
-            this.#streamAbortController = null;
-
-            if (closeHandler) this.#request.off('close', closeHandler);
-        }
-    }
-
-
-    #setSseHeaders() {
-        this.statusCode = 200;
-        this.setHeader('Content-Type',      'text/event-stream; charset=utf-8');
-        this.setHeader('Cache-Control',     'no-cache');
-        this.setHeader('Connection',        'keep-alive');
-        this.setHeader('X-Accel-Buffering', 'no');
-        this.flushHeaders();
+    static autoLoadMixins() {
+        this.actions; // make sure that actions are cached before loading helpers
+        const mixin = this._autoLoadModule(this.mixinDirectory);
+        this.loadMixin(mixin);
     }
 
 
-    writeStreamEvent(evt, data) {
-        if (!this.#isStreaming) throw new NoActiveStreamError();
-        if (this.#streamAbortController?.signal?.aborted || this.writableEnded) return;
-
-        if (evt) {
-            this.#response.write(`event: ${evt}\n`);
-        }
-
-        const msg = `data: ${data}\n\n`;
-        this.#response.write(msg);
-    }
-
-
-    /***********************************************************************************************
-    * HELPERS
-    ***********************************************************************************************/
-    static autoLoadHelpers() {
-        this.actions; // make sure that actions are cached before loading helpers
-        const { StaticMethods, InstanceMethods, Accessors } = this._autoLoadModule(this.autoLoadHelperPath);
+    static loadMixin(mixin) {
+        if (typeof mixin == 'function') mixin = mixin();
+        const { InstanceMethods, StaticMethods, Accessors={}, StaticAccessors={} } = mixin;
 
         if (StaticMethods)   Object.assign(this, StaticMethods);
         if (InstanceMethods) Object.assign(this.prototype, InstanceMethods);
 
-        if (Accessors) {
-            for (const [attrName, attrAccessors] of Object.entries(Accessors)) {
-                Object.defineProperty(this.prototype, attrName, attrAccessors);
-            }
+        for (const [attrName, attrAccessors] of Object.entries(Accessors)) {
+            Object.defineProperty(this.prototype, attrName, attrAccessors);
+        }
+
+        for (const [attrName, attrAccessors] of Object.entries(StaticAccessors)) {
+            Object.defineProperty(this, attrName, attrAccessors);
         }
     }
 
 
     static autoLoadDocumentation() {
-        const docs = this._autoLoadModule(this.autoLoadDocumentationPath);
+        const docs = this._autoLoadModule(this.documentationDirectory);
         Object.assign(this, docs);
     }
 
@@ -469,103 +153,16 @@ class VidaServerController {
     }
 
 
-    static get autoLoadHelperPath() {
+    static get mixinDirectory() {
         return `${process.cwd()}/lib/controllers${this.routePrefix}Controller`;
     }
 
 
-    static get autoLoadDocumentationPath() {
+    static get documentationDirectory() {
         return `${process.cwd()}/lib/controllers/_docs${this.routePrefix}Controller`;
     }
 
 
-    /***********************************************************************************************
-    * CALLBACKS
-    ***********************************************************************************************/
-    async setupRequestState() {}
-    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);
-    }
-
-
-    afterCallback(callback, options={}) {
-        this.#addCallback(callback, options, this.#afterCallbacks);
-    }
-
-
-    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, this.#beforeCallbacksToSkip, actionName);
-    }
-
-
-    async runAfterCallbacks(actionName) {
-        return await this.#runCallbacks(this.#afterCallbacks, this.#afterCallbacksToSkip, 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;
-        }
-
-        return true;
-    }
-
-
-    async #runCallback(callback) {
-        if (typeof callback == 'function') return await callback.call(this);
-        return await this[callback]();
-    }
-
-
-    #shouldRunCallback(actionName, options) {
-        if (options.only) {
-            if (Array.isArray(options.only)) return options.only.includes(actionName);
-            return options.only == actionName;
-        }
-
-        if (options.except) {
-            if (Array.isArray(options.except)) return !options.except.includes(actionName);
-            return options.except != actionName;
-        }
-
-        return true;
-    }
-
-
     /***********************************************************************************************
     * REQUEST PARAMETERS
     ***********************************************************************************************/
@@ -574,6 +171,13 @@ class VidaServerController {
     }
 
 
+    coerceString(value, { fallback = '' } = {}) {
+        if (typeof value !== 'string') return fallback;
+        const trimmed = value.trim();
+        return trimmed || fallback;
+    }
+
+
     coerceBoolean(value, { fallback } = {}) {
         if (typeof value === 'boolean') return value;
         if (typeof value !== 'string')  return fallback;
@@ -604,232 +208,6 @@ class VidaServerController {
     }
 
 
-    /***********************************************************************************************
-    * VALIDATIONS
-    ***********************************************************************************************/
-    async validateParameters(validations) {
-        const errors = {};
-        for (const [parameterName, parameterValidations] of Object.entries(validations)) {
-            const parameterErrors = await this.validateParameter(this.params[parameterName], parameterValidations);
-            if (parameterErrors.length) errors[parameterName] = parameterErrors;
-        }
-
-        if (Object.keys(errors).length) throw new Errors.ValidationError('', errors);
-    }
-
-
-    async 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 = await this[validationMethod](value, validationOptions);
-            if (error) errors.push(error);
-        }
-
-        return errors;
-    }
-
-
-    validatePresence(value) {
-        if (!value) return 'required';
-    }
-
-
-    validateIsInteger(value, options) {
-        const num = parseFloat(value);
-        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}`;
-        }
-    }
-
-
-    validateIsDateTime(value) {
-        if (new Date(value) == 'Invalid Date') return 'invalid date';
-    }
-
-
-    validateIsEnum(value, options) {
-        if (!options.enums.includes(value)) {
-            return options.error || `must be one of [${options.enums.filter(Boolean).join(', ')}]`;
-        }
-    }
-
-
-    validateIsBoolean(value, bool) {
-      if (typeof value == 'boolean' && value === bool) return;
-      return `must be ${bool}`;
-    }
-
-
-    async validateFunction(value, fnc) {
-        const error = await fnc.call(this, value);
-        if (error) return error;
-    }
-
-
-    /***********************************************************************************************
-    * ACTION SETUP
-    ************************************************************************************************
-    * The controller looks for any methods that fit the pattern of `{httpMethod}ActionName`
-    * (e.g. getFooBar) and prepares server routes for them. By default, a method `getFooBar` on a
-    * `BazController` would have an endpoint of  `GET /baz/fooBar`. The server will also prepend
-    * directory names, so if `bazController.js` is nested within the `ban` directory
-    * (e.g. `ban/bazController.js`), the endpoint will be `GET /ban/baz/fooBar`.
-    *
-    * Default routing logic can be overriden by defining custom routes in the `routes` getter. To
-    * provider a custom route for `getFooBar`, `routes` should return an object like:
-    * {getFooBar: '/ban/:accountIdd/foo/:userId/bar'}`
-    ***********************************************************************************************/
-    static get actions() {
-        if (actionStore.has(this)) return actionStore.get(this);
-        const actionNames = this.actionNames;
-        const actions = actionNames.map((actionName => {
-            return this._constructAction(actionName);
-        }).bind(this));
-
-        actionStore.set(this, actions);
-        return actions;
-    }
-
-
-    static _constructAction(actionName) {
-        const routePrefix = this.routePrefix
-        const action      = {};
-        const match       = actionName.match(this.actionRegExp);
-
-        action.method = match.groups.method.toUpperCase();
-        action.action = actionName;
-        action.path   = this._routeForAction(action.method, match.groups.path, routePrefix, actionName);
-        return action;
-    }
-
-
-    static _routeForAction(method, path, routePrefix, actionName) {
-        if (this.routes[actionName]) return this.routes[actionName];
-
-        // If the path starts with Record, use :id as a path parameter
-        /*
-          class UsersController {
-              // Get /users
-              async getIndex() {}
-
-              // Get /user/:id
-              async getRecord() {}
-
-              // Get /user/:id/status
-              async getRecordStatus() {}
-          }
-        */
-        if (/^Record($|[A-Z])/.test(path)) {
-          routePrefix = `${singularize(routePrefix)}/:id`;
-          path = path == 'Record' ? 'Index' : path.replace(/^Record/, '');
-        }
-
-        if (path == 'Index') return routePrefix;
-
-        path = path.charAt(0).toLowerCase() + path.slice(1);
-        return `${routePrefix}/${path}`;
-    }
-
-
-    static get routePrefix() {
-        const controllerName   = this.name.replace(/Controller$/, '');
-        const controllerPrefix = controllerName.charAt(0).toLowerCase() + controllerName.slice(1);
-        
-        return `${this.directoryPrefix || ''}/${controllerPrefix}`;
-    }
-
-
-    static get routes() {
-        return {};
-    }
-
-
-    static get actionNames() {
-        const methodNames = Object.getOwnPropertyNames(this.prototype);
-        const nameRegExp  = this.actionRegExp;
-        return methodNames.filter(name => nameRegExp.test(name));
-    }
-
-
-    static get actionRegExp() {
-        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: []};
-    }
-
-
     /***********************************************************************************************
     * SECURITY
     ***********************************************************************************************/
@@ -857,11 +235,36 @@ class VidaServerController {
     startApmSegment(name, record, handler) {
         return APM.startSegment(name, record, handler);
     }
+
+
+    reportError(err) {
+        APM.reportError(err);
+    }
 }
 
 
-class StreamInProgressError extends Error {}
-class NoActiveStreamError   extends Error {}
+/***************************************************************************************************
+* MIXINS
+***************************************************************************************************/
+const   CallbacksMixin      = require('./controllerMixins/callbacks');
+const   DocumentationMixin  = require('./controllerMixins/documentation');
+const   RendererMixin       = require('./controllerMixins/renderer');
+const   RequestDetailsMixin = require('./controllerMixins/requestDetails');
+const   RoutingMixin        = require('./controllerMixins/routing');
+const   ValidationMixin     = require('./controllerMixins/validations');
+
+VidaServerController.loadMixin(CallbacksMixin);
+VidaServerController.loadMixin(DocumentationMixin);
+VidaServerController.loadMixin(RequestDetailsMixin);
+VidaServerController.loadMixin(RendererMixin);
+VidaServerController.loadMixin(RoutingMixin);
+VidaServerController.loadMixin(ValidationMixin);
+
+
+/***************************************************************************************************
+* ERRORS
+***************************************************************************************************/
+const { NoActiveStreamError, StreamInProgressError } = RendererMixin;
 
 const errorClasses = Object.values(Errors).filter(cls => cls == Errors.ServerError || cls.prototype instanceof Errors.AbstractServerError);
 VidaServerController.prototype.Errors = Object.fromEntries(errorClasses.map(cls => {