princejs 1.5.0 → 1.5.4

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,162 @@ 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 });
+      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 });
+        }
+      }
+      let i = 0;
+      const next = async () => {
+        if (i < this.middlewares.length) {
+          const result = await this.middlewares[i++](req, next);
+          return result ?? new Response("");
         }
-        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/dist/validation.js

@@ -6,7 +6,11 @@ var validate = (schema, source = "body") => {
       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();
+      if (next) {
+        const result = await next();
+        return result;
+      }
+      return;
     } catch (err) {
       return new Response(JSON.stringify({
         error: "Validation failed",