diesel-core 1.4.2 → 1.4.4

package/dist/ctx.d.ts

@@ -1,3 +1,4 @@
 import { Server } from "bun";
 import type { ContextType } from "./types";
 export default function createCtx(req: Request, server: Server, pathname: string, routePattern: string | undefined): ContextType;
+export declare function extractDynamicParams(originalPath: string, incomingPath: string): Record<string, string> | null;

package/dist/handleRequest.d.ts

@@ -1,10 +1,14 @@
 import { BunRequest, Server } from "bun";
-import type { ContextType, DieselT } from "./types";
+import type { ContextType, DieselT, HookType } from "./types";
 /** Fast parse that extracts pathname and raw query without constructing URL */
 export declare function parseRequestUrl(rawUrl: string): string;
 export default function handleRequest(req: BunRequest, server: Server, diesel: DieselT): Promise<Response>;
+export declare function runHooks<T extends any[]>(label: HookType, hooksArray: any, args: T): Promise<any>;
+export declare function runMiddlewares(diesel: DieselT, pathname: string, ctx: ContextType, server: Server): Promise<Response | null>;
 export declare function executeBunMiddlewares(middlewares: Function[], req: BunRequest, server: Server): Promise<any>;
+export declare function runFilter(diesel: DieselT, path: string, ctx: ContextType, server: Server): Promise<any>;
 export declare function handleFilterRequest(diesel: DieselT, path: string, ctx: ContextType, server: Server): Promise<Response | undefined>;
 export declare function handleBunFilterRequest(diesel: DieselT, path: string, req: BunRequest, server: Server): Promise<Response | undefined>;
+export declare function handleRouteNotFound(diesel: DieselT, ctx: ContextType, pathname: string): Promise<Response>;
 export declare function generateErrorResponse(status: number, error: string): Response;
 export declare function handleStaticFiles(diesel: DieselT, pathname: string, ctx: ContextType): Promise<Response | null>;

package/dist/main.d.ts

@@ -1,28 +1,21 @@
 import Trie from "./trie.js";
-import { ContextType, corsT, FilterMethods, HookFunction, HookType, listenArgsT, middlewareFunc, onError, onRequest, RouteNotFoundHandler, type handlerFunction, type Hooks, type HttpMethod } from "./types.js";
+import { CompileConfig, ContextType, corsT, FilterMethods, HookFunction, HookType, listenArgsT, middlewareFunc, onError, onRequest, RouteNotFoundHandler, type handlerFunction, type Hooks, type HttpMethod } from "./types.js";
 import { BunRequest, Server } from "bun";
 import { AdvancedLoggerOptions, LoggerOptions } from "./middlewares/logger/logger.js";
