#Enhancement: Opimizing response and the whole framework

.husky/pre-commit

@@ -1 +0,0 @@
-npm run lint:fix && npm run format

.husky/pre-push

@@ -1 +0,0 @@
-npm run test

README.md

@@ -1,6 +1,6 @@
 # Joor
 
-**Joor** is a modern, high-performance backend framework built on **Node.js**, designed for **efficiency, scalability, and simplicity**. With **built-in tools** and a **lightweight core**, Joor minimizes dependencies while maximizing performance.
+**Joor** is a modern, high-performance backend framework built on **Node.js** (compatible with runtimes like Bun and Deno), designed for **efficiency, scalability, and simplicity**. Featuring **built-in tools** and a **lightweight core**, Joor minimizes dependencies while maximizing performance.
 
 **Note**: Joor is in early development; documentation and features may be incomplete.
 

package.json

@@ -1,6 +1,6 @@
 {
   "name": "joor",
-  "version": "0.0.1",
+  "version": "0.0.0-alpha",
   "description": "Joor is a full-fledged backend web framework for small to enterprise-level projects. Joor.js provides blazing fast responsiveness to the web app with many built-in features.",
   "author": "Joor",
   "license": "MIT",
@@ -73,8 +73,5 @@
   "dependencies": {
     "mime-types": "^2.1.35",
     "socket.io": "^4.8.1"
-  },
-  "exports": {
-    "./middlewares": "./src/middlewares/index.js"
   }
 }

src/core/config/configuration.ts → src/core/config.ts

@@ -1,10 +1,8 @@
 import fs from 'node:fs';
 import path from 'node:path';
 
-import Jrror from '@/core/error/index';
-// import validateConfig from '@/helpers/validateConfig';
-import JoorError from '@/core/error/JoorError';
-import logger from '@/helpers/joorLogger';
+import { handleError, jssert } from '@/core/error';
+import validateConfig from '@/helpers/validateConfig';
 import JOOR_CONFIG from '@/types/config';
 
 /**
@@ -27,16 +25,12 @@ class Configuration {
    */
   private async loadConfig(): Promise<void> {
     // Check if the configuration data is already loaded
-    if (Configuration.configData !== null) {
-      throw new Jrror({
-        code: 'config-loaded-already',
-        docsPath: '/configuration',
-        message:
-          'The configuration data is already loaded. Attempting to load it again is not recommended',
-        type: 'warn',
-      });
-    }
-
+    jssert(
+      Configuration.configData === null,
+      'Configuration data is already loaded. Attempting to load it again is not recommended.',
+      '/configuration',
+      'warn'
+    );
     try {
       // Default config file name is joor.config.js or else fallback to joor.config.ts
       let configFile = 'joor.config.js';
@@ -45,29 +39,21 @@ class Configuration {
         configFile = 'joor.config.ts';
       }
 
-      if (!fs.existsSync(path.resolve(process.cwd(), configFile))) {
-        throw new Jrror({
-          code: 'config-file-missing',
-          docsPath: '/configuration',
-          message:
-            'The configuration file (joor.config.js or joor.config.ts) is missing in the root directory.',
-          type: 'error',
-        });
-      }
+      // Check if the configuration file exists
+      jssert(
+        fs.existsSync(path.resolve(process.cwd(), configFile)),
+        'The configuration file (joor.config.js or joor.config.ts) is missing in the root directory.',
+        '/configuration',
+        'error'
+      );
 
       const configPath = path.resolve(process.cwd(), configFile);
       // Dynamically import the configuration file
       const configData = (await import(configPath)).config as JOOR_CONFIG;
-      // Configuration.configData = validateConfig(configData);
-      Configuration.configData = configData;
+      Configuration.configData = validateConfig(configData);
       this.setConfigToEnv();
     } catch (error) {
-      throw new Jrror({
-        code: 'config-load-failed',
-        message: `Error occured while loading the configuration file. ${error}`,
-        type: 'panic',
-        docsPath: '/configuration',
-      });
+      handleError(error);
     }
   }
 
