princejs 1.3.6 → 1.4.1

package/Readme.md

@@ -1,93 +1,90 @@
-# PrinceJS
+# princejs — The Smallest Bun Framework in History
 
-**The fastest backend framework ever made.**  
-**Beats Hono and Express • Built in 3 days** \
+**2.8 kB gzipped** • **~600k req/30s** • **Built by a 13yo Nigerian**
+
+> *"I didn’t beat Elysia. I outsmarted it."* — @Lil_Prince_1218
 
 ---
 
-### Install
+## 🚀 Get Started
 
 ```bash
-pnpm add princejs
-# or
-bun add princejs
-# or
-npm install princejs
+bun create princejs my-app
+cd my-app
+bun dev
 ```
 
-### Quick Start
-
 ```ts
-import { Prince } from 'princejs';
+import { Prince } from "princejs";
+import { cors } from "princejs/middleware";
 
-const app = new Prince();
+const app = new Prince()
+  .use(cors())
+  .get("/", () => "Hello princejs")
+  .get("/users/:id", (req) => ({ id: req.params.id }));
 
-// CORS + logging
-app.use(async (req, next) => {
-  console.log(`${req.method} ${req.url}`);
-  const res = await next();
-  res.headers.set('Access-Control-Allow-Origin', '*');
-  return res;
-});
+app.listen(5000);
+```
 
-// Global error handler
-app.error((err) => app.json({ error: err.message }, 500));
+---
 
-// Routes
-app.get('/', () => app.json({ hello: 'PrinceJS', age: 13 }));
+## ⚔️ Size War (Gzipped — Real World)
 
-app.post('/pay', async (req) => {
-  let body = {};
-  try { body = await req.json(); } catch {}
-  return app.json({ url: `https://stripe.com/pay/${body.amount || 999}` });
-});
+| Framework    | Gzipped    | Minified   | vs princejs |
+| ------------ | ---------- | ---------- | ----------- |
+| **princejs** | **2.8 kB** | **7.8 kB** | —           |
+| **Hono**     | 7.3 kB     | 18.7 kB    | 2.6× bigger |
+| **Elysia**   | 62.5 kB    | 245 kB     | 22× bigger  |
 
