barejs 0.1.9 → 0.1.12

package/package.json

@@ -1,61 +1,67 @@
-{
-  "name": "barejs",
-  "version": "0.1.9",
-  "author": "xarhang",
-  "description": "High-performance JIT-specialized web framework for Bun",
-  "main": "./src/bare.ts",
-  "types": "./src/bare.ts",
-  "type": "module",
-  "exports": {
-    ".": "./src/bare.ts",
-    "./middleware": "./src/validators.ts"
-  },
-  "sideEffects": false,
-  "repository": {
-    "type": "git",
-    "url": "git+https://github.com/xarhang/barejs.git"
-  },
-  "scripts": {
-    "test": "echo \"Error: no test specified\" && exit 1",
-    "bench": "bun run benchmarks/index.ts",
-    "dev": "bun --watch src/bare.ts",
-    "build": "bun ./scripts/build.ts",
-    "release": "bun run build && npm version patch && npm publish --access public"
-  },
-  "keywords": [
-    "bun",
-    "framework",
-    "fastest",
-    "jit",
-    "typebox",
-    "zod"
-  ],
-  "license": "MIT",
-  "peerDependencies": {
-    "@sinclair/typebox": "^0.34.46",
-    "zod": "^3.0.0"
-  },
-  "peerDependenciesMeta": {
-    "@sinclair/typebox": {
-      "optional": true
-    },
-    "zod": {
-      "optional": true
-    }
-  },
-  "devDependencies": {
-    "@sinclair/typebox": "^0.34.46",
-    "zod": "^3.23.8",
-    "@types/bun": "latest",
-    "elysia": "^1.4.21",
-    "hono": "^4.11.3",
-    "mitata": "^1.0.34",
-    "typescript": "latest"
-  },
-  "files": [
-    "src",
-    "dist",
-    "README.md",
-    "LICENSE"
-  ]
-}
+{
+  "name": "barejs",
+  "version": "0.1.12",
+  "author": "xarhang",
+  "description": "High-performance JIT-specialized web framework for Bun",
+  "main": "./dist/index.js",
+  "module": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "type": "module",
+  "exports": {
+    ".": {
+      "import": "./dist/index.js",
+      "types": "./dist/index.d.ts"
+    }
+  },
+  "sideEffects": false,
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/xarhang/barejs.git"
+  },
+  "scripts": {
+    "test": "bun test",
+    "bench": "bun run benchmarks/index.ts",
+    "dev": "bun --watch src/index.ts",
+    "build": "bun ./scripts/build.ts",
+    "prepublishOnly": "bun run build",
+    "release": "bun run build && npm version patch && npm publish --access public"
+  },
+  "keywords": [
+    "bun",
+    "framework",
+    "fastest",
+    "jit",
+    "typebox",
+    "zod",
+    "barejs",
+    "http-server"
+  ],
+  "license": "MIT",
+  "peerDependencies": {
+    "@sinclair/typebox": "^0.34.46",
+    "zod": "^3.0.0"
+  },
+  "peerDependenciesMeta": {
+    "@sinclair/typebox": {
+      "optional": true
+    },
+    "zod": {
+      "optional": true
+    }
+  },
+  "devDependencies": {
+    "@sinclair/typebox": "^0.34.46",
+    "zod": "^3.23.8",
+    "@types/bun": "latest",
+    "typescript": "latest",
+    "mitata": "^1.0.34",
+    "elysia": "latest",
+    "hono": "latest"
+  },
+  "files": [
+    "dist",
+    "src",
+    "README.md",
+    "LICENSE"
+  ]
+}

package/src/auth.ts

