barehttp 0.4.0 → 0.5.0

package/lib/server.d.ts

@@ -1,5 +1,6 @@
 /// <reference types="node" />
 import { ServerOptions } from 'ws';
+import Ajv from 'ajv';
 import { BareRequest, CacheOpts } from './request';
 import { CookiesManagerOptions } from './middlewares/cookies/cookie-manager';
 import { HttpMethodsUnion, StatusCodesUnion } from './utils';
@@ -17,15 +18,39 @@ declare type RouteOpts<C> = {
      * Request timeout handler in `ms`
      */
     timeout?: number;
+    builtInRuntime?: {
+        output?: boolean;
+    };
+    middlewares?: Array<Middleware>;
 };
 declare type BareOptions<A extends IP> = {
+    /**
+     * Declare a global middlewares array
+     * Default: []
+     */
     middlewares?: Array<Middleware>;
+    /**
+     * Opt-out request body parsing (de-serialization)
+     * Default `false`
+     */
+    doNotParseBody?: boolean;
+    /**
+     * Opt-in to have a custom swagger per route generation
+     * Default `false`
+     */
+    /**
+     * Opt-in to have a custom runtime JSON Schema checker per routes
+     * Default `false`
+     */
+    enableSchemaValidation?: boolean;
     serverPort?: number;
+    declaredRoutesPaths?: Array<string>;
     /**
      * Address to bind the web server to
      * Default '0.0.0.0'
      */
     serverAddress?: A | 'localhost';
+    setRandomPort?: boolean;
     /**
      * Enable request context storage
      * Default `false`
@@ -52,11 +77,6 @@ declare type BareOptions<A extends IP> = {
      * Log the resolved reverse DNS first hop for remote ip of the client (first proxy)
      */
     reverseDns?: boolean;
-    /**
-     * Exposes a report with the routes usage.
-     * Default `false`
-     */
-    statisticsReport?: boolean;
     /**
      * WebSocket server exposure
      */
@@ -90,24 +110,23 @@ export declare type Routes = {
     [K in HttpMethodsUnion | 'declare']: HandlerExposed<K>;
 };
 export declare type BareHttpType<A extends IP = any> = BareServer<A> & Routes;
-export declare type ServerMergedType = {
-    new <A extends IP>(args?: BareOptions<A>): BareHttpType<A>;
-};
 export declare class BareServer<A extends IP> {
     #private;
     private bareOptions;
     server: Server;
     ws?: WebSocketServer;
+    ajv?: Ajv;
+    route: Readonly<Routes>;
     constructor(bareOptions?: BareOptions<A>);
-    private mainOptionsSetter;
+    private applyLaunchOptions;
     private applyMiddlewares;
     /**
      * This handler is used in async generated middlewares runtime function
      */
     private resolveMiddleware;
     private setRoute;
-    private registerReport;
     private handleRoute;
+    private resolveResponse;
     private encodeRoute;
     private explodeRoute;
     private basicErrorHandler;
@@ -117,10 +136,11 @@ export declare class BareServer<A extends IP> {
     get runtimeRoute(): Readonly<Routes>;
     start(cb?: (address: string) => void): Promise<void>;
     stop(cb?: (e?: Error) => void): Promise<void>;
+    loadRoutesSchemas(): void;
     use(middleware: Middleware): this;
     getMiddlewares(): Middleware[];
     setCustomErrorHandler(eh: ErrorHandler): void;
+    getServerPort(): number;
     getRoutes(): string[];
 }
-declare const BareHttp: ServerMergedType;
-export { BareHttp };
+export { BareServer as BareHttp };

package/lib/server.js

@@ -5,47 +5,61 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.BareHttp = exports.BareServer = void 0;
 const find_my_way_1 = __importDefault(require("find-my-way"));
+const ajv_1 = __importDefault(require("ajv"));
 const request_1 = require("./request");
 const logger_1 = require("./logger");
 const context_1 = require("./context");
-const report_1 = require("./report");
 const utils_1 = require("./utils");
 const cors_1 = require("./middlewares/cors/cors");
 const websocket_1 = require("./websocket");
+const generator_1 = require("./schemas/generator");
 const dns_1 = __importDefault(require("dns"));
 const http_1 = require("http");
 class BareServer {
     bareOptions;
     server;
     ws;
+    ajv;
+    route = {};
     #middlewares = [];
     #routes = new Map();
     #routesLib = new Map();
-    #router = find_my_way_1.default({ ignoreTrailingSlash: true });
+    #router = (0, find_my_way_1.default)({ ignoreTrailingSlash: true });
     #errorHandler = this.basicErrorHandler;
     #corsInstance;
     #port = 3000;
     #host = '0.0.0.0';
-    #runMiddlewaresSequence = (_) => _;
+    #globalMiddlewaresRun = (_) => _;
+    #routeMiddlewaresStore = new Map();
+    #routeRuntimeSchemas = new Map();
     constructor(bareOptions = {}) {
         this.bareOptions = bareOptions;
         // init
-        this.server = http_1.createServer(this.#listener.bind(this));
+        this.server = (0, http_1.createServer)(this.#listener.bind(this));
         this.attachGracefulHandlers();
         this.attachRoutesDeclarator();
-        this.mainOptionsSetter();
+        this.applyLaunchOptions();
+        this.loadRoutesSchemas();
         return this;
     }
     #listener = (request, response) => {
-        const { requestTimeFormat, logging } = this.bareOptions;
-        const flow = new request_1.BareRequest(request, response, { logging, requestTimeFormat });
+        const flow = new request_1.BareRequest(request, response, this.bareOptions);
         // init and attach request uuid to the context
         if (this.bareOptions.context) {
-            context_1.newContext('request');
+            (0, context_1.newContext)('request');
             context_1.context.current?.store.set('id', flow.ID.code);
         }
-        // attach a flow to the flow memory storage
-        this.applyMiddlewares(flow).catch((e) => this.#errorHandler(e, flow, 400));
+        // execute global middlewares on the request
+        this.applyMiddlewares(flow)
+            .catch((e) => {
+            this.#errorHandler(e, flow, 400);
+        })
+            .then(() => {
+            // if middlewares sent the response back, stop here
+            if (flow.sent)
+                return;
+            this.#router.lookup(flow._originalRequest, flow._originalResponse);
+        });
     };
     /**
      * This function generates previously defined middlewares for the sequential execution
@@ -63,15 +77,20 @@ class BareServer {
             }
         }
         const text = lines.join('\n');
-        this.#runMiddlewaresSequence = new AsyncFunction('flow', text);
+        this.#globalMiddlewaresRun = new AsyncFunction('flow', text);
     };
-    mainOptionsSetter = () => {
+    applyLaunchOptions = () => {
         const { bareOptions: bo } = this;
-        this.#port = +(bo.serverPort || process.env.PORT || 3000);
+        if (bo.setRandomPort) {
+            this.#port = undefined;
+        }
+        else {
+            this.#port = +(bo.serverPort || process.env.PORT || 3000);
+        }
         this.#host = typeof bo.serverAddress === 'string' ? bo.serverAddress : '0.0.0.0';
         // context setting
         if (bo.context)
-            context_1.enableContext();
+            (0, context_1.enableContext)();
         // ws attachment
         if (bo.ws) {
             this.ws = new websocket_1.WebSocketServer(this.server, bo.wsOptions);
@@ -85,18 +104,15 @@ class BareServer {
             this.#corsInstance = new cors_1.Cors(corsOpts);
         }
         this.#middlewares.push(...(bo.middlewares || []));
-        if (bo.statisticsReport)
-            this.registerReport();
     };
     async applyMiddlewares(flow) {
-        if (!flow) {
-            throw new Error(`No flow been found to apply middlewares for, theres a sync mistake in the server.`); // should NEVER happen
-        }
         if (this.bareOptions.cors) {
             this.resolveMiddleware(flow, 0, this.#corsInstance?.corsMiddleware.bind(this.#corsInstance));
         }
-        // invoke body stream consumption
-        await flow['readBody']();
+        if (this.bareOptions.doNotParseBody !== true) {
+            // invoke body stream consumption
+            await flow['readBody']();
+        }
         // attach cookies middleware
         if (this.bareOptions.cookies) {
             flow['attachCookieManager'](this.bareOptions.cookiesOptions);
@@ -109,11 +125,7 @@ class BareServer {
             flow['setRemoteClient'](remoteClient[0]);
         }
         if (this.#middlewares.length)
-            await this.#runMiddlewaresSequence(flow);
-        // now route the request if middlewares did not send the response back
-        if (!flow.sent) {
-            this.#router.lookup(flow._originalRequest, flow._originalResponse);
-        }
+            await this.#globalMiddlewaresRun(flow);
     }
     /**
      * This handler is used in async generated middlewares runtime function
@@ -129,15 +141,13 @@ class BareServer {
             this.#errorHandler(e, flow);
         }
     }
-    setRoute(method, route, runtime, handler, opts) {
+    setRoute(method, route, isRuntime, handler, opts) {
         const encode = this.encodeRoute(method, route);
-        this.#routes.set(encode, { hits: 0, fails: 0, success: 0 });
         const handleFn = (req, _, routeParams) => {
-            this.#routes.get(encode).hits++;
-            this.handleRoute(req, checkParams(routeParams), handler, encode, opts);
+            this.handleRoute(req, checkParams(routeParams), handler, opts);
         };
         this.#routesLib.set(encode, handleFn);
-        if (runtime) {
+        if (isRuntime) {
             this.#router.reset();
             this.#routesLib.forEach((handlerFn, route) => {
                 const [m, r] = this.explodeRoute(route);
@@ -148,53 +158,63 @@ class BareServer {
             this.#router.on(method, route, handleFn);
         }
     }
-    registerReport() {
-        this.setRoute('GET', '/_report', false, (flow) => {
-            flow.setHeader('content-type', 'text/html');
-            flow.send(report_1.generateReport(this.#routes));
-        });
-    }
-    handleRoute(req, routeParams, handle, encodedRoute, opts) {
+    handleRoute(req, routeParams, handle, routeOpts) {
         const flow = req.flow;
         if (!flow) {
             throw new Error(`No flow been found to route this request, theres a sync mistake in the server.`); // should NEVER happen
         }
-        // apply possible route options
-        if (opts) {
-            if (opts.disableCache)
-                flow.disableCache();
-            if (opts.cache)
-                flow.setCache(opts.cache);
-            if (opts.timeout)
-                flow['attachTimeout'](opts.timeout);
-        }
         // populate with route params
         if (routeParams)
             flow['setParams'](routeParams);
-        // attach a general statistic reports counter
-        if (this.bareOptions.statisticsReport) {
-            flow._originalRequest.on('close', () => {
-                if (flow.statusToSend < 300 && flow.statusToSend >= 200) {
-                    this.#routes.get(encodedRoute).success++;
-                }
-                else {
-                    this.#routes.get(encodedRoute).fails++;
-                }
-            });
+        // apply possible route options
+        if (routeOpts) {
+            if (routeOpts.disableCache)
+                flow.disableCache();
+            if (routeOpts.cache)
+                flow.setCache(routeOpts.cache);
+            if (routeOpts.timeout)
+                flow['attachTimeout'](routeOpts.timeout);
         }
+        // TODO: implement per route middlewares!
         try {
-            const routeReturn = handle.bind(undefined)(flow);
+            const routeReturn = handle(flow);
+            if (flow.sent)
+                return;
             if (routeReturn instanceof Promise) {
-                routeReturn.then((result) => flow.send(result)).catch((e) => this.#errorHandler(e, flow));
-            }
-            else {
-                flow.send(routeReturn);
+                routeReturn
+                    .then((result) => this.resolveResponse(flow, result, req.url, req.method?.toLowerCase(), routeOpts?.builtInRuntime?.output))
+                    .catch((e) => {
+                    this.#errorHandler(e, flow);
+                });
+                return;
             }
+            this.resolveResponse(flow, routeReturn, req.url, req.method?.toLowerCase(), routeOpts?.builtInRuntime?.output);
         }
         catch (e) {
             this.#errorHandler(e, flow);
         }
     }
+    resolveResponse(flow, response, url, method, builtInRuntime) {
+        if (!builtInRuntime || !method || !url) {
+            flow.send(response);
+            return;
+        }
+        const schema = this.#routeRuntimeSchemas.get(`${method}-${url}`);
+        const check = schema?.compiled(response);
+        if ((schema && check) || !schema)
+            flow.send(response);
+        else {
+            logger_1.logMe.error('Response schema error!', {
+                method,
+                url,
+                errors: schema?.compiled.errors,
+                received: response,
+            });
+            flow
+                .status(500)
+                .send({ message: `Response schema error, please communicate to server administrator.` });
+        }
+    }
     encodeRoute(method, route) {
         if (route.endsWith('/'))
             route = route.slice(0, -1);
@@ -232,7 +252,7 @@ class BareServer {
     }
     attachRoutesDeclarator() {
         for (const method of [...Object.keys(utils_1.HttpMethods), 'declare']) {
-            this[method] = (routeSetUp) => {
+            this.route[method] = (routeSetUp) => {
                 checkRouteSetUp(routeSetUp, method);
                 if (method === 'declare') {
                     for (const m of new Set(routeSetUp.methods))
@@ -298,8 +318,10 @@ class BareServer {
         // }
         if (!this.ws)
             await this.stopWs();
+        if (!this.server?.listening)
+            return;
         await new Promise((res, rej) => {
-            this.server?.close((e) => {
+            this.server.close((e) => {
                 if (e) {
                     rej(e);
                     cb?.(e);
@@ -311,6 +333,23 @@ class BareServer {
             });
         });
     }
+    loadRoutesSchemas() {
+        if (!this.bareOptions.enableSchemaValidation) {
+            return;
+        }
+        if (this.bareOptions.declaredRoutesPaths?.length) {
+            this.ajv = new ajv_1.default({ strict: true });
+            for (const path of this.bareOptions.declaredRoutesPaths) {
+                const schemas = (0, generator_1.generateRouteSchema)(path);
+                for (const schema of schemas) {
+                    this.#routeRuntimeSchemas.set(`${schema.methodName}-${schema.route}`, {
+                        raw: schema.jsonSchema,
+                        compiled: this.ajv.compile(schema.jsonSchema),
+                    });
+                }
+            }
+        }
+    }
     use(middleware) {
         this.#middlewares.push(middleware);
         return this;
@@ -321,11 +360,15 @@ class BareServer {
     setCustomErrorHandler(eh) {
         this.#errorHandler = eh;
     }
+    getServerPort() {
+        return this.server.address().port;
+    }
     getRoutes() {
         return [...this.#routes.keys()];
     }
 }
 exports.BareServer = BareServer;
+exports.BareHttp = BareServer;
 function checkRouteSetUp(routeSetUp, key) {
     if (typeof routeSetUp.route !== 'string') {
         throw new TypeError(`A route path for the method ${key} is not a a string`);
@@ -358,5 +401,3 @@ function checkParams(params) {
     }
     return params;
 }
-const BareHttp = BareServer;
-exports.BareHttp = BareHttp;

package/lib/websocket.js

@@ -9,7 +9,7 @@ const callsites_1 = __importDefault(require("callsites"));
 const hyperid_1 = __importDefault(require("hyperid"));
 const logger_1 = require("./logger");
 const utils_1 = require("./utils");
-const generateId = hyperid_1.default();
+const generateId = (0, hyperid_1.default)();
 class WebSocketServer {
     opts;
     _internal;
@@ -42,21 +42,23 @@ class WebSocketServer {
                 if (response instanceof Promise) {
                     response
                         .then((answer) => this.doUpgrade(answer, request, socket, head))
-                        .catch((e) => this.rejectUpgrade(socket, e?.message, e));
+                        .catch((e) => this.rejectUpgrade(request, socket, e?.message, e));
                 }
                 else {
                     this.doUpgrade(response, request, socket, head);
                 }
             }
             catch (e) {
-                this.rejectUpgrade(socket, e?.message, e);
+                if (e instanceof Error) {
+                    this.rejectUpgrade(request, socket, e?.message, e);
+                }
             }
         });
         this.customUpgradeDone = true;
     }
     doUpgrade(answer, request, socket, head) {
         if (!answer.access)
-            this.rejectUpgrade(socket, answer.message);
+            this.rejectUpgrade(request, socket, answer.message);
         else {
             this._internal.handleUpgrade(request, socket, head, (ws) => {
                 const userClient = {
@@ -68,15 +70,15 @@ class WebSocketServer {
             });
         }
     }
-    rejectUpgrade(socket, message = 'Not Authorized', data) {
-        logger_1.logMe.warn(message || `Upgrade rejected for the client from ${socket.remoteAddress}`, data);
+    rejectUpgrade(request, socket, message = 'Not Authorized', data) {
+        logger_1.logMe.warn(message || `Upgrade rejected for the client from ${request.socket.remoteAddress}`, data);
         socket.write('HTTP/1.1 401 Unauthorized\r\n\r\n'); // TODO: enhance to be able to personalize this
         socket.destroy();
     }
     attachTypesHandling() {
         this._internal.on('connection', (ws, _, client) => {
             ws.onmessage = (event) => {
-                const decode = utils_1.JSONParse(event.data);
+                const decode = (0, utils_1.JSONParse)(event.data);
                 if (decode === null) {
                     logger_1.logMe.error('Incorrect data received from the client', {
                         data: event.data,
@@ -105,7 +107,7 @@ class WebSocketServer {
                                     .then((resolvedResponse) => {
                                     if (!resolvedResponse)
                                         return;
-                                    this.send({ ws, client }, utils_1.JSONStringify({ type: `${decode.type}_RESPONSE`, ...resolvedResponse }));
+                                    this.send({ ws, client }, (0, utils_1.JSONStringify)({ type: `${decode.type}_RESPONSE`, ...resolvedResponse }));
                                 })
                                     .catch((e) => logger_1.logMe.error(`Error working out a handler for type ${decode.type}`, {
                                     error: e,
@@ -116,7 +118,7 @@ class WebSocketServer {
                             else {
                                 if (!response)
                                     return;
-                                this.send({ ws, client }, utils_1.JSONStringify({ type: `${decode.type}_RESPONSE`, ...response }));
+                                this.send({ ws, client }, (0, utils_1.JSONStringify)({ type: `${decode.type}_RESPONSE`, ...response }));
                             }
                         }
                         catch (e) {
@@ -147,7 +149,7 @@ class WebSocketServer {
         if (typeof receiver.handler !== 'function') {
             throw new Error(`Can't declare a handler with type ${typeof receiver.handler}, should be a function with following signature: WsMessageHandler<T,?>`);
         }
-        const place = callsites_1.default()[2];
+        const place = (0, callsites_1.default)()[2];
         const loc = `${place.getFileName()}:${place.getLineNumber()}:${place.getColumnNumber()}`;
         this.#types.set(receiver.type, { loc, handler: receiver.handler });
     }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "barehttp",
-  "version": "0.4.0",
+  "version": "0.5.0",
   "description": "Lightweight and fast Node.js web server",
   "main": "lib/index.js",
   "directories": {
@@ -11,11 +11,11 @@
     "lib"
   ],
   "scripts": {
-    "build": "rm -rf ./lib && tsc",
+    "build": "rm -rf ./lib && tsc -p tsconfig.build.json",
     "build:dev": "rm -rf ./dev-lib && tsc -p tsconfig.dev.json",
-    "test": "jest --runInBand --coverage",
+    "test": "jest --coverage",
     "lint": "eslint ./src --fix",
-    "release": "semantic-release"
+    "release": "semantic-release -e ./.releaserc.json"
   },
   "keywords": [
     "nodejs",
@@ -33,37 +33,43 @@
   },
   "license": "MIT",
   "dependencies": {
+    "ajv": "^8.11.0",
     "callsites": "^3.1.0",
-    "cookie": "^0.4.1",
-    "cookie-signature": "^1.1.0",
-    "find-my-way": "^4.3.0",
-    "hyperid": "^2.1.0",
-    "pino": "^6.11.3",
-    "pino-pretty": "^5.0.2",
-    "ws": "^7.4.6"
+    "cookie": "^0.5.0",
+    "cookie-signature": "^1.2.0",
+    "find-my-way": "^5.6.0",
+    "hyperid": "^2.3.1",
+    "lodash": "^4.17.21",
+    "pino": "^7.11.0",
+    "pino-pretty": "^7.6.1",
+    "ts-morph": "^14.0.0",
+    "ws": "^8.6.0"
   },
   "devDependencies": {
-    "@ts-morph/bootstrap": "^0.9.1",
-    "@types/cookie": "^0.4.0",
+    "@semantic-release/git": "^10.0.1",
+    "@semantic-release/github": "^8.0.2",
+    "@ts-morph/bootstrap": "^0.12.2",
+    "@types/cookie": "^0.4.1",
     "@types/cookie-signature": "^1.0.3",
-    "@types/jest": "^26.0.23",
-    "@types/node": "^15.0.2",
-    "@types/pino": "^6.3.8",
-    "@types/ws": "^7.4.7",
-    "@typescript-eslint/eslint-plugin": "^4.22.1",
-    "@typescript-eslint/parser": "^4.22.1",
+    "@types/jest": "^27.0.3",
+    "@types/node": "^14.17.0",
+    "@types/pino": "^7.0.5",
+    "@types/ws": "^8.2.1",
+    "@typescript-eslint/eslint-plugin": "^5.5.0",
+    "@typescript-eslint/parser": "^5.5.0",
     "axios": "^0.21.1",
-    "eslint": "^7.26.0",
-    "eslint-plugin-import": "^2.22.1",
-    "eslint-plugin-jest": "^24.3.6",
+    "eslint": "^8.3.0",
+    "eslint-plugin-import": "^2.25.3",
+    "eslint-plugin-jest": "^25.3.0",
     "express": "^4.17.1",
-    "fastify": "^3.15.1",
-    "jest": "^26.6.3",
-    "semantic-release": "^17.4.2",
+    "fastify": "^3.24.1",
+    "jest": "^27.4.3",
+    "prettier": "^2.5.1",
+    "semantic-release": "^18.0.1",
     "supertest": "^6.1.3",
-    "ts-jest": "^26.5.6",
+    "ts-jest": "^27.0.7",
     "ts-node-dev": "^1.1.6",
-    "typescript": "^4.3.2"
+    "typescript": "^4.6.4"
   },
   "optionalDependencies": {
     "bufferutil": "^4.0.3",

package/lib/report.d.ts

@@ -1,2 +0,0 @@
-import { RouteReport } from './server';
-export declare function generateReport(routes: Map<string, RouteReport>): string;

package/lib/report.js

@@ -1,20 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.generateReport = void 0;
-function generateReport(routes) {
-    const lines = [];
-    lines.push('<!DOCTYPE html><html><head><title>Routes usage</title><meta charset="utf-8"></head><body><table style="border: 2px;border-style: ridge;border-radius: 5px;padding: 10px;"><tr><th>Route</th><th>Hits</th><th>Successes</th><th>Fails</th></tr>');
-    const sorted = [...routes].sort(([a], [b]) => {
-        if (a > b)
-            return 1;
-        else if (b > a)
-            return -1;
-        return 0;
-    });
-    sorted.forEach(([route, stats]) => {
-        lines.push(`<tr><td>${route}</td><td>${stats.hits}</td><td>${stats.success}</td><td>${stats.fails}</td></tr>`);
-    });
-    lines.push('</table></body></html>');
-    return lines.join('');
-}
-exports.generateReport = generateReport;