diesel-core 0.0.1

package/.prettierignore

@@ -0,0 +1,7 @@
+/.vscode
+/node_modules
+./dist
+
+*.env
+.env
+.env.*

package/.prettierrc

@@ -0,0 +1,7 @@
+{
+    "singleQuote": false,
+    "bracketSpacing": true,
+    "tabWidth": 2,
+    "semi": true,
+    "trailingComma": "es5"
+}

package/package.json

@@ -0,0 +1,12 @@
+{
+  "name": "diesel-core",
+  "version": "0.0.1",
+  "main": "index.js",
+  "scripts": {
+    "test": "echo \"Error: no test specified\" && exit 1"
+  },
+  "keywords": [],
+  "author": "",
+  "license": "ISC",
+  "description": ""
+}

package/src/ctx.js

@@ -0,0 +1,192 @@
+export default function createCtx(req, url) {
+  let headers = {};
+  let settedValue = {};
+  let isAuthenticated = false;
+  let parsedQuery = null;
+  let parsedCookie = null;
+  let parsedParams = null;
+  let parsedBody= null
+
+  return {
+    req,
+    url,
+    next: () => {},
+
+    async body() {
+      if (!parsedBody) {
+        parsedBody = await parseBody(req)
+        return parsedBody;
+      }
+      return parsedBody;
+    },
+    setHeader(key, value) {
+      headers[key] = value;
+    },
+
+    set(key, value) {
+      settedValue[key] = value;
+    },
+
+    get(key) {
+      return settedValue[key];
+    },
+
+    setAuth(authStatus) {
+      isAuthenticated = authStatus;
+    },
+
+    getAuth() {
+      return isAuthenticated;
+    },
+
+    text(data, status = 200) {
+      return new Response(data, {
+        status,
+        headers: headers,
+      });
+    },
+
+    json(data, status = 200) {
+      return new Response(JSON.stringify(data), {
+        status,
+        headers: {
+          "Content-Type": "application/json",
+          ...headers,
+        },
+      });
+    },
+
+    html(filepath) {
+      return new Response(Bun.file(filepath), {
+        status: 200,
+        headers: {
+          ...headers,
+        },
+      });
+    },
+    file(filePath) {
+      return new Response(Bun.file(filePath), {
+        status: 200,
+        headers: {
+          ...headers,
+        },
+      });
+    },
+
+    redirect(path, status = 302) {
+      return new Response(null, {
+        status,
+        headers: {
+          Location: path,
+          ...headers,
+        },
+      });
+    },
+
+    getParams(props) {
+      if (!parsedParams) {
+        parsedParams = extractDynamicParams(req.routePattern, url.pathname);
+      }
+      return props ? parsedParams[props] : parsedParams;
+    },
+
+    getQuery(props) {
+      if (!parsedQuery) {
+        parsedQuery = Object.fromEntries(url.searchParams.entries());
+      }
+      return props ? parsedQuery[props] : parsedQuery;
+    },
+
+    cookie(name, value, options = {}) {
+      let cookieString = `${encodeURIComponent(name)}=${encodeURIComponent(value)}`;
+
+      // Add options to cookie string (e.g., expiration, path, HttpOnly, etc.)
+      if (options.maxAge) cookieString += `; Max-Age=${options.maxAge}`;
+      if (options.expires) cookieString += `; Expires=${options.expires.toUTCString()}`;
+      if (options.path) cookieString += `; Path=${options.path}`;
+      if (options.domain) cookieString += `; Domain=${options.domain}`;
+      if (options.secure) cookieString += `; Secure`;
+      if (options.httpOnly) cookieString += `; HttpOnly`;
+      if (options.sameSite) cookieString += `; SameSite=${options.sameSite}`;
+
+      if (headers["Set-Cookie"]) {
+        // If it's already an array, push the new cookie, otherwise convert to array
+        const existingCookies = Array.isArray(headers["Set-Cookie"]) ? headers["Set-Cookie"] : [headers["Set-Cookie"]];
+
+        // Add the new cookie string to the array
+        existingCookies.push(cookieString);
+
+        // Update Set-Cookie header
+        headers["Set-Cookie"] = existingCookies;
+      } else {
+        // If no cookies exist, initialize the header
+        headers["Set-Cookie"] = cookieString;
+      }
+    },
+    getCookie(cookieName) {
+      if (!parsedCookie) {
+        parsedCookie = parseCookie(req.headers.get("cookie"));
+      }
+      return cookieName ? parsedCookie[cookieName] : parsedCookie;
+    },
+  };
+}
+
+function parseCookie(header) {
+  const cookies = {};
+  if (!header) return cookies;
+
+  const cookieArray = header.split(";");
+  cookieArray.forEach((cookie) => {
+    const [cookieName, cookievalue] = cookie.trim().split("=");
+    cookies[cookieName] = cookievalue.split(" ")[0];
+  });
+  return cookies;
+}
+
+const extractDynamicParams = (routePattern, path) => {
+  const object = {};
+  const routeSegments = routePattern.split("/");
+  const [pathWithoutQuery] = path.split("?"); // Ignore the query string in the path
+  const pathSegments = pathWithoutQuery.split("/"); // Re-split after removing query
+
+  if (routeSegments.length !== pathSegments.length) {
+    return null; // Path doesn't match the pattern
+  }
+
+  routeSegments.forEach((segment, index) => {
+    if (segment.startsWith(":")) {
+      const dynamicKey = segment.slice(1); // Remove ':' to get the key name
+      object[dynamicKey] = pathSegments[index]; // Map the path segment to the key
+    }
+  });
+
+  return object;
+};
+
+async function parseBody(req) {
+  const contentType = req.headers.get("Content-Type");
+  if (contentType.includes("application/json")) {
+    try {
+      return await req.json();
+    } catch (error) {
+      return new Response({ error: "Invalid JSON format" });
+    }
+  } else if (contentType.startsWith("application/x-www-form-urlencoded")) {
+    const body = await req.text();
+    return Object.fromEntries(new URLSearchParams(body));
+  } else if (contentType.startsWith("multipart/form-data")) {
+    const formData = await req.formData();
+    return formDataToObject(formData);
+  } else {
+    return new Response({ error: "unknown request body" });
+  }
+}
+
+function formDataToObject(formData) {
+  const obj = {};
+  for (const [key, value] of formData.entries()) {
+    obj[key] = value;
+  }
+  return obj;
+}

