feat(Router): route params added to Request.

fix(core): core freeze when loadConfig method didn't run.
fix(types): Request and Response code suggestion didn't work for Javascript.
chore(core): some changes in request handling structure.

README.md

@@ -177,6 +177,7 @@ AxonJs has some types which can help you in developing your applications for aut
 - `AxonCoreConfig`: Type of core config object for configuration Axon core as you want.
 - `Request`: Type of controller request param. (IncomingMessage)
 - `Response`: Type of controller response param. (ServerResponse)
+- `Headers`: Type of response headers. (OutgoingHeaders)
 
 ## Contributing
 

benchmark.py

@@ -3,7 +3,7 @@
 
 
 start_time = time.time()
-duration = 1
+duration = 10
 requests_count = 0
 response_time = []
 

package.json

@@ -41,18 +41,19 @@
   },
   "devDependencies": {
     "@types/jest": "^29.5.12",
-    "@types/node": "^22.1.0",
     "jest": "^29.7.0",
     "nodemon": "^3.1.4",
+    "path-to-regexp": "^8.1.0",
     "ts-jest": "^29.2.5",
     "ts-node": "^10.9.2",
     "tsup": "^8.2.4",
     "typescript": "^5.5.4"
   },
   "dependencies": {
     "@spacingbat3/kolor": "^4.0.0",
+    "moment": "^2.30.1",
     "pino": "^9.4.0",
     "pino-pretty": "^11.2.2",
-    "moment": "^2.30.1"
+    "@types/node": "^22.5.4"
   }
 }

src/core/coreTypes.ts

@@ -2,8 +2,26 @@ interface AxonCoreConfig {
     DEBUG?: boolean;
     LOGGER?: boolean;
     LOGGER_VERBOSE?: boolean;
+    RESPONSE_MESSAGES?: AxonResponseMessage;
+}
+
+interface AxonResponseMessage {
+    /**
+     * response error message for 404 not found response from core
+     */
+    notFound?:  string;
+    /**
+     * response error message for 500 internal server error response from core
+     */
+    serverError?:  string;
+    /**
+     * response error message for 405 method not allowed response from core
+     */
+    methodNotAllowed?: string;
+    [key: string]: string | undefined;
 }
 
 export {
-    AxonCoreConfig  
+    AxonCoreConfig,
+    AxonResponseMessage
 }

src/core/index.ts

@@ -1,17 +1,26 @@
 import Router from "../Router";
-import { HttpMethods, JsonResponse, CoreReq } from "../types"
+import { HttpMethods, JsonResponse } from "../types"
 import * as http from "http";
 import { routeDuplicateException } from "./CoreExceptions";
 import addRoutePrefix from "./utils/routePrefixHandler";
 import { AxonCoreConfig } from "./coreTypes";
 import { logger } from "./utils/coreLogger";
 import { colors } from "@spacingbat3/kolor"
 import getRequestBody from "./utils/getRequestBody";
