princejs 1.3.5 → 1.4.0

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/dist/prince.js

@@ -1,4 +1,129 @@
 // @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);
@@ -57,6 +182,21 @@ class Prince {
   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;

package/package.json

@@ -1,9 +1,23 @@
 {
   "name": "princejs",
-  "version": "1.3.5",
+  "version": "1.4.0",
   "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 ./src/middleware.ts ./src/validation.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"
   }
 }