-app.listen(3000);
-```
+> princejs fits in a tweet. Elysia needs a ZIP file.
 
 ---
 
-## Features
+## ⚡ Benchmarks (3×3 — Windows, Nov 11, 2025)
 
-All HTTP methods: **GET, POST, PUT, DELETE, PATCH, OPTIONS, HEAD**
+| Framework    | Requests (30s) | Req/s      | Notes          |
+| ------------ | -------------- | ---------- | -------------- |
+| **princejs** | **599k**       | **19,966** | 🥈 2nd fastest |
+| **Elysia**   | 602k           | 20,071     | 🥇 0.5% faster |
+| **Hono**     | 578k           | 19,254     | 🥉 Slower      |
 
-```bash
-app.json(data, status?) — clean JSON with status
-app.error(handler) — global error handling
-```
+> Elysia is only 0.5% faster. But princejs is **22× smaller**.
 
 ---
 
-## 🔥 Benchmark Comparison (real Windows laptop)
-
-Real-world 30-second load test with `autocannon -c 100 -d 30`.
+## 🧹 Features
 
-### **Framework Performance Table**
+```ts
+.use(rateLimit({ max: 100 }))
+.use(validate(z.object({ name: z.string() })))
+```
 
-| Framework            | Avg Req/sec  | Total Requests (30s) | Avg Bytes/sec | Avg Latency  |
-| -------------------- | ------------ | -------------------- | ------------- | ------------ |
-| **PrinceJS** | **8,526.34** | **256,000**          | **1.14 MB/s** | **11.22 ms** |
-| Hono                 | 8,044.8      | 241,000              | 1.08 MB/s     | 11.22 ms     |
-| Elysia               | 9,531.21     | 286,000              | 1.28 MB/s     | 10 ms        |
+✅ Zod Validation
+✅ CORS + Logger
+✅ Rate Limit Middleware
 
 ---
 
-### Author
-
-Matthew Micheal — Nigeria
+## 📦 Install
 
-Made in PowerShell on a school laptop.
+```bash
+npm i princejs
+# or
+bun add princejs
+```
 
-### Links
+---
 
-npm: [https://www.npmjs.com/package/princejs](https://www.npmjs.com/package/princejs)
+## 📚 Docs
 
-github: [https://github.com/MatthewTheCoder1218/princejs](https://github.com/MatthewTheCoder1218/princejs)
+**coming soon →** [princejs.vercel.app](https://princejs.vercel.app)
 
 ---
 
-PrinceJS — Small. Fast. Unbeatable.
+## 🇳🇬 Built in Nigeria
 
-```bash
-pnpm add princejs
-```
+**@Lil_Prince_1218 — 13 years old**
+Lagos, Nigeria
+**November 11, 2025**
+
+> *“2.8 kB. 600k req. No excuses.”*

package/dist/index.js

@@ -0,0 +1,346 @@
+// @bun
+// src/prince.ts
+class TrieNode {
+  children = Object.create(null);
+  paramChild;
+  wildcardChild;
+  catchAllChild;
+  handlers = null;
+}
+
+class ResponseBuilder {
+  _status = 200;
+  _headers = {};
+  _body = null;
+  status(code) {
+    this._status = code;
+    return this;
+  }
+  header(key, value) {
+    this._headers[key] = value;
+    return this;
+  }
+  json(data) {
+    this._headers["Content-Type"] = "application/json";
+    this._body = JSON.stringify(data);
+    return this.build();
+  }
+  text(data) {
+    this._headers["Content-Type"] = "text/plain";
+    this._body = data;
+    return this.build();
+  }
+  html(data) {
+    this._headers["Content-Type"] = "text/html";
+    this._body = data;
+    return this.build();
+  }
+  redirect(url, status = 302) {
+    this._status = status;
+    this._headers["Location"] = url;
+    return this.build();
+  }
+  build() {
+    return new Response(this._body, {
+      status: this._status,
+      headers: this._headers
+    });
+  }
+}
+
+class Prince {
+  devMode;
+  rawRoutes = [];
+  middlewares = [];
+  errorHandler;
+  prefix = "";
+  constructor(devMode = false) {
+    this.devMode = devMode;
+  }
+  use(mw) {
+    this.middlewares.push(mw);
+    return this;
+  }
+  error(fn) {
+    this.errorHandler = fn;
+    return this;
+  }
+  json(data, status = 200) {
+    return new Response(JSON.stringify(data), {
+      status,
+      headers: { "Content-Type": "application/json" }
+    });
+  }
+  response() {
+    return new ResponseBuilder;
+  }
+  route(path) {
+    const group = new Prince(this.devMode);
+    group.prefix = path;
+    group.middlewares = [...this.middlewares];
+    return {
+      get: (subpath, handler) => {
+        this.get(path + subpath, handler);
+        return group;
+      },
+      post: (subpath, handler) => {
+        this.post(path + subpath, handler);
+        return group;
+      },
+      put: (subpath, handler) => {
+        this.put(path + subpath, handler);
+        return group;
+      },
+      delete: (subpath, handler) => {
+        this.delete(path + subpath, handler);
+        return group;
+      },
+      patch: (subpath, handler) => {
+        this.patch(path + subpath, handler);
+        return group;
+      }
+    };
+  }
+  get(path, handler) {
+    return this.add("GET", path, handler);
+  }
+  post(path, handler) {
+    return this.add("POST", path, handler);
+  }
+  put(path, handler) {
+    return this.add("PUT", path, handler);
+  }
+  delete(path, handler) {
+    return this.add("DELETE", path, handler);
+  }
+  patch(path, handler) {
+    return this.add("PATCH", path, handler);
+  }
+  options(path, handler) {
+    return this.add("OPTIONS", path, handler);
+  }
+  head(path, handler) {
+    return this.add("HEAD", path, handler);
+  }
+  add(method, path, handler) {
+    if (!path.startsWith("/"))
+      path = "/" + path;
+    if (path.length > 1 && path.endsWith("/"))
+      path = path.slice(0, -1);
+    const parts = path === "/" ? [""] : path.split("/").slice(1);
+    this.rawRoutes.push({ method: method.toUpperCase(), path, parts, handler });
+    return this;
+  }
+  parseUrl(req) {
+    const url = new URL(req.url);
+    const query = {};
+    for (const [key, value] of url.searchParams.entries()) {
+      query[key] = value;
+    }
+    return {
+      pathname: url.pathname,
+      query
+    };
+  }
+  async parseBody(req) {
+    const ct = req.headers.get("content-type") || "";
+    if (ct.includes("application/json")) {
+      return await req.json();
+    }
+    if (ct.includes("application/x-www-form-urlencoded")) {
+      const text = await req.text();
+      const params = {};
+      const pairs = text.split("&");
+      for (const pair of pairs) {
+        const [key, val] = pair.split("=");
+        params[decodeURIComponent(key)] = decodeURIComponent(val || "");
+      }
+      return params;
+    }
+    if (ct.includes("text/")) {
+      return await req.text();
+    }
+    return null;
+  }
+  buildRouter() {
+    const root = new TrieNode;
+    for (const route of this.rawRoutes) {
+      let node = root;
+      const parts = route.parts;
+      if (parts.length === 1 && parts[0] === "") {
+        if (!node.handlers)
+          node.handlers = Object.create(null);
+        node.handlers[route.method] = route.handler;
+        continue;
+      }
+      for (let i = 0;i < parts.length; i++) {
+        const part = parts[i];
+        if (part === "**") {
+          if (!node.catchAllChild) {
+            node.catchAllChild = { name: "**", node: new TrieNode };
+          }
+          node = node.catchAllChild.node;
+          break;
+        } else if (part === "*") {
+          if (!node.wildcardChild)
+            node.wildcardChild = new TrieNode;
+          node = node.wildcardChild;
+        } else if (part.startsWith(":")) {
+          const name = part.slice(1);
+          if (!node.paramChild)
+            node.paramChild = { name, node: new TrieNode };
+          node = node.paramChild.node;
+        } else {
+          if (!node.children[part])
+            node.children[part] = new TrieNode;
+          node = node.children[part];
+        }
+      }
+      if (!node.handlers)
+        node.handlers = Object.create(null);
+      node.handlers[route.method] = route.handler;
+    }
+    return root;
+  }
+  compilePipeline(handler, paramsGetter) {
+    const mws = this.middlewares.slice();
+    const hasMiddleware = mws.length > 0;
+    if (!hasMiddleware) {
+      return async (req, params, query) => {
+        const princeReq = req;
+        princeReq.params = params;
+        princeReq.query = query;
+        if (req.method === "POST" || req.method === "PUT" || req.method === "PATCH") {
+          princeReq.body = await this.parseBody(req);
+        }
+        const res = await handler(princeReq);
+        if (res instanceof Response)
+          return res;
+        if (typeof res === "string")
+          return new Response(res, { status: 200 });
+        if (res instanceof Uint8Array || res instanceof ArrayBuffer)
+          return new Response(res, { status: 200 });
+        return this.json(res);
+      };
+    }
+    return async (req, params, query) => {
+      const princeReq = req;
+      princeReq.params = params;
+      princeReq.query = query;
+      let idx = 0;
+      const runNext = async () => {
+        if (idx >= mws.length) {
+          if (req.method === "POST" || req.method === "PUT" || req.method === "PATCH") {
+            princeReq.body = await this.parseBody(req);
+          }
+          const res = await handler(princeReq);
+          if (res instanceof Response)
+            return res;
+          if (typeof res === "string")
+            return new Response(res, { status: 200 });
+          if (res instanceof Uint8Array || res instanceof ArrayBuffer)
+            return new Response(res, { status: 200 });
+          return this.json(res);
+        }
+        const mw = mws[idx++];
+        return await mw(req, runNext);
+      };
+      const out = await runNext();
+      if (out instanceof Response)
+        return out;
+      if (out !== undefined) {
+        if (typeof out === "string")
+          return new Response(out, { status: 200 });
+        if (out instanceof Uint8Array || out instanceof ArrayBuffer)
+          return new Response(out, { status: 200 });
+        return this.json(out);
+      }
+      return new Response(null, { status: 204 });
+    };
+  }
+  listen(port = 3000) {
+    const root = this.buildRouter();
+    const handlerMap = new Map;
+    Bun.serve({
+      port,
+      fetch: async (req) => {
+        try {
+          const { pathname, query } = this.parseUrl(req);
+          const segments = pathname === "/" ? [] : pathname.slice(1).split("/");
+          let node = root;
+          const params = {};
+          let matched = true;
+          if (segments.length === 0) {
+            if (!node.handlers)
+              return this.json({ error: "Route not found" }, 404);
+            const handler2 = node.handlers[req.method];
+            if (!handler2)
+              return this.json({ error: "Method not allowed" }, 405);
+            let methodMap2 = handlerMap.get(node);
+            if (!methodMap2) {
+              methodMap2 = {};
+              handlerMap.set(node, methodMap2);
+            }
+            if (!methodMap2[req.method]) {
+              methodMap2[req.method] = this.compilePipeline(handler2, (_) => params);
+            }
+            return await methodMap2[req.method](req, params, query);
+          }
+          for (let i = 0;i < segments.length; i++) {
+            const seg = segments[i];
+            if (node.children[seg]) {
+              node = node.children[seg];
+              continue;
+            }
+            if (node.paramChild) {
+              params[node.paramChild.name] = seg;
+              node = node.paramChild.node;
+              continue;
+            }
+            if (node.wildcardChild) {
+              node = node.wildcardChild;
+              continue;
+            }
+            if (node.catchAllChild) {
+              const remaining = segments.slice(i).join("/");
+              if (node.catchAllChild.name)
+                params[node.catchAllChild.name] = remaining;
+              node = node.catchAllChild.node;
+              break;
+            }
+            matched = false;
+            break;
+          }
+          if (!matched || !node || !node.handlers) {
+            return this.json({ error: "Route not found" }, 404);
+          }
+          const handler = node.handlers[req.method];
+          if (!handler)
+            return this.json({ error: "Method not allowed" }, 405);
+          let methodMap = handlerMap.get(node);
+          if (!methodMap) {
+            methodMap = {};
+            handlerMap.set(node, methodMap);
+          }
+          if (!methodMap[req.method]) {
+            methodMap[req.method] = this.compilePipeline(handler, (_) => params);
+          }
+          return await methodMap[req.method](req, params, query);
+        } catch (err) {
+          if (this.errorHandler) {
+            try {
+              return this.errorHandler(err, req);
+            } catch {}
+          }
+          return this.json({ error: String(err) }, 500);
+        }
+      }
+    });
+    console.log(`\uD83D\uDE80 PrinceJS running at http://localhost:${port}`);
+  }
+}
+var prince = (dev = false) => new Prince(dev);
+export {
+  prince,
+  Prince
+};

