diesel-core 0.0.13 → 0.0.14

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

@@ -38,11 +38,89 @@ 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 (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" });
+  }
+  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
+    ctx.set("user", user);
+
+    // Proceed to the next middleware/route handler
+    return ctx.next();
+  } catch (error) {
+    return ctx.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
+  return xl.json({ msg: "You are authenticated!" });
+});
+
+// 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.

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/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,7 +19,6 @@ 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);
 
@@ -42,17 +43,15 @@ app
 .permitAll()
 .require(authJwt)
 
+// 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 user = xl.get('user')
+    return xl.json({user:user});
 });
 
 app.get("/test/:id", async (xl) => {
@@ -73,7 +72,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 +86,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.14",
   "main": "dist/main.js",
   "types": "dist/main.d.ts",
   "scripts": {

package/src/handleRequest.ts

@@ -1,16 +1,17 @@
 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 = {}
+
+const routeCache:RouteCache = {}
 
 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);;
+  let routeHandler: RouteHandlerT | undefined = diesel.trie.search(url.pathname, req.method);
+ 
   // if(routeCache[url.pathname+req.method]) {
   //   routeHandler = routeCache[url.pathname+req.method]
   // } else {
@@ -31,24 +32,29 @@ export default async function handleRequest(req: Request, server: Server, url: U
   // 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";
@@ -86,6 +86,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,10 @@
   "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
+    // "emitDeclarationOnly": true,              // 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;