@vida-global/core 1.3.1 → 1.3.3

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'
           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: '24'
+          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/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

@@ -3,7 +3,7 @@ const { ControllerImporter } = require('./controllerImporter');
 
 class ApiDocsGenerator {
     #controllerDirectories
-    #controllers;
+    #controllerClasses;
     #docs = {};
     
     constructor(server) {
@@ -13,29 +13,60 @@ class ApiDocsGenerator {
 
     generateDocs() {
 console.log("\n\n");
-        this.controllers.forEach(controller => {
-            controller.actions.forEach(action => {
-                this.generateDocsForAction(action);
+        this.controllerClasses.forEach(controllerClass => {
+            controllerClass.actions.forEach(action => {
+                this.generateDocsForAction(action, controllerClass);
             });
         });
-console.log("\n\n");
+console.log("\n");
     }
 
 
-    generateDocsForAction(action) {
-        const endpoint       = this.formatEndpoint(action);
+    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()] = {foo: 1};
-      console.log(actionDocs);
+        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 controllers() {
-        if (!this.#controllers) {
+    get controllerClasses() {
+        if (!this.#controllerClasses) {
             const controllerImporter = new ControllerImporter(this.#controllerDirectories);
-            this.#controllers        = controllerImporter.controllers;
+            this.#controllerClasses  = controllerImporter.controllerClasses;
         }
-        return this.#controllers;
+        return [...this.#controllerClasses];
     }
 
 

package/lib/server/controllerImporter.js

@@ -4,7 +4,7 @@ const { VidaServerController } = require('./serverController');
 
 class ControllerImporter {
     #controllerDirectories;
-    #controllers;
+    #controllerClasses;
 
 
     constructor(controllerDirectories) {
@@ -15,16 +15,16 @@ class ControllerImporter {
     }
 
 
-    get controllers() {
-        if (!this.#controllers) {
-            this.#importControllers();
+    get controllerClasses() {
+        if (!this.#controllerClasses) {
+            this.#importControllerClasses();
         }
-        return this.#controllers;
+        return this.#controllerClasses;
     }
 
 
-    #importControllers() {
-        this.#controllers = [];
+    #importControllerClasses() {
+        this.#controllerClasses = [];
         this.#controllerDirectories.forEach(dir => {
             this.#importDirectory(dir, dir);
         });
@@ -44,12 +44,14 @@ class ControllerImporter {
 
 
     #importFromFile(filePath, dir, topLevelDirectory) {
-        const exports     = Object.values(require(filePath));
+        const exports = Object.values(require(filePath));
         exports.forEach(_export => {
             if (_export.prototype instanceof VidaServerController) {
                 const directoryPrefix   = dir.replace(topLevelDirectory, '');
                 _export.directoryPrefix = directoryPrefix;
-                this.#controllers.push(_export);
+                _export.autoLoadHelpers();
+                _export.autoLoadDocumentation();
+                this.#controllerClasses.push(_export);
             }
         });
     }

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,39 +94,26 @@ class VidaServer {
     }
 
 
-    get loggingMiddleware() {
-        return httpLogger({
-            logger: this.middlewareLogger,
-            customLogLevel: (res, err) => {
-                if (res.statusCode >= 500) return 'error';
-                if (res.statusCode >= 400) return 'warn';
-                return 'info';
-            },
-            serializers: {
-                // Format the request log as a string
-                req: (req) => `Request: ${req.method} ${req.url}`,
-                // Format the response log as a string
-                res: (res) => `statusCode=${res.statusCode}, responseTime=${res.get('X-Response-Time')}`,
-            },
-            wrapSerializers: false,
-        })
+    get octetStreamParsingMiddleware() {
+        return express.raw({ type: 'application/octet-stream', limit: this.octetStreamLimit });
     }
 
 
-    get middlewareLogger() {
-      return pino({
-            level: process.env.HTTP_LOG_LEVEL || 'info',
-            transport: {
-                level: process.env.HTTP_LOG_LEVEL || 'info',
-                target: 'pino-pretty',
-                options: {
-                    colorize: true,
-                    ignore: 'pid,hostname',
-                    translateTime: 'SYS:standard',
-                    messageFormat: '{msg}',
-                }
-            },
-        });
+    get octetStreamLimit() {
+        return '128mb';
+    }
+
+
+    get loggingMiddleware() {
+        return httpLogger({
+            logger:               this.middlewareLogger,
+            customLogLevel:       this.requestLogLevel.bind(this),
+            customSuccessMessage: this.requestLogMessage.bind(this),
+            customErrorMessage:   this.requestLogMessage.bind(this),
+            customErrorObject:    this.requestLogDetails.bind(this),
+            customSuccessObject:  this.requestLogDetails.bind(this),
+            wrapSerializers:      false,
+        })
     }
 
 
@@ -151,6 +135,53 @@ class VidaServer {
     use() { this.#expressServer.use(...arguments); }
 
 
+    /***********************************************************************************************
+    * LOGGING
+    ***********************************************************************************************/
+    requestLogDetails(req, res, err) {
+        const details = {
+            req: `${req.method} ${req.url}`,
+            res: `statusCode=${res.statusCode}, responseTime=${res.get('X-Response-Time')}`,
+        };
+
+        if (res.statusCode >= 500 && res.error) {
+            details.error = this.requestLogErrorDetails(req, res, res.error);
+        }
+
+        return details;
+    }
+
+
+    requestLogErrorDetails(req, res, err) {
+        if (typeof err == 'string') return {message: err};
+        return {
+            type: err.constructor.name,
+            message: err.message,
+            stack: err.stack
+        }
+    }
+
+    
+    requestLogMessage(req, res) {
+        const prefix = '[VidaServer]';
+        if (req.controller) {
+            return `${prefix} ${req.controller.constructor.name}#${req.action}`;
+        }
+
+        return `${prefix} ${res.status >= 500 ? 'request errored' : 'request completed'}`;
+    }
+
+
+    requestLogLevel(req, res) {
+        return 'debug';
+    }
+
+
+    get middlewareLogger() {
+        return logger;
+    }
+
+
     /***********************************************************************************************
     * SETTINGS
     ***********************************************************************************************/
@@ -193,7 +224,6 @@ class VidaServer {
 
 
     #registerController(controllerCls) {
-        controllerCls.autoLoadHelpers();
         controllerCls.actions.forEach((action => {
             this.#registerAction(action, controllerCls)
         }).bind(this));
@@ -215,12 +245,14 @@ 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) {
         return async function(request, response) {
-            if (process.env.NODE_ENV != 'test') this.logger.info(`${controllerCls.name}#${action}`);
             const controllerInstance = this.buildController(controllerCls, request, response);
+            request.controller       = controllerInstance;
+            request.action           = action;
             await controllerInstance.performRequest(action);
         }.bind(this);
     }
@@ -232,41 +264,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 +297,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); }