diesel-core 0.0.13 → 0.0.15

package/CONTRIBUTING.md

@@ -1 +1 @@
-if you changes code OR fixing bugs  so after doing make sure to run bun build.js
+if you changes code OR fixing bugs  so after doing make sure to run tsc and  bun build.js

package/README.md

@@ -19,13 +19,13 @@ bun add diesel-core
 
 ### Code Example
 ```javascript
-import { Diesel } from "diesel-core"
+import Diesel  from "diesel-core"
 
 const app = new Diesel()
 const port = 3000
 
-app.get("/", async (xl) => {
- return xl.status(200).text("Hello world...!")
+app.get("/", async (ctx:ContextType) => {
+ return ctx.status(200).text("Hello world...!")
   // OR
   // return xl.text("Hello world!")
   // OR 
@@ -38,11 +38,95 @@ app.listen(port, () => {
 })
 
 ```
+## Filter and Route Security
+**Diesel** provides a simple way to manage public and protected routes by using a filter() method. You can define specific routes to be publicly accessible, while others will require authentication or custom middleware functions.
+
+### How to Use the Filter
+The **filter()** method allows you to secure certain endpoints while keeping others public. You can specify routes that should be publicly accessible using permitAll(), and apply authentication or other middleware to the remaining routes with require().
+
+
+### Example Usage
+```javascript
+import  Diesel  from "diesel-core";
+import jwt from 'jsonwebtoken';
+
+
+const app = new Diesel();
+
+async function authJwt (xl:ContextType, server?:Server): Promise<void | Response> {
+  const token = await xl.getCookie("accessToken");  // Retrieve the JWT token from cookies
+  if (!token) {
+    return xl.status(401).json({ message: "Authentication token missing" });
+  }
+  try {
+    // Verify the JWT token using a secret key
+    const user = jwt.verify(token, secret);  // Replace with your JWT secret
+    // Set the user data in context
+    xl.setUser(user);
+
+    // Proceed to the next middleware/route handler
+    return xl.next();
+  } catch (error) {
+    return xl.status(403).json({ message: "Invalid token" });
+  }
+}
+
+// Define routes and apply filter
+app
+  .filter()
+  .routeMatcher('/api/user/register', '/api/user/login', '/test/:id', '/cookie') // Define public routes
+  .permitAll() // Mark these routes as public (no auth required)
+  .require(authJwt); // Apply the authJwt middleware to all other routes
+
+// Example public route (no auth required)
+app.get("/api/user/register", async (xl) => {
+  return xl.json({ msg: "This is a public route. No authentication needed." });
+});
+
+// Example protected route (requires auth)
+app.get("/api/user/profile", async (xl) => {
+  // This route is protected, so the auth middleware will run before this handler
+  const user = xl.getUser()
+  return xl.json({ 
+    msg: "You are authenticated!" ,
+    user
+    });
+});
+
+// Start the server
+const port = 3000;
+app.listen(port, () => {
+  console.log(`Diesel is running on port ${port}`);
+})
+
+```
+## Filter Methods
+1. **routeMatcher(...routes: string[])** : Passed endpoints in this routeMatcher will be ***Public*** means they don't need authentication, including those with dynamic parameters (e.g., /test/:id).
+
+```javascript 
+.routeMatcher('/api/user/register', '/api/user/login', '/test/:id')
+```
+1. **permitAll()** : Marks the routes specified in routeMatcher() as publicly accessible, meaning no middleware (like authentication) will be required for these routes.
+
+```javascript 
+.permitAll()
+```
+1. **require(fnc?: middlewareFunc)** :Means that defined routes in ***routeMatcher*** is public & All endpoints needs authentication.
+
+*Note* : If you don't pass a middleware function to require(), DieselJS will throw an "Unauthorized" error by default. Ensure that you implement and pass a valid authentication function
+```javascript 
+.require(authJwt)
+```
+## Use Case
+ * **Public Routes** :  Some routes ***(like /api/user/register or /api/user/login)*** are often open to all users without authentication. These routes can be specified with permitAll().
+
+ * **Protected Routes** : For other routes ***(like /api/user/profile)***, you'll want to require authentication or custom middleware. Use require(authJwt) to ensure that the user is authenticated before accessing these routes.
 
 ## Using Hooks in DieselJS
 
 DieselJS allows you to enhance your request handling by utilizing hooks at various stages of the request lifecycle. This gives you the flexibility to execute custom logic for logging, authentication, data manipulation, and more.
 