@@ -0,0 +1,100 @@
+import type {  Next } from './context';
+
+/**
+ * UTILS: Internal Crypto Helpers using Native Web Crypto
+ * This approach is Type-safe and highly compatible with Bun
+ */
+const encoder = new TextEncoder();
+
+const signData = async (data: string, secret: string): Promise<string> => {
+  // Using Bun.crypto.hmac with 'any' cast to bypass version-specific type issues
+  const hmac = (Bun as any).crypto.hmac("sha256", secret, data);
+  return Buffer.from(hmac).toString("hex");
+};
+
+const verifyData = async (data: string, signature: string, secret: string): Promise<boolean> => {
+  const expectedSignature = await signData(data, secret);
+  // Using crypto.subtle.timingSafeEqual or Bun's native timingSafeEqual
+  return (Bun as any).crypto.timingSafeEqual(
+    encoder.encode(signature),
+    encoder.encode(expectedSignature)
+  );
+};
+
+/**
+ * 1. BARE TOKEN AUTH (High Performance JWT-like)
+ */
+export const bareAuth = (secret: string) => {
+  return async (ctx: any, next: Next) => {
+    const authHeader = ctx.req.headers.get('Authorization');
+    if (!authHeader?.startsWith('Bearer ')) {
+      return ctx.status(401).json({ status: 'error', message: 'Bearer token required' });
+    }
+
+    const token = authHeader.split(' ')[1];
+    if (!token) return ctx.status(401).json({ status: 'error', message: 'Invalid token format' });
+
+    const parts = token.split('.');
+    if (parts.length !== 2) {
+      return ctx.status(401).json({ status: 'error', message: 'Malformed token' });
+    }
+
+    const [payloadBase64, signature] = parts;
+
+    try {
+      const payloadRaw = Buffer.from(payloadBase64!, 'base64').toString();
+      const isValid = await verifyData(payloadRaw, signature!, secret);
+
+      if (!isValid) {
+        return ctx.status(401).json({ status: 'error', message: 'Invalid signature' });
+      }
+
+      ctx.set('user', JSON.parse(payloadRaw));
+      return next();
+    } catch (e) {
+      return ctx.status(401).json({ status: 'error', message: 'Token verification failed' });
+    }
+  };
+};
+
+/**
+ * 2. BASIC AUTH
+ */
+export const basicAuth = (credentials: { user: string; pass: string }) => {
+  return async (ctx: any, next: Next) => {
+    const authHeader = ctx.req.headers.get('Authorization');
+    if (!authHeader?.startsWith('Basic ')) {
+      return ctx.status(401).json({ status: 'error', message: 'Basic Auth required' });
+    }
+
+    const token = authHeader.split(' ')[1];
+    if (!token) return ctx.status(401).json({ status: 'error', message: 'Missing credentials' });
+
+    const decoded = Buffer.from(token, 'base64').toString();
+    const [user, pass] = decoded.split(':');
+
+    if (user === credentials.user && pass === credentials.pass) {
+      return next();
+    }
+
+    return ctx.status(401).json({ status: 'error', message: 'Invalid credentials' });
+  };
+};
+
+/**
+ * 3. PASSWORD UTILS (Bun Native)
+ */
+export const Password = {
+  hash: (password: string) => Bun.password.hash(password, { algorithm: "argon2id" }),
+  verify: (password: string, hash: string) => Bun.password.verify(password, hash)
+};
+
+/**
+ * 4. TOKEN GENERATOR
+ */
+export const createToken = async (payload: object, secret: string): Promise<string> => {
+  const payloadStr = JSON.stringify(payload);
+  const payloadBase64 = Buffer.from(payloadStr).toString('base64');
+  const signature = await signData(payloadStr, secret);
+  return `${payloadBase64}.${signature}`;
+};

package/src/bare.ts

@@ -1,9 +1,9 @@
-// src/bare.ts
-export * from './context';   
+// All comments in English
+export * from './context';
 export * from './validators';
 