package/package.json

@@ -1,9 +1,23 @@
 {
   "name": "princejs",
-  "version": "1.3.6",
+  "version": "1.4.1",
   "description": "An easy and fast backend framework — by a 13yo developer, for developers.",
   "main": "dist/prince.js",
   "types": "dist/prince.d.ts",
+  "exports": {
+    ".": {
+      "import": "./dist/prince.js",
+      "types": "./dist/prince.d.ts"
+    },
+    "./middleware": {
+      "import": "./dist/middleware.js",
+      "types": "./dist/middleware.d.ts"
+    },
+    "./validation": {
+      "import": "./dist/validation.js",
+      "types": "./dist/validation.d.ts"
+    }
+  },
   "files": [
     "dist"
   ],
@@ -13,7 +27,10 @@
     "framework",
     "bun",
     "easy",
-    "princejs"
+    "princejs",
+    "rest",
+    "server",
+    "typescript"
   ],
   "author": "Matthew Michael (MatthewTheCoder1218)",
   "license": "MIT",
@@ -23,12 +40,11 @@
   },
   "devDependencies": {
     "@types/bun": "^1.3.2",
-    "bun-types": "latest"
-  },
-  "dependencies": {
+    "bun-types": "latest",
+    "typescript": "^5.9.3",
     "zod": "^4.1.12"
   },
   "scripts": {
-    "build": "bun build ./src/prince.ts --outdir dist --target bun"
+    "build": "bun build src/index.ts --outdir dist --target bun && bun build src/middleware.ts --outdir dist --target bun && bun build src/validation.ts --outdir dist --target bun"
   }
 }