princejs 1.5.0 → 1.5.2

package/dist/create.js

@@ -0,0 +1,153 @@
+#!/usr/bin/env bun
+// @bun
+
+// bin/create.ts
+import { existsSync, mkdirSync, writeFileSync } from "fs";
+import { join } from "path";
+var name = Bun.argv[2];
+if (!name) {
+  console.error("\u274C Error: Please provide a project name");
+  console.log("Usage: bunx create-princejs <project-name>");
+  process.exit(1);
+}
+if (existsSync(name)) {
+  console.error(`\u274C Error: Directory "${name}" already exists`);
+  process.exit(1);
+}
+console.log(`\uD83C\uDFA8 Creating PrinceJS project: ${name}...`);
+mkdirSync(name, { recursive: true });
+mkdirSync(join(name, "src"), { recursive: true });
+var packageJson = {
+  name,
+  version: "1.0.0",
+  type: "module",
+  scripts: {
+    dev: "bun --watch src/index.ts",
+    start: "bun src/index.ts"
+  },
+  dependencies: {
+    princejs: "latest"
+  },
+  devDependencies: {
+    "@types/bun": "latest",
+    "bun-types": "latest"
+  }
+};
+writeFileSync(join(name, "package.json"), JSON.stringify(packageJson, null, 2));
+var indexContent = `import { prince } from "princejs";
+import { cors, logger } from "princejs/middleware";
+
+const app = prince(true); // dev mode enabled
+
+// Middleware
+app.use(cors());
+app.use(logger({ format: "dev" }));
+
+// Routes
+app.get("/", () => {
+  return { message: "Welcome to PrinceJS! \uD83D\uDE80" };
+});
+
+app.get("/hello/:name", (req) => {
+  return { message: \`Hello, \${req.params.name}!\` };
+});
+
+app.post("/echo", (req) => {
+  return { echo: req.body };
+});
+
+// WebSocket example
+app.ws("/ws", {
+  open: (ws) => {
+    console.log("Client connected");
+    ws.send("Welcome to WebSocket!");
+  },
+  message: (ws, msg) => {
+    console.log("Received:", msg);
+    ws.send(\`Echo: \${msg}\`);
+  },
+  close: (ws) => {
+    console.log("Client disconnected");
+  }
+});
+
+// Start server
+const PORT = process.env.PORT || 3000;
+app.listen(PORT);
+`;
+writeFileSync(join(name, "src", "index.ts"), indexContent);
+var tsconfigContent = {
+  compilerOptions: {
+    lib: ["ESNext"],
+    target: "ESNext",
+    module: "ESNext",
+    moduleDetection: "force",
+    jsx: "react-jsx",
+    allowJs: true,
+    moduleResolution: "bundler",
+    allowImportingTsExtensions: true,
+    verbatimModuleSyntax: true,
+    noEmit: true,
+    strict: true,
+    skipLibCheck: true,
+    noFallthroughCasesInSwitch: true,
+    noUnusedLocals: false,
+    noUnusedParameters: false,
+    noPropertyAccessFromIndexSignature: false,
+    types: ["bun-types"]
+  }
+};
+writeFileSync(join(name, "tsconfig.json"), JSON.stringify(tsconfigContent, null, 2));
+var gitignoreContent = `node_modules
+.DS_Store
+*.log
+dist
+.env
+.env.local
+`;
+writeFileSync(join(name, ".gitignore"), gitignoreContent);
+var readmeContent = `# ${name}
+
+A PrinceJS application.
+
+## Getting Started
+
+Install dependencies:
+\`\`\`bash
+bun install
+\`\`\`
+
+Run the development server:
+\`\`\`bash
+bun run dev
+\`\`\`
+
+Your server will be running at \`http://localhost:3000\`
+
+## Available Endpoints
+
+- \`GET /\` - Welcome message
+- \`GET /hello/:name\` - Personalized greeting
+- \`POST /echo\` - Echo back request body
+- \`WS /ws\` - WebSocket connection
+
+## Learn More
+
+- [PrinceJS Documentation](https://github.com/MatthewTheCoder1218/princejs)
+- [Bun Documentation](https://bun.sh/docs)
+`;
+writeFileSync(join(name, "README.md"), readmeContent);
+var envContent = `PORT=3000
+`;
+writeFileSync(join(name, ".env.example"), envContent);
+console.log(`
+\u2705 Project created successfully!
+`);
+console.log("\uD83D\uDCC2 Next steps:");
+console.log(`   cd ${name}`);
+console.log("   bun install");
+console.log(`   bun run dev
+`);
+console.log("\uD83D\uDE80 Your server will start at http://localhost:3000");
+console.log(`\uD83D\uDCDA Check README.md for more information
+`);