@@ -107,11 +93,7 @@ class Configuration {
       try {
         await this.loadConfig();
       } catch (error: unknown) {
-        if (error instanceof Jrror || error instanceof JoorError) {
-          error.handle();
-        } else {
-          logger.error(error);
-        }
+        handleError(error);
       }
     }
 

src/core/error.ts

@@ -0,0 +1,241 @@
+import joorData from '@/data/joor';
+import logger from '@/helpers/joorLogger';
+import marker from '@/packages/marker';
+import { JOOR_ERROR } from '@/types/error';
+
+/**
+ * Custom class with additional metadata such as error code, message and type.
+ * Extends the native `Error` class to support structured error handling
+ */
+class JoorError extends Error {
+  /**
+   * The unique code indentifying the error
+   * @type number
+   */
+  public errorCode: JOOR_ERROR['code'];
+
+  /**
+   * The type of error
+   * @type "warn"|"error"|"panic"
+   */
+  public type: JOOR_ERROR['type'];
+
+  /**
+   * The path to the documentation for the error
+   * @type string
+   */
+  public docsPath: JOOR_ERROR['docsPath'];
+
+  /**
+   * The stack trace of the error, captured at the point of instantiation.
+   * @type {string | undefined}
+   */
+  public stackTrace: string | undefined;
+
+  /**
+   * Constructs a new `JoorError` instance.
+   *
+   * @param {Object} params - The parameters for creating the error.
+   * @param {JOOR_ERROR["message"]} params.message - A descriptive message for the error.
+   * @param {JOOR_ERROR["errorCode"]} params.errorCode - A unique identifier for the error.
+   * @param {JOOR_ERROR["type"]} params.type - The type of the error (e.g., "warn", "panic").
+   */
+
+  constructor({
+    message,
+    errorCode,
+    type,
+    docsPath,
+  }: {
+    message: JOOR_ERROR['message'];
+    errorCode: JOOR_ERROR['code'];
+    type: JOOR_ERROR['type'];
+    docsPath?: JOOR_ERROR['docsPath'];
+  }) {
+    super(message);
+    this.name = this.constructor.name;
+    this.errorCode = errorCode;
+    this.type = type;
+    this.docsPath = docsPath;
+    // Capture stack trace if the environment supports it
+    if (Error.captureStackTrace) {
+      Error.captureStackTrace(this, JoorError);
+    }
+    this.stackTrace = this.stack;
+    // Set the prototype chain correctly for proper inheritance
+    Object.setPrototypeOf(this, JoorError.prototype);
+  }
+  /**
+   * Method to handle the error by logging it to the console
+   * If the type of error thrown is `panic`, using `handle` method will cause the program to stop
+   *  @example
+   * ```typescript
+   * try{
+   * ...
+   * }
+   * catch(error:unknown){
+   *    if (error instanceof Jrror){
+   *        error.handle()
+   *    }
+   * }
+   *
+   */
+  public handle(): void {
+    const errorMessage = this.formatMessage();
+
+    if (this.type === 'warn') {
+      logger.warn(errorMessage);
+    } else if (this.type === 'error') {
+      logger.error(`${errorMessage}\nStack Trace:\n${this.stackTrace}`);
+    } else if (this.type === 'panic') {
+      logger.error(`${errorMessage}\nStack Trace:\n${this.stackTrace}`);
+      process.exit(1);
+    }
+  }
+
+  /**
+   * Method to reject the error by not logging it console
+   * @example
+   * ```typescript
+   * try{
+   * ...
+   * }
+   * catch(error:unknown){
+   *    if (error instanceof Jrror){
+   *        error.reject()
+   *    }
+   * }
+   *
+   */
+  public reject(): void {
+    return;
+  }
+  /**
+   * Formats the error message for user-friendly display, including the error code, message, and a link to documentation.
+   *
+   * @returns {string} The formatted error message.
+   */
+  private formatMessage(): string {
+    const docLink = `${joorData.docs}/${joorData.docsVersion}${this.docsPath}?error=${this.errorCode}`;
+
+    return `
+              Error Code: ${this.errorCode}
+              Message: ${this.message}
+              ${marker.greenBright(
+                'For more information, visit:'
+              )} ${marker.bgGreenBright.whiteBright(docLink)}
+              `;
+  }
+}
+
+/**
+ * Class to work with errors
+ *
+ * @example
+ * ```typescript
+ * // Throwing an error
+ * throw new Jrror({code:"config-p1",
+ * message: `Error: The configuration file '${joorData.configFile}' for Joor app is not found.\nMake sure the file is in the root directory of your project.`,
+ * type: "panic"
+ * })
+ *
+ * // Handling the thrown error
+ * try{
+ * ...
+ * }
+ * catch(error:unknown){
+ *    if (error instanceof Jrror){
+ *          if (error.type !=="warn"){
+ *              error.handle() // Call this method to log and handle the error based on its type
+ *          }
+ *          else{
+ *              error.reject() // Call this method to reject the error
+ *          }
+ *    }
+ * }
+ *
+ */
+
+class Jrror extends JoorError {
+  constructor(errorData: JOOR_ERROR) {
+    // Validate the error data provided when creating the instance of Jrror class
+    if (!errorData?.code || !errorData.message || !errorData.type) {
+      // Throws error code joor-e1 if errorData is not provided, e2 if code is not provided, e3 if message is not provided, e4 if type is not provided
+      throw new Jrror({
+        message: `Instance of Jrror has been created without passing required data. 
+              Missing: ${
+                !errorData
+                  ? 'errorData'
+                  : !errorData.code
+                    ? 'error code'
+                    : !errorData.message
+                      ? 'message'
+                      : 'type'
+              }`,
+        code: `jrror-${
+          !errorData
+            ? 'e1'
+            : !errorData.code
+              ? 'e2'
+              : !errorData.message
+                ? 'e3'
+                : 'e4'
+        }`,
+        type: 'error',
+      });
+    }
+    super({
+      errorCode: errorData.code,
+      message: errorData.message,
+      type: errorData.type,
+      docsPath: errorData.docsPath ?? '/',
+    });
+  }
+}
+
+/**
+ * Handles errors by checking their type and calling the appropriate method.
+ * If the error is not an instance of Jrror or JoorError, it logs the error.
+ *
+ * @param {unknown} error - The error to handle.
+ *
+ * Meant to reduce code duplication while handling errors in the codebase.
+ */
+function handleError(error: unknown): void {
+  if (error instanceof Jrror || error instanceof JoorError) {
+    error.handle();
+  } else {
+    logger.error(error);
+  }
+}
+
+/**
+ * Implicitly asserts that a condition is true. If the condition is false, it throws an error with the provided message and documentation path.
+ * Alternative to `assert(condition, message)` from the `node:assert` module.
+ *
+ * For naming convention, `jssert` is used to avoid confusion with the `assert` function from the `node:assert` module.
+ *
+ * @param {boolean} condition - The condition to assert.
+ * @param {string} message - The error message to throw if the assertion fails.
+ * @param {string} docsPath - The documentation path for the error.
+ * @param {JOOR_ERROR['type']} type - The type of error to throw ["warn" | "error" | panic]
+ *
+ */
+function jssert(
+  condition: boolean,
+  message: string,
+  docsPath: string = '/assertion',
+  type: JOOR_ERROR['type'] = 'error'
+): asserts condition {
+  if (!condition) {
+    throw new Jrror({
+      code: 'assertion-failed',
+      message,
+      type: type,
+      docsPath: docsPath,
+    });
+  }
+}
+
+export { JoorError, jssert, handleError };
+export default Jrror;