barejs 0.1.8 → 0.1.10

package/README.md

@@ -68,14 +68,42 @@ bun add barejs
 Create an `index.ts` and get your server running in seconds:
 
 ```typescript
-import { BareJS } from 'barejs';
+import { BareJS, type Context, typebox } from 'barejs';
+import * as TB from '@sinclair/typebox';
 
 const app = new BareJS();
 
-// Simple Route
-app.get('/ping', (ctx) => ctx.json({ message: 'pong' }));
+// Create Schema with TypeBox
+const UserSchema = TB.Type.Object({
+  name: TB.Type.String(),
+  age: TB.Type.Number()
+});
+
+// ✅ Route 1: Using TypeBox Validator (Fastest for Bun)
+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 });
+});
+
+// ✅ 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' }
+});
+
 
-// Start Server
 app.listen('0.0.0.0', 3000);
 
 ```
@@ -87,20 +115,28 @@ app.listen('0.0.0.0', 3000);
 
 Every handler receives a `Context` object, providing a high-speed interface to the request:
 
-* `ctx.req`: The [Native Bun Request](https://www.google.com/search?q=https://bun.sh/docs/api/http%23request).
-* `ctx.json(data)`: Optimized JSON response helper with pre-defined headers.
-* `ctx.body`: The validated JSON payload (available when using validators).
-* `ctx.params`: Route parameters (e.g., `/user/:id`).
+* `ctx.req`: The Native Bun Request.
+* `ctx.json(data)`: High-speed JSON helper with pre-defined headers.
+* `ctx.params`: Object containing route parameters (e.g., { id: "123" }).
+* `ctx.body`: Validated payload (populated by typebox, zod, or native).
+* `ctx.status(code)`: Chainable status setter (e.g., ctx.status(201).json(...)).
+* `ctx.setResHeader(key, value)`: Direct response header manipulation.
 
 ### 2. Middleware (The Onion Model)
 
-BareJS supports an asynchronous recursive pipeline, allowing you to wrap logic before and after the handler.
+BareJS supports an asynchronous recursive pipeline, allowing you to wrap logic before and after the handler. Using Context from the main package ensures full type safety.
 
 ```typescript
-app.use(async (ctx, next) => {
+import { type Context, type Next } from 'barejs';
+
+app.use(async (ctx: Context, next: Next) => {
   const start = performance.now();
+  
   const response = await next(); // Proceed to next middleware or handler
-  console.log(`Latency: ${(performance.now() - start).toFixed(2)}ms`);
+  
+  const duration = (performance.now() - start).toFixed(2);
+  console.log(`Latency: ${duration}ms`);
+  
   return response;
 });
 
@@ -108,15 +144,17 @@ app.use(async (ctx, next) => {
 
 ### 3. Full Plugin System
 
-Encapsulate complex logic into reusable modules that plug directly into the engine lifecycle.
+Encapsulate complex logic into reusable modules. Plugins have direct access to the BareJS instance during the installation phase.
 
 ```typescript
+import { type Context, type Next, type BareJS } from 'barejs';
+
 const databasePlugin = {
   name: 'barejs-db',
   version: '1.0.0',
   install: (app: BareJS) => {
-    app.use(async (ctx, next) => {
-      ctx.db = "CONNECTED";
+    app.use(async (ctx: Context, next: Next) => {
+      ctx.db = "CONNECTED"; // Attach custom properties to context
       return await next();
     });
   }
@@ -126,6 +164,27 @@ app.use(databasePlugin);
 
 ```
 
+### 4. Native WebSocket Support (MAX Speed)
+
+BareJS leverages Bun's native WebSocket implementation, allowing you to handle real-time binary and text streams with minimal overhead.
+
+```typescript
+import { BareJS } from 'barejs';
+
+const app = new BareJS();
+
+app.ws('/chat', {
+  open: (ws) => console.log('Client connected!'),
+  message: (ws, msg) => {
+    ws.send(`Echo: ${msg}`);
+  },
+  close: (ws, code, reason) => console.log('Closed')
+});
+
+app.listen();
+
+```
+
 ---
 
 ## 🛡️ Schema Validation
@@ -133,20 +192,27 @@ app.use(databasePlugin);
 BareJS allows you to use different validators for different routes, focusing on high-speed schema checks.
 
 ```typescript
-import { typebox, zod, native } from 'barejs/middleware';
+import { BareJS, typebox, zod, native, type Context } from 'barejs';
 import { Type } from '@sinclair/typebox';
 import { z } from 'zod';
 
-// High Performance: TypeBox
+const app = new BareJS();
+
+// 🚀 Tier 1: High Performance (TypeBox)
+// Best for Bun. Compiled JIT validation.
 const UserSchema = Type.Object({ name: Type.String() });
-app.post('/tb', typebox(UserSchema), (ctx) => ctx.json(ctx.body));
+app.post('/tb', typebox(UserSchema), (ctx: Context) => ctx.json(ctx.body));
 
-// Popular Choice: Zod
+// 💎 Tier 2: Popular Choice (Zod)
+// Flexible and feature-rich.
 const ZodSchema = z.object({ age: z.number() });
-app.post('/zod', zod(ZodSchema), (ctx) => ctx.json(ctx.body));
+app.post('/zod', zod(ZodSchema), (ctx: Context) => ctx.json(ctx.body));
 
-// Zero Dependency: Native
-app.post('/native', native({ properties: { id: { type: 'number' } } }), (ctx) => ctx.json(ctx.body));
+// 🍃 Tier 3: Zero Dependency (Native)
+// Extremely lightweight. Uses built-in typeof checks.
+app.post('/native', native({ properties: { id: { type: 'number' } } }), (ctx: Context) => {
+  return ctx.json(ctx.body);
+});
 
 ```
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "barejs",
-  "version": "0.1.8",
+  "version": "0.1.10",
   "author": "xarhang",
   "description": "High-performance JIT-specialized web framework for Bun",
   "main": "./src/bare.ts",
@@ -8,7 +8,7 @@
   "type": "module",
   "exports": {
     ".": "./src/bare.ts",
-    "./middleware": "./src/middleware/index.ts"
+    "./middleware": "./src/validators.ts"
   },
   "sideEffects": false,
   "repository": {

package/src/bare.ts

@@ -1,4 +1,7 @@
 // src/bare.ts
+export * from './context';   
+export * from './validators';
+
 import { BareContext } from './context';
 import type { Context, Middleware, Handler, WSHandlers } from './context';
 

package/src/index.ts

@@ -1,39 +1,4 @@
-import { BareJS} from './bare';
-import type { Context } from './context';
-import { typebox, native } from './validators';
-import * as TB from '@sinclair/typebox';
-
-const app = new BareJS();
-
-// Create Schema with TypeBox
-const UserSchema = TB.Type.Object({
-  name: TB.Type.String(),
-  age: TB.Type.Number()
-});
-
-// ✅ Route 1: Using TypeBox Validator (Fastest for Bun)
-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 });
-});
-
-// ✅ 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);
+export { BareJS } from './bare';
+export { BareContext } from './context';
+export type { Context, Middleware, Handler, Next } from './context';
+export { typebox, native, zod } from './validators';