diesel-core 0.0.21 → 0.0.22

package/CONTRIBUTING.md

@@ -1,3 +1,3 @@
-only i know folder structure and codebase , if u dont understand it dont worry , just ping me.
-
+only i know folder structure and codebase , if u dont understand it dont worry , just ping me.
+
 if you changes code OR fixing bugs  so after doing make sure to run tsc and bun build.js

package/LICENSE

@@ -1,8 +1,8 @@
-Diesel.js License
-Copyright (c) 2024 Pradeep Sahu
-
-Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
-
-1. The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
-
-2. The Software is provided "as is", without warranty of any kind, express or implied, including but not limited to the warranties of merchantability, fitness for a particular purpose, and non-infringement. In no event shall the authors or copyright holders be liable for any claim, damages, or other liability, whether in an action of contract, tort, or otherwise, arising from, out of, or in connection with the Software or the use or other dealings in the Software.
+Diesel.js License
+Copyright (c) 2024 Pradeep Sahu
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
+
+1. The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
+
+2. The Software is provided "as is", without warranty of any kind, express or implied, including but not limited to the warranties of merchantability, fitness for a particular purpose, and non-infringement. In no event shall the authors or copyright holders be liable for any claim, damages, or other liability, whether in an action of contract, tort, or otherwise, arising from, out of, or in connection with the Software or the use or other dealings in the Software.

package/README.md