+
 ### Available Hooks
 
 1. **onRequest**: Triggered when a request is received.
@@ -65,19 +149,19 @@ app.addHooks("onRequest",(xl) =>{
 // Define a preHandler hook
 app.addHooks("preHandler",(xl) =>{
     // Check for authentication token
-  const authToken = ctx.req.headers.get("Authorization");
+  const authToken = xl.req.headers.get("Authorization");
   if (!authToken) {
     return new Response("Unauthorized", { status: 401 });
   }
 })
 
 // Define a postHandler hook
-app.addHooks('postHandler', async (ctx) => {
-  console.log(`Response sent for: ${ctx.req.url}`);
+app.addHooks('postHandler', async (xl) => {
+  console.log(`Response sent for: ${xl.req.url}`);
 });
 
 // Define an onSend hook
-app.addHooks('onSend',async (ctx, result) => {
+app.addHooks('onSend',async (xl, result) => {
   console.log(`Sending response with status: ${result.status}`);
   return result; // You can modify the response here if needed
 });

package/build.js

@@ -1,12 +1,14 @@
-// build.js
-await Bun.build({
+// tsc will create main folder
+Bun.build({
     entrypoints: [
-        './src/main.ts',
-        './src/ctx.ts',
-        './src/handleRequest.ts',
-        './src/trie.ts',
-        './src/router.ts'
+        './main/main.ts',
+        './main/ctx.ts',
+        './main/handleRequest.ts',
+        './main/trie.ts',
+        './main/router.ts'
     ],
     outdir: './dist',
     minify: true, // Enable minification
-});
+})
+
+await Bun.spawn(['rm', '-rf', './main']);

package/dist/main.d.ts

@@ -1,9 +1,8 @@
 import Trie from "./trie.js";
 import rateLimit from "./utils.js";
-import { corsT, FilterMethods, HookFunction, HookType, middlewareFunc, type handlerFunction, type Hooks, type listenCalllBackType } from "./types.js";
+import { corsT, FilterMethods, HookFunction, HookType, middlewareFunc, type handlerFunction, type Hooks, type HttpMethod, type listenCalllBackType } from "./types.js";
 import { Server } from "bun";
 export default class Diesel {
-    #private;
     routes: string[] | undefined;
     globalMiddlewares: middlewareFunc[];
     middlewares: Map<string, middlewareFunc[]>;
@@ -17,6 +16,8 @@ export default class Diesel {
     corsConfig: corsT;
     filters: string[];
     filterFunction: middlewareFunc | null;
+    hasFilterEnabled: boolean;
+    wss: WebSocket | null | undefined;
     constructor();
     filter(): FilterMethods;
     cors(corsConfig: corsT): void;
@@ -24,6 +25,7 @@ export default class Diesel {
     compile(): void;
     listen(port: number, callback?: listenCalllBackType, { sslCert, sslKey }?: any): Server | void;
     register(pathPrefix: string, handlerInstance: any): void;
+    addRoute(method: HttpMethod, path: string, handlers: handlerFunction[]): void;
     use(pathORHandler?: string | middlewareFunc, handler?: middlewareFunc): void;
     get(path: string, ...handlers: handlerFunction[]): this;
     post(path: string, ...handlers: handlerFunction[]): this;

package/dist/route.d.ts

@@ -0,0 +1,11 @@
+import Diesel from "./main";
+import type { handlerFunction } from "./types";
+declare class Router extends Diesel {
+    constructor();
+    get(path: string, ...handlers: handlerFunction[]): this;
+    post(path: string, ...handlers: handlerFunction[]): this;
+    put(path: string, ...handlers: handlerFunction[]): this;
+    patch(path: string, ...handlers: handlerFunction[]): this;
+    delete(path: string, ...handlers: handlerFunction[]): this;
+}
+export default Router;

package/dist/types.d.ts

@@ -1,7 +1,7 @@
 import { Server } from "bun";
 export type listenCalllBackType = () => void;
 export type handlerFunction = (ctx: ContextType, server?: Server) => Response | Promise<Response | null | void>;
-export type middlewareFunc = (ctx: ContextType, server?: Server) => void | Response | Promise<Response>;
+export type middlewareFunc = (ctx: ContextType, server?: Server | undefined) => void | Response | Promise<Response>;
 export type HookFunction = (ctx: ContextType, result?: Response | null | void, server?: Server) => Response | Promise<Response | null | void>;
 export type HttpMethod = "GET" | "POST" | "PUT" | "DELETE" | "PATCH" | "OPTIONS" | "HEAD";
 export declare enum HookType {
@@ -25,6 +25,8 @@ export interface ContextType {
     server: Server;
     url: URL;
     next: () => void;
+    setUser: (data?: any) => void;
+    getUser: () => any;
     status: (status: number) => this;
     getIP: () => any;
     body: () => Promise<any>;
@@ -76,6 +78,7 @@ export interface DieselT {
         onSend: ((ctx?: ContextType, result?: Response | null | void, serer?: Server) => Promise<Response | void | null>) | null;
     };
     filters: string[];
+    hasFilterEnabled: boolean;
     filterFunction: (ctx: ContextType, serer?: Server) => void | Response | Promise<Response | void>;
     corsConfig: corsT | null;
     globalMiddlewares: Array<(ctx: ContextType, serer?: Server) => void | Promise<Response | null | void>>;

package/example/main.ts

@@ -1,15 +1,17 @@
-import {Diesel} from "diesel-core";
+import { Server } from "bun";
+import Diesel ,{rateLimit} from "../src/main";
+import { ContextType, CookieOptions, middlewareFunc } from "../dist/types";
 import jwt from 'jsonwebtoken'
 
 const app = new Diesel()
-const secret = 'pussy'
+const secret = 'pradeep'
 // app.cors({
 //   origin: ['http://localhost:5173','*'],
 //   methods: 'GET,POST,PUT,DELETE',
 //   allowedHeaders: 'Content-Type,Authorization'
 // })
 
-async function authJwt(ctx:any, server:any) {
+async function authJwt (ctx:ContextType, server?:Server): Promise<void | Response> {
   const token = await ctx.getCookie("accessToken");  // Retrieve the JWT token from cookies
   if (!token) {
     return ctx.status(401).json({ message: "Authentication token missing" });
@@ -17,9 +19,8 @@ async function authJwt(ctx:any, server:any) {
   try {
     // Verify the JWT token using a secret key
     const user = jwt.verify(token, secret);  // Replace with your JWT secret
-    console.log(user)
     // Set the user data in context
-    ctx.set("user", user);
+    ctx.setUser(user);
 
     // Proceed to the next middleware/route handler
     return ctx.next();
@@ -36,23 +37,22 @@ const limiter = rateLimit({
 // app.use(h)
 // app.use(limiter)
 
-app
-.filter()
-.routeMatcher('/api/user/register','/api/user/login','/test/:id','/cookie')
-.permitAll()
-.require(authJwt)
+// app
+// .filter()
+// .routeMatcher('/api/user/register','/api/user/login','/test/:id','/cookie')
+// .permitAll()
+// .require(authJwt as middlewareFunc)
+
+// app.use(authJwt)
 
 // .require(you can pass jwt auth parser)
 
 app.get("/", async(xl) => {
-  // const ip = xl.req
-  // console.log(ip)
-    return xl.json({
-      message: 'Hello from Express!',
-      author: 'Pradeep',
-      app: 'Express App',
-      features: ['Fast', 'Flexible', 'Lightweight']
-    });
+  // // const ip = xl.req
+  // // console.log(ip)
+  // const user = xl.getUser()
+  //   return xl.json({user:user});
+  return xl.status(200).text("hello world")
 });
 
 app.get("/test/:id", async (xl) => {
@@ -73,7 +73,7 @@ app.get("/test/:id", async (xl) => {
   
     const accessToken = jwt.sign(user, secret, { expiresIn: "1d" });
     const refreshToken = jwt.sign(user, secret, { expiresIn: "10d" });
-    const options = {
+    const options : CookieOptions= {
       httpOnly: true, // Makes cookie accessible only by the web server (not JS)
       secure: true, // Ensures the cookie is sent over HTTPS
       maxAge: 24 * 60 * 60 * 1000, // 1 day in milliseconds
@@ -87,4 +87,6 @@ app.get("/test/:id", async (xl) => {
     return xl.json({msg:"setting cookies"})
   });
 
+
+
 app.listen(3000)

package/example/package.json

@@ -11,7 +11,7 @@
   "description": "",
   "dependencies": {
     "@types/jsonwebtoken": "^9.0.7",
-    "diesel-core": "^0.0.12",
+    "diesel-core": "^0.0.13",
     "jsonwebtoken": "^9.0.2",
     "jwt": "^0.2.0"
   }

package/example/route.js

@@ -1,4 +1,4 @@
-import Router from "../src/router";
+import Router from "../src/route";
 
 const route = new Router();
 
@@ -10,7 +10,7 @@ const s = () =>{
   console.log('s')
 }
 
-route.get("/register", h,(xl) => {
+route.get("/register/:id", h,(xl) => {
   return xl.text("from register user");
 })
 

package/example/tester.js

@@ -1,9 +1,11 @@
-import {Diesel} from "../src/main";
+import Diesel from "../dist/main";
 import jwt from "jsonwebtoken";
 
 const app = new Diesel();
 const secret = "secret";
 
+// app.filter().permitAll().require()
+
 app.get("/r", (xl) => {
   return xl.html(`${import.meta.dir}/index.html`);
 });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "diesel-core",
-  "version": "0.0.13",
+  "version": "0.0.15",
   "main": "dist/main.js",
   "types": "dist/main.d.ts",
   "scripts": {

package/src/ctx.ts

@@ -5,11 +5,12 @@ export default function createCtx(req: Request, server:Server ,url: URL): Contex
   let headers: Headers = new Headers()
   let settedValue: Record<string, string> = {};
   let isAuthenticated: boolean = false;
-  let parsedQuery: any = null;
-  let parsedCookie: any = null
-  let parsedParams: any = null;
+  let parsedQuery: any = {};
+  let parsedCookie: any = {}
+  let parsedParams: any = {};
   let parsedBody: ParseBodyResult | null;
   let responseStatus: number = 200;
+  let user : any = {}
 
   return {
     req,
@@ -17,6 +18,16 @@ export default function createCtx(req: Request, server:Server ,url: URL): Contex
     url,
     next: () => { },
 
+    getUser(){
+      return user
+    },
+
+    setUser(data?:any){
+     if (data) {
+       user = data
+     }
+    },
+
     // Set response status for chaining
     status(status: number): ContextType {
       responseStatus = status;
@@ -135,7 +146,7 @@ export default function createCtx(req: Request, server:Server ,url: URL): Contex
     async getCookie(cookieName?: string)
       : Promise<string | Record<string, string> | null> {
       if (!parsedCookie) {
-        const cookieHeader = req.headers.get("cookie")
+        const cookieHeader = req.headers?.get("cookie")
         if (cookieHeader) {
           parsedCookie = await parseCookie(cookieHeader);
         }

package/src/handleRequest.ts

@@ -1,23 +1,14 @@
 import { Server } from "bun";
 import createCtx from "./ctx";
-import type { ContextType, corsT, DieselT, handlerFunction, middlewareFunc, RouteCache, RouteHandlerT } from "./types";
-import { binaryS } from "./utils";
-
-// const routeCache:RouteCache = {}
+import type { ContextType, corsT, DieselT, middlewareFunc, RouteHandlerT } from "./types";
 
 export default async function handleRequest(req: Request, server: Server, url: URL, diesel: DieselT): Promise<Response> {
 
-  const ctx: ContextType = createCtx(req, server, url);
 
-  // Try to find the route handler in the trie
-  let routeHandler: RouteHandlerT | undefined = diesel.trie.search(url.pathname, req.method);;
-  // if(routeCache[url.pathname+req.method]) {
-  //   routeHandler = routeCache[url.pathname+req.method]
-  // } else {
-  //   routeHandler = diesel.trie.search(url.pathname, req.method);
-  //   routeCache[url.pathname+req.method]=routeHandler
-  // }
 
+  // Try to find the route handler in the trie
+  const routeHandler: RouteHandlerT | undefined = diesel.trie.search(url.pathname, req.method);
+ 
   // Early return if route or method is not found
   if (!routeHandler || routeHandler.method !== req.method) {
     return new Response(routeHandler ? "Method not allowed" : `Route not found for ${url.pathname}`, {
@@ -28,27 +19,35 @@ export default async function handleRequest(req: Request, server: Server, url: U
   // If the route is dynamic, we only set routePattern if necessary
   if (routeHandler.isDynamic) req.routePattern = routeHandler.path;
 
+  // create the context which contains the methods Req,Res, many more
+  const ctx: ContextType = createCtx(req, server, url);
+
   // cors execution
   if (diesel.corsConfig) {
     const corsResult = await applyCors(req, ctx, diesel.corsConfig)
-    if(corsResult) return corsResult;
+    if (corsResult) return corsResult;
   }
 
   // OnReq hook 1
   if (diesel.hasOnReqHook && diesel.hooks.onRequest) diesel.hooks.onRequest(ctx, server)
 
   // filter applying
-  if (diesel.filters.length > 0) {
+  if (diesel.hasFilterEnabled) {
 
     const path = req.routePattern ?? url.pathname
     const hasRoute = diesel.filters.includes(path)
-
     if (hasRoute === false) {
       if (diesel.filterFunction) {
-        const filterResult = await diesel?.filterFunction(ctx, server)
-        if (filterResult) return filterResult
-      }
-      else {
+        try {
+          const filterResult = await diesel.filterFunction(ctx, server)
+          if (filterResult) return filterResult
+        } catch (error) {
+          console.error("Error in filterFunction:", error);
+          return new Response(JSON.stringify({
+            message: "Internal Server Error"
+          }), { status: 500 });
+        }
+      } else {
         return new Response(JSON.stringify({
           message: "Authentication required"
         }), { status: 400 })

package/src/main.ts

@@ -3,6 +3,7 @@ import handleRequest from "./handleRequest.js";
 import rateLimit from "./utils.js";
 import {
   corsT,
+  DieselT,
   FilterMethods,
   HookFunction,
   HookType,
@@ -17,6 +18,7 @@ import { Server } from "bun";
 
 
 export default class Diesel {
+
   routes : string[] | undefined
   globalMiddlewares: middlewareFunc[]
   middlewares: Map<string, middlewareFunc[]>;
@@ -30,11 +32,11 @@ export default class Diesel {
   corsConfig: corsT
   filters: string[]
   filterFunction : middlewareFunc | null
+  hasFilterEnabled: boolean
+  wss : WebSocket | null | undefined
 
   constructor() {
     this.routes = []
-    this.filters = []
-    this.filterFunction = null
     this.globalMiddlewares = [];
     this.middlewares = new Map();
     this.trie = new Trie();
@@ -52,10 +54,15 @@ export default class Diesel {
       onError: null,
       onClose: null
     }
+    this.filters = []
+    this.filterFunction = null
+    this.hasFilterEnabled = false
+    this.wss = null
   }
 
   
   filter() :FilterMethods {
+    this.hasFilterEnabled = true
 
     return {
       routeMatcher: (...routes:string[]) => {
@@ -67,17 +74,13 @@ export default class Diesel {
         for(const route of this?.routes!){
           this.filters.push(route)
         }
-        // this.routes = []
         return this.filter()
       },
 
       require: (fnc?:middlewareFunc) => {
-        if(!fnc || typeof fnc !== 'function' ){
-          return new Response(JSON.stringify({
-            message:"Authentication required"
-          }),{status:400})
+        if (fnc) {
+          this.filterFunction = fnc
         }
-        this.filterFunction = fnc
       }
     };
   }
@@ -138,13 +141,13 @@ export default class Diesel {
     }
 
     this.compile();
-    const dieselInstance = this as Diesel
+
     const options: any = {
       port,
       fetch: async (req: Request, server: Server) => {
         const url = new URL(req.url);
         try {
-          return await handleRequest(req, server, url, this);
+          return await handleRequest(req, server, url, this as DieselT);
         } catch (error) {
           return new Response("Internal Server Error", { status: 500 });
         }
@@ -160,7 +163,7 @@ export default class Diesel {
     }
     const server = Bun.serve(options);
 
-    // Bun?.gc(false)
+    Bun?.gc(false)
 
     if (typeof callback === "function") {
       return callback();
@@ -186,7 +189,7 @@ export default class Diesel {
       throw new Error("handler parameter should be a instance of router object", handlerInstance)
     }
     const routeEntries: [string, RouteNodeType][] = Object.entries(handlerInstance.trie.root.children) as [string, RouteNodeType][];
-
+    
     handlerInstance.trie.root.subMiddlewares.forEach((middleware: middlewareFunc[], path: string) => {
       if (!this.middlewares.has(pathPrefix + path)) {
         this.middlewares.set(pathPrefix + path, []);
@@ -208,7 +211,7 @@ export default class Diesel {
     handlerInstance.trie = new Trie();
   }
 
-  #addRoute(
+  addRoute(
     method: HttpMethod, 
     path: string, 
     handlers: handlerFunction[]
@@ -252,7 +255,7 @@ export default class Diesel {
       }
       return
     }
-    // now it means it is path midl
+    
     const path: string = pathORHandler as string;
 
     if (!this.middlewares.has(path)) {
@@ -270,7 +273,7 @@ export default class Diesel {
     path: string, 
     ...handlers: handlerFunction[]
   ) : this {
-    this.#addRoute("GET", path, handlers);
+    this.addRoute("GET", path, handlers);
     return this
   }
 
@@ -278,12 +281,12 @@ export default class Diesel {
     path: string, 
     ...handlers: handlerFunction[]
   ): this {
-    this.#addRoute("POST", path, handlers);
+    this.addRoute("POST", path, handlers);
     return this
   }
 
   put(path: string, ...handlers: handlerFunction[]) : this{
-    this.#addRoute("PUT", path, handlers);
+    this.addRoute("PUT", path, handlers);
     return this
   }
 
@@ -291,7 +294,7 @@ export default class Diesel {
     path: string, 
     ...handlers: handlerFunction[]
   ) : this {
-    this.#addRoute("PATCH", path, handlers);
+    this.addRoute("PATCH", path, handlers);
     return this
   }
 
@@ -299,7 +302,7 @@ export default class Diesel {
     path: any, 
     ...handlers: handlerFunction[]
   ) : this {
-    this.#addRoute("DELETE", path, handlers);
+    this.addRoute("DELETE", path, handlers);
     return this;
   }
 }

package/src/route.ts

@@ -0,0 +1,56 @@
+import Diesel from "./main";
+import type { handlerFunction, HttpMethod } from "./types";
+
+class Router extends Diesel {
+  constructor() {
+    super();
+  }
+  
+  // #addRoute(method:HttpMethod, path:string, handlers:handlerFunction[]) {
+  //     if (!this.trie.root.subMiddlewares.has(path)) {
+  //         this.trie.root.subMiddlewares.set(path,[])
+  //       }  
+  //       const middlewareHandlers : handlerFunction[]= handlers.slice(0, -1);
+
+  //       const currentMiddlewares = this.trie.root.subMiddlewares.get(path)
+        
+  //       middlewareHandlers.forEach((midl:handlerFunction) => {
+  //         if (!currentMiddlewares?.includes(midl)) {
+  //           currentMiddlewares?.push(midl)
+  //         }
+  //       })
+
+  //   // if (!this.trie.root.subMiddlewares.get(path).includes(...middlewareHandlers)) {
+  //   //     this.trie.root.subMiddlewares.get(path).push(...middlewareHandlers)
+  //   // }
+
+  //   const handler : handlerFunction = handlers[handlers.length - 1];
+  //   this.trie.insert(path, { handler, method });
+  // }
+  get(path:string, ...handlers:handlerFunction[]) {
+    this.addRoute("GET", path, handlers);
+    return this
+  }
+
+  post(path:string, ...handlers:handlerFunction[]) {
+    this.addRoute("POST", path, handlers);
+    return this;
+  }
+
+  put(path:string, ...handlers:handlerFunction[]) {
+    this.addRoute("PUT", path, handlers);
+    return this
+  }
+
+  patch(path:string, ...handlers:handlerFunction[]) {
+      this.addRoute("PATCH", path, handlers);
+      return this
+  }
+
+  delete(path:string, ...handlers:handlerFunction[]) {
+    this.addRoute("DELETE", path, handlers);
+    return this;
+  }
+}
+
+export default Router;

package/src/trie.ts

@@ -59,9 +59,11 @@ class TrieNode {
         node = node.children[key];
         // Set dynamic route information if applicable
         node.isDynamic = isDynamic;
-        node.pattern = segment;  // Store the actual pattern like ':id'
+        node.pattern = segment;
+        node.method.push(route.method)
+        node.handler.push(route.handler)
+        node.path = path;  // Store the actual pattern like ':id'
       }
-    
       // After looping through the entire path, assign route details
       node.isEndOfWord = true;
       node.method.push(route.method);    
@@ -95,7 +97,7 @@ class TrieNode {
           node = node.children[key];
         }
       }
-    
+      
       // Method matching
       let routeMethodIndex = node.method.indexOf(method); // More efficient method match
       if (routeMethodIndex !== -1) {

package/src/types.ts

@@ -2,7 +2,7 @@ import { Server } from "bun";
 
 export type listenCalllBackType = () => void;
 export type handlerFunction = (ctx: ContextType, server?: Server) => Response | Promise<Response | null | void>;
-export type middlewareFunc = (ctx:ContextType,server?:Server) => void | Response | Promise<Response>
+export type middlewareFunc = (ctx:ContextType,server?:Server | undefined) => void | Response | Promise<Response>
 export type HookFunction = (ctx: ContextType, result?: Response | null | void, server?: Server) => Response | Promise<Response | null | void>
 // export type onSendHookFunc = (result?: Response | null | void, ctx?:ContextType) => Response | Promise<Response | null | void>
 export type HttpMethod = "GET" | "POST" | "PUT" | "DELETE" | "PATCH" | "OPTIONS" | "HEAD";
@@ -30,6 +30,8 @@ export interface ContextType {
     server: Server;
     url: URL;
     next: () => void;
+    setUser: (data?:any) => void
+    getUser: () => any
     status: (status: number) => this;
     getIP: () => any;
     body: () => Promise<any>;
@@ -86,6 +88,7 @@ export interface DieselT {
         onSend: ((ctx?: ContextType, result?: Response | null | void, serer?: Server) => Promise<Response | void | null>) | null;
     };
     filters: string[]
+    hasFilterEnabled:boolean
     filterFunction: (ctx:ContextType,serer?:Server) => void | Response | Promise<Response|void>
     corsConfig: corsT | null
     globalMiddlewares: Array<(ctx: ContextType, serer?: Server) => void | Promise<Response | null | void>>

package/tsconfig.json

@@ -2,10 +2,11 @@
   "compilerOptions": {
     "target": "ES6",                   // Specify ECMAScript target version
     "module": "ESNext",              // Specify module code generation
-    "outDir": "./dist",                // Redirect output structure to the 'dist' directory
+    "outDir": "./main",                // Redirect output structure to the 'dist' directory
     "rootDir": "./src", 
     "declaration": true, 
-    "emitDeclarationOnly": true,              // Specify the root directory of input files
+    "declarationDir": "./dist",
+    "emitDeclarationOnly": false,              // Specify the root directory of input files
     "strict": true,                     // Enable all strict type-checking options
     "esModuleInterop": true,            // Enables emit interoperability between CommonJS and ES Modules
     "skipLibCheck": true,               // Skip type checking of declaration files

package/src/router.ts

@@ -1,55 +0,0 @@
-import Diesel from "./main";
-import type { handlerFunction, HttpMethod } from "./types";
-
-class Router extends Diesel {
-  constructor() {
-    super();
-  }
-  #addRoute(method:HttpMethod, path:string, handlers:handlerFunction[]) {
-      if (!this.trie.root.subMiddlewares.has(path)) {
-          this.trie.root.subMiddlewares.set(path,[])
-        }  
-        const middlewareHandlers : handlerFunction[]= handlers.slice(0, -1);
-
-        const currentMiddlewares = this.trie.root.subMiddlewares.get(path)
-        
-        middlewareHandlers.forEach((midl:handlerFunction) => {
-          if (!currentMiddlewares?.includes(midl)) {
-            currentMiddlewares?.push(midl)
-          }
-        })
-
-    // if (!this.trie.root.subMiddlewares.get(path).includes(...middlewareHandlers)) {
-    //     this.trie.root.subMiddlewares.get(path).push(...middlewareHandlers)
-    // }
-
-    const handler : handlerFunction = handlers[handlers.length - 1];
-    this.trie.insert(path, { handler, method });
-  }
-  get(path:string, ...handlers:handlerFunction[]) {
-    this.#addRoute("GET", path, handlers);
-    return this
-  }
-
-  post(path:string, ...handlers:handlerFunction[]) {
-    this.#addRoute("POST", path, handlers);
-    return this;
-  }
-
-  put(path:string, ...handlers:handlerFunction[]) {
-    this.#addRoute("PUT", path, handlers);
-    return this
-  }
-
-  patch(path:string, ...handlers:handlerFunction[]) {
-      this.#addRoute("PATCH", path, handlers);
-      return this
-  }
-
-  delete(path : string, ...handlers:handlerFunction[]) {
-    this.#addRoute("DELETE", path, handlers);
-    return this;
-  }
-}
-
-export default Router;