te.js 1.2.0 → 1.3.0

package/example/index.js

@@ -1,4 +1,4 @@
 import Tejas from 'te.js';
 
 const tejas = new Tejas();
-tejas.takeoff();
+tejas.takeoff();

package/example/targets/index.target.js

@@ -1,11 +1,7 @@
-import { Target } from 'te.js';
+import { Target, TejError } from 'te.js';
 
 const target = new Target();
 
-target.register('/hello', (ammo) => {
-  throw new Error('Error thrown to demonstrate robust error handling of te.js');
-  ammo.fire({
-    status: 200,
-    body: 'Hello, World!'
-  });
+target.register('/', (ammo) => {
+  throw new TejError(500, 'Hello')
 });

package/example/tejas.config.json

@@ -6,9 +6,5 @@
   },
   "dir":{
     "targets": "targets"
-  },
-  "db": {
-    "type": "mongodb",
-    "uri": "mongodb+srv://sheldon-cooper:J1T6P1rK4TYXCzUB@adb-cloaker.bhw9t.mongodb.net/retag-cloaker?retryWrites=true&w=majority"
   }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "te.js",
-  "version": "1.2.0",
+  "version": "1.3.0",
   "description": "A nodejs framework",
   "type": "module",
   "main": "te.js",

package/server/ammo/dispatch-helper.js

@@ -1,48 +1,98 @@
 import status from 'statuses';
 
 const formattedData = (data) => {
-  if (typeof data === 'object') return JSON.stringify(data);
+  if (data === null || data === undefined) return '';
+
+  if (typeof data === 'object') {
+    try {
+      return JSON.stringify(data);
+    } catch (error) {
+      return String(data);
+    }
+  }
+
   if (typeof data === 'string') return data;
-  if (typeof data === 'number') return status[data];
-  return data;
+  if (typeof data === 'number') return status[data] || String(data);
+
+  return String(data);
 };
 
 const statusAndData = (args) => {
-  if (!args || args.length === 0)
+  // Handle no arguments
+  if (!args || args.length === 0) {
     return {
       statusCode: 204,
       data: status(204),
       contentType: 'text/plain',
     };
+  }
+
+  // Handle single argument
+  if (args.length === 1) {
+    const arg = args[0];
 
-  if (args.length === 1 && typeof args[0] === 'number')
+    // If it's a number, treat as status code
+    if (typeof arg === 'number') {
+      return {
+        statusCode: arg,
+        data: status(arg) || String(arg),
+        contentType: 'text/plain',
+      };
+    }
+
+    // Otherwise treat as data
     return {
-      statusCode: args[0],
-      data: status(args[0]),
-      contentType: 'text/plain',
+      statusCode: 200,
+      data: formattedData(arg),
+      contentType: contentType(arg),
     };
+  }
 
+  // Handle multiple arguments
   let statusCode = 200;
   let data = args[0];
-  if (args.length > 1) {
+
+  // If first argument is a number, treat as status code
+  if (typeof args[0] === 'number') {
     statusCode = args[0];
     data = args[1];
-    if (!data) data = status[statusCode];
+  } else {
+    // If first argument is not a number, check if second is
+    if (typeof args[1] === 'number') {
+      statusCode = args[1];
+    }
+  }
+
+  // If data is undefined, use status message
+  if (data === undefined) {
+    data = status[statusCode] || String(statusCode);
   }
 
+  // If third argument is provided, it's the content type
+  const customContentType = args.length > 2 ? args[2] : null;
+
   return {
     statusCode,
     data: formattedData(data),
-    contentType: contentType(data),
+    contentType: customContentType || contentType(data),
   };
 };
 
 const contentType = (data) => {
+  if (data === null || data === undefined) return 'text/plain';
+
   switch (typeof data) {
     case 'object':
       return 'application/json';
     case 'string':
-      return 'text/html';
+      // Check if string is HTML
+      if (
+        data.trim().toLowerCase().startsWith('<!DOCTYPE') ||
+        data.trim().toLowerCase().startsWith('<html')
+      ) {
+        return 'text/html';
+      }
+      return 'text/plain';
     case 'number':
       return 'text/plain';
     default:
@@ -50,4 +100,4 @@ const contentType = (data) => {
   }
 };
 
-export { statusAndData, contentType };
+export { statusAndData, contentType, formattedData };

package/server/ammo.js

@@ -8,7 +8,32 @@ import html from '../utils/tejas-entrypoint-html.js';
 import ammoEnhancer from './ammo/enhancer.js';
 import TejError from './error.js';
 
+/**
+ * Ammo class for handling HTTP requests and responses.
+ *
+ * @description
+ * Ammo is a utility class that simplifies HTTP request handling and response generation.
+ * It provides methods for processing requests, sending responses, and handling errors.
+ *
+ * @example
+ *
+ * if (ammo.GET) {
+ *   ammo.fire(200, { message: 'Hello World' });
+ * } else {
+ *   ammo.notAllowed();
+ * }
+ */
 class Ammo {
+  /**
+   * Creates a new Ammo instance.
+   *
+   * @param {http.IncomingMessage} req - The HTTP request object
+   * @param {http.ServerResponse} res - The HTTP response object
+   *
+   * @description
+   * Initializes a new Ammo instance with the provided request and response objects.
+   * Sets up default values for various properties that will be populated by the enhance method.
+   */
   constructor(req, res) {
     this.req = req;
     this.res = res;
@@ -39,6 +64,24 @@ class Ammo {
     this.dispatchedData = undefined;
   }
 
+  /**
+   * Enhances the Ammo instance with request data and sets HTTP method flags.
+   *
+   * @description
+   * This method processes the request and sets various properties on the Ammo instance:
+   * - HTTP method flags (GET, POST, PUT, etc.)
+   * - Request data (IP, headers, payload, method)
+   * - URL data (protocol, hostname, path, endpoint, fullURL)
+   *
+   * This method should be called before using any other Ammo methods.
+   *
+   * @returns {Promise<void>} A promise that resolves when enhancement is complete
+   *
+   * @example
+   * const ammo = new Ammo(req, res);
+   * await ammo.enhance();
+   * // Now you can use ammo.GET, ammo.path, etc.
+   */
   async enhance() {
     await ammoEnhancer(this);
 
@@ -51,6 +94,52 @@ class Ammo {
     this.OPTIONS = this.method === 'OPTIONS';
   }
 
+  /**
+   * Sends a response to the client with the specified data and status code.
+   *
+   * @param {number|any} [arg1] - If a number, treated as status code. Otherwise treated as data to send.
+   * @param {any} [arg2] - If arg1 is a number, this is the data to send. Otherwise ignored.
+   * @param {string} [arg3] - Optional content type override.
+   *
+   * @description
+   * The fire method is flexible and can handle different argument patterns:
+   *
+   * 1. No arguments: Sends a 204 No Content response
+   * 2. Single number: Sends a response with the given status code
+   * 3. Single non-number: Sends a 200 OK response with the given data
+   * 4. Two arguments (number, data): Sends a response with the given status code and data
+   * 5. Three arguments: Sends a response with the given status code, data, and content type
+   *
+   * The fire method can be used with any HTTP status code, including error codes (4xx, 5xx).
+   * For error responses, you can use either fire() or throw(). The main difference is that
+   * throw() can accept an Error instance and has special handling for it, while fire() only
+   * accepts status codes, strings, or other data types.
+   *
+   * @example
+   * // Send a 200 OK response with JSON data
+   * ammo.fire(200, { message: 'Success' });
+   *
+   * @example
+   * // Send a 404 Not Found response with custom message
+   * ammo.fire(404, 'Resource not found');
+   *
+   * @example
+   * // Send a 500 Internal Server Error response
+   * ammo.fire(500, 'Something went wrong');
+   *
+   * @example
+   * // Send HTML content with custom content type
+   * ammo.fire(200, '<html><body>Hello</body></html>', 'text/html');
+   *
+   * @example
+   * // Send just a status code (will use default status message)
+   * ammo.fire(204);
+   *
+   * @example
+   * // Send just data (will use 200 status code)
+   * ammo.fire({ message: 'Success' });
+   * ammo.fire('Hello World');
+   */
   fire() {
     const { statusCode, data, contentType } = statusAndData(arguments);
     const contentTypeHeader = { 'Content-Type': contentType };
@@ -62,50 +151,176 @@ class Ammo {
     this.res.end();
   }
 
+  /**
+   * Throws a 404 Not Found error.
+   *
+   * @description
+   * This is a convenience method that throws a 404 Not Found error.
+   * It's equivalent to calling `throw(404) ` or `fire(404)`.
+   *
+   * @throws {TejError} Always throws a TejError with status code 404
+   *
+   * @example
+   * // If resource not found
+   * if (!resource) {
+   *   ammo.notFound();
+   * }
+   */
   notFound() {
     throw new TejError(404, 'Not Found');
   }
 
+  /**
+   * Throws a 405 Method Not Allowed error.
+   *
+   * @description
+   * This is a convenience method that throws a 405 Method Not Allowed error.
+   * It's equivalent to calling `throw(405)` or `fire(405)`.
+   *
+   * @throws {TejError} Always throws a TejError with status code 405
+   *
+   * @example
+   * // If method not allowed
+   * if (!allowedMethods.includes(ammo.method)) {
+   *   ammo.notAllowed();
+   * }
+   */
   notAllowed() {
     throw new TejError(405, 'Method Not Allowed');
   }
 
+  /**
+   * Throws a 401 Unauthorized error.
+   *
+   * @description
+   * This is a convenience method that throws a 401 Unauthorized error.
+   * It's equivalent to calling `throw(401) ` or `fire(401)`.
+   *
+   * @throws {TejError} Always throws a TejError with status code 401
+   *
+   * @example
+   * // If user is not authenticated
+   * if (!user) {
+   *   ammo.unauthorized();
+   * }
+   */
   unauthorized() {
     throw new TejError(401, 'Unauthorized');
   }
 
+  /**
+   * Sends the default entry point HTML.
+   *
+   * @description
+   * This method sends the default HTML entry point for the application.
+   * It's typically used as a fallback when no specific route is matched.
+   *
+   * @example
+   * // In a catch-all route
+   * ammo.defaultEntry();
+   */
   defaultEntry() {
     this.fire(html);
   }
 
+  /**
+   * Throws an error response with appropriate status code and message.
+   *
+   * @param {number|Error|string} [arg1] - Status code, Error object, or error message
+   * @param {string} [arg2] - Error message (only used when arg1 is a status code)
+   *
+   * @description
+   * The throw method is flexible and can handle different argument patterns:
+   *
+   * 1. No arguments: Sends a 500 Internal Server Error response
+   * 2. Status code: Sends a response with the given status code and default message
+   * 3. Status code and message: Sends a response with the given status code and message
+   * 4. Error object: Extracts status code and message from the error
+   * 5. String: Treats as error message with 500 status code
+   *
+   * The key difference between throw() and fire() is that throw() can accept an Error instance
+   * and has special handling for it. Internally, throw() still calls fire() to send the response.
+   *
+   * @example
+   * // Throw a 404 Not Found error
+   * ammo.throw(404);
+   *
+   * @example
+   * // Throw a 404 Not Found error with custom message
+   * ammo.throw(404, 'Resource not found');
+   *
+   * @example
+   * // Throw an error from an Error object
+   * ammo.throw(new Error('Something went wrong'));
+   *
+   * @example
+   * // Throw an error with a custom message
+   * ammo.throw('Something went wrong');
+   */
   throw() {
-    const errCode = arguments[0];
-    const err = arguments[1];
+    // Handle different argument patterns
+    const args = Array.from(arguments);
 
-    let errMsg = err instanceof Error ? err.message : err.toString();
+    // Case 1: No arguments provided
+    if (args.length === 0) {
+      this.fire(500, 'Internal Server Error');
+      return;
+    }
 
-    if (errCode && isStatusCode(errCode)) {
-      if (!errMsg) errMsg = toStatusMessage(errCode);
-      this.fire(errCode, errMsg);
+    // Case 2: First argument is a status code
+    if (isStatusCode(args[0])) {
+      const statusCode = args[0];
+      const message = args[1] || toStatusMessage(statusCode);
+      this.fire(statusCode, message);
       return;
     }
 
-    if (err instanceof Error) {
-      const errMessage = err.message;
+    // Case 3.1: First argument is an instance of TejError
+    if (args[0] instanceof TejError) {
+      const error = args[0];
+      const statusCode = error.code;
+      const message = error.message;
 
-      if (!isNaN(parseInt(errMessage))) {
-        // Execute when errMessage is a number. Notice ! in front of isNan
-        const message = toStatusMessage(errMessage) ?? toStatusMessage(500);
-        this.fire(message, message);
+      this.fire(statusCode, message);
+      return;
+    }
+
+    // Case 3.2: First argument is an Error object
+    if (args[0] instanceof Error) {
+      const error = args[0];
+
+      // Check if error message is a numeric status code
+      if (!isNaN(parseInt(error.message))) {
+        const statusCode = parseInt(error.message);
+        const message = toStatusMessage(statusCode) || toStatusMessage(500);
+        this.fire(statusCode, message);
         return;
       }
 
-      const code = toStatusCode(errMsg) ?? 500;
-      this.fire(code, errMsg);
+      // Use error message as status code if it's a valid status code string
+      const statusCode = toStatusCode(error.message);
+      if (statusCode) {
+        this.fire(statusCode, error.message);
+        return;
+      }
+
+      // Default error handling
+      this.fire(500, error.message);
+      return;
+    }
+
+    // Case 4: First argument is a string or other value
+    const errorValue = args[0];
+
+    // Check if the string represents a status code
+    const statusCode = toStatusCode(errorValue);
+    if (statusCode) {
+      this.fire(statusCode, toStatusMessage(statusCode));
       return;
     }
 
-    this.fire(err);
+    // Default case: treat as error message
+    this.fire(500, errorValue.toString());
   }
 }
 

package/server/endpoint.js

@@ -0,0 +1,53 @@
+import isMiddlewareValid from './targets/middleware-validator.js';
+import { isPathValid, standardizePath } from './targets/path-validator.js';
+import isShootValid from './targets/shoot-validator.js';
+
+class Endpoint {
+  constructor() {
+    this.path = '';
+    this.middlewares = [];
+    this.handler = null;
+  }
+
+  setPath(base, path) {
+    const standardizedBase = standardizePath(base);
+    const standardizedPath = standardizePath(path);
+
+    let fullPath = `${standardizedBase}${standardizedPath}`;
+    if (fullPath.length === 0) fullPath = '/';
+
+    if (!isPathValid(fullPath)) return this;
+
+    this.path = fullPath;
+    return this;
+  }
+
+  setMiddlewares(middlewares) {
+    const validMiddlewares = middlewares.filter(isMiddlewareValid);
+    if (validMiddlewares.length === 0) return this;
+
+    this.middlewares = this.middlewares.concat(validMiddlewares);
+    return this;
+  }
+
+  setHandler(handler) {
+    if (!isShootValid(handler)) return this;
+    this.handler = handler;
+
+    return this;
+  }
+
+  getPath() {
+    return this.path;
+  }
+
+  getMiddlewares() {
+    return this.middlewares;
+  }
+
+  getHandler() {
+    return this.handler;
+  }
+}
+
+export default Endpoint;

package/server/handler.js

@@ -1,72 +1,87 @@
-import { env } from 'tej-env';
-import TejLogger from 'tej-logger';
-import logHttpRequest from '../utils/request-logger.js';
-
-import Ammo from './ammo.js';
-import TejError from './error.js';
-import TargetRegistry from './targets/registry.js';
-
-const targetRegistry = new TargetRegistry();
-const errorLogger = new TejLogger('Tejas.Exception');
-
-const executeChain = async (target, ammo) => {
-  let i = 0;
-
-  const chain = targetRegistry.globalMiddlewares.concat(target.middlewares);
-  chain.push(target.shoot);
-
-  const next = async () => {
-    const middleware = chain[i];
-    i++;
-
-    const args =
-      middleware.length === 3 ? [ammo.req, ammo.res, next] : [ammo, next];
-
-    try {
-      await middleware(...args);
-    } catch (err) {
-      errorHandler(ammo, err);
-    }
-  };
-
-  await next();
-};
-
-const errorHandler = (ammo, err) => {
-  if (env('LOG_EXCEPTIONS')) errorLogger.error(err);
-
-  if (err instanceof TejError) return ammo.throw(err.code, err);
-
-  ammo.throw(500, err);
-};
-
-const handler = async (req, res) => {
-  const target = targetRegistry.aim(req.method, req.url.split('?')[0]);
-  const ammo = new Ammo(req, res);
-
-  try {
-    if (target) {
-      await ammo.enhance();
-
-      if (env('LOG_HTTP_REQUESTS')) logHttpRequest(ammo);
-      await executeChain(target, ammo);
-
-    } else {
-      if (req.url === '/') {
-        ammo.defaultEntry();
-      } else {
-        errorHandler(
-          ammo,
-          new TejError(
-            404,
-            `No target found for URL ${ammo.fullURL} with method ${ammo.method}`,
-          ),
-        );
-      }
-    }
-  } catch (err) {
-    errorHandler(ammo, err);
-  }
-};
-
-export default handler;
+import { env } from 'tej-env';
+import TejLogger from 'tej-logger';
+import logHttpRequest from '../utils/request-logger.js';
+
+import Ammo from './ammo.js';
+import TejError from './error.js';
+import TargetRegistry from './targets/registry.js';
+
+const targetRegistry = new TargetRegistry();
+const errorLogger = new TejLogger('Tejas.Exception');
+
+/**
+ * Executes the middleware and handler chain for a given target.
+ *
+ * @param {Object} target - The target endpoint object.
+ * @param {Ammo} ammo - The Ammo instance containing request and response objects.
+ * @returns {Promise<void>} A promise that resolves when the chain execution is complete.
+ */
+const executeChain = async (target, ammo) => {
+  let i = 0;
+
+  const chain = targetRegistry.globalMiddlewares.concat(
+    target.getMiddlewares(),
+  );
+  chain.push(target.getHandler());
+
+  const next = async () => {
+    const middleware = chain[i];
+    i++;
+
+    const args =
+      middleware.length === 3 ? [ammo.req, ammo.res, next] : [ammo, next];
+
+    try {
+      await middleware(...args);
+    } catch (err) {
+      errorHandler(ammo, err);
+    }
+  };
+
+  await next();
+};
+
+/**
+ * Handles errors by logging them and sending an appropriate response.
+ *
+ * @param {Ammo} ammo - The Ammo instance containing request and response objects.
+ * @param {Error} err - The error object to handle.
+ */
+const errorHandler = (ammo, err) => {
+  if (env('LOG_EXCEPTIONS')) errorLogger.error(err);
+
+  if (err instanceof TejError) return ammo.throw(err);
+  return ammo.throw(err);
+};
+
+/**
+ * Main request handler function.
+ *
+ * @param {http.IncomingMessage} req - The HTTP request object.
+ * @param {http.ServerResponse} res - The HTTP response object.
+ * @returns {Promise<void>} A promise that resolves when the request handling is complete.
+ */
+const handler = async (req, res) => {
+  const url = req.url.split('?')[0];
+  const target = targetRegistry.aim(url);
+  const ammo = new Ammo(req, res);
+
+  try {
+    if (target) {
+      await ammo.enhance();
+
+      if (env('LOG_HTTP_REQUESTS')) logHttpRequest(ammo);
+      await executeChain(target, ammo);
+    } else {
+      if (req.url === '/') {
+        ammo.defaultEntry();
+      } else {
+        errorHandler(ammo, new TejError(404, `URL not found: ${url}`));
+      }
+    }
+  } catch (err) {
+    errorHandler(ammo, err);
+  }
+};
+
+export default handler;

package/server/target.js

@@ -1,52 +1,133 @@
+import TejLogger from 'tej-logger';
+
 import isMiddlewareValid from './targets/middleware-validator.js';
-import TargetRegistry from './targets/registry.js';
+import Endpoint from './endpoint.js';
 
+import TargetRegistry from './targets/registry.js';
 const targetRegistry = new TargetRegistry();
 
-const isEndpointValid = (endpoint) => {
-  if (typeof endpoint !== 'string') return false;
-  if (endpoint.length === 0) return false;
-  return endpoint[0] === '/';
-};
-
-const isShootValid = (shoot) => typeof shoot === 'function';
+const logger = new TejLogger('Target');
 
+/**
+ * Target class represents a base routing configuration for endpoints. Think of it as router in express.
+ * It provides functionality to set base paths, add middleware, and register endpoints.
+ *
+ * @class
+ * @example
+ * // Create a new target for user-related endpoints
+ * const userTarget = new Target('/user');
+ *
+ * // Add middleware that applies to all user endpoints
+ * userTarget.midair(authMiddleware, loggingMiddleware);
+ *
+ * // Register endpoints
+ * userTarget.register('/profile', (ammo) => {
+ *   // Handle GET /user/profile
+ *   ammo.fire({ name: 'John Doe' });
+ * });
+ *
+ * userTarget.register('/settings', authMiddleware, (ammo) => {
+ *   // Handle GET /user/settings with additional auth middleware
+ *   ammo.fire({ theme: 'dark' });
+ * });
+ */
 class Target {
+  /**
+   * Creates a new Target instance.
+   *
+   * @param {string} [base=''] - The base path for all endpoints registered under this target.
+   *                            Must start with '/' if provided.
+   * @example
+   * const apiTarget = new Target('/api');
+   * const userTarget = new Target('/user');
+   */
   constructor(base = '') {
     this.base = base;
     this.targetMiddlewares = [];
   }
 
+  /**
+   * Sets the base path for the target.
+   *
+   * @param {string} base - The base path to set. Must start with '/'.
+   * @returns {void}
+   * @example
+   * const target = new Target();
+   * target.base('/api/v1');
+   */
   base(base) {
     if (!base || !base.startsWith('/')) return;
     this.base = base;
   }
 
+  /**
+   * Adds middleware functions to the target.
+   * These middleware functions will be applied to all endpoints registered under this target.
+   *
+   * @param {...Function} middlewares - One or more middleware functions to add.
+   * @returns {void}
+   * @example
+   * // Add authentication middleware to all endpoints
+   * target.midair(authMiddleware);
+   *
+   * // Add multiple middleware functions
+   * target.midair(loggingMiddleware, errorHandler, rateLimiter);
+   */
   midair() {
     if (!arguments) return;
     const middlewares = [...arguments];
+
     const validMiddlewares = middlewares.filter(isMiddlewareValid);
     this.targetMiddlewares = this.targetMiddlewares.concat(validMiddlewares);
   }
 
+  /**
+   * Registers a new endpoint under this target.
+   *
+   * @param {string} path - The path for the endpoint, relative to the base path.
+   * @param {...Function} [middlewares] - Optional middleware functions specific to this endpoint.
+   * @param {Function} shoot - The handler function for the endpoint.
+   * @returns {void}
+   * @throws {Error} If there's an error registering the endpoint.
+   * @example
+   * // Register a simple endpoint
+   * target.register('/hello', (ammo) => {
+   *   ammo.fire({ message: 'Hello World' });
+   * });
+   *
+   * // Register an endpoint with specific middleware
+   * target.register('/protected', authMiddleware, (ammo) => {
+   *   ammo.fire({ data: 'Protected data' });
+   * });
+   *
+   * // Register an endpoint with multiple middleware
+   * target.register('/api/data',
+   *   authMiddleware,
+   *   rateLimiter,
+   *   (ammo) => {
+   *     ammo.fire({ data: 'Rate limited data' });
+   *   }
+   * );
+   */
   register() {
     let args = arguments;
     if (!args) return;
 
-    const endpoint = args[0];
-    if (!isEndpointValid(endpoint)) return;
-
+    const path = args[0];
     const shoot = args[args.length - 1];
-    if (!isShootValid(shoot)) return;
-
     const middlewares = Array.from(args).slice(1, args.length - 1);
-    const validMiddlewares = middlewares.filter(isMiddlewareValid);
 
-    targetRegistry.targets.push({
-      endpoint: this.base + endpoint,
-      middlewares: this.targetMiddlewares.concat(validMiddlewares),
-      shoot,
-    });
+    try {
+      const endpoint = new Endpoint();
+      endpoint
+        .setPath(this.base, path)
+        .setMiddlewares(middlewares)
+        .setHandler(shoot);
+
+      targetRegistry.targets.push(endpoint);
+    } catch (error) {
+      logger.error(`Error registering target ${path}: ${error.message}`);
+    }
   }
 }
 

package/server/targets/path-validator.js

@@ -0,0 +1,21 @@
+import TejLogger from 'tej-logger';
+
+const logger = new TejLogger('PathValidator');
+
+const standardizePath = (path) => {
+  if (!path || path.length === 0) return '';
+
+  let standardized = path.startsWith('/') ? path : `/${path}`;
+  return standardized.endsWith('/') ? standardized.slice(0, -1) : standardized;
+};
+
+const isPathValid = (path) => {
+  if (typeof path !== 'string') {
+    logger.error(`Path ${path} should be a string. Skipping...`);
+    return false;
+  }
+
+  return true;
+};
+
+export { isPathValid, standardizePath };

package/server/targets/registry.js

@@ -32,13 +32,24 @@ class TargetRegistry {
     }
   }
 
-  aim(method, endpoint) {
+  aim(endpoint) {
     return this.targets.find((target) => {
-      return (
-        target.endpoint === endpoint
-      );
+      return target.getPath() === endpoint;
     });
   }
+
+  getAllEndpoints(grouped) {
+    if (grouped) {
+      return this.targets.reduce((acc, target) => {
+        const group = target.getPath().split('/')[1];
+        if (!acc[group]) acc[group] = [];
+        acc[group].push(target.getPath());
+        return acc;
+      }, {});
+    } else {
+      return this.targets.map((target) => target.getPath());
+    }
+  }
 }
 
 export default TargetRegistry;

package/server/targets/shoot-validator.js

@@ -0,0 +1,21 @@
+import TejLogger from 'tej-logger';
+import Ammo from '../ammo.js';
+const logger = new TejLogger('ShootValidator');
+
+const isShootValid = (shoot) => {
+  if (typeof shoot !== 'function') {
+    logger.error(`Shoot ${shoot} should be a function. Skipping...`);
+    return false;
+  }
+
+  // Shoot should have 1 parameter, and it must be an instance of Ammo
+  if (shoot.length !== 1) {
+    logger.error(`Shoot function must have 1 parameter. Skipping...`);
+    return false;
+  }
+
+
+  return true;
+};
+
+export default isShootValid;

package/te.js

@@ -1,129 +1,137 @@
-import { createServer } from 'node:http';
-
-import { env, setEnv } from 'tej-env';
-import TejLogger from 'tej-logger';
-import database from './database/index.js';
-
-import TargetRegistry from './server/targets/registry.js';
-
-import { loadConfigFile, standardizeObj } from './utils/configuration.js';
-
-import targetHandler from './server/handler.js';
-import { findTargetFiles } from './utils/auto-register.js';
-import { pathToFileURL } from 'node:url';
-
-const logger = new TejLogger('Tejas');
-const targetRegistry = new TargetRegistry();
-
-class Tejas {
-  /*
-   * Constructor for Tejas
-   * @param {Object} args - Arguments for Tejas
-   * @param {Number} args.port - Port to run Tejas on
-   * @param {Boolean} args.log.http_requests - Whether to log incoming HTTP requests
-   * @param {Boolean} args.log.exceptions - Whether to log exceptions
-   * @param {String} args.db.type - Database type. It can be 'mongodb', 'mysql', 'postgres', 'sqlite'
-   * @param {String} args.db.uri - Connection URI string for the database
-   */
-  constructor(args) {
-    if (Tejas.instance) return Tejas.instance;
-    Tejas.instance = this;
-
-    this.generateConfiguration(args);
-    this.registerTargetsDir();
-  }
-
-  /*
-   * Connect to a database
-   * @param {Object}
-   * @param {String} args.db - Database type. It can be 'mongodb', 'mysql', 'postgres', 'sqlite'
-   * @param {String} args.uri - Connection URI string for the database
-   * @param {Object} args.options - Options for the database connection
-   */
-  connectDatabase(args) {
-    const db = env('DB_TYPE');
-    const uri = env('DB_URI');
-
-    if (!db) return;
-    if (!uri) {
-      logger.error(
-        `Tejas could not connect to ${db} as it couldn't find a connection URI. See our documentation for more information.`,
-        false,
-      );
-      return;
-    }
-
-    const connect = database[db];
-    if (!connect) {
-      logger.error(
-        `Tejas could not connect to ${db} as it is not supported. See our documentation for more information.`,
-        false,
-      );
-      return;
-    }
-
-    connect(uri, {}, (error) => {
-      if (error) {
-        logger.error(
-          `Tejas could not connect to ${db}. Error: ${error}`,
-          false,
-        );
-        return;
-      }
-
-      logger.info(`Tejas connected to ${db} successfully.`);
-    });
-  }
-
-  generateConfiguration(options) {
-    const configVars = standardizeObj(loadConfigFile());
-    const envVars = standardizeObj(process.env);
-    const userVars = standardizeObj(options);
-
-    const config = { ...configVars, ...envVars, ...userVars };
-    for (const key in config) {
-      if (config.hasOwnProperty(key)) {
-        setEnv(key, config[key]);
-      }
-    }
-
-    // Load defaults
-    if (!env('PORT')) setEnv('PORT', 1403);
-  }
-
-  midair() {
-    if (!arguments) return;
-    targetRegistry.addGlobalMiddleware(...arguments);
-  }
-
-  registerTargetsDir() {
-    findTargetFiles().then((targetFiles) => {
-      if (targetFiles) {
-        for (const file of targetFiles) {
-          import(pathToFileURL(`${file.path}/${file.name}`));
-        }
-      }
-
-    }).catch((err) => {
-      logger.error(
-        `Tejas could not register target files. Error: ${err}`,
-        false,
-      );
-    });
-  }
-
-  takeoff() {
-    this.engine = createServer(targetHandler);
-    this.engine.listen(env('PORT'), () => {
-      logger.info(`Took off from port ${env('PORT')}`);
-      this.connectDatabase();
-    });
-  }
-}
-
-export {default as Target} from './server/target.js';
-export {default as TejFileUploader} from './server/files/uploader.js';
-export default Tejas;
-
-// TODO Ability to register a target (route) from tejas instance
-// TODO tejas as CLI tool
+import { createServer } from 'node:http';
+
+import { env, setEnv } from 'tej-env';
+import TejLogger from 'tej-logger';
+import database from './database/index.js';
+
+import TargetRegistry from './server/targets/registry.js';
+
+import { loadConfigFile, standardizeObj } from './utils/configuration.js';
+
+import targetHandler from './server/handler.js';
+import { findTargetFiles } from './utils/auto-register.js';
+import { pathToFileURL } from 'node:url';
+import { log } from 'node:console';
+
+const logger = new TejLogger('Tejas');
+const targetRegistry = new TargetRegistry();
+
+class Tejas {
+  /*
+   * Constructor for Tejas
+   * @param {Object} args - Arguments for Tejas
+   * @param {Number} args.port - Port to run Tejas on
+   * @param {Boolean} args.log.http_requests - Whether to log incoming HTTP requests
+   * @param {Boolean} args.log.exceptions - Whether to log exceptions
+   * @param {String} args.db.type - Database type. It can be 'mongodb', 'mysql', 'postgres', 'sqlite'
+   * @param {String} args.db.uri - Connection URI string for the database
+   */
+  constructor(args) {
+    if (Tejas.instance) return Tejas.instance;
+    Tejas.instance = this;
+
+    this.generateConfiguration(args);
+    this.registerTargetsDir();
+  }
+
+  /*
+   * Connect to a database
+   * @param {Object}
+   * @param {String} args.db - Database type. It can be 'mongodb', 'mysql', 'postgres', 'sqlite'
+   * @param {String} args.uri - Connection URI string for the database
+   * @param {Object} args.options - Options for the database connection
+   */
+  connectDatabase(args) {
+    const db = env('DB_TYPE');
+    const uri = env('DB_URI');
+
+    if (!db) return;
+    if (!uri) {
+      logger.error(
+        `Tejas could not connect to ${db} as it couldn't find a connection URI. See our documentation for more information.`,
+        false,
+      );
+      return;
+    }
+
+    const connect = database[db];
+    if (!connect) {
+      logger.error(
+        `Tejas could not connect to ${db} as it is not supported. See our documentation for more information.`,
+        false,
+      );
+      return;
+    }
+
+    connect(uri, {}, (error) => {
+      if (error) {
+        logger.error(
+          `Tejas could not connect to ${db}. Error: ${error}`,
+          false,
+        );
+        return;
+      }
+
+      logger.info(`Tejas connected to ${db} successfully.`);
+    });
+  }
+
+  generateConfiguration(options) {
+    const configVars = standardizeObj(loadConfigFile());
+    const envVars = standardizeObj(process.env);
+    const userVars = standardizeObj(options);
+
+    const config = { ...configVars, ...envVars, ...userVars };
+    for (const key in config) {
+      if (config.hasOwnProperty(key)) {
+        setEnv(key, config[key]);
+      }
+    }
+
+    // Load defaults
+    if (!env('PORT')) setEnv('PORT', 1403);
+  }
+
+  midair() {
+    if (!arguments) return;
+    targetRegistry.addGlobalMiddleware(...arguments);
+  }
+
+  registerTargetsDir() {
+    findTargetFiles()
+      .then((targetFiles) => {
+        if (targetFiles) {
+          for (const file of targetFiles) {
+            import(pathToFileURL(`${file.parentPath}/${file.name}`));
+          }
+        }
+      })
+      .catch((err) => {
+        logger.error(
+          `Tejas could not register target files. Error: ${err}`,
+          false,
+        );
+      });
+  }
+
+  takeoff() {
+    this.engine = createServer(targetHandler);
+    this.engine.listen(env('PORT'), () => {
+      logger.info(`Took off from port ${env('PORT')}`);
+      this.connectDatabase();
+    });
+  }
+}
+
+const listAllEndpoints = (grouped = false) => {
+  return targetRegistry.getAllEndpoints(grouped);
+};
+
+export { default as Target } from './server/target.js';
+export { default as TejFileUploader } from './server/files/uploader.js';
+export { default as TejError } from './server/error.js';
+export { listAllEndpoints };
+export default Tejas;
+
+// TODO Ability to register a target (route) from tejas instance
+// TODO tejas as CLI tool