barejs 0.1.6 → 0.1.8

package/README.md

@@ -158,8 +158,8 @@ app.post('/native', native({ properties: { id: { type: 'number' } } }), (ctx) =>
 * [x] **JIT Static Routing**:  lookup via compiled static maps.
 * [x] **Validation Integration**: Support for TypeBox, Zod, and Native JSON.
 * [x] **Full Plugin System**: Modular extensibility with zero overhead.
-* [ ] **Dynamic Path JIT**: Compiled Regex for parameterized routes (e.g., `/user/:id`).
-* [ ] **Native WebSocket Support**: High-speed binary streaming.
+* [x] **Dynamic Path JIT**: Compiled Regex for parameterized routes (e.g., `/user/:id`).
+* [x] **Native WebSocket Support**: High-speed binary streaming.
 
 ---
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "barejs",
-  "version": "0.1.6",
+  "version": "0.1.8",
   "author": "xarhang",
   "description": "High-performance JIT-specialized web framework for Bun",
   "main": "./src/bare.ts",
@@ -58,4 +58,4 @@
     "README.md",
     "LICENSE"
   ]
-}
+}

package/src/bare.ts

@@ -1,14 +1,6 @@
-export interface Context {
-  req: Request;
-  params: Record<string, string>;
-  json: (data: any) => Response;
-  body?: any;
-  [key: string]: any;
-}
-
-export type Next = () => Promise<any> | any;
-export type Middleware = (ctx: Context, next: Next) => any;
-export type Handler = (ctx: Context) => any;
+// src/bare.ts
+import { BareContext } from './context';
+import type { Context, Middleware, Handler, WSHandlers } from './context';
 
 export interface BarePlugin {
   name: string;
@@ -17,19 +9,50 @@ export interface BarePlugin {
 }
 
 export class BareJS {
-  private routes: { method: string; path: string; handlers: (Middleware | Handler)[] }[] = [];
-  private globalMiddlewares: Middleware[] = [];
-  private compiledFetch?: (req: Request) => Promise<Response> | Response;
-  private staticMap: Record<string, any> = {};
-
-  // --- Routing 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; };
-
-  // --- Plugin & Middleware System ---
+  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;
+  
+  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);
@@ -38,91 +61,134 @@ export class BareJS {
     }
     return this;
   };
-
-  // --- Core Engine ---
-  public fetch = (req: Request): Promise<Response> | Response => {
-    if (!this.compiledFetch) this.compile();
-    return this.compiledFetch!(req);
-  };
-
+  
   private compile() {
-    this.routes.forEach((route) => {
-      // Middleware Onion Runner
-      const chain = async (ctx: Context) => {
-        let idx = 0;
-        const middlewares = [...this.globalMiddlewares, ...route.handlers];
-        const next = async (): Promise<any> => {
-          const handler = middlewares[idx++];
-          if (!handler) return;
-          // Support both async and sync handlers
-          return await (handler.length > 1
-            ? (handler as Middleware)(ctx, next)
-            : (handler as Handler)(ctx));
-        };
-        return await next();
-      };
-      this.staticMap[`${route.method}:${route.path}`] = chain;
-    });
-
-    // JIT Optimized Fetch Function
-    const fnBody = `
-      const staticMap = this.staticMap;
-      const EMPTY_PARAMS = Object.freeze({});
-      const jsonHeader = { "content-type": "application/json" };
+    this.staticMap.clear();
+    this.dynamicRoutes.length = 0;
+    
+    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;
+      }
+      
+      // FAST PATH: Single handler with params OR multiple handlers
+      const total = gLen + hLen;
+      let composed: Function;
       
-      return async (req) => {
-        const url = req.url;
-        const pathStart = url.indexOf('/', 8);
-        const path = pathStart === -1 ? '/' : url.substring(pathStart);
-        const key = req.method + ":" + path;
+      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];
         
-        const runner = staticMap[key];
-        if (runner) {
-          const ctx = { 
-            req, 
-            params: EMPTY_PARAMS, 
-            json: (d) => new Response(JSON.stringify(d), { headers: jsonHeader }) 
+        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 await runner(ctx);
+          return exec();
+        };
+      }
+      
+      if (hasDynamic) {
+        const pNames: string[] = [];
+        const regexPath = route.path.replace(/:([^/]+)/g, (_, n) => {
+          pNames.push(n);
+          return "([^/]+)";
+        });
+        this.dynamicRoutes.push({
+          m: route.method,
+          r: new RegExp(`^${regexPath}$`),
+          p: pNames,
+          c: composed
+        });
+      } else {
+        this.staticMap.set(route.method + route.path, composed);
+      }
+    }
+    
+    // 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 Not Found', { status: 404 });
-      };`;
-
-    this.compiledFetch = new Function(fnBody).bind(this)();
+      }
+      
+      return new Response('404', { status: 404 });
+    };
   }