package/src/handleRequest.js

@@ -0,0 +1,63 @@
+import createCtx from "./ctx";
+
+export default async function handleRequest(req, url, diesel) {
+  const { pathname } = url;
+  const { method } = req;
+
+  // Try to find the route handler in the trie
+  const routeHandler = diesel.trie.search(pathname, method);
+  
+  // Early return if route or method is not found
+  if (!routeHandler || !routeHandler.handler) return responseNotFound(pathname);
+  if (routeHandler.method !== method) return responseMethodNotAllowed();
+
+  // If the route is dynamic, we only set routePattern if necessary
+  if (routeHandler.isDynamic) req.routePattern = routeHandler.path;
+
+  const ctx = createCtx(req, url);
+
+  if (diesel.hasMiddleware) {
+  const middlewares = [
+    ...diesel.globalMiddlewares,
+    ...(diesel.middlewares.get(pathname) || [])
+  ];
+
+  const middlewareResult = await executeMiddleware(middlewares, ctx);
+  if (middlewareResult) return middlewareResult;
+  
+}
+ 
+
+  // Finally, execute the route handler and return its result
+  try {
+    const result = await routeHandler.handler(ctx);
+    return result ?? responseNoHandler();
+  } catch (error) {
+    return responseServerError();
+  }
+}
+
+// Optimized middleware execution: stops as soon as a middleware returns a response
+async function executeMiddleware(middlewares, ctx) {
+  for (const middleware of middlewares) {
+    const result = await middleware(ctx);
+    if (result) return result;  // Early exit if middleware returns a result
+  }
+}
+
+// Reused response functions for better organization and clarity
+function responseNotFound(path) {
+  return new Response(`Route not found for ${path}`, { status: 404 });
+}
+
+function responseMethodNotAllowed() {
+  return new Response("Method not allowed", { status: 405 });
+}
+
+function responseNoHandler() {
+  return new Response("No response from handler", { status: 204 });
+}
+
+function responseServerError() {
+  return new Response("Internal Server Error", { status: 500 });
+}

package/src/router.js

