azurajs 1.0.4 → 2.1.0

package/README.md

@@ -31,12 +31,43 @@ or with Bun:
 bun add azurajs
 ```
 
+## Modular Imports
+
+AzuraJS supports modular imports for tree-shaking and better organization:
+
+```typescript
+// Main package
+import { AzuraClient, applyDecorators } from "azurajs";
+
+// Decorators
+import { Controller, Get, Post, Body, Param } from "azurajs/decorators";
+
+// Middleware
+import { createLoggingMiddleware } from "azurajs/middleware";
+
+// Plugins
+import { cors } from "azurajs/cors";
+import { rateLimit } from "azurajs/rate-limit";
+
+// Utilities
+import { logger } from "azurajs/logger";
+import { HttpError } from "azurajs/http-error";
+import { validateDto } from "azurajs/validators";
+import { parseCookiesHeader } from "azurajs/cookies";
+
+// Config
+import type { ConfigTypes } from "azurajs/config";
+
+// Router
+import { Router } from "azurajs/router";
+```
+
 ## Quick Start
 
 ### 1. Create `azura.config.ts`
 
 ```typescript
-import type { ConfigTypes } from "azurajs";
+import type { ConfigTypes } from "azurajs/config";
 
 const config: ConfigTypes = {
   environment: "development",
@@ -69,19 +100,10 @@ export default config;
 ### 2. Create your server
 
 ```typescript
-import { 
-  AzuraClient, 
-  Controller, 
-  Get, 
-  Post, 
-  Body, 
-  Param, 
-  Query, 
-  Res,
-  applyDecorators,
-  createLoggingMiddleware 
-} from "azurajs";
-import type { ResponseServer } from "azurajs";
+import { AzuraClient, applyDecorators } from "azurajs";
+import { Controller, Get, Post, Body, Param, Query, Res } from "azurajs/decorators";
+import { createLoggingMiddleware } from "azurajs/middleware";
+import type { ResponseServer } from "azurajs/types";
 
 @Controller("/api")
 class UserController {
@@ -122,6 +144,77 @@ await app.listen();
 bun run index.ts
 ```
 
+## Alternative: Use with Custom Servers
+
+AzuraJS can be used with **any server** that supports the Web Fetch API, just like Hono! This includes Bun, Deno, Cloudflare Workers, and more.
+
+### Using with Bun.serve
+
+```typescript
+import { AzuraClient } from "azurajs";
+
+const app = new AzuraClient();
+
+app.get("/", (req, res) => {
+  res.json({ message: "Hello from Bun!" });
+});
+
+// Use with Bun's native server
+const server = Bun.serve({
+  port: 3000,
+  fetch: app.fetch.bind(app),
+});
+
+console.log(`Server running on http://localhost:${server.port}`);
+```
+
+### Using with Deno
+
+```typescript
+import { AzuraClient } from "azurajs";
+
+const app = new AzuraClient();
+
+app.get("/", (req, res) => {
+  res.json({ message: "Hello from Deno!" });
+});
+
+// Use with Deno.serve
+Deno.serve({ port: 3000 }, app.fetch.bind(app));
+```
+
+### Using with Cloudflare Workers
+
+```typescript
+import { AzuraClient } from "azurajs";
+
+const app = new AzuraClient();
+
+app.get("/", (req, res) => {
+  res.json({ message: "Hello from Cloudflare!" });
+});
+
+// Export for Cloudflare Workers
+export default {
+  fetch: app.fetch.bind(app),
+};
+```
+
+### Using with Node.js HTTP
+
+```typescript
+import { AzuraClient } from "azurajs";
+
+const app = new AzuraClient();
+
+app.get("/", (req, res) => {
+  res.json({ message: "Hello from Node.js!" });
+});
+
+// Built-in Node.js HTTP server
+await app.listen(3000);
+```
+
 ## API Reference
 
 ### Decorators
@@ -247,7 +340,7 @@ res.location(url: string)
 ### Middleware
 
 ```typescript
-import { createLoggingMiddleware } from "azurajs";
+import { createLoggingMiddleware } from "azurajs/middleware";
 
 const app = new AzuraClient();
 
@@ -314,8 +407,9 @@ type ConfigTypes = {
 ### Complete CRUD API
 
 ```typescript
-import { AzuraClient, Controller, Get, Post, Put, Delete, Body, Param, Res, applyDecorators } from "azurajs";
-import type { ResponseServer } from "azurajs";
+import { AzuraClient, applyDecorators } from "azurajs";
+import { Controller, Get, Post, Put, Delete, Body, Param, Res } from "azurajs/decorators";
+import type { ResponseServer } from "azurajs/types";
 
 interface User {
   id: number;
@@ -461,12 +555,9 @@ AzuraJS is designed for high performance:
 Full TypeScript support with complete type definitions:
 
 ```typescript
-import type { 
-  RequestServer, 
-  ResponseServer, 
-  ConfigTypes, 
-  RequestHandler 
-} from "azurajs";
+import type { RequestServer, ResponseServer } from "azurajs/types";
+import type { ConfigTypes } from "azurajs/config";
+import type { RequestHandler } from "azurajs/types";
 ```
 
 > ⚠️ Azura is TypeScript-only.
@@ -491,7 +582,7 @@ MIT License - see LICENSE file for details
 
 - [GitHub Repository](https://github.com/0xviny/azurajs)
 - [NPM Package](https://www.npmjs.com/package/azurajs)
-- [Documentation](https://azurajs.dev)
+- [Documentation](https://azura.js.org/docs/en)
 - [Examples](https://github.com/0xviny/azurajs/tree/main/examples)
 
 ## Support

package/package.json

@@ -1,16 +1,136 @@
 {
   "name": "azurajs",
-  "version": "1.0.4",
+  "version": "2.1.0",
   "description": "Modern TypeScript-first web framework with decorator-based routing, zero dependencies, and built for performance",
-  "main": "src/index.ts",
-  "module": "src/index.ts",
-  "types": "src/index.ts",
+  "main": "./src/index.ts",
+  "module": "./src/index.ts",
+  "types": "./src/index.ts",
   "type": "module",
   "exports": {
     ".": {
+      "types": "./src/index.ts",
       "import": "./src/index.ts",
-      "require": "./src/index.ts",
-      "types": "./src/index.ts"
+      "default": "./src/index.ts"
+    },
+    "./decorators": {
+      "types": "./src/decorators/index.ts",
+      "import": "./src/decorators/index.ts",
+      "default": "./src/decorators/index.ts"
+    },
+    "./middleware": {
+      "types": "./src/middleware/index.ts",
+      "import": "./src/middleware/index.ts",
+      "default": "./src/middleware/index.ts"
+    },
+    "./types": {
+      "types": "./src/types/index.ts",
+      "import": "./src/types/index.ts",
+      "default": "./src/types/index.ts"
+    },
+    "./infra": {
+      "types": "./src/infra/index.ts",
+      "import": "./src/infra/index.ts",
+      "default": "./src/infra/index.ts"
+    },
+    "./router": {
+      "types": "./src/infra/Router.ts",
+      "import": "./src/infra/Router.ts",
+      "default": "./src/infra/Router.ts"
+    },
+    "./config": {
+      "types": "./src/shared/config/index.ts",
+      "import": "./src/shared/config/index.ts",
+      "default": "./src/shared/config/index.ts"
+    },
+    "./plugins": {
+      "types": "./src/shared/plugins/index.ts",
+      "import": "./src/shared/plugins/index.ts",
+      "default": "./src/shared/plugins/index.ts"
+    },
+    "./cors": {
+      "types": "./src/shared/plugins/CORSPlugin.ts",
+      "import": "./src/shared/plugins/CORSPlugin.ts",
+      "default": "./src/shared/plugins/CORSPlugin.ts"
+    },
+    "./rate-limit": {
+      "types": "./src/shared/plugins/RateLimitPlugin.ts",
+      "import": "./src/shared/plugins/RateLimitPlugin.ts",
+      "default": "./src/shared/plugins/RateLimitPlugin.ts"
+    },
+    "./utils": {
+      "types": "./src/utils/index.ts",
+      "import": "./src/utils/index.ts",
+      "default": "./src/utils/index.ts"
+    },
+    "./cookies": {
+      "types": "./src/utils/cookies/index.ts",
+      "import": "./src/utils/cookies/index.ts",
+      "default": "./src/utils/cookies/index.ts"
+    },
+    "./validators": {
+      "types": "./src/utils/validators/index.ts",
+      "import": "./src/utils/validators/index.ts",
+      "default": "./src/utils/validators/index.ts"
+    },
+    "./logger": {
+      "types": "./src/utils/Logger.ts",
+      "import": "./src/utils/Logger.ts",
+      "default": "./src/utils/Logger.ts"
+    },
+    "./http-error": {
+      "types": "./src/infra/utils/HttpError.ts",
+      "import": "./src/infra/utils/HttpError.ts",
+      "default": "./src/infra/utils/HttpError.ts"
+    },
+    "./package.json": "./package.json"
+  },
+  "typesVersions": {
+    "*": {
+      "*": [
+        "./src/*"
+      ],
+      "decorators": [
+        "./src/decorators/index.ts"
+      ],
+      "middleware": [
+        "./src/middleware/index.ts"
+      ],
+      "types": [
+        "./src/types/index.ts"
+      ],
+      "infra": [
+        "./src/infra/index.ts"
+      ],
+      "router": [
+        "./src/infra/Router.ts"
+      ],
+      "config": [
+        "./src/shared/config/index.ts"
+      ],
+      "plugins": [
+        "./src/shared/plugins/index.ts"
+      ],
+      "cors": [
+        "./src/shared/plugins/CORSPlugin.ts"
+      ],
+      "rate-limit": [
+        "./src/shared/plugins/RateLimitPlugin.ts"
+      ],
+      "utils": [
+        "./src/utils/index.ts"
+      ],
+      "cookies": [
+        "./src/utils/cookies/index.ts"
+      ],
+      "validators": [
+        "./src/utils/validators/index.ts"
+      ],
+      "logger": [
+        "./src/utils/Logger.ts"
+      ],
+      "http-error": [
+        "./src/infra/utils/HttpError.ts"
+      ]
     }
   },
   "files": [

package/src/infra/Router.ts

@@ -34,23 +34,31 @@ export class Router {
   find(method: string, path: string): MatchResult {
     const segments = path.split("/").filter(Boolean);
     let node = this.root;
-
     const params: Record<string, string> = {};
-    for (const seg of segments) {
-      if (node.children.has(seg)) {
-        node = node.children.get(seg)!;
-      } else if (node.children.has(":")) {
-        node = node.children.get(":")!;
-
-        if (node.isParam && node.paramName) {
-          params[node.paramName] = seg;
-        }
+    
+    for (let i = 0; i < segments.length; i++) {
+      const seg = segments[i];
+      let child = node.children.get(seg);
+      
+      if (child) {
+        node = child;
       } else {
-        throw new HttpError(404, "Route not found");
+        child = node.children.get(":");
+        if (child) {
+          node = child;
+          if (node.paramName) {
+            params[node.paramName] = seg;
+          }
+        } else {
+          throw new HttpError(404, "Route not found");
+        }
       }
     }
 
     const handlers = node.handlers.get(method.toUpperCase()) as Handler[];
+    if (!handlers) {
+      throw new HttpError(404, "Route not found");
+    }
     return { handlers, params };
   }
 }

package/src/infra/Server.ts

@@ -114,6 +114,213 @@ export class AzuraClient {
       logger("info", `[${who}] listening on http://localhost:${port}`);
       if (this.opts.server?.ipHost) getIP(port);
     });