-
-  public listen(ip: string = '0.0.0.0', port: number = 3000) {
+  
+  public fetch = (req: Request) => {
+    if (!this.compiledFetch) this.compile();
+    return this.compiledFetch!(req);
+  };
+  
+  public listen(ip = '0.0.0.0', port = 3000) {
     this.compile();
-
-
-
-
-    const reset = "\x1b[0m";
-    const cyan = "\x1b[36m";
-    const yellow = "\x1b[33m";
-    const gray = "\x1b[90m";
-    const bold = "\x1b[1m";
-    if (process.env.NODE_ENV !== 'production' && process.env.BARE_SILENT !== 'true') {
-      console.log(`
-${cyan}${bold}  ____                      _ ____  
- | __ )  __ _ _ __ ___     | / ___| 
- |  _ \\ / _\` | '__/ _ \\ _  | \\___ \\ 
- | |_) | (_| | | |  __/| |_| |___) |
- |____/ \\__,_|_|  \\___| \\___/|____/ 
-${reset}
- ${yellow}BareJS${reset} ${gray}${reset}
- ${gray}-----------------------------------${reset}
- 🚀 Running at: ${cyan}http://${ip}:${port}${reset}
- ${gray}Ready to build everything awesome!${reset}
-`);
-    } else {
-
-      console.log(`🚀 BareJS running at http://${ip}:${port}`);
-    }
+    console.log(`\x1b[32m⚡ BareJS MAX at http://${ip}:${port}\x1b[0m`);
+    
     return Bun.serve({
       hostname: ip,
       port,
-      fetch: (req) => this.fetch(req),
+      reusePort: true,
+      fetch: this.fetch.bind(this),
+      websocket: {
+        open: (ws) => this.wsHandler?.handlers.open?.(ws),
+        message: (ws, msg) => this.wsHandler?.handlers.message?.(ws, msg),
+        close: (ws, code, res) => this.wsHandler?.handlers.close?.(ws, code, res),
+      }
     });
   }
-}
+}

package/src/context.ts

@@ -0,0 +1,54 @@
+
+// src/context.ts
+export interface WSHandlers {
+  open?: (ws: any) => void;
+  message?: (ws: any, message: string | Buffer) => void;
+  close?: (ws: any, code: number, reason: string) => void;
+  drain?: (ws: any) => void;
+}
+
+export type Next = () => any;
+export type Middleware = (ctx: Context, next: Next) => any;
+export type Handler = (ctx: Context, next: Next) => any;
+
+export interface Context {
+  req: Request;
+  res?: Response;
+  params: Record<string, string>;
+  body?: any;
+  [key: string]: any;
+  json: (data: any) => void;
+  status: (code: number) => this;
+  setResHeader: (key: string, value: string) => void;
+}
+
+export class BareContext {
+  public res?: Response;
+  public params: Record<string, string> = {};
+  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), {
+      status: this._status,
+      headers: this._headers,
+    });
+  }
+  
+  status(code: number) {
+    this._status = code;
+    return this;
+  }
+  
+  setResHeader(k: string, v: string) {
+    this._headers[k] = v;
+  }
+  
+  _finalize() {
+    return this.res || new Response(null, { status: this._status, headers: this._headers });
+  }
+}

package/src/index.ts

@@ -1,5 +1,6 @@
-import { BareJS, type Context } from './bare';
-import { typebox, native } from './middleware/validators';
+import { BareJS} from './bare';
+import type { Context } from './context';
+import { typebox, native } from './validators';
 import * as TB from '@sinclair/typebox';
 
 const app = new BareJS();
@@ -15,6 +16,7 @@ app.post('/users-tb', typebox(UserSchema), (ctx: Context) => {
   return ctx.json({ message: "Saved via TypeBox", user: ctx.body });
 });
 