@@ -0,0 +1,53 @@
+import diesel from "./server";
+
+class Router extends diesel{
+    constructor(){
+        super()
+    }
+    #addRoute(method,path,handlers){
+        
+        const middlewareHandlers = handlers.slice(0, -1);
+
+        if (!this.middlewares.has(path)) {
+            this.middlewares.set(path,[])
+        }
+        if (path === '/') {
+            middlewareHandlers.forEach(midlleware => {
+                if(!this.globalMiddlewares.includes(midlleware)){
+                    this.globalMiddlewares.push(midlleware)
+                }
+            })
+        } else {
+            if (!this.middlewares.get(path).includes(...middlewareHandlers)) {
+                this.middlewares.get(path).push(...middlewareHandlers);
+            }
+        }
+
+        const handler = handlers[handlers.length-1]
+        this.trie.insert(path,{handler,method})
+        
+    }
+    get(path,...handlers){
+        return this.#addRoute("GET",path,handlers)
+}
+
+post(path,...handlers){
+        return this.#addRoute("POST",path,handlers)
+}
+
+put(path,...handlers){
+        return this.#addRoute("PUT",path,handlers)
+}
+
+patch(path,...handlers){
+    if (handlers.length>0) {
+        return this.#addRoute("PATCH",path,handlers)
+    }
+}
+
+delete(path,...handlers){
+        return this.#addRoute("DELETE",path,handlers)
+}
+}
+
+export default Router

package/src/server.js

@@ -0,0 +1,131 @@
+import {serve} from 'bun'
+import Trie from './trie.js';
+import handleRequest  from './handleRequest.js'
+
+class diesel {
+    constructor(){
+        this.routes = new Map()
+        this.globalMiddlewares = [];
+        this.middlewares = new Map()
+        this.trie = new Trie()
+        this.hasMiddleware = false;
+    }
+
+    compile (){
+        if (this.globalMiddlewares.length > 0) {
+            this.hasMiddleware = true;
+        }
+        for (const [path, middlewares] of this.middlewares.entries()) {
+            if (middlewares.length > 0) {
+                this.hasMiddleware = true;
+                break;
+            }
+        }
+    }
+
+    listen(port,callback){
+        this.compile()
+        const server = serve({
+            port,
+            fetch: (req) => {
+                const url = new  URL(req.url)
+                return handleRequest(req,url,this)
+            },
+            onClose() {
+                console.log("Server is shutting down...");
+            }
+          });
+        if (typeof callback === 'function') {
+            return callback();
+          }
+          console.log(`Server is running on http://localhost:${port}`);
+          return server;
+    }
+
+    register(pathPrefix,handlerInstance){
+        const routeEntries = Object.entries(handlerInstance.trie.root.children);
+        handlerInstance.trie.root.subMiddlewares.forEach((middleware,path)=>{
+            if (!this.middlewares.has(pathPrefix+path)) {
+              this.middlewares.set(pathPrefix+path, []);
+            } 
+            if (!this.middlewares.get(pathPrefix+path).includes(...middleware)) {
+              this.middlewares.get(pathPrefix+path).push(...middleware);
+            }
+          })
+          for (const [routeKey, routeNode] of routeEntries) {
+            const fullpath = pathPrefix + routeNode?.path;
+            const routeHandler = routeNode.handler[0];
+            const httpMethod = routeNode.method[0];
+            this.trie.insert(fullpath, { handler: routeHandler, method: httpMethod });
+          }
+          handlerInstance.trie = new Trie();
+    }
+
+    #addRoute(method,path,handlers){
+        
+        const middlewareHandlers = handlers.slice(0, -1);
+
+        if (!this.middlewares.has(path)) {
+            this.middlewares.set(path,[])
+        }
+        if (path === '/') {
+            middlewareHandlers.forEach(midlleware => {
+                if(!this.globalMiddlewares.includes(midlleware)){
+                    this.globalMiddlewares.push(midlleware)
+                }
+            })
+        } else {
+            if (!this.middlewares.get(path).includes(...middlewareHandlers)) {
+                this.middlewares.get(path).push(...middlewareHandlers);
+            }
+        }
+
+        const handler = handlers[handlers.length-1]
+        this.trie.insert(path,{handler,method})
+        
+    }
+
+
+    use(pathORHandler,handler){
+        if (typeof pathORHandler === 'function') {
+            if (!this.globalMiddlewares.includes(pathORHandler)) {
+                return this.globalMiddlewares.push(pathORHandler)
+            }
+        }
+        // now it means it is path midl
+        const path = pathORHandler
+        if (!this.middlewares.has(path)) {
+            this.middlewares.set(path,[])
+        }
+
+        if(!this.middlewares.get(path).includes(handler)){
+            this.middlewares.get(path).push(handler)
+        }
+    }
+
+    get(path,...handlers){
+            return this.#addRoute("GET",path,handlers)
+    }
+
+    post(path,...handlers){
+            return this.#addRoute("POST",path,handlers)
+    }
+
+    put(path,...handlers){
+            return this.#addRoute("PUT",path,handlers)
+    }
+
+    patch(path,...handlers){
+        if (handlers.length>0) {
+            return this.#addRoute("PATCH",path,handlers)
+        }
+    }
+
+    delete(path,...handlers){
+            return this.#addRoute("DELETE",path,handlers)
+    }
+
+}
+
+
+export default diesel;