-import { ServerOptions } from "http";
 export default class Diesel {
     private static instance;
-    fecth: ServerOptions['fetch'];
+    fecth: any;
     routes: Record<string, Function>;
     private tempRoutes;
     globalMiddlewares: middlewareFunc[];
     middlewares: Map<string, middlewareFunc[]>;
     trie: Trie;
-    hasOnReqHook: boolean;
-    hasMiddleware: boolean;
-    hasPreHandlerHook: boolean;
-    hasPostHandlerHook: boolean;
-    hasOnSendHook: boolean;
-    hasOnError: boolean;
     hooks: Hooks;
     corsConfig: corsT;
     FilterRoutes: string[] | null | undefined;
     filters: Set<string>;
-    filterFunction: middlewareFunc[];
-    hasFilterEnabled: boolean;
+    filterFunction: Function[];
+    private hasFilterEnabled;
     private serverInstance;
     staticPath: any;
     staticFiles: any;
@@ -32,6 +25,7 @@ export default class Diesel {
     idleTimeOut: number;
     routeNotFoundFunc: (c: ContextType) => void | Promise<void> | Promise<Response> | Response;
     private prefixApiUrl;
+    compileConfig: CompileConfig | null;
     constructor({ jwtSecret, baseApiUrl, enableFileRouting, idleTimeOut, prefixApiUrl, }?: {
         jwtSecret?: string;
         baseApiUrl?: string;
@@ -57,9 +51,9 @@ export default class Diesel {
     private loadRoutes;
     useLogger(options: LoggerOptions): this;
     useAdvancedLogger(options: AdvancedLoggerOptions): this;
-    BunRoute(method: string, path: string, ...handlers: any[]): void;
+    BunRoute(method: string, path: string, ...handlersOrResponse: any[]): this;
     listen(port: any, ...args: listenArgsT[]): Server | void;
-    fetch(): (req: BunRequest, server: Server) => Promise<Response>;
+    fetch(): (req: BunRequest, server: Server) => Promise<any>;
     close(callback?: () => void): void;
     /**
      * Registers a router instance for subrouting.

package/dist/middlewares/logger/logger.js

@@ -1,3 +1,3 @@
-var t={reset:"\x1B[0m",info:"\x1B[36m",warn:"\x1B[33m",error:"\x1B[31m",method:{GET:"\x1B[32m",POST:"\x1B[34m",PUT:"\x1B[35m",DELETE:"\x1B[31m",PATCH:"\x1B[36m"}},p=(d,n,o)=>{let i=t[d]||t.reset,g=o?.method?t.method[o.method]||t.reset:t.reset,u=o?.status?o.status>=500?t.error:o.status>=400?t.warn:t.info:t.reset;console.log(`
-${i}[${d.toUpperCase()}]${t.reset} ${n} - ${g}${o?.method||""}${t.reset}`);let s={timestamp:new Date().toISOString(),...o,status:o?.status?`${u}${o.status}${t.reset}`:void 0,method:o?.method?`${g>i}${o.method}${t.reset}`:void 0};console.log(JSON.stringify(s,null,2)+`
-`)},$=(d)=>{let{app:n,logger:o,logLevel:i="info",onRequest:g,onSend:u,onError:s}=d||{};n?.addHooks("onRequest",(e,r)=>{e.startTime=Date.now(),o?.()??p(i,"Incoming Request",{method:e.method,url:r.toString(),headers:{"user-agent":e.headers.get("user-agent"),"content-type":e.headers.get("content-type")}}),g?.(e,r)}),n?.addHooks("onSend",async(e)=>{let r=`${Date.now()-e.req.startTime}ms`;o?.()??p(i,"Response Sent",{method:e.req.method,url:e.url.toString(),status:e.status,duration:r,reqId:e.get?.("requestId"),headers:{"content-type":e.headers.get("content-type")}});let a=await u?.(e);if(a instanceof Response)return a}),n?.addHooks("onError",async(e,r,a)=>{o?.()??p("error","Unhandled Error",{method:r.method,url:a.toString(),status:500,error:e.message});let m=await s?.(e,r,a);if(m instanceof Response)return m})},c=(d,n,o,i=0,g,u)=>{let s=t.method[n]||t.reset,e=i>=500?t.error:i>=400?t.warn:t.info,r=u?`[${u}] `:"",a=d==="<--"?`${d} ${s}${n}${t.reset} ${o} ${r}`:`${d} ${s}${n}${t.reset} ${o} ${e}${i}${t.reset} ${g??""} ${r}`;console.log(a)},l=(d)=>{let n=Date.now()-d;return n<1000?`${n}ms`:`${Math.round(n/1000)}s`},h=(d)=>{let{app:n,log:o,onRequest:i,onSend:g,onError:u}=d;n.addHooks("onRequest",(s,e)=>{s.startTime=Date.now(),o?.()??c("<--",s.method,e.pathname),i?.(s,e)}),n.addHooks("onSend",async(s)=>{let{method:e,url:r}=s.req,a=new URL(r).pathname,m=s.get?.("requestId");o?.()??c("-->",e,a,s.status,l(s.req.startTime),m);let R=await g?.(s);if(R instanceof Response)return R}),n.addHooks("onError",async(s,e,r)=>{o?.()??c(s.message,e.method,r.toString(),500);let a=await u?.(s,e,r);if(a instanceof Response)return a})};export{h as logger,$ as advancedLogger};
+var t={reset:"\x1B[0m",info:"\x1B[36m",warn:"\x1B[33m",error:"\x1B[31m",method:{GET:"\x1B[32m",POST:"\x1B[34m",PUT:"\x1B[35m",DELETE:"\x1B[31m",PATCH:"\x1B[36m"}},p=(i,n,o)=>{let a=t[i]||t.reset,g=o?.method?t.method[o.method]||t.reset:t.reset,u=o?.status?o.status>=500?t.error:o.status>=400?t.warn:t.info:t.reset;console.log(`
+${a}[${i.toUpperCase()}]${t.reset} ${n} - ${g}${o?.method||""}${t.reset}`);let s={timestamp:new Date().toISOString(),...o,status:o?.status?`${u}${o.status}${t.reset}`:void 0,method:o?.method?`${g>a}${o.method}${t.reset}`:void 0};console.log(JSON.stringify(s,null,2)+`
+`)},$=(i)=>{let{app:n,logger:o,logLevel:a="info",onRequest:g,onSend:u,onError:s}=i||{};n?.addHooks("onRequest",(e,r)=>{e.startTime=Date.now(),o?.()??p(a,"Incoming Request",{method:e.method,url:r,headers:{"user-agent":e.headers.get("user-agent"),"content-type":e.headers.get("content-type")}}),g?.(e,r)}),n?.addHooks("onSend",async(e)=>{let r=`${Date.now()-e.req.startTime}ms`;o?.()??p(a,"Response Sent",{method:e.req.method,url:e.url.toString(),status:e.status,duration:r,reqId:e.get?.("requestId"),headers:{"content-type":e.headers.get("content-type")}});let d=await u?.(e);if(d instanceof Response)return d}),n?.addHooks("onError",async(e,r,d)=>{o?.()??p("error","Unhandled Error",{method:r.method,url:d,status:500,error:e.message});let m=await s?.(e,r,d);if(m instanceof Response)return m})},c=(i,n,o,a=0,g,u)=>{let s=t.method[n]||t.reset,e=a>=500?t.error:a>=400?t.warn:t.info,r=u?`[${u}] `:"",d=i==="<--"?`${i} ${s}${n}${t.reset} ${o} ${r}`:`${i} ${s}${n}${t.reset} ${o} ${e}${a}${t.reset} ${g??""} ${r}`;console.log(d)},R=(i)=>{let n=Date.now()-i;return n<1000?`${n}ms`:`${Math.round(n/1000)}s`},h=(i)=>{let{app:n,log:o,onRequest:a,onSend:g,onError:u}=i;n.addHooks("onRequest",(s,e)=>{s.startTime=Date.now(),o?.()??c("<--",s.method,e),a?.(s,e)}),n.addHooks("onSend",async(s)=>{let{method:e,url:r}=s.req,d=new URL(r).pathname,m=s.get?.("requestId");o?.()??c("-->",e,d,s.status,R(s.req.startTime),m);let l=await g?.(s);if(l instanceof Response)return l}),n.addHooks("onError",async(s,e,r)=>{o?.()??c(s.message,e.method,r,500);let d=await u?.(s,e,r);if(d instanceof Response)return d})};export{h as logger,$ as advancedLogger};

package/dist/middlewares/ratelimit/implementation.d.ts

@@ -10,11 +10,4 @@ declare class RedisStore implements RateLimitStore {
     set(key: string, value: string, ttlMs: number): Promise<void>;
     reset(key: string): Promise<void>;
 }
-declare class DiceDbStore implements RateLimitStore {
-    private dicedb;
-    constructor(dicedb: any);
-    get(key: string): Promise<number | null>;
-    set(key: string, value: string, ttlMs: number): Promise<void>;
-    reset(key: string): Promise<void>;
-}
-export { RedisStore, DiceDbStore };
+export { RedisStore, };

package/dist/middlewares/ratelimit/implementation.js

@@ -1 +1 @@
-class i{redis;constructor(t){this.redis=t}async get(t){let e=await this.redis.get(t);return e?parseInt(e):null}async set(t,e,s){await this.redis.set(t,e,"PX",s)}async reset(t){await this.redis.del(t)}}class r{dicedb;constructor(t){this.dicedb=t}async get(t){let e=await this.dicedb.get(t);return e?parseInt(e):null}async set(t,e,s){await this.dicedb.set(t,e,"PX",s)}async reset(t){await this.dicedb.del(t)}}export{i as RedisStore,r as DiceDbStore};
+class r{redis;constructor(t){this.redis=t}async get(t){let e=await this.redis.get(t);return e?parseInt(e):null}async set(t,e,s){await this.redis.set(t,e,"PX",s)}async reset(t){await this.redis.del(t)}}export{r as RedisStore};

package/dist/request_pipeline.d.ts

@@ -0,0 +1,3 @@
+import { CompileConfig, DieselT } from "./types";
+export declare const buildRequestPipeline: (config: CompileConfig, diesel: DieselT) => any;
+export declare const BunRequestPipline: (config: CompileConfig, diesel: DieselT, method: string, path: string, ...handlersOrResponse: Function[]) => any;

package/dist/trie.d.ts

@@ -1,4 +1,4 @@
-import type { handlerFunction, HttpMethod, RouteT } from "./types";
+import type { handlerFunction, HttpMethod, RouteHandlerT } from "./types";
 declare class TrieNode {
     children: Record<string, TrieNode>;
     isEndOfWord: boolean;
@@ -12,13 +12,11 @@ declare class TrieNode {
 export default class Trie {
     root: TrieNode;
     constructor();
-    insert(path: string, route: RouteT): void;
+    insert(path: string, route: RouteHandlerT): void;
     search(path: string, method: HttpMethod): {
         path: string;
         handler: handlerFunction;
-        isDynamic: boolean;
         pattern: string;
-        method: string;
     } | null;
 }
 export {};

package/dist/types.d.ts

@@ -94,6 +94,7 @@ export interface DieselT {
     routeNotFoundFunc: RouteNotFoundHandler;
     routerInstance: DieselT;
     tempRoutes: Map<string, TempRouteEntry>;
+    routes: Record<string, Function>;
 }
 export type corsT = {
     origin?: string | string[] | null;
@@ -126,3 +127,12 @@ declare global {
         [key: string]: any;
     }
 }
+export interface CompileConfig {
+    hasMiddleware: boolean;
+    hasOnReqHook: boolean;
+    hasPreHandlerHook: boolean;
+    hasOnError: boolean;
+    hasPostHandlerHook: boolean;
+    hasOnSendHook: boolean;
+    hasFilterEnabled: boolean;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "diesel-core",
-  "version": "1.4.2",
+  "version": "1.4.4",
   "description": "Web framework built on Web Standards",
   "main": "index.js",
   "types": "index.d.ts",