barejs 0.1.44 → 0.1.47

package/dist/types/{bare.d.ts → core/bare.d.ts}

@@ -9,10 +9,11 @@ export interface NotFoundResponse {
 export declare class BareJS extends BareRouter {
     private tree;
     private pool;
-    private poolIdx;
     private hotFetch?;
     private compiled;
     private poolMask;
+    private _useLog;
+    useLog(enabled?: boolean): this;
     constructor(poolSize?: number);
     private notFoundHandler;
     setNotFound(handler: () => NotFoundResponse): void;

package/dist/types/core/config.d.ts

@@ -0,0 +1,11 @@
+export interface BareConfig {
+    hash: {
+        algorithm: "argon2id" | "bcrypt";
+        memoryCost: number;
+        timeCost: number;
+    };
+    port: number;
+}
+export declare const DEFAULT_CONFIG: BareConfig;
+export declare let BARE_CONFIG: BareConfig;
+export declare const initConfig: (userConfig?: Partial<BareConfig>) => BareConfig;

package/dist/types/{context.d.ts → core/context.d.ts}

@@ -11,6 +11,7 @@ export declare class Context {
     _headers?: Record<string, string> | undefined;
     store: Map<string, any>;
     body: any;
+    query: Record<string, string>;
     constructor();
     jsonBody(): Promise<any>;
     reset(req: Request): this;
@@ -19,4 +20,5 @@ export declare class Context {
     set(key: string, value: any): this;
     get(key: string): any;
     setHeader(name: string, value: string): this;
+    send(message: string, extra?: Record<string, any>): Response;
 }

package/dist/types/core/loader.d.ts

@@ -0,0 +1 @@
+export declare function bootstrapConfig(): Promise<import("./config").BareConfig>;

package/dist/types/{router.d.ts → core/router.d.ts}

@@ -1,13 +1,9 @@
-import { type Middleware, type Handler } from './context';
+import { type Middleware, type Handler } from '../core/context';
 type HandlersChain = (Middleware | Handler)[];
 export declare class BareRouter {
     prefix: string;
     groupMiddleware: any[];
-    routes: {
-        method: string;
-        path: string;
-        handlers: any[];
-    }[];
+    routes: any[];
     constructor(prefix?: string, groupMiddleware?: any[]);
     private _add;
     get: (path: string, ...h: HandlersChain) => this;
@@ -16,10 +12,6 @@ export declare class BareRouter {
     patch: (path: string, ...h: HandlersChain) => this;
     delete: (path: string, ...h: HandlersChain) => this;
     group: (path: string, ...args: any[]) => this;
-    /**
-     * 🔗 Use: Mounts a router or middleware
-     * Supports nested routers with automatic path prefixing
-     */
     use(mw: any): this;
 }
 export {};

package/dist/types/index.d.ts

@@ -4,28 +4,20 @@
  * Built for Bun with Mechanical Sympathy
  * Optimized to outperform competitors by 55% [2026-01-05]
  */
-export { BareJS } from './bare';
+export { BareJS } from './core/bare';
 /**
  * Plugin Interface for BareJS
  */
 export interface BarePlugin {
     install: (app: any) => void;
 }
-export type { Middleware, Handler, Next, Context, Params, AuthUser } from './context';
-/**
- * รองรับทั้ง T, Type และ TypeBox
- * ใช้สำหรับสร้าง Schema เช่น T.String() หรือ Type.Number()
- */
+export type { Middleware, Handler, Next, Context, Params, AuthUser } from './core/context';
 import { Type } from "@sinclair/typebox";
 export { Type, Type as T, Type as TypeBox };
-/**
- * รองรับทั้ง t, typebox และ v, validate (Auto)
- * สำหรับ Zod รองรับทั้ง Z (Builder) และ z (Middleware)
- */
-import { typebox, zod, native, validate, Z } from './validators';
+import { typebox, zod, native, validate, Z } from './security/validators';
 export { typebox, typebox as t, zod, zod as z, Z, Z as Zod, native, native as n, validate, validate as v };
-export { logger } from './logger';
-export { cors } from './cors';
-export { staticFile } from './static';
-export { BareRouter } from './router';
-export { bareAuth, createToken, Hash as Password, Hash } from './auth';
+export { cors } from './security/cors';
+export { staticFile } from './utils/static';
+export { BareRouter } from './core/router';
+export { bareAuth, createToken } from './security/auth';
+export { Hash as Password, Hash } from './security/hash';

package/dist/types/{auth.d.ts → security/auth.d.ts}

@@ -1,4 +1,4 @@
-import type { Next } from './context';
+import type { Next } from '../core/context';
 /**
  * 4. TOKEN GENERATOR (Standard JWT)
  */
@@ -16,15 +16,6 @@ export declare const basicAuth: (credentials: {
     user: string;
     pass: string;
 }) => (ctx: any, next: Next) => Promise<any>;
-/**
- * 3. PASSWORD UTILS (Bun Native)
- * Uses Argon2id - the gold standard for password hashing
- */
-export declare const Hash: {
-    make: (data: string) => Promise<string>;
-    verify: (data: string, hash: string) => Promise<boolean>;
-    needsRehash: (hash: string) => boolean;
-};
 /**
  * 5. ROLE AUTHORIZATION (Bonus Max Function)
  * Ensures user has specific permissions after bareAuth

package/dist/types/{cors.d.ts → security/cors.d.ts}

@@ -1,4 +1,4 @@
-import type { Middleware } from './context';
+import type { Middleware } from '../core/context';
 export declare const cors: (options?: {
     origin?: string;
     methods?: string;

package/dist/types/security/hash.d.ts

@@ -0,0 +1,5 @@
+export declare const Hash: {
+    make: (data: string) => Promise<string>;
+    verify: (data: string, hash: string) => Promise<boolean>;
+    needsRehash: (hash: string) => boolean;
+};

package/dist/types/{validators.d.ts → security/validators.d.ts}

@@ -4,7 +4,7 @@
  * Optimized for Bun Runtime & Mechanical Sympathy [2026-01-05]
  */
 import { z } from 'zod';
-import type { Middleware } from './context';
+import type { Middleware } from '../core/context';
 export declare const Z: typeof z;
 /**
  * TypeBox JIT Engine (t)

package/package.json

@@ -1,68 +1,68 @@
-{
-  "name": "barejs",
-  "version": "0.1.44",
-  "author": "xarhang",
-  "description": "High-performance JIT-specialized web framework for Bun",
-  "main": "./dist/index.js",
-  "module": "./dist/index.js",
-  "types": "./dist/types/index.d.ts",
-  "type": "module",
-  "exports": {
-    ".": {
-      "import": "./dist/index.js",
-      "types": "./dist/types/index.d.ts"
-    }
-  },
-  "sideEffects": false,
-  "repository": {
-    "type": "git",
-    "url": "git+https://github.com/xarhang/barejs.git"
-  },
-  "scripts": {
-    "test": "bun test",
-    "benchs": "bun run benchmarks/index.ts",
-    "bench": "bun run benchmarks/head-to-head.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",
-    "@types/bun": "^1.3.5",
-    "elysia": "latest",
-    "hono": "latest",
-    "mitata": "^1.0.34",
-    "typescript": "latest",
-    "zod": "^3.23.8"
-  },
-  "files": [
-    "dist",
-    "src",
-    "README.md",
-    "LICENSE"
-  ]
-}
+{
+  "name": "barejs",
+  "version": "0.1.47",
+  "author": "xarhang",
+  "description": "High-performance JIT-specialized web framework for Bun",
+  "main": "./dist/index.js",
+  "module": "./dist/index.js",
+  "types": "./dist/types/index.d.ts",
+  "type": "module",
+  "exports": {
+    ".": {
+      "import": "./dist/index.js",
+      "types": "./dist/types/index.d.ts"
+    }
+  },
+  "sideEffects": false,
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/xarhang/barejs.git"
+  },
+  "scripts": {
+    "test": "bun test",
+    "benchs": "bun run benchmarks/index.ts",
+    "bench": "bun run benchmarks/head-to-head.ts",
+    "dev": "bun --watch example/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.47",
+    "@types/bun": "^1.3.5",
+    "elysia": "latest",
+    "hono": "latest",
+    "mitata": "^1.0.34",
+    "typescript": "latest",
+    "zod": "^3.25.76"
+  },
+  "files": [
+    "dist",
+    "src",
+    "README.md",
+    "LICENSE"
+  ]
+}

package/src/{bare.ts → core/bare.ts}

@@ -4,6 +4,8 @@ import { Context } from './context';
 import { Type as typebox, Type as t } from '@sinclair/typebox';
 import { join } from "node:path";
 import { readFileSync } from "node:fs";
+import { bootstrapConfig } from "./loader";
+
 export interface NotFoundResponse {
   status: number;
   message: string;
@@ -12,13 +14,18 @@ export interface NotFoundResponse {
 export class BareJS extends BareRouter {
   private tree = new RadixNode();
   private pool: Context[] = [];
-  private poolIdx = 0;
+  // private poolIdx = 0;
   private hotFetch?: (req: Request) => any;
   private compiled = false;
   private poolMask: number;
-
+  private _useLog: boolean = false;
+  public useLog(enabled: boolean = true): this {
+    this._useLog = enabled;
+    return this;
+  }
   constructor(poolSize: number = 1024) {
     super();
+    bootstrapConfig();
     const size = Math.pow(2, Math.ceil(Math.log2(poolSize)));
     this.poolMask = size - 1;
     for (let i = 0; i < size; i++) {
@@ -58,34 +65,41 @@ export class BareJS extends BareRouter {
 
     // Inline Finalizer
     const finalizeCode = `
-      if (res instanceof Response) return res;
-      //  Smart Finalizer: Handle String vs Object vs Null
+      if (res instanceof Response) {
+        if (typeof doLog === 'function') doLog(res.status); 
+        return res;
+      }
+      
+      const finalStatus = ctx._status || 200;
+      if (typeof doLog === 'function') doLog(finalStatus);
+
       if (typeof res === 'string') {
          return new Response(res, {
-            status: ctx._status,
+            status: finalStatus,
             headers: ctx._headers || { "content-type": "text/plain" }
          });
       }
       
-      //  FASTEST PATH: 200 OK + No Custom Headers -> Use Cached Init
-      if (ctx._status === 200 && !ctx._headers) {
-         return Response.json(res ?? null, json200);
-      }
-
       return Response.json(res ?? null, {
-        status: ctx._status,
+        status: finalStatus,
         headers: ctx._headers && ctx._headers["content-type"] ? ctx._headers : { "content-type": "application/json" }
       });
     `;
 
     if (len === 1) {
-      // 🚀 Fast path: no middleware (just the handler)
+      // Fast path: no middleware (just the handler)
       const fn0 = pipeline[0];
-      return new Function('fn0', 'json200', `return function(ctx) {
+      return new Function('fn0', 'json200', `return function(ctx, doLog) {
         const res = fn0(ctx);
         if (res && res.then) return res.then(v => { const res = v; ${finalizeCode} });
         ${finalizeCode}
       }`)(fn0, json200);
+
+      // return new Function('fn0', 'json200', `return function(ctx) {
+      //   const res = fn0(ctx);
+      //   if (res && res.then) return res.then(v => { const res = v; ${finalizeCode} });
+      //   ${finalizeCode}
+      // }`)(fn0, json200);
     }
 
     // Check async
@@ -131,13 +145,16 @@ export class BareJS extends BareRouter {
 
     const noop = () => { };
 
-    const fnHeader = isAsync ? 'return async function(ctx)' : 'return function(ctx)';
-
+    // const fnHeader = isAsync ? 'return async function(ctx)' : 'return function(ctx)';
+    const fnHeader = pipeline.some(fn => fn.constructor.name === 'AsyncFunction')
+      ? 'return async function(ctx, doLog)' // ⚡️ รับ doLog เข้ามา
+      : 'return function(ctx, doLog)';
     // Construct Function: (...fns, noop, json200) -> return function(ctx) { ... }
     return new Function(...fnNames, 'noop', 'json200', `${fnHeader} { ${code} }`)(...pipeline, noop, json200);
   }
 
   public compile() {
+    const isLog = this._useLog;
     this.tree = new RadixNode();
     for (const route of this.routes) {
       this.tree.insert(route.path, route.method, this.compileHandler(route.handlers));
@@ -151,7 +168,7 @@ export class BareJS extends BareRouter {
     const hError = (err: any) => ({
       status: 500,
       message: err.message || "Internal Server Error",
-      stack: process.env.NODE_ENV === 'development' ? err.stack : undefined
+      stack: process.env.NODE_ENV !== 'production' ? err.stack : undefined
     });
 
     //  JIT Compiler: Create all Code instead of tree.lookup
@@ -163,7 +180,9 @@ export class BareJS extends BareRouter {
     };
 
     const routerCode = tree.jitCompile(register);
-
+// console.log("--- GENERATED JIT CODE ---");
+// console.log(routerCode); 
+// console.log("--------------------------");
     // Create seamless Fetcher (JIT Edition)
     // We send nodes into the closure so the code can use them
     const EMPTY_PARAMS = Object.freeze({});
@@ -172,42 +191,58 @@ export class BareJS extends BareRouter {
     const args = ['pool', 'pIdx', 'mask', 'hNotFound', 'hError', 'EMPTY_PARAMS', ...hNames];
     const values = [pool, pIdx, mask, hNotFound, hError, EMPTY_PARAMS, ...hoistedHandlers];
 
-    const fnBody = `
-      return function(req) {
-        const url = req.url;
-        // Start searching after "http://" (7) or "https://" (8)
-        let s = url.indexOf('/', 8);
-
-        // Handle root path or missing slash
-        if (s === -1) {
-            s = url.length;
-        } else if (url.charCodeAt(s) === 47) {
-            // Skip the leading slash to match split() behavior (['users'] not ['/users'])
-            s++;
-        }
-
-        const method = req.method;
-        const ctx = pool[(++pIdx) & mask];
-        try {
-        //  INLINED Context.reset() for max speed (No function call overhead)
-        ctx.req = req;
-        ctx._status = 200;
-        ctx._headers = undefined;
-        if (ctx.store.size > 0) ctx.store.clear();
-        ctx.params = EMPTY_PARAMS;
-        ctx.body = undefined;
-
-        //  JIT Generated Code Start
-        ${routerCode}
-        //  JIT Generated Code End
-        const errorBody = hNotFound();
-        return Response.json(errorBody, { status: errorBody.status || 404 });
-        } catch (e) {
-          const errorBody = hError(e);
-          return Response.json(errorBody, { status: errorBody.status || 500 });
-        }
-      }
-    `;
+
+    // ส่วนใน compile() method (หาบรรทัดที่สร้าง fnBody)
+
+const fnBody = `
+  return function(req) {
+    const start = performance.now();
+    const url = req.url + " "; 
+    const urlLen = req.url.length; // ✅ ความยาวจริงของ URL
+    
+    let s = url.indexOf('/', 8);
+    if (s !== -1) s++; 
+    else s = urlLen; // ✅ เปลี่ยนจาก url.length เป็น urlLen
+
+    const method = req.method;
+    const ctx = pool[(++pIdx) & mask];
+
+    const doLog = (status) => {
+      if (!${isLog}) return;
+      const duration = (performance.now() - start).toFixed(3);
+      console.log(
+        \` \\x1b[90m\${new Date().toLocaleTimeString()}\\x1b[0m \` +
+        \`\\x1b[1m\\x1b[38;5;117m\${method.padEnd(7)}\\x1b[0m \` +
+        \`\\x1b[38;5;250m\${req.url.substring(req.url.indexOf('/', 8))}\\x1b[0m \` +
+        \`\${status >= 400 ? '\\x1b[33m' : '\\x1b[32m'}\${status}\\x1b[0m \` +
+        \`\\x1b[90m(\${duration}ms)\\x1b[0m\`
+      );
+    };
+
+    try {
+      ctx.req = req;
+      ctx._status = 200;
+      ctx._headers = undefined;
+      if (ctx.store.size > 0) ctx.store.clear();
+      ctx.params = EMPTY_PARAMS;
+      ctx.body = undefined;
+
+      // ⚡️ รัน JIT Code (ต้อง replace url.length เป็น urlLen)
+      ${routerCode
+        .replace(/h(\d+)\(ctx\)/g, 'h$1(ctx, doLog)')
+        .replace(/url\.length/g, 'urlLen')} 
+
+      const errorBody = hNotFound();
+      const status = errorBody.status || 404;
+      doLog(status);
+      return Response.json(errorBody, { status });
+
+    } catch (e) {
+      doLog(500);
+      return Response.json(hError(e), { status: 500 });
+    }
+  }
+`;
 
     this.hotFetch = new Function(...args, fnBody)(...values);
     this.compiled = true;
@@ -224,25 +259,32 @@ export class BareJS extends BareRouter {
   };
   public name: string = "App";
 
-  public listen(port: number = 3000, hostname: string = '0.0.0.0', reusePort: boolean = true) {
+  public listen(port?: number, hostname: string = '0.0.0.0', reusePort: boolean = true) {
     if (!this.compiled) this.compile();
+
+    // ดึงค่า Config ล่าสุดมาใช้
+    const { BARE_CONFIG } = require("./config");
+
+    // ลำดับความสำคัญ: Parameter > Config File > Default (3000)
+    const finalPort = port || BARE_CONFIG.port || 3000;
     const isProd = process.env.NODE_ENV === 'production';
 
     if (!isProd) {
       console.log(`
-  \x1b[33m  ____                      _ ____  \x1b[0m
-  \x1b[33m | __ )  __ _ _ __ ___     | / ___| \x1b[0m
-  \x1b[33m |  _ \\ / _\` | '__/ _ \\ _  | \\___ \\ \x1b[0m
-  \x1b[33m | |_) | (_| | | |  __/| |_| |___) |\x1b[0m
-  \x1b[33m |____/ \\__,_|_|  \\___| \\___/|____/ \x1b[0m
-                                        
-  \x1b[32m🚀 ${this.name} is running in development mode\x1b[0m
-  \x1b[90m⚙️  Pool Size: ${this.pool.length} | JIT: Enabled | Port: ${port}\x1b[0m
+  \x1b[33m  ____                    _ _____ \x1b[0m
+  \x1b[33m | __ )  __ _ _ __ ___     | | ____|\x1b[0m
+  \x1b[33m |  _ \\ / _\` | '__/ _ \\ _  | |  _|  \x1b[0m
+  \x1b[33m | |_) | (_| | | |  __/| |_| | |___ \x1b[0m
+  \x1b[33m |____/ \\__,_|_|  \\___| \\___/|_____|\x1b[0m
+                                         
+   \x1b[32m🚀 ${this.name} is running in development mode\x1b[0m
+   \x1b[90m⚙️  Pool Size: ${this.pool.length} | JIT: Enabled | Port: ${finalPort}\x1b[0m
+   \x1b[36m🛡️  Hash: ${BARE_CONFIG.hash.algorithm} (${BARE_CONFIG.hash.memoryCost / 1024}MB) | Iterations: ${BARE_CONFIG.hash.timeCost}\x1b[0m
       `);
     }
 
     const server = Bun.serve({
-      port,
+      port: finalPort,
       hostname,
       fetch: this.fetch,
       reusePort: reusePort,

package/src/core/config.ts

@@ -0,0 +1,32 @@
+// src/core/config.ts
+
+export interface BareConfig {
+  hash: {
+    algorithm: "argon2id" | "bcrypt";
+    memoryCost: number;
+    timeCost: number;
+  };
+  port: number;
+  
+}
+
+export const DEFAULT_CONFIG: BareConfig = {
+  hash: {
+    algorithm: "argon2id",
+    memoryCost: 65536, // 64MB
+    timeCost: 2
+  },
+  port: 3000
+};
+
+export let BARE_CONFIG = DEFAULT_CONFIG;
+
+
+export const initConfig = (userConfig: Partial<BareConfig> = {}) => {
+  BARE_CONFIG = {
+    ...DEFAULT_CONFIG,
+    ...userConfig,
+    hash: { ...DEFAULT_CONFIG.hash, ...userConfig.hash }
+  };
+  return BARE_CONFIG;
+};