package/src/trie.js

@@ -0,0 +1,132 @@
+class TrieNode {
+    constructor() {
+      this.children = {};
+      this.isEndOfWord = false;
+      this.handler = [];
+      this.isImportant = false;
+      this.isDynamic = false;
+      this.pattern = '';
+      this.path = "";
+      this.method = []
+      this.subMiddlewares= new Map()
+    }
+  }
+  
+  export default class Trie {
+    constructor() {
+      this.root = new TrieNode();
+    }
+  
+    insert(path, route) {
+      let node = this.root;
+      const pathSegments = path.split('/').filter(Boolean); // Split path by segments
+    
+      // If it's the root path '/', treat it separately
+      if (path === '/') {
+        node.isEndOfWord = true;
+        node.handler.push(route.handler)
+        node.isImportant = route.isImportant;
+        node.path = path;
+        node.method.push(route.method)
+        return;
+      }
+    
+      for (const segment of pathSegments) {
+        let isDynamic = false;
+        let key = segment;
+    
+        if (segment.startsWith(':')) {
+          isDynamic = true;
+          key = ':';  // Store dynamic routes under the key ':'
+        }
+    
+        if (!node.children[key]) {
+          node.children[key] = new TrieNode();
+        }
+    
+        node = node.children[key];
+        // Set dynamic route information if applicable
+        node.isDynamic = isDynamic;
+        node.pattern = segment;  // Store the actual pattern like ':id'
+      }
+    
+      // After looping through the entire path, assign route details
+      node.isEndOfWord = true;
+      node.method.push(route.method);    
+      node.handler.push(route.handler)
+      node.isImportant = route.isImportant;
+      node.path = path;  // Store the original path
+    }
+    
+    insertMidl(midl){
+      if (!this.root.subMiddlewares.has(midl)) {
+        this.root.subMiddlewares.set(midl)
+      }
+    }
+    
+  
+    search(path, method) {
+      let node = this.root;
+      const pathSegments = path.split('/').filter(Boolean); // Split path into segments
+    
+      for (const segment of pathSegments) {
+        let key = segment;
+    
+        // Check for exact match first (static)
+        if (!node.children[key]) {
+          // Try dynamic match (e.g., ':id')
+          if (node.children[':']) {
+            node = node.children[':'];
+          } else {
+            return null; // No match
+          }
+        } else {
+          node = node.children[key];
+        }
+      }
+    
+      // Method matching
+      let routeMethodIndex = node.method.indexOf(method); // More efficient method match
+      if (routeMethodIndex !== -1) {
+        return {
+          path: node.path,
+          handler: node.handler[routeMethodIndex],
+          isDynamic: node.isDynamic,
+          pattern: node.pattern,
+          method: node.method[routeMethodIndex]
+        };
+      }
+    
+      // Fallback if method is not found
+      return null;
+    }
+    
+    
+  
+      // New getAllRoutes method
+  
+    getAllRoutes() {
+      const routes = [];
+      // Helper function to recursively collect all routes
+      const traverse = (node, currentPath) => {
+        if (node.isEndOfWord) {
+          routes.push({
+            path: currentPath,
+            handler: node.handler,
+            isImportant: node.isImportant,
+            isDynamic: node.isDynamic,
+            pattern: node.pattern,
+          });
+        }
+        // Recursively traverse all children
+        for (const key in node.children) {
+          const child = node.children[key];
+          const newPath = currentPath + (key === ':' ? '/:' + child.pattern : '/' + key); // Reconstruct the full path
+          traverse(child, newPath);
+        }
+      };
+      // Start traversal from the root
+      traverse(this.root, "");
+      return routes;
+    }
+  }