+
 // ✅ Route 2: Using Native Validator (Safe alternative if TypeBox has issues)
 app.post('/users-native', native(UserSchema), (ctx: Context) => {
   return ctx.json({ message: "Saved via Native", user: ctx.body });
@@ -22,5 +24,16 @@ app.post('/users-native', native(UserSchema), (ctx: Context) => {
 
 // ✅ Route 3: No Validator (Pure speed, 0 ns overhead)
 app.get('/ping', (ctx: Context) => ctx.json({ message: "pong" }));
+// Dynamic Path
+app.get('/user/:id', (ctx: Context) => {
+  const userId = ctx.params.id;
+  return ctx.json({ user: userId, status: 'active' });
+});
+
+// Multiple Params
+app.get('/post/:category/:id', (ctx: Context) => {
+  return ctx.json(ctx.params); // { category: 'tech', id: '1' }
+});
+
 
 app.listen('0.0.0.0', 3000);

package/src/validators.ts

@@ -0,0 +1,55 @@
+// src/validators.ts
+import * as Compiler from '@sinclair/typebox/compiler';
+import type { Context, Next } from './context';
+
+export const typebox = (schema: any) => {
+  const check = Compiler.TypeCompiler.Compile(schema);
+  return async (ctx: Context, next: Next) => {
+    try {
+      const body = await ctx.req.json();
+      if (!check.Check(body)) return new Response("Validation Failed", { status: 400 });
+      ctx.body = body;
+      return next();
+    } catch { 
+      return new Response("Invalid JSON", { status: 400 }); 
+    }
+  };
+};
+
+export const native = (schema: any) => {
+  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;
+      
+      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 }); 
+    }
+  };
+};
+
+export const zod = (schema: any) => {
+  return async (ctx: Context, next: Next) => {
+    try {
+      const body = await ctx.req.json();
+      const result = schema.safeParse(body);
+      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 }); 
+    }
+  };
+};

package/src/middleware/validators.ts

@@ -1,53 +0,0 @@
-import * as Compiler from '@sinclair/typebox/compiler';
-
-/**
- * 1. TypeBox Validator: Highest Performance (JIT Optimized)
- * Best for: Production and Benchmarking
- */
-export const typebox = (schema: any) => {
-  const check = Compiler.TypeCompiler.Compile(schema);
-  return async (ctx: any, next: any) => {
-    try {
-      const body = await ctx.req.json();
-      if (!check.Check(body)) return new Response("TypeBox Validation Failed", { status: 400 });
-      ctx.body = body;
-      return next();
-    } catch { return new Response("Invalid JSON", { status: 400 }); }
-  };
-};
-
-/**
- * 2. Native Validator: Zero Dependency
- * Best for: Avoiding Runtime bugs or keeping the bundle lightweight.
- */
-export const native = (schema: any) => {
-  const properties = schema.properties || {};
-  const keys = Object.keys(properties);
-  return async (ctx: any, next: any) => {
-    try {
-      const body = await ctx.req.json();
-      for (const key of keys) {
-        if (typeof body[key] !== properties[key].type) 
-          return new Response(`Native Validation Failed: ${key} is not ${properties[key].type}`, { status: 400 });
-      }
-      ctx.body = body;
-      return next();
-    } catch { return new Response("Invalid JSON", { status: 400 }); }
-  };
-};
-
-/**
- * 3. Zod Validator: Best Developer Experience
- * Note: Requires 'npm install zod'
- */
-export const zod = (schema: any) => {
-  return async (ctx: any, next: any) => {
-    try {
-      const body = await ctx.req.json();
-      const result = schema.safeParse(body);
-      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 }); }
-  };
-};

package/src/types.ts

@@ -1,24 +0,0 @@
-// src/context.ts
-export class Context {
-  public res: Response;
-
-  constructor(public req: Request) {
-    this.res = new Response("Not Found", { status: 404 });
-  }
-
-  json(data: any) {
-    this.res = new Response(JSON.stringify(data), {
-      headers: { "Content-Type": "application/json" },
-    });
-  }
-
-
-  setResHeader(key: string, value: string) {
-    const newHeaders = new Headers(this.res.headers);
-    newHeaders.set(key, value);
-    this.res = new Response(this.res.body, {
-      status: this.res.status,
-      headers: newHeaders,
-    });
-  }
-}