+
+    return this.server;
+  }
+
+  /**
+   * Fetch handler compatible with Web API (Bun, Deno, Cloudflare Workers, etc.)
+   * @example
+   * ```typescript
+   * const app = new AzuraClient();
+   * app.get('/', (req, res) => res.text('Hello World!'));
+   * 
+   * // Use with Bun
+   * Bun.serve({
+   *   port: 3000,
+   *   fetch: app.fetch.bind(app),
+   * });
+   * 
+   * // Use with Deno
+   * Deno.serve({ port: 3000 }, app.fetch.bind(app));
+   * ```
+   */
+  public async fetch(request: Request): Promise<Response> {
+    await this.initPromise;
+
+    const url = new URL(request.url);
+    const urlPath = url.pathname;
+    
+    const safeQuery: Record<string, string> = {};
+    if (url.search) {
+      const rawQuery = parseQS(url.search.slice(1));
+      for (const k in rawQuery) {
+        const v = rawQuery[k];
+        safeQuery[k] = Array.isArray(v) ? v[0] || "" : v as string;
+      }
+    }
+
+    const cookieHeader = request.headers.get("cookie") || "";
+    const cookies = parseCookiesHeader(cookieHeader);
+
+    let body: any = {};
+    if (["POST", "PUT", "PATCH"].includes(request.method.toUpperCase())) {
+      const contentType = request.headers.get("content-type") || "";
+      try {
+        if (contentType.includes("application/json")) {
+          body = await request.json();
+        } else if (contentType.includes("application/x-www-form-urlencoded")) {
+          const text = await request.text();
+          const parsed = parseQS(text || "");
+          const b: Record<string, string> = {};
+          for (const k in parsed) {
+            const v = parsed[k];
+            b[k] = Array.isArray(v) ? v[0] || "" : (v as string) || "";
+          }
+          body = b;
+        } else {
+          body = await request.text();
+        }
+      } catch {
+        body = {};
+      }
+    }
+
+    const protocol = url.protocol.slice(0, -1) as "http" | "https";
+    
+    const headersObj: Record<string, string | string[]> = {};
+    request.headers.forEach((value, key) => {
+      headersObj[key] = value;
+    });
+    
+    const rawReq: Partial<RequestServer> = {
+      method: request.method,
+      url: url.pathname + url.search,
+      originalUrl: url.pathname + url.search,
+      path: urlPath || "/",
+      protocol,
+      secure: url.protocol === "https:",
+      hostname: url.hostname,
+      subdomains: url.hostname ? url.hostname.split(".").slice(0, -2) : [],
+      query: safeQuery,
+      cookies,
+      params: {},
+      body,
+      headers: headersObj as any,
+      get: (name: string) => request.headers.get(name.toLowerCase()) || undefined,
+      header: (name: string) => request.headers.get(name.toLowerCase()) || undefined,
+      ip: request.headers.get("x-forwarded-for")?.split(",")[0]?.trim() || "",
+      ips: request.headers.get("x-forwarded-for")?.split(/\s*,\s*/) || [],
+    };
+
+    let statusCode = 200;
+    const responseHeaders = new Headers();
+    let responseBody: any = null;
+
+    const rawRes: Partial<ResponseServer> = {
+      statusCode,
+      status: (code: number) => {
+        statusCode = code;
+        return rawRes as ResponseServer;
+      },
+      set: (field: string, value: string | number | string[]) => {
+        responseHeaders.set(field, String(value));
+        return rawRes as ResponseServer;
+      },
+      header: (field: string, value: string | number | string[]) => {
+        responseHeaders.set(field, String(value));
+        return rawRes as ResponseServer;
+      },
+      get: (field: string) => responseHeaders.get(field) || undefined,
+      type: (t: string) => {
+        responseHeaders.set("Content-Type", t);
+        return rawRes as ResponseServer;
+      },
+      contentType: (t: string) => {
+        responseHeaders.set("Content-Type", t);
+        return rawRes as ResponseServer;
+      },
+      location: (u: string) => {
+        responseHeaders.set("Location", u);
+        return rawRes as ResponseServer;
+      },
+      redirect: ((a: number | string, b?: string) => {
+        if (typeof a === "number") {
+          statusCode = a;
+          responseHeaders.set("Location", b!);
+        } else {
+          statusCode = 302;
+          responseHeaders.set("Location", a);
+        }
+        return rawRes as ResponseServer;
+      }) as ResponseServer["redirect"],
+      cookie: (name: string, val: string, opts: CookieOptions = {}) => {
+        const s = serializeCookie(name, val, opts);
+        const prev = responseHeaders.get("Set-Cookie");
+        if (prev) {
+          responseHeaders.append("Set-Cookie", s);
+        } else {
+          responseHeaders.set("Set-Cookie", s);
+        }
+        return rawRes as ResponseServer;
+      },
+      clearCookie: (name: string, opts: CookieOptions = {}) => {
+        return rawRes.cookie!(name, "", { ...opts, expires: new Date(1), maxAge: 0 });
+      },
+      send: (b: any) => {
+        if (b === undefined || b === null) {
+          responseBody = "";
+        } else if (typeof b === "object") {
+          responseHeaders.set("Content-Type", "application/json");
+          responseBody = JSON.stringify(b);
+        } else {
+          responseBody = String(b);
+        }
+        return rawRes as ResponseServer;
+      },
+      json: (b: any) => {
+        responseHeaders.set("Content-Type", "application/json");
+        responseBody = JSON.stringify(b);
+        return rawRes as ResponseServer;
+      },
+    };
+
+    const errorHandler = (err: any) => {
+      statusCode = err instanceof HttpError ? err.status : 500;
+      responseHeaders.set("Content-Type", "application/json");
+      responseBody = JSON.stringify(
+        err instanceof HttpError
+          ? err.payload ?? { error: err.message || "Internal Server Error" }
+          : { error: err?.message || "Internal Server Error" }
+      );
+    };
+
+    try {
+      const { handlers, params } = this.router.find(request.method, urlPath || "/");
+      rawReq.params = params || {};
+      
+      const chain = [
+        ...this.middlewares.map(adaptRequestHandler),
+        ...handlers.map(adaptRequestHandler),
+      ];
+      
+      let idx = 0;
+      const next = async (err?: any) => {
+        if (err) return errorHandler(err);
+        if (idx >= chain.length) return;
+        const fn = chain[idx++];
+        try {
+          await fn({
+            request: rawReq as RequestServer,
+            response: rawRes as ResponseServer,
+            req: rawReq as RequestServer,
+            res: rawRes as ResponseServer,
+            next,
+          });
+        } catch (e) {
+          return errorHandler(e);
+        }
+      };
+      
+      await next();
+    } catch (err) {
+      errorHandler(err);
+    }
+
+    return new Response(responseBody, {
+      status: statusCode,
+      headers: responseHeaders,
+    });
   }
 
   private async handle(rawReq: RequestServer, rawRes: ResponseServer) {

package/src/infra/index.ts

@@ -0,0 +1,3 @@
+export { Server } from "./Server";
+export { Router } from "./Router";
+export { HttpError } from "./utils/HttpError";

package/src/shared/config/index.ts

@@ -0,0 +1,2 @@
+export { ConfigModule } from "./ConfigModule";
+export type { ConfigTypes } from "./ConfigModule";

package/src/shared/plugins/index.ts

@@ -0,0 +1,2 @@
+export { cors } from "./CORSPlugin";
+export { rateLimit } from "./RateLimitPlugin";

package/src/types/index.ts

@@ -0,0 +1,5 @@
+export type { RequestServer } from "./http/request.type";
+export type { ResponseServer } from "./http/response.type";
+export type { RequestHandler, HttpContext } from "./common.type";
+export type { RouteDefinition, ParamDefinition, ParamSource } from "./routes.type";
+export type { Schema as ValidationSchema } from "./validations.type";

package/src/utils/Parser.ts

@@ -1,16 +1,28 @@
 export function parseQS(qs: string): Record<string, string | string[]> {
   const out: Record<string, string | string[]> = {};
   if (!qs) return out;
-  const parts = qs.replace(/^\?/, "").split("&");
-  for (const p of parts) {
+  
+  const parts = qs.split("&");
+  for (let i = 0; i < parts.length; i++) {
+    const p = parts[i];
     if (!p) continue;
+    
     const idx = p.indexOf("=");
-    const k = idx === -1 ? decodeURIComponent(p) : decodeURIComponent(p.slice(0, idx));
-    const v = idx === -1 ? "" : decodeURIComponent(p.slice(idx + 1));
-    if (Object.prototype.hasOwnProperty.call(out, k)) {
-      const cur = out[k];
-      if (Array.isArray(cur)) cur.push(v);
-      else out[k] = [cur as string, v];
+    if (idx === -1) {
+      out[decodeURIComponent(p)] = "";
+      continue;
+    }
+    
+    const k = decodeURIComponent(p.slice(0, idx));
+    const v = decodeURIComponent(p.slice(idx + 1));
+    
+    const existing = out[k];
+    if (existing !== undefined) {
+      if (Array.isArray(existing)) {
+        existing.push(v);
+      } else {
+        out[k] = [existing as string, v];
+      }
     } else {
       out[k] = v;
     }

package/src/utils/cookies/index.ts

@@ -0,0 +1,2 @@
+export { parseCookiesHeader } from "./ParserCookie";
+export { serializeCookie } from "./SerializeCookie";

package/src/utils/index.ts

@@ -0,0 +1,4 @@
+export { logger } from "./Logger";
+export { parseQS } from "./Parser";
+export * from "./cookies";
+export * from "./validators";

package/src/utils/validators/index.ts

@@ -0,0 +1,2 @@
+export { validateDto, getDtoValidators } from "./DTOValidator";
+export { validateSchema } from "./SchemaValidator";