-import { BareContext } from './context';
-import type { Context, Middleware, Handler, WSHandlers } from './context';
+import type { Middleware, WSHandlers } from './context';
+import type { Server, ServerWebSocket } from "bun";
 
 export interface BarePlugin {
   name: string;
@@ -12,10 +12,14 @@ export interface BarePlugin {
 }
 
 export class BareJS {
-  private routes: Array<{ method: string; path: string; handlers: Array<Middleware | Handler> }> = [];
+  private routes: Array<{ method: string; path: string; handlers: Array<any> }> = [];
   private globalMiddlewares: Array<Middleware> = [];
   private compiledFetch?: Function;
-  
+
+  private _reusePort: boolean = true;
+  // ✅ Explicitly provide the generic argument to satisfy strict TS rules
+  private _server: Server<any> | null = null; 
+
   private staticMap: Map<string, Function> = new Map();
   private dynamicRoutes: Array<{
     m: string;
@@ -23,39 +27,28 @@ export class BareJS {
     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 get server(): Server<any> | null { return this._server; }
+  public set server(value: Server<any> | null) { this._server = value; }
+
+  public get = (path: string, ...h: any[]) => { this.routes.push({ method: "GET", path, handlers: h }); return this; };
+  public post = (path: string, ...h: any[]) => { this.routes.push({ method: "POST", path, handlers: h }); return this; };
+  public put = (path: string, ...h: any[]) => { this.routes.push({ method: "PUT", path, handlers: h }); return this; };
+  public patch = (path: string, ...h: any[]) => { this.routes.push({ method: "PATCH", path, handlers: h }); return this; };
+  public delete = (path: string, ...h: any[]) => { this.routes.push({ method: "DELETE", path, handlers: h }); return this; };
+
   public ws = (path: string, handlers: WSHandlers) => {
     this.wsHandler = { path, handlers };
     return this;
   };
-  
+
+  public reusePort = (enabled: boolean) => {
+    this._reusePort = enabled;
+    return this;
+  };
+
   public use = (arg: Middleware | BarePlugin) => {
     if (typeof arg === 'object' && 'install' in arg) {
       arg.install(this);
@@ -64,134 +57,127 @@ export class BareJS {
     }
     return this;
   };
-  
+
   private compile() {
     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++) {
+
+    for (let i = 0; i < this.routes.length; 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;
-      
-      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();
+      const pipeline = [...this.globalMiddlewares, ...route.handlers];
+      const pLen = pipeline.length;
+
+      const composed = (req: Request, params: Record<string, string>): any => {
+        let idx = 0;
+        const next = (): any => {
+          if (idx < pLen) {
+            const result = pipeline[idx++]!(req, params, next);
+            if (result && result.constructor === Object) {
+              return new Response(JSON.stringify(result), {
+                headers: { 'Content-Type': 'application/json' }
+              });
+            }
+            return result;
+          }
+          return new Response(null, { status: 404 });
         };
-      }
-      
-      if (hasDynamic) {
+        return next();
+      };
+
+      if (route.path.indexOf(':') !== -1) {
         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
-        });
+        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);
+
+    /**
+     * ✅ Added <any> to Server type in the fetch signature
+     */
+    this.compiledFetch = (req: Request, server?: Server<any>): any => {
+      if (this.wsHandler && req.headers.get("upgrade") === "websocket") {
+        const s = req.url.indexOf('/', 8);
+        const path = s === -1 ? '/' : req.url.substring(s);
+        if (path === this.wsHandler.path) {
+          if (server?.upgrade(req)) return;
+        }
       }
-      
+
+      const url = req.url;
+      const s = url.indexOf('/', 8);
+      const path = s === -1 ? '/' : url.substring(s);
       const method = req.method;
-      for (let j = 0; j < dLen; j++) {
+
+      const runner = this.staticMap.get(method + path);
+      if (runner) return runner(req, {});
+
+      const dRoutes = this.dynamicRoutes;
+      for (let j = 0; j < dRoutes.length; 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);
+            const params: Record<string, string> = {};
+            for (let k = 0; k < d.p.length; k++) params[d.p[k]!] = m[k + 1]!;
+            return d.c(req, params);
           }
         }
       }
-      
-      return new Response('404', { status: 404 });
+      return new Response('404 Not Found', { status: 404 });
     };
   }
-  
-  public fetch = (req: Request) => {
+
+  // ✅ Maintain consistency in the public fetch method
+  public fetch = (req: Request, server?: Server<any>) => {
     if (!this.compiledFetch) this.compile();
-    return this.compiledFetch!(req);
+    return this.compiledFetch!(req, server);
   };
-  
-  public listen(ip = '0.0.0.0', port = 3000) {
+
+  public async listen(arg1?: number | string, arg2?: number | string) {
     this.compile();
-    console.log(`\x1b[32m⚡ BareJS MAX at http://${ip}:${port}\x1b[0m`);
-    
-    return Bun.serve({
-      hostname: ip,
-      port,
-      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),
+    let port = 3000, host = '0.0.0.0';
+
+    if (typeof arg1 === 'number') {
+      port = arg1;
+      if (typeof arg2 === 'string') host = arg2;
+    } else if (typeof arg1 === 'string') {
+      if (!isNaN(Number(arg1))) port = Number(arg1);
+      else host = arg1;
+      if (typeof arg2 === 'number') port = arg2;
+    }
+
+    // ✅ Cast the configuration to 'any' or explicitly use the correct Bun Options type
+    const serveOptions: any = {
+      hostname: host,
+      port: port,
+      reusePort: this._reusePort,
+      fetch: (req: Request, server: Server<any>) => this.fetch(req, server),
+    };
+
+    if (this.wsHandler) {
+      serveOptions.websocket = {
+        open: (ws: ServerWebSocket<any>) => this.wsHandler?.handlers.open?.(ws),
+        message: (ws: ServerWebSocket<any>, msg: string | Buffer) => this.wsHandler?.handlers.message?.(ws, msg),
+        close: (ws: ServerWebSocket<any>, code: number, res: string) => this.wsHandler?.handlers.close?.(ws, code, res),
+        drain: (ws: ServerWebSocket<any>) => this.wsHandler?.handlers.drain?.(ws),
+      };
+    }
+
+    this.server = Bun.serve(serveOptions);
+    console.log(`[BAREJS] 🚀 Server started at http://${host}:${port}`);
+
+    const shutdown = () => {
+      if (this.server) {
+        this.server.stop();
+        process.exit(0);
       }
-    });
+    };
+
+    process.on('SIGINT', shutdown);
+    process.on('SIGTERM', shutdown);
+
+    return this.server;
   }
-}
+}

package/src/context.ts

@@ -1,54 +1,36 @@
 
-// src/context.ts
+/**
+ * High-performance Middleware signature
+ * Arguments are passed directly to avoid object allocation overhead.
+ */
+export type Middleware = (
+  req: Request, 
+  params: Record<string, string>, 
+  next: Next
+) => any;
+// All comments in English
+export type Next = () => any;
+
+/**
+ * The Elysia-style Context
+ * Extends the native Request with params and high-speed state
+ */
+export type Context = Request & {
+  params: Record<string, string>;
+  set: (key: string, value: any) => void;
+  get: <T>(key: string) => T;
+  // Metadata for internal use
+  store: Map<string, any>;
+};
+
+/**
+ * Unified Handler type for auto-inference
+ */
+export type Handler = (c: Context, next: Next) => any;
+
 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/cors.ts

@@ -0,0 +1,27 @@
+import type { Middleware } from './context';
+
+export const cors = (options: { origin?: string; methods?: string } = {}) => {
+  const origin = options.origin || '*';
+  const methods = options.methods || 'GET,POST,PUT,PATCH,DELETE,OPTIONS';
+
+  const mw: Middleware = async (req, params, next) => {
+    if (req.method === 'OPTIONS') {
+      return new Response(null, { 
+        status: 204, 
+        headers: { 
+          'Access-Control-Allow-Origin': origin,
+          'Access-Control-Allow-Methods': methods,
+          'Access-Control-Allow-Headers': 'Content-Type, Authorization'
+        } 
+      });
+    }
+
+    const res = await next();
+    if (res instanceof Response) {
+      res.headers.set('Access-Control-Allow-Origin', origin);
+      res.headers.set('Access-Control-Allow-Methods', methods);
+    }
+    return res;
+  };
+  return mw;
+};