@@ -1,275 +1,276 @@
-# DieselJS
-
-**made only for bun***
-
-**Diesel** is a simple and lightweight HTTP server library for Bun.js that provides you with complete control over your API routes and middleware. It is designed to be intuitive and efficient, allowing you to quickly set up a server, define routes, and optimize important paths for faster response times. 
-
-With built-in support for TypeScript, DieselJS ensures type safety and improved developer experience, making it easier to catch errors during development. Whether you are building a small application or a large API, DieselJS helps you manage your routes and middleware seamlessly.
-
-
-## Installation
-Install diesel-core via bun | npm | yarn | pnpm 
-
-```bash
-npm install diesel-core
-```
-```bash
-bun add diesel-core
-```
-
-### Code Example
-```javascript
-import {Diesel}  from "diesel-core"
-
-const app = new Diesel()
-const port = 3000
-
-app.get("/", async (ctx:ContextType) => {
- return ctx.status(200).text("Hello world...!")
-})
-
-// Start the server
-app.listen(port, () => {
-  console.log(`diesel is running on port ${port}`)
-})
-```
-
-# CORS
-
-### Diesel supports cors out of the box
-
-``` javascript
-app.cors({
-  origin: ['http://localhost:5173','*'],
-  methods: 'GET,POST,PUT,DELETE',
-  allowedHeaders: 'Content-Type,Authorization'
-})
-```
-
-# 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.
-2. **preHandler**: Invoked just before the request handler executes.
-3. **postHandler**: Executed after the request handler completes but before sending the response.
-4. **onSend**: Called just before the response is sent to the client.
-5. **onError** : Executes if any error occurs
-
-### How to Define Hooks
-
-To define hooks in your DieselJS application, you can add them directly to your `Diesel` instance. Here's how to set up and use each hook:
-
-### Example Usage
-
-```javascript
-
-// define and onError hook
-
-app.addHooks("onError",(error,req,url,server) => {
-  console.log(`error occured ${error.message}`)
-  // retunr new Response(......)
-})
-
-// Define an onRequest hook
-app.addHooks("onRequest",(req,url,server) =>{
-    console.log(`Request received: ${req.method} ${url}`);
-})
-// you get req,url & server instance in onReq
-
-// Define a preHandler hook
-app.addHooks("preHandler",(xl) =>{
-    // Check for authentication token
-  const authToken = xl.req.headers.get("Authorization");
-  if (!authToken) {
-    return new Response("Unauthorized", { status: 401 });
-  }
-})
-
-// Define a postHandler hook
-app.addHooks('postHandler', async (xl) => {
-  console.log(`Response sent for: ${xl.req.url}`);
-});
-
-// Define an onSend hook
-app.addHooks('onSend',async (xl, result) => {
-  console.log(`Sending response with status: ${result.status}`);
-  return result; // You can modify the response here if needed
-});
-```
-
-# Middleware example
-
-**No Need to call NonSense *next()* in Middleware**
-
-**just dont return , if evrything goes right**
-
-```javascript
-async function authJwt (ctx:ContextType, server?:Server): Promise<void | Response> {
-  
-  try {
-    const token = ctx?.getCookie("accessToken"); 
-    if (!token) {
-      return ctx.status(401).json({ message: "Authentication token missing" });
-    }
-    // Verify the JWT token using a secret key
-    const user = jwt.verify(token, secret);
-    ctx.set('user',user);
-  } catch (error) {
-    return ctx.status(403).json({ message: "Invalid token" });
-  }
-}
-
-// this is a global middleware
-app.use(authJwt)
-
-// path middleware example
-app.use("/user",authJWT)
-
-```
-
-# set cookies
-
-```javascript
-app.get("/set-cookie", async(xl) => {
-  const user = {
-    name: "pk",
-    age: 22,
-  }
-
-  const accessToken = jwt.sign(user, secret, { expiresIn: "1d" })
-
-  const refreshToken = jwt.sign(user, secret ,{ expiresIn: "10d" })
-
-  const options = {
-    httpOnly: true, 
-    secure: true, 
-    maxAge: 24 * 60 * 60 * 1000, 
-    sameSite: "Strict", 
-    path: "/", 
-  }
-
-  xl
-  .setCookie("accessToken", accessToken, options)
-  .setCookie("refreshToken", refreshToken, options)
-
-  return xl.json({msg:"setting cookies"})
-})
-```
-
-# Render a HTML page
-```javascript
-app.get("/render",async (xl) => {
-  return xl.html(`${import.meta.dir}/index.html`)
-})
-```
-# redirect
-```javascript
-app.get("/redirect",(xl) => {
-  return xl.redirect("/");
-})
-```
-# get params
-
-**You can use set ***Multiparams***** , ***like this***
-
-```javascript
-app.get("/product/:productId/:productName)
-```
-
-```javascript
-app.get("/hello/:id/",(xl) => {
-  const id = xl.getParams("id")
-  const query = xl.getQuery() // you can pass query name also , you wanna get
-  return xl.json({ msg: "Hello", id });
-})
-```
-
-
+# DieselJS
+
+**made only for bun***
+
+**Diesel** is a simple and lightweight HTTP server library for Bun.js that provides you with complete control over your API routes and middleware. It is designed to be intuitive and efficient, allowing you to quickly set up a server, define routes, and optimize important paths for faster response times. 
+
+With built-in support for TypeScript, DieselJS ensures type safety and improved developer experience, making it easier to catch errors during development. Whether you are building a small application or a large API, DieselJS helps you manage your routes and middleware seamlessly.
+
+
+## Installation
+Install diesel-core via bun | npm | yarn | pnpm 
+
+```bash
+npm install diesel-core
+```
+```bash
+bun add diesel-core
+```
+
+### Code Example
+```javascript
+import {Diesel}  from "diesel-core"
+
+const app = new Diesel()
+const port = 3000
+
+app.get("/", async (ctx:ContextType) => {
+ return ctx.text("Hello world...!",200)
+ // Note :- passing statusCode is optional
+})
+
+// Start the server
+app.listen(port, () => {
+  console.log(`diesel is running on port ${port}`)
+})
+```
+
+# CORS
+
+### Diesel supports cors out of the box
+
+``` javascript
+app.cors({
+  origin: ['http://localhost:5173','*'],
+  methods: 'GET,POST,PUT,DELETE',
+  allowedHeaders: 'Content-Type,Authorization'
+})
+```
+
+# 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.json({ message: "Authentication token missing" },401);
+  }
+  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.setUser(user);
+
+    // Proceed to the next middleware/route handler
+    return ctx.next();
+  } catch (error) {
+    return ctx.json({ message: "Invalid token" },403);
+  }
+}
+
+// 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 (ctx:ContextType) => {
+  return ctx.json({ msg: "This is a public route. No authentication needed." });
+});
+
+// Example protected route (requires auth)
+app.get("/api/user/profile", async (ctx:ContextType) => {
+  // This route is protected, so the auth middleware will run before this handler
+  const user = ctx.getUser()
+  return ctx.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.
+2. **preHandler**: Invoked just before the request handler executes.
+3. **postHandler**: Executed after the request handler completes but before sending the response.
+4. **onSend**: Called just before the response is sent to the client.
+5. **onError** : Executes if any error occurs
+
+### How to Define Hooks
+
+To define hooks in your DieselJS application, you can add them directly to your `Diesel` instance. Here's how to set up and use each hook:
+
+### Example Usage
+
+```javascript
+
+// define and onError hook
+
+app.addHooks("onError",(error,req,url,server) => {
+  console.log(`error occured ${error.message}`)
+  // retunr new Response(......)
+})
+
+// Define an onRequest hook
+app.addHooks("onRequest",(req,url,server) =>{
+    console.log(`Request received: ${req.method} ${url}`);
+})
+// you get req,url & server instance in onReq
+
+// Define a preHandler hook
+app.addHooks("preHandler",(ctx:ContextType) =>{
+    // Check for authentication token
+  const authToken = ctx.req.headers.get("Authorization");
+  if (!authToken) {
+    return new Response("Unauthorized", { status: 401 });
+  }
+})
+
+// Define a postHandler hook
+app.addHooks('postHandler', async (ctx:ContextType) => {
+  console.log(`Response sent for: ${ctx.req.url}`);
+});
+
+// Define an onSend hook
+app.addHooks('onSend',async (ctx, result) => {
+  console.log(`Sending response with status: ${result.status}`);
+  return result; // You can modify the response here if needed
+});
+```
+
+# Middleware example
+
+**No Need to call NonSense *next()* in Middleware**
+
+**just dont return , if evrything goes right**
+
+```javascript
+async function authJwt (ctx:ContextType, server?:Server): Promise<void | Response> {
+  
+  try {
+    const token = ctx?.getCookie("accessToken"); 
+    if (!token) {
+      return ctx.json({ message: "Authentication token missing" },401);
+    }
+    // Verify the JWT token using a secret key
+    const user = jwt.verify(token, secret);
+    ctx.set('user',user);
+  } catch (error) {
+    return ctx.json({ message: "Invalid token" },403);
+  }
+}
+
+// this is a global middleware
+app.use(authJwt)
+
+// path middleware example
+app.use("/user",authJWT)
+
+```
+
+# set cookies
+
+```javascript
+app.get("/set-cookie", async(ctx:ContextType) => {
+  const user = {
+    name: "pk",
+    age: 22,
+  }
+
+  const accessToken = jwt.sign(user, secret, { expiresIn: "1d" })
+
+  const refreshToken = jwt.sign(user, secret ,{ expiresIn: "10d" })
+
+  const options = {
+    httpOnly: true, 
+    secure: true, 
+    maxAge: 24 * 60 * 60 * 1000, 
+    sameSite: "Strict", 
+    path: "/", 
+  }
+
+  ctx
+  .setCookie("accessToken", accessToken, options)
+  .setCookie("refreshToken", refreshToken, options)
+
+  return ctx.json({msg:"setting cookies"})
+})
+```
+
+# Render a HTML page
+```javascript
+app.get("/render",async (ctx) => {
+  return ctx.file(`${import.meta.dir}/index.html`)
+})
+```
+# redirect
+```javascript
+app.get("/redirect",(ctx:ContextType) => {
+  return ctx.redirect("/");
+})
+```
+# get params
+
+**You can use set ***Multiparams***** , ***like this***
+
+```javascript
+app.get("/product/:productId/:productName)
+```
+
+```javascript
+app.get("/hello/:id/",(ctx:ContextType) => {
+  const id = ctx.getParams("id")
+  const query = ctx.getQuery() // you can pass query name also , you wanna get
+  return ctx.json({ msg: "Hello", id });
+})
+```
+
+

package/build.js

@@ -1,32 +1,32 @@
-import path from 'path';
-const entryPoints = [
-    './src/main.ts',
-    './src/ctx.ts',
-    './src/handleRequest.ts',
-    './src/trie.ts',
-    './src/router.ts',
-    './src/utils.ts'
-];
-
-entryPoints.forEach(entry => {
-    console.log(`Building: ${entry}`);
-    try {
-        Bun.build({
-            entrypoints: [path.resolve(entry)],
-            outdir: './dist',
-            minify: true,
-        });
-    } catch (error) {
-        console.error(`Failed to build ${entry}:`, error);
-    }
-});
-
-// Bun.spawn(['rm','-rf','./main'])
-
-// oha test
-// oha -c 500 -n 100000 -H "Cookie: accessToken=eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJuYW1lIjoicGsiLCJhZ2UiOjIyLCJpYXQiOjE3Mjk5MjQxOTQsImV4cCI6MTczMDAxMDU5NH0._dEjx5iUuOLoq15-xTPgXOemfzIPrg06Qmruiv-I5cc" http://localhost:3000/
-
-// bombardier
-
-
-//  bombardier -c 500 -n 100000 -H "Cookie: accessToken=eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJuYW1lIjoicGsiLCJhZ2UiOjIyLCJpYXQiOjE3Mjk5MjQxOTQsImV4cCI6MTczMDAxMDU5NH0._dEjx5iUuOLoq15-xTPgXOemfzIPrg06Qmruiv-I5cc" http://localhost:3000/
+import path from 'path';
+const entryPoints = [
+    './src/main.ts',
+    './src/ctx.ts',
+    './src/handleRequest.ts',
+    './src/trie.ts',
+    // './src/router.ts',
+    './src/utils.ts'
+];
+
+entryPoints.forEach(entry => {
+    console.log(`Building: ${entry}`);
+    try {
+        Bun.build({
+            entrypoints: [path.resolve(entry)],
+            outdir: './dist',
+            minify: true,
+        });
+    } catch (error) {
+        console.error(`Failed to build ${entry}:`, error);
+    }
+});
+
+// Bun.spawn(['rm','-rf','./main'])
+
+// oha test
+// oha -c 500 -n 100000 -H "Cookie: accessToken=eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJuYW1lIjoicGsiLCJhZ2UiOjIyLCJpYXQiOjE3Mjk5MjQxOTQsImV4cCI6MTczMDAxMDU5NH0._dEjx5iUuOLoq15-xTPgXOemfzIPrg06Qmruiv-I5cc" http://localhost:3000/
+
+// bombardier
+
+
+//  bombardier -c 500 -n 100000 -H "Cookie: accessToken=eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJuYW1lIjoicGsiLCJhZ2UiOjIyLCJpYXQiOjE3Mjk5MjQxOTQsImV4cCI6MTczMDAxMDU5NH0._dEjx5iUuOLoq15-xTPgXOemfzIPrg06Qmruiv-I5cc" http://localhost:3000/