+import { Key, pathToRegexp, Keys } from "path-to-regexp";
+import { Request, Response, Headers } from "..";
+
+const defaultResponses = {
+    notFound: "Not found",
+    serverError: "Internal server error",
+    methodNotAllowed: "Method not allowed"
+}
 
 export default class AxonCore {
     private routes: HttpMethods;
     private config: AxonCoreConfig;
     private configsLoaded: boolean;
+    private passConfig: boolean;
     private routesLoaded: boolean;
 
     constructor() {
@@ -27,10 +36,12 @@ export default class AxonCore {
         this.config = {
             DEBUG: false,
             LOGGER: true,
-            LOGGER_VERBOSE: false
+            LOGGER_VERBOSE: false,
+            RESPONSE_MESSAGES: defaultResponses
         };
 
         this.configsLoaded = false;
+        this.passConfig = true;
         this.routesLoaded = false;
     }
 
@@ -41,9 +52,11 @@ export default class AxonCore {
      * @param config core config object
      */
     loadConfig(config: AxonCoreConfig) {
+        this.passConfig = false;
         this.config.DEBUG = config.DEBUG || false
         this.config.LOGGER = config.LOGGER || true
         this.config.LOGGER_VERBOSE = config.LOGGER_VERBOSE || false
+        this.config.RESPONSE_MESSAGES = { ...config.RESPONSE_MESSAGES }
 
         if (this.config.DEBUG) {
             logger.level = "debug"
@@ -89,7 +102,7 @@ export default class AxonCore {
      * @param res server response
      * @returns 
      */
-    async #handleRequest(req: http.IncomingMessage, res: http.ServerResponse) {
+    async #handleRequest(req: Request, res: Response) {
         // log incoming requests
         if (this.config.LOGGER_VERBOSE) {
             logger.request({
@@ -107,7 +120,7 @@ export default class AxonCore {
             res.statusCode = 405
 
             res.write(JSON.stringify({
-                msg: `Method ${req.method} not allowed`
+                message: this.config.RESPONSE_MESSAGES?.methodNotAllowed || defaultResponses.methodNotAllowed
             }));
 
             return res.end();
@@ -118,50 +131,93 @@ export default class AxonCore {
         (Object.keys(this.routes) as Array<keyof HttpMethods>).forEach(async (method) => {
             if (method == req.method) {
                 if (req.url) {
-                    try {
-                        controller = await this.routes[method][req.url]["controller"](req, res)
 
-                        if (controller.responseMessage) {
-                            res.statusMessage = controller.responseMessage
-                        }
+                    let findedRoute = false;
+
+                    if (Object.keys(this.routes[method]).length === 0) {
+                        res.statusCode = 404
+                        res.write(JSON.stringify({
+                            message: this.config.RESPONSE_MESSAGES?.notFound || defaultResponses.notFound
+                        }))
+
+                        return res.end()
+                    }
+
+                    return Object.keys(this.routes[method]).forEach(async (route, index) => {
+                        let keys: Keys;
+                        const regexp = pathToRegexp(route);
+                        keys = regexp.keys
+                        const match: RegExpExecArray | null = regexp.regexp.exec(req.url as string);
+
+                        if (match) {
+                            try {
+                                if (!findedRoute) {
+                                    findedRoute = true
+
+                                    const params: Record<string, string | undefined> = {};
+
+                                    keys.forEach((key: Key, index: number) => {
+                                        params[key.name] = match[index + 1];
+                                    });
+
+                                    req.params = params;
+
+                                    controller = await this.routes[method][route]["controller"](req, res)
+
+                                    if (controller.responseMessage) {
+                                        res.statusMessage = controller.responseMessage
+                                    }
 
-                        res.statusCode = controller.responseCode
+                                    if (typeof controller.body !== "object") {
+                                        throw new TypeError(`Response body can't be ${typeof controller.body}`)
+                                    }
 
-                        if (controller.headers) {
-                            for (const key in controller.headers) {
-                                if (controller.headers[key]) {
-                                    res.setHeader(key, controller.headers[key])
+                                    if (typeof controller.responseCode !== "number") {
+                                        throw new TypeError(`Response code can't be ${typeof controller.responseCode}`);
+                                    }
+
+                                    res.statusCode = controller.responseCode
+
+                                    if (controller.headers) {
+                                        for (const key in controller.headers) {
+                                            if (controller.headers[key]) {
+                                                res.setHeader(key, controller.headers[key])
+                                            }
+                                        }
+                                    }
+
+                                    res.write(JSON.stringify(controller.body))
+
+                                    return res.end()
+                                } else {
+                                    return;
                                 }
+                            } catch (error) {
+                                logger.error(error)
+
+                                res.statusCode = 500
+                                res.write(JSON.stringify({
+                                    message: this.config.RESPONSE_MESSAGES?.serverError || defaultResponses.serverError
+                                }))
+                                return res.end()
                             }
                         }
 
-                        res.write(JSON.stringify(controller.body))
-
-                        return res.end()
-                    } catch (error) {
-                        if (error instanceof TypeError) {
+                        if (!findedRoute && (Object.keys(this.routes[method]).length == (index + 1))) {
                             res.statusCode = 404
                             res.write(JSON.stringify({
-                                message: "Not found"
+                                message: this.config.RESPONSE_MESSAGES?.notFound || defaultResponses.notFound
                             }))
 
                             return res.end()
                         }
-                        res.statusCode = 500
-                        res.write(JSON.stringify({
-                            message: "Internal Server Error"
-                        }))
 
-                        return res.end()
-                    }
+                    })
                 }
             }
         })
     }
 
-    async #responseHandler(req: CoreReq, res: http.ServerResponse) { }
-
-
     /**
      * Start listening to http incoming requests
      * @param {string} host server host address
@@ -174,9 +230,18 @@ export default class AxonCore {
         const corePreloader = async (): Promise<void> => {
             return new Promise((resolve) => {
                 const interval = setInterval(() => {
-                    if (this.routesLoaded && this.configsLoaded) {
-                        clearInterval(interval);
-                        resolve();
+                    if (this.passConfig) {
+                        if (this.routesLoaded) {
+                            logger.info("all routes loaded!");
+                            clearInterval(interval);
+                            resolve();
+                        }
+                    } else {
+                        if (this.routesLoaded && this.configsLoaded) {
+                            logger.info("all configs and routes loaded!");
+                            clearInterval(interval);
+                            resolve();
+                        }
                     }
                 }, 100);
             });