princejs 1.3.3 → 1.3.5

package/dist/middleware.js

@@ -0,0 +1,110 @@
+// @bun
+// src/middleware.ts
+var MIDDLEWARE_EXECUTED = Symbol("middlewareExecuted");
+var cors = (options) => {
+  const origin = options?.origin || "*";
+  const methods = options?.methods || "GET,POST,PUT,DELETE,PATCH,OPTIONS";
+  const headers = options?.headers || "Content-Type,Authorization";
+  const credentials = options?.credentials || false;
+  return async (req, next) => {
+    if (req[MIDDLEWARE_EXECUTED]?.cors) {
+      return await next();
+    }
+    if (!req[MIDDLEWARE_EXECUTED]) {
+      req[MIDDLEWARE_EXECUTED] = {};
+    }
+    req[MIDDLEWARE_EXECUTED].cors = true;
+    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": headers,
+          ...credentials ? { "Access-Control-Allow-Credentials": "true" } : {}
+        }
+      });
+    }
+    const res = await next();
+    if (!res)
+      return res;
+    const newHeaders = new Headers(res.headers);
+    newHeaders.set("Access-Control-Allow-Origin", origin);
+    if (credentials)
+      newHeaders.set("Access-Control-Allow-Credentials", "true");
+    return new Response(res.body, {
+      status: res.status,
+      statusText: res.statusText,
+      headers: newHeaders
+    });
+  };
+};
+var logger = (options) => {
+  const format = options?.format || "dev";
+  const colors = options?.colors !== false;
+  const colorize = (code, text) => {
+    if (!colors)
+      return text;
+    if (code >= 500)
+      return `\x1B[31m${text}\x1B[0m`;
+    if (code >= 400)
+      return `\x1B[33m${text}\x1B[0m`;
+    if (code >= 300)
+      return `\x1B[36m${text}\x1B[0m`;
+    if (code >= 200)
+      return `\x1B[32m${text}\x1B[0m`;
+    return text;
+  };
+  return async (req, next) => {
+    if (req[MIDDLEWARE_EXECUTED]?.logger) {
+      return await next();
+    }
+    if (!req[MIDDLEWARE_EXECUTED]) {
+      req[MIDDLEWARE_EXECUTED] = {};
+    }
+    req[MIDDLEWARE_EXECUTED].logger = true;
+    const start = Date.now();
+    const pathname = new URL(req.url).pathname;
+    const res = await next();
+    if (!res)
+      return res;
+    const duration = Date.now() - start;
+    const status = res.status;
+    if (format === "dev") {
+      console.log(`${colorize(status, req.method)} ${pathname} ${colorize(status, String(status))} ${duration}ms`);
+    } else if (format === "tiny") {
+      console.log(`${req.method} ${pathname} ${status} - ${duration}ms`);
+    } else {
+      const date = new Date().toISOString();
+      console.log(`[${date}] ${req.method} ${pathname} ${status} ${duration}ms`);
+    }
+    return res;
+  };
+};
+var rateLimit = (options) => {
+  const store = new Map;
+  return async (req, next) => {
+    const ip = req.headers.get("x-forwarded-for") || "unknown";
+    const now = Date.now();
+    const windowMs = options.window * 1000;
+    let record = store.get(ip);
+    if (!record || now > record.resetAt) {
+      record = { count: 1, resetAt: now + windowMs };
+      store.set(ip, record);
+      return await next();
+    }
+    if (record.count >= options.max) {
+      return new Response(JSON.stringify({ error: options.message || "Too many requests" }), {
+        status: 429,
+        headers: { "Content-Type": "application/json" }
+      });
+    }
+    record.count++;
+    return await next();
+  };
+};
+export {
+  rateLimit,
+  logger,
+  cors
+};

package/dist/prince.js

@@ -1,5 +1,5 @@
 // @bun
-// prince.ts
+// src/prince.ts
 class TrieNode {
   children = Object.create(null);
   paramChild;
@@ -8,11 +8,52 @@ class TrieNode {
   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;
   }
@@ -30,6 +71,36 @@ class Prince {
       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);
   }
@@ -71,6 +142,44 @@ class Prince {
     const end = q !== -1 ? q : h !== -1 ? h : u.length;
     return u.slice(start, end);
   }
