barejs 0.1.7 → 0.1.8

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "barejs",
-  "version": "0.1.7",
+  "version": "0.1.8",
   "author": "xarhang",
   "description": "High-performance JIT-specialized web framework for Bun",
   "main": "./src/bare.ts",

package/src/bare.ts

@@ -1,3 +1,4 @@
+// src/bare.ts
 import { BareContext } from './context';
 import type { Context, Middleware, Handler, WSHandlers } from './context';
 
@@ -8,37 +9,50 @@ export interface BarePlugin {
 }
 
 export class BareJS {
-  private routes: { method: string; path: string; handlers: (Middleware | Handler)[] }[] = [];
-  private globalMiddlewares: Middleware[] = [];
-  private compiledFetch?: (req: Request, server: any) => Promise<Response> | Response;
-
-  private staticMap: Record<string, (ctx: BareContext) => Promise<Response>> = {};
-
-  private dynamicRoutes: { 
-    method: string; 
-    regex: RegExp; 
-    paramNames: string[]; 
-    chain: (ctx: BareContext) => Promise<Response> 
-  }[] = [];
+  private routes: Array<{ method: string; path: string; handlers: Array<Middleware | Handler> }> = [];
+  private globalMiddlewares: Array<Middleware> = [];
+  private compiledFetch?: Function;
+  
+  private staticMap: Map<string, Function> = new Map();
+  private dynamicRoutes: Array<{
+    m: string;
+    r: RegExp;
+    p: string[];
+    c: Function;
+  }> = [];
   
   private wsHandler: { path: string; handlers: WSHandlers } | null = null;
-  private ContextClass = BareContext;
-
-  private errorHandler: (err: any, ctx: Context) => Response = (err) => 
-    new Response(JSON.stringify({ error: err.message }), { status: 500 });
-
-  // --- HTTP Methods ---
-  public get = (path: string, ...h: (Middleware | Handler)[]) => { this.routes.push({ method: "GET", path, handlers: h }); return this; };
-  public post = (path: string, ...h: (Middleware | Handler)[]) => { this.routes.push({ method: "POST", path, handlers: h }); return this; };
-  public put = (path: string, ...h: (Middleware | Handler)[]) => { this.routes.push({ method: "PUT", path, handlers: h }); return this; };
-  public patch = (path: string, ...h: (Middleware | Handler)[]) => { this.routes.push({ method: "PATCH", path, handlers: h }); return this; };
-  public delete = (path: string, ...h: (Middleware | Handler)[]) => { this.routes.push({ method: "DELETE", path, handlers: h }); return this; };
-
+  
+  public get = (path: string, ...h: Array<Middleware | Handler>) => { 
+    this.routes.push({ method: "GET", path, handlers: h }); 
+    return this; 
+  };
+  
+  public post = (path: string, ...h: Array<Middleware | Handler>) => { 
+    this.routes.push({ method: "POST", path, handlers: h }); 
+    return this; 
+  };
+  
+  public put = (path: string, ...h: Array<Middleware | Handler>) => { 
+    this.routes.push({ method: "PUT", path, handlers: h }); 
+    return this; 
+  };
+  
+  public patch = (path: string, ...h: Array<Middleware | Handler>) => { 
+    this.routes.push({ method: "PATCH", path, handlers: h }); 
+    return this; 
+  };
+  
+  public delete = (path: string, ...h: Array<Middleware | Handler>) => { 
+    this.routes.push({ method: "DELETE", path, handlers: h }); 
+    return this; 
+  };
+  
   public ws = (path: string, handlers: WSHandlers) => {
     this.wsHandler = { path, handlers };
     return this;
   };
-
+  
   public use = (arg: Middleware | BarePlugin) => {
     if (typeof arg === 'object' && 'install' in arg) {
       arg.install(this);
@@ -47,105 +61,129 @@ export class BareJS {
     }
     return this;
   };
-
   
-  private async handleDynamic(req: Request, method: string, path: string): Promise<Response> {
-    const dr = this.dynamicRoutes;
-    const len = dr.length;
+  private compile() {
+    this.staticMap.clear();
+    this.dynamicRoutes.length = 0;
     
-    for (let i = 0; i < len; i++) {
-      const route = dr[i];
-      if (route && route.method === method) {
-        const match = path.match(route.regex);
-        if (match) {
-          const ctx = new this.ContextClass(req);
-          const pNames = route.paramNames;
-          
-         
-          for (let j = 0; j < pNames.length; j++) {
-            const name = pNames[j];
-            const value = match[j + 1];
-            
-            
-            if (name && value) {
-              ctx.params[name] = value;
-            }
-          }
-          return await route.chain(ctx);
-        }
+    const gLen = this.globalMiddlewares.length;
+    const hasGlobal = gLen > 0;
+    const rLen = this.routes.length;
+    
+    for (let i = 0; i < rLen; i++) {
+      const route = this.routes[i]!;
+      const handlers = route.handlers;
+      const hLen = handlers.length;
+      const hasDynamic = route.path.indexOf(':') !== -1;
+      
+      // ULTRA FAST PATH: No middleware, single handler, no params
+      if (!hasGlobal && hLen === 1 && !hasDynamic) {
+        const h = handlers[0]!;
+        this.staticMap.set(route.method + route.path, (ctx: BareContext) => {
+          const r = h(ctx, () => ctx._finalize());
+          return r instanceof Response ? r : ctx._finalize();
+        });
+        continue;
       }
-    }
-    return new Response('404 Not Found', { status: 404 });
-  }
-
-  private compile() {
-    this.staticMap = {};
-    this.dynamicRoutes = [];
-
-    for (const route of this.routes) {
-      const pipeline = [...this.globalMiddlewares, ...route.handlers];
       
-      // เทคนิค Compose: มัด Middleware จากหลังมาหน้า
-      // เพื่อให้ตัวแรกสุดกลายเป็นฟังก์ชันเดียวที่เรียกตัวถัดไปได้ทันที
-      let composed = async (ctx: BareContext): Promise<Response> => ctx._finalize();
-
-      for (let i = pipeline.length - 1; i >= 0; i--) {
-        const current = pipeline[i];
-        const nextFn = composed;
-        composed = async (ctx: BareContext) => {
-          const res = await (current as any)(ctx, () => nextFn(ctx));
-          if (res instanceof Response) ctx.res = res;
-          return ctx.res || ctx._finalize();
+      // FAST PATH: Single handler with params OR multiple handlers
+      const total = gLen + hLen;
+      let composed: Function;
+      
+      if (total === 1) {
+        const h = handlers[0] || this.globalMiddlewares[0];
+        composed = (ctx: BareContext) => {
+          const r = h!(ctx, () => ctx._finalize());
+          return r instanceof Response ? r : ctx._finalize();
+        };
+      } else {
+        const pipeline = Array(total);
+        for (let j = 0; j < gLen; j++) pipeline[j] = this.globalMiddlewares[j];
+        for (let j = 0; j < hLen; j++) pipeline[gLen + j] = handlers[j];
+        
+        composed = (ctx: BareContext) => {
+          let idx = 0;
+          const exec = (): any => {
+            if (idx >= total) return ctx._finalize();
+            const fn = pipeline[idx++]!;
+            const r = fn(ctx, exec);
+            if (r instanceof Response) ctx.res = r;
+            return ctx.res || (idx >= total ? ctx._finalize() : exec());
+          };
+          return exec();
         };
       }
-
-      if (route.path.includes(':')) {
-        const paramNames: string[] = [];
-        const regexPath = route.path.replace(/:([^\/]+)/g, (_, name) => {
-          paramNames.push(name);
+      
+      if (hasDynamic) {
+        const pNames: string[] = [];
+        const regexPath = route.path.replace(/:([^/]+)/g, (_, n) => {
+          pNames.push(n);
           return "([^/]+)";
         });
         this.dynamicRoutes.push({
-          method: route.method,
-          regex: new RegExp(`^${regexPath}$`),
-          paramNames,
-          chain: composed
+          m: route.method,
+          r: new RegExp(`^${regexPath}$`),
+          p: pNames,
+          c: composed
         });
       } else {
-        this.staticMap[`${route.method}:${route.path}`] = composed;
+        this.staticMap.set(route.method + route.path, composed);
       }
     }
-
-    // JIT: ใช้พารามิเตอร์แบบกระจายเพื่อลด Overhead ของ Scope
-    this.compiledFetch = new Function(
-      'staticMap', 'hd', 'Ctx',
-      `return async (req, server) => {
-        const url = req.url;
-        const start = url.indexOf('/', 8);
-        const path = start === -1 ? '/' : url.substring(start);
-        const method = req.method;
-
-        const runner = staticMap[method + ":" + path];
-        if (runner) return await runner(new Ctx(req));
-
-        return await hd(req, method, path);
-      }`
-    )(this.staticMap, this.handleDynamic.bind(this), this.ContextClass);
+    
+    // MAXIMUM JIT: Inline everything, minimal allocations
+    const sMap = this.staticMap;
+    const dRoutes = this.dynamicRoutes;
+    const dLen = dRoutes.length;
+    
+    this.compiledFetch = (req: Request) => {
+      const url = req.url;
+      let i = url.indexOf('/', 8);
+      if (i === -1) i = url.length;
+      
+      const path = i === url.length ? '/' : url.substring(i);
+      const key = req.method + path;
+      
+      const runner = sMap.get(key);
+      if (runner) {
+        const ctx = new BareContext(req);
+        return runner(ctx);
+      }
+      
+      const method = req.method;
+      for (let j = 0; j < dLen; j++) {
+        const d = dRoutes[j]!;
+        if (d.m === method) {
+          const m = d.r.exec(path);
+          if (m) {
+            const ctx = new BareContext(req);
+            const pLen = d.p.length;
+            for (let k = 0; k < pLen; k++) {
+              ctx.params[d.p[k]!] = m[k + 1]!;
+            }
+            return d.c(ctx);
+          }
+        }
+      }
+      
+      return new Response('404', { status: 404 });
+    };
   }
-
-  public fetch = (req: Request, server: any = {} as any): Promise<Response> | Response => {
+  
+  public fetch = (req: Request) => {
     if (!this.compiledFetch) this.compile();
-    return this.compiledFetch!(req, server);
+    return this.compiledFetch!(req);
   };
-
-  public listen(ip: string = '0.0.0.0', port: number = 3000) {
+  
+  public listen(ip = '0.0.0.0', port = 3000) {
     this.compile();
-    console.log(`\x1b[32m⚡ BareJS Extreme (2x Optimized) running at http://${ip}:${port}\x1b[0m`);
+    console.log(`\x1b[32m⚡ BareJS MAX at http://${ip}:${port}\x1b[0m`);
+    
     return Bun.serve({
       hostname: ip,
       port,
-      reusePort: true, 
-      fetch: (req, server) => this.fetch(req, server),
+      reusePort: true,
+      fetch: this.fetch.bind(this),
       websocket: {
         open: (ws) => this.wsHandler?.handlers.open?.(ws),
         message: (ws, msg) => this.wsHandler?.handlers.message?.(ws, msg),
@@ -153,4 +191,4 @@ export class BareJS {
       }
     });
   }
-}
+}

package/src/context.ts

@@ -1,3 +1,5 @@
+
+// src/context.ts
 export interface WSHandlers {
   open?: (ws: any) => void;
   message?: (ws: any, message: string | Buffer) => void;
@@ -5,14 +7,13 @@ export interface WSHandlers {
   drain?: (ws: any) => void;
 }
 
-export type Next = () => Promise<any> | any;
+export type Next = () => any;
 export type Middleware = (ctx: Context, next: Next) => any;
-export type Handler = (ctx: Context) => any;
-
+export type Handler = (ctx: Context, next: Next) => any;
 
 export interface Context {
   req: Request;
-  res: Response; 
+  res?: Response;
   params: Record<string, string>;
   body?: any;
   [key: string]: any;
@@ -22,14 +23,14 @@ export interface Context {
 }
 
 export class BareContext {
-  public res: Response | undefined;
+  public res?: Response;
   public params: Record<string, string> = {};
-  public body: any = undefined;
+  public body: any;
   public _status = 200;
   public _headers: Record<string, string> = {};
-
+  
   constructor(public req: Request) {}
-
+  
   json(data: any) {
     this._headers["Content-Type"] = "application/json";
     this.res = new Response(JSON.stringify(data), {
@@ -37,18 +38,17 @@ export class BareContext {
       headers: this._headers,
     });
   }
-
-  status(code: number): this {
+  
+  status(code: number) {
     this._status = code;
     return this;
   }
-
+  
   setResHeader(k: string, v: string) {
     this._headers[k] = v;
   }
-
-  public _finalize(): Response {
-    if (this.res) return this.res;
-    return new Response(null, { status: this._status, headers: this._headers });
+  
+  _finalize() {
+    return this.res || new Response(null, { status: this._status, headers: this._headers });
   }
-}
+}

package/src/validators.ts

@@ -1,5 +1,5 @@
+// src/validators.ts
 import * as Compiler from '@sinclair/typebox/compiler';
-// ใช้ import type สำหรับ Types เพื่อความปลอดภัยของ TS
 import type { Context, Next } from './context';
 
 export const typebox = (schema: any) => {
@@ -7,26 +7,36 @@ export const typebox = (schema: any) => {
   return async (ctx: Context, next: Next) => {
     try {
       const body = await ctx.req.json();
-      if (!check.Check(body)) return new Response("TypeBox Validation Failed", { status: 400 });
+      if (!check.Check(body)) return new Response("Validation Failed", { status: 400 });
       ctx.body = body;
       return next();
-    } catch { return new Response("Invalid JSON", { status: 400 }); }
+    } catch { 
+      return new Response("Invalid JSON", { status: 400 }); 
+    }
   };
 };
 
 export const native = (schema: any) => {
-  const properties = schema.properties || {};
-  const keys = Object.keys(properties);
+  const props = schema.properties || {};
+  const keys = Object.keys(props);
+  const kLen = keys.length;
+  
   return async (ctx: Context, next: Next) => {
     try {
-      const body = await ctx.req.json() as any; // Cast เป็น any เพื่อแก้ปัญหา 'unknown'
-      for (const key of keys) {
-        if (typeof body[key] !== properties[key].type) 
-          return new Response(`Native Validation Failed: ${key}`, { status: 400 });
+      const body = await ctx.req.json() as any;
+      
+      for (let i = 0; i < kLen; i++) {
+        const k = keys[i]!;
+        if (typeof body[k] !== props[k]?.type) {
+          return new Response(`Validation Failed: ${k}`, { status: 400 });
+        }
       }
+      
       ctx.body = body;
       return next();
-    } catch { return new Response("Invalid JSON", { status: 400 }); }
+    } catch { 
+      return new Response("Invalid JSON", { status: 400 }); 
+    }
   };
 };
 
@@ -38,6 +48,8 @@ export const zod = (schema: any) => {
       if (!result.success) return new Response(JSON.stringify(result.error), { status: 400 });
       ctx.body = result.data;
       return next();
-    } catch { return new Response("Invalid JSON", { status: 400 }); }
+    } catch { 
+      return new Response("Invalid JSON", { status: 400 }); 
+    }
   };
-};
+};