princejs 1.4.2 → 1.5.0

package/Readme.md

@@ -9,8 +9,13 @@
 ## 🚀 Get Started
 
 ```bash
+# Create a new PrinceJS app
 bun create princejs my-app
+
+# Move into the project
 cd my-app
+
+# Run in development mode
 bun dev
 ```
 

package/bin/create.ts

@@ -0,0 +1,16 @@
+#!/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");

package/dist/index.js

@@ -40,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 });
   }
 }
 
@@ -54,6 +60,8 @@ class Prince {
   middlewares = [];
   errorHandler;
   prefix = "";
+  wsRoutes = {};
+  openapiData = null;
   constructor(devMode = false) {
     this.devMode = devMode;
   }
@@ -74,6 +82,27 @@ class Prince {
   response() {
     return new ResponseBuilder;
   }
+  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;
+  }
   route(path) {
     const group = new Prince(this.devMode);
     group.prefix = path;
@@ -86,18 +115,6 @@ class Prince {
       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;
       }
     };
   }
@@ -116,12 +133,6 @@ 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;
@@ -134,32 +145,31 @@ class Prince {
   parseUrl(req) {
     const url = new URL(req.url);
     const query = {};
-    for (const [key, value] of url.searchParams.entries()) {
+    for (const [key, value] of url.searchParams.entries())
       query[key] = value;
-    }
-    return {
-      pathname: url.pathname,
-      query
-    };
+    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.startsWith("multipart/form-data")) {
+      const form = await req.formData();
+      const files = {};
+      const fields = {};
+      for (const [k, v] of form.entries()) {
+        if (v instanceof File)
+          files[k] = v;
+        else
+          fields[k] = v;
+      }
+      return { files, fields };
     }
+    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;
+      return Object.fromEntries(new URLSearchParams(await req.text()).entries());
     }
-    if (ct.includes("text/")) {
+    if (ct.startsWith("text/"))
       return await req.text();
-    }
     return null;
   }
   buildRouter() {
@@ -173,166 +183,110 @@ class Prince {
         node.handlers[route.method] = route.handler;
         continue;
       }
-      for (let i = 0;i < parts.length; i++) {
-        const part = parts[i];
+      for (const part of parts) {
         if (part === "**") {
-          if (!node.catchAllChild) {
+          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];
+          node = node.children[part] ??= new TrieNode;
         }
       }
-      if (!node.handlers)
-        node.handlers = Object.create(null);
+      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) {
+  compilePipeline(handler) {
+    const mws = this.middlewares;
+    if (mws.length === 0)
       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);
+        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, { status: 200 });
-        if (res instanceof Uint8Array || res instanceof ArrayBuffer)
-          return new Response(res, { status: 200 });
+          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 r = req;
+      r.params = params;
+      r.query = query;
+      let i = 0;
+      const next = async () => {
+        if (i < mws.length)
+          return await mws[i++](req, next) ?? new Response(null);
+        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);
       };
-      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 segments = pathname === "/" ? [] : pathname.slice(1).split("/");
+    let node = this.buildRouter(), 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 await pipeline(req, params, query);
+  }
   listen(port = 3000) {
-    const root = this.buildRouter();
-    const handlerMap = new Map;
+    const self = this;
     Bun.serve({
       port,
-      fetch: async (req) => {
+      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 });
+        }
         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);
+          return self.handleFetch(req);
         } catch (err) {
-          if (this.errorHandler) {
-            try {
-              return this.errorHandler(err, req);
-            } catch {}
-          }
-          return this.json({ error: String(err) }, 500);
+          if (self.errorHandler)
+            return self.errorHandler(err, req);
+          return self.json({ error: String(err) }, 500);
+        }
+      },
+      websocket: {
+        open(ws) {
+          ws.data.route?.open?.(ws);
+        },
+        message(ws, msg) {
+          ws.data.route?.message?.(ws, msg);
+        },
+        close(ws) {
+          ws.data.route?.close?.(ws);
         }
       }
     });

package/package.json

@@ -1,9 +1,12 @@
 {
   "name": "princejs",
-  "version": "1.4.2",
+  "version": "1.5.0",
   "description": "An easy and fast backend framework — by a 13yo developer, for developers.",
   "main": "dist/prince.js",
   "types": "dist/prince.d.ts",
+  "bin": {
+    "create-princejs": "bin/create.ts"
+  },
   "exports": {
     ".": {
       "import": "./dist/prince.js",