+  parseQuery(url) {
+    const q = url.indexOf("?");
+    if (q === -1)
+      return {};
+    const query = {};
+    const search = url.slice(q + 1);
+    const pairs = search.split("&");
+    for (let i = 0;i < pairs.length; i++) {
+      const pair = pairs[i];
+      const eq = pair.indexOf("=");
+      if (eq === -1) {
+        query[decodeURIComponent(pair)] = "";
+      } else {
+        query[decodeURIComponent(pair.slice(0, eq))] = decodeURIComponent(pair.slice(eq + 1));
+      }
+    }
+    return 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) {
@@ -85,7 +194,9 @@ class Prince {
       for (let i = 0;i < parts.length; i++) {
         const part = parts[i];
         if (part === "**") {
-          node.catchAllChild ??= { node: new TrieNode };
+          if (!node.catchAllChild) {
+            node.catchAllChild = { name: "**", node: new TrieNode };
+          }
           node = node.catchAllChild.node;
           break;
         } else if (part === "*") {
@@ -109,14 +220,38 @@ class Prince {
     }
     return root;
   }
-  compilePipeline(handler, paramsFromMatch) {
+  compilePipeline(handler, paramsGetter) {
     const mws = this.middlewares.slice();
-    return async (req) => {
+    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) {
-          const params = paramsFromMatch(req);
-          const res = await handler(req, params);
+          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")
@@ -126,8 +261,7 @@ class Prince {
           return this.json(res);
         }
         const mw = mws[idx++];
-        const maybe = await mw(req, runNext);
-        return maybe;
+        return await mw(req, runNext);
       };
       const out = await runNext();
       if (out instanceof Response)
@@ -150,9 +284,10 @@ class Prince {
       fetch: async (req) => {
         try {
           const pathname = this.fastPathname(req);
+          const query = this.parseQuery(req.url);
           const segments = pathname === "/" ? [] : pathname.slice(1).split("/");
           let node = root;
-          const params = Object.create(null);
+          const params = {};
           let matched = true;
           if (segments.length === 0) {
             if (!node.handlers)
@@ -162,20 +297,16 @@ class Prince {
               return this.json({ error: "Method not allowed" }, 405);
             let methodMap2 = handlerMap.get(node);
             if (!methodMap2) {
-              methodMap2 = Object.create(null);
+              methodMap2 = {};
               handlerMap.set(node, methodMap2);
             }
             if (!methodMap2[req.method]) {
               methodMap2[req.method] = this.compilePipeline(handler2, (_) => params);
             }
-            return await methodMap2[req.method](req);
+            return await methodMap2[req.method](req, params, query);
           }
           for (let i = 0;i < segments.length; i++) {
             const seg = segments[i];
-            if (!node) {
-              matched = false;
-              break;
-            }
             if (node.children[seg]) {
               node = node.children[seg];
               continue;
@@ -194,7 +325,6 @@ class Prince {
               if (node.catchAllChild.name)
                 params[node.catchAllChild.name] = remaining;
               node = node.catchAllChild.node;
-              i = segments.length;
               break;
             }
             matched = false;
@@ -202,19 +332,18 @@ class Prince {
           }
           if (!matched || !node || !node.handlers)
             return this.json({ error: "Route not found" }, 404);
-          const byMethod = node.handlers;
-          const handler = byMethod[req.method] ?? byMethod["GET"];
+          const handler = node.handlers[req.method];
           if (!handler)
             return this.json({ error: "Method not allowed" }, 405);
           let methodMap = handlerMap.get(node);
           if (!methodMap) {
-            methodMap = Object.create(null);
+            methodMap = {};
             handlerMap.set(node, methodMap);
           }
           if (!methodMap[req.method]) {
             methodMap[req.method] = this.compilePipeline(handler, (_) => params);
           }
-          return await methodMap[req.method](req);
+          return await methodMap[req.method](req, params, query);
         } catch (err) {
           if (this.errorHandler) {
             try {
@@ -225,7 +354,7 @@ class Prince {
         }
       }
     });
-    console.log(`PrinceJS v2 running at http://localhost:${port}`);
+    console.log(`\uD83D\uDE80 PrinceJS running at http://localhost:${port}`);
   }
 }
 var prince = (dev = false) => new Prince(dev);

package/dist/validation.js

@@ -0,0 +1,23 @@
+// @bun
+// src/validation.ts
+var validate = (schema, source = "body") => {
+  return async (req, next) => {
+    try {
+      const data = source === "body" ? req.body : source === "query" ? req.query : req.params;
+      const validated = schema.parse(data);
+      req[`validated${source.charAt(0).toUpperCase() + source.slice(1)}`] = validated;
+      return await next();
+    } catch (err) {
+      return new Response(JSON.stringify({
+        error: "Validation failed",
+        details: err.errors || err.message
+      }), {
+        status: 400,
+        headers: { "Content-Type": "application/json" }
+      });
+    }
+  };
+};
+export {
+  validate
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "princejs",
-  "version": "1.3.3",
+  "version": "1.3.5",
   "description": "An easy and fast backend framework — by a 13yo developer, for developers.",
   "main": "dist/prince.js",
   "types": "dist/prince.d.ts",
@@ -25,7 +25,10 @@
     "@types/bun": "^1.3.2",
     "bun-types": "latest"
   },
+  "dependencies": {
+    "zod": "^4.1.12"
+  },
   "scripts": {
-    "build": "bun build prince.ts --outdir dist --target bun"
+    "build": "bun build ./src/prince.ts ./src/middleware.ts ./src/validation.ts --outdir dist --target bun"
   }
 }