package/dist/index.js

@@ -59,7 +59,6 @@ class Prince {
   rawRoutes = [];
   middlewares = [];
   errorHandler;
-  prefix = "";
   wsRoutes = {};
   openapiData = null;
   constructor(devMode = false) {
@@ -103,21 +102,6 @@ class Prince {
     this.get(path, () => this.openapiData);
     return this;
   }
-  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;
-      }
-    };
-  }
   get(path, handler) {
     return this.add("GET", path, handler);
   }
@@ -136,26 +120,30 @@ class Prince {
   add(method, path, handler) {
     if (!path.startsWith("/"))
       path = "/" + path;
-    if (path.length > 1 && path.endsWith("/"))
+    if (path !== "/" && path.endsWith("/"))
       path = path.slice(0, -1);
     const parts = path === "/" ? [""] : path.split("/").slice(1);
-    this.rawRoutes.push({ method: method.toUpperCase(), path, parts, handler });
+    this.rawRoutes.push({ method, 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;
+    for (const [k, v] of url.searchParams.entries())
+      query[k] = v;
     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"))
+      return Object.fromEntries(new URLSearchParams(await req.text()).entries());
     if (ct.startsWith("multipart/form-data")) {
-      const form = await req.formData();
+      const fd = await req.formData();
       const files = {};
       const fields = {};
-      for (const [k, v] of form.entries()) {
+      for (const [k, v] of fd.entries()) {
         if (v instanceof File)
           files[k] = v;
         else
@@ -163,73 +151,46 @@ class Prince {
       }
       return { files, fields };
     }
-    if (ct.includes("application/json"))
-      return await req.json();
-    if (ct.includes("application/x-www-form-urlencoded")) {
-      return Object.fromEntries(new URLSearchParams(await req.text()).entries());
-    }
     if (ct.startsWith("text/"))
       return await req.text();
     return null;
   }
   buildRouter() {
     const root = new TrieNode;
-    for (const route of this.rawRoutes) {
+    for (const r 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;
+      if (r.parts.length === 1 && r.parts[0] === "") {
+        node.handlers ??= {};
+        node.handlers[r.method] = r.handler;
         continue;
       }
-      for (const part of parts) {
-        if (part === "**") {
-          if (!node.catchAllChild)
-            node.catchAllChild = { name: "**", node: new TrieNode };
-          node = node.catchAllChild.node;
-          break;
-        } else if (part.startsWith(":")) {
+      for (const part of r.parts) {
+        if (part.startsWith(":")) {
           const name = part.slice(1);
-          if (!node.paramChild)
-            node.paramChild = { name, node: new TrieNode };
+          node.paramChild ??= { name, node: new TrieNode };
           node = node.paramChild.node;
         } else {
-          node = node.children[part] ??= new TrieNode;
+          node.children[part] ??= new TrieNode;
+          node = node.children[part];
         }
       }
-      node.handlers ??= Object.create(null);
-      node.handlers[route.method] = route.handler;
+      node.handlers ??= {};
+      node.handlers[r.method] = r.handler;
     }
     return root;
   }
   compilePipeline(handler) {
-    const mws = this.middlewares;
-    if (mws.length === 0)
-      return async (req, params, query) => {
-        const r = req;
-        r.params = params;
-        r.query = query;
-        if (["POST", "PUT", "PATCH"].includes(req.method))
-          r.body = await this.parseBody(req);
-        const res = await handler(r);
-        if (res instanceof Response)
-          return res;
-        if (typeof res === "string")
-          return new Response(res);
-        return this.json(res);
-      };
     return async (req, params, query) => {
-      const r = req;
-      r.params = params;
-      r.query = query;
+      req.params = params;
+      req.query = query;
       let i = 0;
       const next = async () => {
-        if (i < mws.length)
-          return await mws[i++](req, next) ?? new Response(null);
+        if (i < this.middlewares.length) {
+          return await this.middlewares[i++](req, next) ?? new Response("");
+        }
         if (["POST", "PUT", "PATCH"].includes(req.method))
-          r.body = await this.parseBody(req);
-        const res = await handler(r);
+          req.body = await this.parseBody(req);
+        const res = await handler(req);
         if (res instanceof Response)
           return res;
         if (typeof res === "string")
@@ -241,8 +202,10 @@ class Prince {
   }
   async handleFetch(req) {
     const { pathname, query } = this.parseUrl(req);
+    const r = req;
     const segments = pathname === "/" ? [] : pathname.slice(1).split("/");
-    let node = this.buildRouter(), params = {};
+    let node = this.buildRouter();
+    let params = {};
     for (const seg of segments) {
       if (node.children[seg])
         node = node.children[seg];
@@ -256,7 +219,7 @@ class Prince {
     if (!handler)
       return this.json({ error: "Method Not Allowed" }, 405);
     const pipeline = this.compilePipeline(handler);
-    return await pipeline(req, params, query);
+    return pipeline(r, params, query);
   }
   listen(port = 3000) {
     const self = this;
@@ -264,33 +227,30 @@ class Prince {
       port,
       fetch(req, server) {
         const { pathname } = new URL(req.url);
-        const wsRoute = self.wsRoutes[pathname];
-        if (wsRoute) {
-          if (server.upgrade(req, { data: { route: wsRoute } }))
-            return;
-          return new Response("Upgrade failed", { status: 500 });
+        const ws = self.wsRoutes[pathname];
+        if (ws) {
+          server.upgrade(req, { data: { ws } });
+          return;
         }
-        try {
-          return self.handleFetch(req);
-        } catch (err) {
+        return self.handleFetch(req).catch((err) => {
           if (self.errorHandler)
             return self.errorHandler(err, req);
           return self.json({ error: String(err) }, 500);
-        }
+        });
       },
       websocket: {
         open(ws) {
-          ws.data.route?.open?.(ws);
+          ws.data.ws?.open?.(ws);
         },
         message(ws, msg) {
-          ws.data.route?.message?.(ws, msg);
+          ws.data.ws?.message?.(ws, msg);
         },
         close(ws) {
-          ws.data.route?.close?.(ws);
+          ws.data.ws?.close?.(ws);
         }
       }
     });
-    console.log(`\uD83D\uDE80 PrinceJS running at http://localhost:${port}`);
+    console.log(`\uD83D\uDE80 PrinceJS running http://localhost:${port}`);
   }
 }
 var prince = (dev = false) => new Prince(dev);

package/dist/middleware.js

@@ -83,27 +83,76 @@ var logger = (options) => {
 };
 var rateLimit = (options) => {
   const store = new Map;
+  setInterval(() => {
+    const now = Date.now();
+    for (const [key, record] of store.entries()) {
+      if (now > record.resetAt) {
+        store.delete(key);
+      }
+    }
+  }, options.window * 1000);
   return async (req, next) => {
-    const ip = req.headers.get("x-forwarded-for") || "unknown";
+    if (req[MIDDLEWARE_EXECUTED]?.rateLimit) {
+      return await next();
+    }
+    if (!req[MIDDLEWARE_EXECUTED]) {
+      req[MIDDLEWARE_EXECUTED] = {};
+    }
+    req[MIDDLEWARE_EXECUTED].rateLimit = true;
+    const key = options.keyGenerator ? options.keyGenerator(req) : req.headers.get("x-forwarded-for") || req.headers.get("x-real-ip") || "unknown";
     const now = Date.now();
     const windowMs = options.window * 1000;
-    let record = store.get(ip);
+    let record = store.get(key);
     if (!record || now > record.resetAt) {
       record = { count: 1, resetAt: now + windowMs };
-      store.set(ip, record);
+      store.set(key, record);
       return await next();
     }
     if (record.count >= options.max) {
-      return new Response(JSON.stringify({ error: options.message || "Too many requests" }), {
+      const retryAfter = Math.ceil((record.resetAt - now) / 1000);
+      return new Response(JSON.stringify({
+        error: options.message || "Too many requests",
+        retryAfter
+      }), {
         status: 429,
-        headers: { "Content-Type": "application/json" }
+        headers: {
+          "Content-Type": "application/json",
+          "Retry-After": String(retryAfter)
+        }
       });
     }
     record.count++;
     return await next();
   };
 };
+var serve = (options) => {
+  const root = options.root || "./public";
+  const index = options.index || "index.html";
+  const dotfiles = options.dotfiles || "deny";
+  return async (req, next) => {
+    const url = new URL(req.url);
+    let filepath = url.pathname;
+    if (filepath.includes("..")) {
+      return new Response("Forbidden", { status: 403 });
+    }
+    if (dotfiles === "deny" && filepath.split("/").some((part) => part.startsWith("."))) {
+      return new Response("Forbidden", { status: 403 });
+    }
+    try {
+      const file = Bun.file(`${root}${filepath}`);
+      if (await file.exists()) {
+        return new Response(file);
+      }
+      const indexFile = Bun.file(`${root}${filepath}/${index}`);
+      if (await indexFile.exists()) {
+        return new Response(indexFile);
+      }
+    } catch (err) {}
+    return await next();
+  };
+};
 export {
+  serve,
   rateLimit,
   logger,
   cors

package/dist/prince.js

@@ -1,129 +1,4 @@
 // @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();
-  };
-};
-
-// 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" }
-      });
-    }
-  };
-};
-
 // src/prince.ts
 class TrieNode {
   children = Object.create(null);
@@ -165,11 +40,17 @@ class ResponseBuilder {
     this._headers["Location"] = url;
     return this.build();
   }
-  build() {
-    return new Response(this._body, {
-      status: this._status,
-      headers: this._headers
+  stream(cb) {
+    const encoder = new TextEncoder;
+    const stream = new ReadableStream({
+      start(controller) {
+        cb((chunk) => controller.enqueue(encoder.encode(chunk)), () => controller.close());
+      }
     });
+    return new Response(stream, { status: this._status, headers: this._headers });
+  }
+  build() {
+    return new Response(this._body, { status: this._status, headers: this._headers });
   }
 }
 
@@ -178,25 +59,12 @@ class Prince {
   rawRoutes = [];
   middlewares = [];
   errorHandler;
-  prefix = "";
+  wsRoutes = {};
+  openapiData = null;
+  router = null;
   constructor(devMode = false) {
     this.devMode = devMode;
   }
-  useCors(options) {
-    this.use(cors(options));
-    return this;
-  }
-  useLogger(options) {
-    this.use(logger(options));
-    return this;
-  }
-  useRateLimit(options) {
-    this.use(rateLimit(options));
-    return this;
-  }
-  validate(schema, source = "body") {
-    return validate(schema, source);
-  }
   use(mw) {
     this.middlewares.push(mw);
     return this;
@@ -214,32 +82,26 @@ class Prince {
   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;
-      }
+  ws(path, options) {
+    this.wsRoutes[path] = options;
+    return this;
+  }
+  openapi(path = "/docs") {
+    const paths = {};
+    for (const route of this.rawRoutes) {
+      paths[route.path] ??= {};
+      paths[route.path][route.method.toLowerCase()] = {
+        summary: "",
+        responses: { 200: { description: "OK" } }
+      };
+    }
+    this.openapiData = {
+      openapi: "3.1.0",
+      info: { title: "PrinceJS API", version: "1.0.0" },
+      paths
     };
+    this.get(path, () => this.openapiData);
+    return this;
   }
   get(path, handler) {
     return this.add("GET", path, handler);
@@ -256,245 +118,161 @@ class Prince {
   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("/"))
+    if (path !== "/" && path.endsWith("/"))
       path = path.slice(0, -1);
     const parts = path === "/" ? [""] : path.split("/").slice(1);
-    this.rawRoutes.push({ method: method.toUpperCase(), path, parts, handler });
+    this.rawRoutes.push({ method, path, parts, handler });
+    this.router = null;
     return this;
   }
-  fastPathname(req) {
-    const u = req.url;
-    const protoSep = u.indexOf("://");
-    const start = protoSep !== -1 ? u.indexOf("/", protoSep + 3) : u.indexOf("/");
-    if (start === -1)
-      return "/";
-    const q = u.indexOf("?", start);
-    const h = u.indexOf("#", start);
-    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 {};
+  parseUrl(req) {
+    const url = new URL(req.url);
     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;
+    for (const [k, v] of url.searchParams.entries())
+      query[k] = v;
+    return { pathname: url.pathname, query };
   }
   async parseBody(req) {
     const ct = req.headers.get("content-type") || "";
-    if (ct.includes("application/json")) {
+    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 || "");
+    if (ct.includes("application/x-www-form-urlencoded"))
+      return Object.fromEntries(new URLSearchParams(await req.text()).entries());
+    if (ct.startsWith("multipart/form-data")) {
+      const fd = await req.formData();
+      const files = {};
+      const fields = {};
+      for (const [k, v] of fd.entries()) {
+        if (v instanceof File)
+          files[k] = v;
+        else
+          fields[k] = v;
       }
-      return params;
+      return { files, fields };
     }
-    if (ct.includes("text/")) {
+    if (ct.startsWith("text/"))
       return await req.text();
-    }
     return null;
   }
   buildRouter() {
+    if (this.router)
+      return this.router;
     const root = new TrieNode;
-    for (const route of this.rawRoutes) {
+    for (const r 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;
+      if (r.parts.length === 1 && r.parts[0] === "") {
+        node.handlers ??= {};
+        node.handlers[r.method] = r.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(":")) {
+      for (const part of r.parts) {
+        if (part.startsWith(":")) {
           const name = part.slice(1);
-          if (!node.paramChild)
-            node.paramChild = { name, node: new TrieNode };
+          node.paramChild ??= { name, node: new TrieNode };
           node = node.paramChild.node;
         } else {
-          if (!node.children[part])
-            node.children[part] = new TrieNode;
+          node.children[part] ??= new TrieNode;
           node = node.children[part];
         }
       }
-      if (!node.handlers)
-        node.handlers = Object.create(null);
-      node.handlers[route.method] = route.handler;
+      node.handlers ??= {};
+      node.handlers[r.method] = r.handler;
     }
+    this.router = root;
     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);
+  compilePipeline(handler) {
+    return async (req, params, query) => {
+      Object.defineProperty(req, "params", { value: params, writable: true, configurable: true });
+      Object.defineProperty(req, "query", { value: query, writable: true, configurable: true });
+      let i = 0;
+      const next = async () => {
+        if (i < this.middlewares.length) {
+          return await this.middlewares[i++](req, next) ?? new Response("");
+        }
+        if (["POST", "PUT", "PATCH"].includes(req.method)) {
+          const parsed = await this.parseBody(req);
+          if (parsed && typeof parsed === "object" && "files" in parsed && "fields" in parsed) {
+            Object.defineProperty(req, "body", { value: parsed.fields, writable: true, configurable: true });
+            Object.defineProperty(req, "files", { value: parsed.files, writable: true, configurable: true });
+          } else {
+            Object.defineProperty(req, "body", { value: parsed, writable: true, configurable: true });
+          }
         }
-        const res = await handler(princeReq);
+        const res = await handler(req);
         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 new Response(res);
+        if (res instanceof Uint8Array)
+          return new Response(res);
         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 });
+      return next();
     };
   }
+  async handleFetch(req) {
+    const { pathname, query } = this.parseUrl(req);
+    const r = req;
+    const segments = pathname === "/" ? [] : pathname.slice(1).split("/");
+    const router = this.buildRouter();
+    let node = router;
+    let params = {};
+    for (const seg of segments) {
+      if (node.children[seg]) {
+        node = node.children[seg];
+      } else if (node.paramChild) {
+        params[node.paramChild.name] = seg;
+        node = node.paramChild.node;
+      } else {
+        return this.json({ error: "Not Found" }, 404);
+      }
+    }
+    const handler = node.handlers?.[req.method];
+    if (!handler)
+      return this.json({ error: "Method Not Allowed" }, 405);
+    const pipeline = this.compilePipeline(handler);
+    return pipeline(r, params, query);
+  }
   listen(port = 3000) {
-    const root = this.buildRouter();
-    const handlerMap = new Map;
+    const self = this;
     Bun.serve({
       port,
-      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 = {};
-          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 {}
+      fetch(req, server) {
+        const { pathname } = new URL(req.url);
+        const ws = self.wsRoutes[pathname];
+        if (ws && server.upgrade(req, { data: { ws } })) {
+          return;
+        }
+        return self.handleFetch(req).catch((err) => {
+          if (self.errorHandler)
+            return self.errorHandler(err, req);
+          if (self.devMode) {
+            console.error("Error:", err);
+            return self.json({ error: String(err), stack: err.stack }, 500);
           }
-          return this.json({ error: String(err) }, 500);
+          return self.json({ error: "Internal Server Error" }, 500);
+        });
+      },
+      websocket: {
+        open(ws) {
+          ws.data.ws?.open?.(ws);
+        },
+        message(ws, msg) {
+          ws.data.ws?.message?.(ws, msg);
+        },
+        close(ws, code, reason) {
+          ws.data.ws?.close?.(ws, code, reason);
+        },
+        drain(ws) {
+          ws.data.ws?.drain?.(ws);
         }
       }
     });
-    console.log(`\uD83D\uDE80 PrinceJS running at http://localhost:${port}`);
+    console.log(`\uD83D\uDE80 PrinceJS running on http://localhost:${port}`);
   }
 }
 var prince = (dev = false) => new Prince(dev);

package/package.json

@@ -1,11 +1,12 @@
 {
   "name": "princejs",
-  "version": "1.5.0",
+  "version": "1.5.2",
   "description": "An easy and fast backend framework — by a 13yo developer, for developers.",
   "main": "dist/prince.js",
   "types": "dist/prince.d.ts",
+  "type": "module",
   "bin": {
-    "create-princejs": "bin/create.ts"
+    "create-princejs": "./dist/create.js"
   },
   "exports": {
     ".": {
@@ -22,7 +23,9 @@
     }
   },
   "files": [
-    "dist"
+    "dist",
+    "README.md",
+    "LICENSE"
   ],
   "keywords": [
     "backend",
@@ -33,21 +36,37 @@
     "princejs",
     "rest",
     "server",
-    "typescript"
+    "typescript",
+    "websocket",
+    "middleware"
   ],
   "author": "Matthew Michael (MatthewTheCoder1218)",
   "license": "MIT",
-  "repository": "https://github.com/MatthewTheCoder1218/princejs",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/MatthewTheCoder1218/princejs"
+  },
+  "bugs": {
+    "url": "https://github.com/MatthewTheCoder1218/princejs/issues"
+  },
+  "homepage": "https://princejs.vercel.app",
   "publishConfig": {
     "access": "public"
   },
   "devDependencies": {
     "@types/bun": "^1.3.2",
     "bun-types": "latest",
-    "typescript": "^5.9.3",
-    "zod": "^4.1.12"
+    "typescript": "^5.9.3"
+  },
+  "peerDependencies": {
+    "zod": "^3.0.0"
+  },
+  "peerDependenciesMeta": {
+    "zod": {
+      "optional": true
+    }
   },
   "scripts": {
-    "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"
+    "build": "bun build src/prince.ts --outdir dist --target bun && bun build src/middleware.ts --outdir dist --target bun && bun build src/validation.ts --outdir dist --target bun && bun build bin/create.ts --outdir dist --target bun --format esm"
   }
 }

package/bin/create.ts

@@ -1,16 +0,0 @@
-#!/usr/bin/env bun
-import { mkdirSync, writeFileSync } from "fs";
-
-const name = Bun.argv[2] || "prince-app";
-mkdirSync(name, { recursive: true });
-writeFileSync(`${name}/index.ts`, `
-import { prince } from "princejs";
-const app = prince();
-app.get("/", () => ({ message: "Hello from PrinceJS!" }));
-app.listen(3000);
-`);
-console.log("✅ Created", name);
-console.log("👉 To get started:");
-console.log(`   cd ${name}`);
-console.log("   bun install princejs");
-console.log("   bun run index.ts");