azurajs 1.0.0

package/package.json

@@ -0,0 +1,62 @@
+{
+  "name": "azurajs",
+  "version": "1.0.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",
+  "type": "module",
+  "exports": {
+    ".": {
+      "import": "./src/index.ts",
+      "require": "./src/index.ts",
+      "types": "./src/index.ts"
+    }
+  },
+  "files": [
+    "src",
+    "README.md",
+    "LICENSE"
+  ],
+  "scripts": {
+    "prepublishOnly": "echo '✅ Ready to publish'",
+    "test": "bun test"
+  },
+  "keywords": [
+    "typescript",
+    "framework",
+    "web",
+    "api",
+    "rest",
+    "decorators",
+    "router",
+    "http",
+    "server",
+    "backend",
+    "bun",
+    "node",
+    "zero-dependency",
+    "lightweight",
+    "fast"
+  ],
+  "author": "0xviny.dev@gmail.com",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/0xviny/azurajs.git"
+  },
+  "bugs": {
+    "url": "https://github.com/0xviny/azurajs/issues"
+  },
+  "homepage": "https://github.com/0xviny/azurajs#readme",
+  "engines": {
+    "node": ">=18.0.0",
+    "bun": ">=1.0.0"
+  },
+  "devDependencies": {
+    "@types/bun": "latest"
+  },
+  "peerDependencies": {
+    "typescript": "^5.0.0"
+  }
+}

package/src/decorators/Route.ts

@@ -0,0 +1,141 @@
+import type { AzuraClient } from "../infra/Server";
+import type { RequestServer } from "../types/http/request.type";
+import type { ResponseServer } from "../types/http/response.type";
+import type { ParamDefinition, ParamSource, RouteDefinition } from "../types/routes.type";
+
+const PREFIX = new WeakMap<Function, string>();
+const ROUTES = new WeakMap<Function, RouteDefinition[]>();
+const PARAMS = new WeakMap<Function, Map<string, ParamDefinition[]>>();
+
+export function Controller(prefix = ""): ClassDecorator {
+  return (target) => {
+    PREFIX.set(target as Function, prefix);
+  };
+}
+
+function createMethodDecorator(method: string) {
+  return function (path = ""): MethodDecorator {
+    return (target, propertyKey) => {
+      const ctor =
+        typeof target === "function" ? (target as Function) : (target as any).constructor;
+      const key = String(propertyKey);
+      const routes = ROUTES.get(ctor) ?? [];
+      const params = PARAMS.get(ctor)?.get(key) ?? [];
+
+      const exists = routes.some(
+        (r) => r.method === method && r.path === path && r.propertyKey === key
+      );
+      if (!exists) {
+        routes.push({
+          method,
+          path,
+          propertyKey: key,
+          params,
+        });
+        ROUTES.set(ctor, routes);
+      }
+    };
+  };
+}
+
+function createParamDecorator(type: ParamSource) {
+  return function (name?: string): ParameterDecorator {
+    return (target, propertyKey, parameterIndex) => {
+      const ctor =
+        typeof target === "function" ? (target as Function) : (target as any).constructor;
+      let map = PARAMS.get(ctor);
+      if (!map) {
+        map = new Map<string, ParamDefinition[]>();
+        PARAMS.set(ctor, map);
+      }
+
+      const key = String(propertyKey);
+      const list = map.get(key) ?? [];
+      const exists = list.some(
+        (p) => p.index === parameterIndex && p.type === type && p.name === name
+      );
+      if (!exists) {
+        list.push({
+          index: parameterIndex,
+          type,
+          name,
+        });
+        map.set(key, list);
+      }
+    };
+  };
+}
+
+export const Get = createMethodDecorator("GET");
+export const Post = createMethodDecorator("POST");
+export const Put = createMethodDecorator("PUT");
+export const Delete = createMethodDecorator("DELETE");
+export const Patch = createMethodDecorator("PATCH");
+export const Head = createMethodDecorator("HEAD");
+export const Options = createMethodDecorator("OPTIONS");
+
+export const Req = createParamDecorator("req");
+export const Res = createParamDecorator("res");
+export const Next = createParamDecorator("next");
+export const Param = createParamDecorator("param");
+export const Query = createParamDecorator("query");
+export const Body = createParamDecorator("body");
+export const Headers = createParamDecorator("headers");
+export const Ip = createParamDecorator("ip");
+export const UserAgent = createParamDecorator("useragent");
+
+export function applyDecorators(app: AzuraClient, controllers: Array<new () => any>) {
+  controllers.forEach((ControllerClass) => {
+    const prefix = PREFIX.get(ControllerClass) ?? "";
+    const instance = new ControllerClass();
+    const routes = ROUTES.get(ControllerClass) ?? [];
+
+    routes.forEach((r) => {
+      const handler = async (
+        req: RequestServer,
+        res: ResponseServer,
+        next: (err?: unknown) => void
+      ) => {
+        try {
+          const params = (r.params ?? []).slice().sort((a, b) => a.index - b.index);
+          const args = params.map((p) => {
+            switch (p.type) {
+              case "req":
+                return req;
+              case "res":
+                return res;
+              case "next":
+                return next;
+              case "param":
+                return p.name ? req.params[p.name] : req.params;
+              case "query":
+                return p.name ? req.query[p.name] : req.query;
+              case "body": {
+                const body = req.body as Record<string, unknown> | undefined;
+                return p.name ? body?.[p.name] : body;
+              }
+              case "headers":
+                return p.name ? req.headers[p.name.toLowerCase()] : req.headers;
+              case "ip":
+                return req.ip;
+              case "useragent":
+                return req.headers["user-agent"];
+              default:
+                return undefined;
+            }
+          });
+
+          const fn = (instance as Record<string, unknown>)[r.propertyKey] as (
+            ...args: unknown[]
+          ) => unknown;
+          const result = fn(...args);
+          if (result instanceof Promise) await result;
+        } catch (err) {
+          next(err);
+        }
+      };
+
+      app.addRoute(r.method, prefix + r.path, handler);
+    });
+  });
+}

package/src/decorators/index.ts

@@ -0,0 +1,24 @@
+export {
+  Controller,
+  Get,
+  Post,
+  Put,
+  Delete,
+  Patch,
+  Head,
+  Options,
+  Req,
+  Res,
+  Next,
+  Param,
+  Query,
+  Body,
+  Headers,
+  Ip,
+  UserAgent,
+  applyDecorators,
+} from "./Route";
+
+export type { RouteDefinition, ParamDefinition, ParamSource } from "../types/routes.type";
+export type { RequestServer } from "../types/http/request.type";
+export type { ResponseServer } from "../types/http/response.type";

package/src/index.ts

@@ -0,0 +1,28 @@
+// Core Server & Router
+export * from "./infra/Server";
+export { Router } from "./infra/Router";
+
+// Decorators
+export * from "./decorators";
+
+// Middleware
+export * from "./middleware";
+
+// Types
+export * from "./types/http/request.type";
+export * from "./types/http/response.type";
+export * from "./types/common.type";
+export * from "./types/routes.type";
+export * from "./types/validations.type";
+
+// Configuration
+export * from "./shared/config/ConfigModule";
+
+// Utils
+export { logger } from "./utils/Logger";
+export { parseQS } from "./utils/Parser";
+export { HttpError } from "./infra/utils/HttpError";
+export { parseCookiesHeader } from "./utils/cookies/ParserCookie";
+export { serializeCookie } from "./utils/cookies/SerializeCookie";
+export { validateSchema } from "./utils/validators/SchemaValidator";
+export { validateDto, getDtoValidators } from "./utils/validators/DTOValidator";

package/src/infra/Router.ts

@@ -0,0 +1,56 @@
+import { HttpError } from "./utils/HttpError";
+import { Node, type Handler } from "./utils/route/Node";
+
+interface MatchResult {
+  handlers: Handler[];
+  params: Record<string, string>;
+}
+
+export class Router {
+  private root = new Node();
+
+  add(method: string, path: string, ...handlers: Handler[]) {
+    const segments = path.split("/").filter(Boolean);
+    let node = this.root;
+
+    for (const seg of segments) {
+      let child: Node;
+
+      if (seg.startsWith(":")) {
+        child = new Node();
+        child.isParam = true;
+        child.paramName = seg.slice(1);
+      } else {
+        child = node.children.get(seg) ?? new Node();
+      }
+
+      node.children.set(seg.startsWith(":") ? ":" : seg, child);
+      node = child;
+    }
+
+    node.handlers.set(method.toUpperCase(), handlers);
+  }
+
+  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;
+        }
+      } else {
+        throw new HttpError(404, "Route not found");
+      }
+    }
+
+    const handlers = node.handlers.get(method.toUpperCase()) as Handler[];
+    return { handlers, params };
+  }
+}

package/src/infra/Server.ts

@@ -0,0 +1,274 @@
+import http from "node:http";
+import cluster from "node:cluster";
+import os from "node:os";
+
+import { ConfigModule } from "../shared/config/ConfigModule";
+import { getOpenPort } from "./utils/GetOpenPort";
+import type { RequestServer } from "../types/http/request.type";
+import type { CookieOptions, ResponseServer } from "../types/http/response.type";
+import { HttpError } from "./utils/HttpError";
+import { logger } from "../utils/Logger";
+import { parseQS } from "../utils/Parser";
+import { serializeCookie } from "../utils/cookies/SerializeCookie";
+import { parseCookiesHeader } from "../utils/cookies/ParserCookie";
+import { adaptRequestHandler } from "./utils/RequestHandler";
+import { Router } from "./Router";
+import type { RequestHandler } from "../types/common.type";
+import { getIP } from "./utils/GetIp";
+import type { Handler } from "./utils/route/Node";
+
+export { createLoggingMiddleware } from "../middleware/LoggingMiddleware";
+
+export class AzuraClient {
+  private opts: ReturnType<ConfigModule["getAll"]>;
+
+  private server?: http.Server;
+  private port: number = 3000;
+  private initPromise: Promise<void>;
+
+  public router = new Router();
+  private middlewares: RequestHandler[] = [];
+
+  constructor() {
+    const config = new ConfigModule();
+    try {
+      config.initSync();
+    } catch (error: any) {
+      console.error("[Azura] ❌ Falha ao carregar configuração:");
+      console.error("        ", error.message);
+      process.exit(1);
+    }
+    this.opts = config.getAll();
+    this.initPromise = this.init();
+  }
+
+  public getConfig() {
+    return this.opts;
+  }
+
+  private async init() {
+    this.port = await getOpenPort(this.opts.server?.port || 3000);
+    if (this.opts.server?.cluster && cluster.isPrimary) {
+      for (let i = 0; i < os.cpus().length; i++) cluster.fork();
+      cluster.on("exit", () => cluster.fork());
+      return;
+    }
+    this.server = http.createServer();
+    this.server.on("request", this.handle.bind(this));
+  }
+
+  public use(mw: RequestHandler) {
+    this.middlewares.push(mw);
+  }
+
+  public addRoute(method: string, path: string, ...handlers: RequestHandler[]) {
+    const adapted = handlers.map(adaptRequestHandler);
+    this.router.add(method, path, ...(adapted as unknown as Handler[]));
+  }
+
+  public get = (p: string, ...h: RequestHandler[]) => this.addRoute("GET", p, ...h);
+  public post = (p: string, ...h: RequestHandler[]) => this.addRoute("POST", p, ...h);
+  public put = (p: string, ...h: RequestHandler[]) => this.addRoute("PUT", p, ...h);
+  public delete = (p: string, ...h: RequestHandler[]) => this.addRoute("DELETE", p, ...h);
+  public patch = (p: string, ...h: RequestHandler[]) => this.addRoute("PATCH", p, ...h);
+
+  public async listen(port = this.port) {
+    await this.initPromise;
+
+    try {
+      if (!this.server) {
+        logger("error", "Server not initialized");
+        return;
+      }
+
+      const who = cluster.isPrimary ? "master" : "worker";
+      this.server.listen(port, () =>
+        logger("info", `[${who}] listening on http://localhost:${port}`)
+      );
+
+      if (this.opts.server?.ipHost) getIP(port);
+    } catch (error: Error | any) {
+      logger("error", "Server failed to start: " + error?.message || String(error));
+      process.exit(1);
+    }
+  }
+
+  private async handle(rawReq: RequestServer, rawRes: ResponseServer) {
+    rawReq.originalUrl = rawReq.url || "";
+    rawReq.protocol = this.opts.server?.https ? "https" : "http";
+    rawReq.secure = rawReq.protocol === "https";
+    rawReq.hostname = String(rawReq.headers["host"] || "").split(":")[0] || "";
+    rawReq.subdomains = rawReq.hostname ? rawReq.hostname.split(".").slice(0, -2) : [];
+    const ipsRaw = rawReq.headers["x-forwarded-for"];
+    rawReq.ips = typeof ipsRaw === "string" ? ipsRaw.split(/\s*,\s*/) : [];
+    rawReq.get = rawReq.header = (name: string) => {
+      const v = rawReq.headers[name.toLowerCase()];
+      if (Array.isArray(v)) return v[0];
+      return typeof v === "string" ? v : undefined;
+    };
+
+    rawRes.status = (code: number) => {
+      rawRes.statusCode = code;
+      return rawRes;
+    };
+
+    rawRes.set = rawRes.header = (field: string, value: string | number | string[]) => {
+      rawRes.setHeader(field, value);
+      return rawRes;
+    };
+
+    rawRes.get = (field: string) => {
+      const v = rawRes.getHeader(field);
+      if (Array.isArray(v)) return v[0];
+      return typeof v === "number" ? String(v) : (v as string | undefined);
+    };
+
+    rawRes.type = rawRes.contentType = (t: string) => {
+      rawRes.setHeader("Content-Type", t);
+      return rawRes;
+    };
+
+    rawRes.location = (u: string) => {
+      rawRes.setHeader("Location", u);
+      return rawRes;
+    };
+
+    rawRes.redirect = ((a: number | string, b?: string) => {
+      if (typeof a === "number") {
+        rawRes.statusCode = a;
+        rawRes.setHeader("Location", b!);
+      } else {
+        rawRes.statusCode = 302;
+        rawRes.setHeader("Location", a);
+      }
+      rawRes.end();
+      return rawRes;
+    }) as ResponseServer["redirect"];
+
+    rawRes.cookie = (name: string, val: string, opts: CookieOptions = {}) => {
+      const s = serializeCookie(name, val, opts);
+      const prev = rawRes.getHeader("Set-Cookie");
+      if (prev) {
+        const list = Array.isArray(prev) ? prev.concat(s) : [String(prev), s];
+        rawRes.setHeader("Set-Cookie", list);
+      } else {
+        rawRes.setHeader("Set-Cookie", s);
+      }
+      return rawRes;
+    };
+
+    rawRes.clearCookie = (name: string, opts: CookieOptions = {}) => {
+      return rawRes.cookie(name, "", { ...opts, expires: new Date(1), maxAge: 0 });
+    };
+
+    rawRes.send = (b: any) => {
+      if (b === undefined || b === null) {
+        rawRes.end();
+        return rawRes;
+      }
+      if (typeof b === "object") {
+        rawRes.setHeader("Content-Type", "application/json");
+        rawRes.end(JSON.stringify(b));
+      } else {
+        rawRes.end(String(b));
+      }
+      return rawRes;
+    };
+
+    rawRes.json = (b: any) => {
+      rawRes.setHeader("Content-Type", "application/json");
+      rawRes.end(JSON.stringify(b));
+      return rawRes;
+    };
+
+    const [urlPath, qs] = (rawReq.url || "").split("?");
+    rawReq.path = urlPath || "/";
+    const rawQuery = parseQS(qs || "");
+    const safeQuery: Record<string, string> = {};
+    for (const k in rawQuery) {
+      const v = rawQuery[k];
+      safeQuery[k] = Array.isArray(v) ? v[0] || "" : (v as string) || "";
+    }
+    rawReq.query = safeQuery;
+
+    rawReq.cookies = parseCookiesHeader((rawReq.headers["cookie"] as string) || "");
+    rawReq.params = {};
+
+    const ipRaw = rawReq.headers["x-forwarded-for"] || rawReq.socket.remoteAddress || "";
+    const ipStr = Array.isArray(ipRaw) ? ipRaw[0] : ipRaw;
+    rawReq.ip = String(ipStr).split(",")[0]?.trim() || "";
+
+    rawReq.body = {};
+    if (["POST", "PUT", "PATCH"].includes((rawReq.method || "").toUpperCase())) {
+      await new Promise<void>((resolve) => {
+        let buf = "";
+        rawReq.on("data", (chunk: Buffer | string) => {
+          buf += chunk;
+        });
+        rawReq.on("end", () => {
+          try {
+            const ct = String(rawReq.headers["content-type"] || "");
+            if (ct.includes("application/json")) {
+              rawReq.body = JSON.parse(buf || "{}");
+            } else {
+              const parsed = parseQS(buf || "");
+              const b: Record<string, string> = {};
+              for (const k in parsed) {
+                const v = parsed[k];
+                b[k] = Array.isArray(v) ? v[0] || "" : (v as string) || "";
+              }
+              rawReq.body = b;
+            }
+          } catch {
+            rawReq.body = {};
+          }
+          resolve();
+        });
+        rawReq.on("error", (err: Error) => {
+          logger("error", "Body parse error: " + err.message);
+          resolve();
+        });
+      });
+    }
+
+    const errorHandler = (err: any) => {
+      logger("error", err?.message || String(err));
+      rawRes
+        .status(err instanceof HttpError ? err.status : 500)
+        .json(
+          err instanceof HttpError
+            ? err.payload ?? { error: err.message || "Internal Server Error" }
+            : { error: err?.message || "Internal Server Error" }
+        );
+    };
+
+    try {
+      const { handlers, params } = this.router.find(rawReq.method || "GET", rawReq.path);
+      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,
+            response: rawRes,
+            req: rawReq,
+            res: rawRes,
+            next,
+          });
+        } catch (e) {
+          return errorHandler(e);
+        }
+      };
+      await next();
+    } catch (err) {
+      errorHandler(err);
+    }
+  }
+}

package/src/infra/utils/GetIp.ts

@@ -0,0 +1,15 @@
+import os from "node:os";
+import cluster from "node:cluster";
+import { logger } from "../../utils/Logger";
+
+export function getIP(port: number) {
+  const networkInterfaces = os.networkInterfaces();
+  Object.values(networkInterfaces).forEach((ifaceList) => {
+    ifaceList?.forEach((iface) => {
+      if (iface.family === "IPv4" && !iface.internal) {
+        const who = cluster.isPrimary ? "master" : "worker";
+        logger("info", `[${who}] accessible at http://${iface.address}:${port}`);
+      }
+    });
+  });
+}

package/src/infra/utils/GetOpenPort.ts

@@ -0,0 +1,15 @@
+import net from "node:net";
+
+export function getOpenPort(startPort: number): Promise<number> {
+  return new Promise((resolve) => {
+    const server = net.createServer();
+    server.unref();
+
+    server.on("error", () => {
+      resolve(getOpenPort(startPort + 1));
+    });
+    server.listen(startPort, () => {
+      server.close(() => resolve(startPort));
+    });
+  });
+}

package/src/infra/utils/HttpError.ts

@@ -0,0 +1,9 @@
+export class HttpError extends Error {
+  status: number;
+  payload?: any;
+  constructor(status: number, message?: string, payload?: any) {
+    super(message ?? String(message ?? "Error"));
+    this.status = status;
+    this.payload = payload;
+  }
+}

package/src/infra/utils/RequestHandler.ts

@@ -0,0 +1,33 @@
+import type { RequestServer } from "../../types/http/request.type";
+import type { ResponseServer } from "../../types/http/response.type";
+
+export function adaptRequestHandler(mw: any) {
+  if (typeof mw !== "function") return mw;
+  return async (ctx: {
+    request: RequestServer;
+    response: ResponseServer;
+    next: (err?: any) => Promise<void>;
+  }) => {
+    try {
+      if (mw.length === 3) {
+        await new Promise<void>((resolve, reject) => {
+          try {
+            const maybe = mw(ctx.request, ctx.response, (err?: any) => {
+              if (err) reject(err);
+              else resolve();
+            });
+            if (maybe && typeof (maybe as Promise<any>).then === "function") {
+              (maybe as Promise<any>).then(() => resolve()).catch(reject);
+            }
+          } catch (e) {
+            reject(e);
+          }
+        });
+      } else {
+        await mw(ctx);
+      }
+    } catch (err) {
+      throw err;
+    }
+  };
+}

package/src/infra/utils/route/Node.ts

@@ -0,0 +1,15 @@
+import type { RequestServer } from "../../../types/http/request.type";
+import type { ResponseServer } from "../../../types/http/response.type";
+
+export type Handler = (ctx: {
+  req: RequestServer;
+  res: ResponseServer;
+  next?: (err?: any) => void;
+}) => Promise<void> | void;
+
+export class Node {
+  children = new Map<string, Node>();
+  handlers = new Map<string, Handler[]>();
+  paramName?: string;
+  isParam?: boolean;
+}

package/src/middleware/LoggingMiddleware.ts

@@ -0,0 +1,108 @@
+import type { RequestServer } from "../types/http/request.type";
+import type { ResponseServer } from "../types/http/response.type";
+import type { ConfigTypes } from "../shared/config/ConfigModule";
+import type { RequestHandler } from "../types/common.type";
+
+export function createLoggingMiddleware(config: ConfigTypes): RequestHandler {
+  const isEnabled = config.logging?.enabled ?? true;
+  const showDetails = config.logging?.showDetails ?? true;
+  const env = config.environment || "development";
+
+  const reset = "\x1b[0m";
+  const bold = "\x1b[1m";
+  const dim = "\x1b[2m";
+  const colors: Record<string, string> = {
+    GET: "\x1b[36m",
+    POST: "\x1b[32m",
+    PUT: "\x1b[33m",
+    DELETE: "\x1b[31m",
+    PATCH: "\x1b[35m",
+    DEFAULT: "\x1b[37m",
+  };
+
+  const fn = async (...args: any[]) => {
+    let req: RequestServer | undefined;
+    let res: ResponseServer | undefined;
+    let next: ((err?: any) => Promise<void> | void) | undefined;
+
+    if (args.length === 1 && typeof args[0] === "object" && args[0] !== null) {
+      const ctx = args[0];
+      req = (ctx.request || ctx.req) as RequestServer | undefined;
+      res = (ctx.response || ctx.res) as ResponseServer | undefined;
+      next = ctx.next;
+    } else {
+      req = args[0] as RequestServer | undefined;
+      res = args[1] as ResponseServer | undefined;
+      next = args[2] as typeof next;
+    }
+
+    if (!req || !res) {
+      if (typeof next === "function") await next();
+      return;
+    }
+
+    if (!isEnabled) {
+      if (typeof next === "function") await next();
+      return;
+    }
+
+    const start = Date.now();
+    const methodRaw = String(req.method || "GET").toUpperCase();
+    const methodPad = methodRaw.padEnd(6, " ");
+    const methodColor = colors[methodRaw] || colors.DEFAULT;
+    const url = String((req as any).originalUrl || req.url || "/");
+    const ip = String((req as any).ip || "").replace("::ffff:", "");
+    const time = new Date().toLocaleTimeString("pt-BR", { hour12: false });
+
+    try {
+      if (env === "development") {
+        const header = `${dim}·${reset} ${bold}${time}${reset}  ${methodColor}${methodPad}${reset} ${bold}${url}${reset}`;
+        console.log(header);
+        if (showDetails) {
+          try {
+            if (req.query && Object.keys(req.query).length > 0) {
+              console.log(`${dim}   › query:${reset} ${JSON.stringify(req.query)}`);
+            }
+          } catch {}
+          try {
+            const params = (req as any).params;
+            if (params && Object.keys(params).length > 0) {
+              console.log(`${dim}   › params:${reset} ${JSON.stringify(params)}`);
+            }
+          } catch {}
+          try {
+            if (req.body && Object.keys(req.body).length > 0) {
+              console.log(`${dim}   › body:${reset} ${JSON.stringify(req.body)}`);
+            }
+          } catch {}
+        }
+      } else {
+        console.log(
+          `${dim}·${reset} ${time}  ${methodColor}${methodPad}${reset} ${url} ${dim}• IP:${ip}${reset}`
+        );
+      }
+    } catch {}
+
+    try {
+      if (typeof (res as any).on === "function") {
+        (res as any).on("finish", () => {
+          const duration = Date.now() - start;
+          const statusCode = Number((res as any).statusCode || 0);
+          const statusColor =
+            statusCode >= 500 ? "\x1b[31m" : statusCode >= 400 ? "\x1b[33m" : "\x1b[32m";
+          const statusText = `${statusColor}${statusCode}${reset}`;
+          const durationText = `${dim}(${duration}ms)${reset}`;
+          const ipShort = ip || "-";
+          const line = `${dim}→${reset} ${statusText} ${durationText} ${dim}• IP:${ipShort}${reset}`;
+          console.log(line);
+        });
+      }
+    } catch {}
+
+    if (typeof next === "function") {
+      await next();
+    }
+  };
+
+  return fn as unknown as RequestHandler;
+}

package/src/middleware/index.ts

@@ -0,0 +1,14 @@
+export * from "./LoggingMiddleware";
+
+const MIDDLEWARES = new WeakMap<object, string[]>();
+
+export function Middleware() {
+  return function (_: Function, context: ClassMethodDecoratorContext) {
+    context.addInitializer(function () {
+      const list = MIDDLEWARES.get(this as object) ?? [];
+      list.push(String(context.name));
+
+      MIDDLEWARES.set(this as object, list);
+    });
+  };
+}

package/src/shared/config/ConfigModule.ts

@@ -0,0 +1,113 @@
+import { existsSync, readFileSync } from "node:fs";
+import path from "node:path";
+
+/**
+ * Config Files Extensions Supported
+ * ex: azura.config.*extension
+ */
+
+type SupportedConfigFile = ".ts" | ".json" | ".yaml" | ".yml";
+
+export type ConfigTypes = {
+  environment?: "development" | "production";
+  server?: {
+    port?: number;
+    cluster?: boolean;
+    ipHost?: boolean;
+    https?: boolean;
+  };
+  plugins?: {
+    rateLimit?: {
+      enabled: boolean;
+      limit: number;
+      timeframe: number;
+    };
+    cors?: {
+      enabled: boolean;
+      origins: string[];
+    };
+  };
+  logging?: {
+    enabled?: boolean;
+    showDetails?: boolean;
+  };
+};
+
+export class ConfigModule {
+  private config: ConfigTypes = {};
+
+  /**
+   * Load config files first (azura.config.*)
+   * Recivied error if config file not found or invalid format
+   * @param configFiles
+   */
+
+  initSync(): void {
+    const cdw = process.cwd();
+    const configFiles = [
+      "azura.config.ts",
+      "azura.config.json",
+      "azura.config.yaml",
+      "azura.config.yml",
+    ];
+
+    let loaded = false;
+    for (const fileName of configFiles) {
+      const filePath = path.join(cdw, fileName);
+      if (!existsSync(filePath)) continue;
+
+      const extension = path.extname(fileName) as SupportedConfigFile;
+      const raw = readFileSync(filePath, "utf8");
+
+      try {
+        let parsed: ConfigTypes;
+        switch (extension) {
+          case ".ts":
+            const mod = require(filePath);
+            parsed = mod.default || mod;
+            break;
+          case ".json":
+            parsed = JSON.parse(raw);
+            break;
+          case ".yaml":
+          case ".yml":
+            parsed = require("js-yaml").load(raw);
+            break;
+          default:
+            throw new Error(`Invalid config file extension: ${extension}`);
+        }
+
+        this.config = { ...this.config, ...parsed };
+        loaded = true;
+        break;
+      } catch (error: Error | any) {
+        throw new Error(`Error loading config file: ${filePath}\n${error.message}`);
+      }
+    }
+
+    if (!loaded) {
+      throw new Error("Nothing config file found in the current directory.");
+    }
+  }
+
+  /**
+   * Get all configs from loaded config file
+   * @returns ConfigTypes
+   */
+
+  getAll(): ConfigTypes {
+    return this.config;
+  }
+
+  /**
+   * Return a specific config from loaded config file
+   *
+   * @template T
+   * @param {T} key - key of the config to retrieve
+   * @returns {ConfigTypes[T]}
+   */
+
+  get<T extends keyof ConfigTypes>(key: T): ConfigTypes[T] {
+    return this.config[key];
+  }
+}

package/src/types/common.type.ts

@@ -0,0 +1,4 @@
+import type { RequestServer } from "./http/request.type";
+import type { ResponseServer } from "./http/response.type";
+
+export type RequestHandler = (req: RequestServer, res: ResponseServer, next: (err?: Error | any) => void) => void;

package/src/types/http/request.type.ts

@@ -0,0 +1,21 @@
+import { IncomingMessage, type IncomingHttpHeaders } from "node:http";
+
+export interface RequestServer extends IncomingMessage {
+  path: string;
+  originalUrl: string;
+  method: string;
+  protocol: "http" | "https";
+  secure: boolean;
+  hostname: string;
+  subdomains: string[];
+  ip: string;
+  ips?: string[];
+  params: Record<string, string>;
+  query: Record<string, string>;
+  body: unknown;
+  cookies: Record<string, string>;
+  headers: IncomingHttpHeaders;
+  
+  get(name: string): string | undefined;
+  header(name: string): string | undefined;
+}

package/src/types/http/response.type.ts

@@ -0,0 +1,32 @@
+import { ServerResponse } from "node:http";
+
+export interface CookieOptions {
+  domain?: string;
+  encode?: (value: string) => string;
+  expires?: Date;
+  httpOnly?: boolean;
+  maxAge?: number;
+  path?: string;
+  sameSite?: "strict" | "lax" | "none";
+  secure?: boolean;
+}
+
+export interface ResponseServer extends ServerResponse {
+  end(cb?: () => void): this;
+  end(chunk: any, cb?: () => void): this;
+  end(chunk: any, encoding: string, cb?: () => void): this;
+  headersSent: boolean;
+  status(code: number): this;
+  set(field: string, value: string | number | string[]): this;
+  header(field: string, value: string | number | string[]): this;
+  get(field: string): string | undefined;
+  type(type: string): this;
+  contentType(type: string): this;
+  redirect(url: string): this;
+  redirect(status: number, url: string): this;
+  location(url: string): this;
+  cookie(name: string, value: string, options?: CookieOptions): this;
+  clearCookie(name: string, options?: CookieOptions): this;
+  send(body: any): this;
+  json(body: any): this;
+}

package/src/types/routes.type.ts

@@ -0,0 +1,23 @@
+export type ParamSource =
+  | "param"
+  | "query"
+  | "body"
+  | "headers"
+  | "req"
+  | "res"
+  | "next"
+  | "ip"
+  | "useragent";
+
+export interface ParamDefinition {
+  index: number;
+  type: ParamSource;
+  name?: string;
+}
+
+export interface RouteDefinition {
+  method: string;
+  path: string;
+  propertyKey: string;
+  params: ParamDefinition[];
+}

package/src/types/validations.type.ts

@@ -0,0 +1,2 @@
+export type PrimitiveType = "string" | "number" | "boolean";
+export type Schema = PrimitiveType | Schema[] | { [key: string]: Schema };

package/src/utils/Logger.ts

@@ -0,0 +1,5 @@
+export function logger(level: "info" | "warn" | "error", msg: string) {
+  if (level === "error") console.error("[Azura]", msg);
+  else if (level === "warn") console.warn("[Azura]", msg);
+  else console.log("[Azura]", msg);
+}

package/src/utils/Parser.ts

@@ -0,0 +1,19 @@
+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) {
+    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];
+    } else {
+      out[k] = v;
+    }
+  }
+  return out;
+}

package/src/utils/cookies/ParserCookie.ts

@@ -0,0 +1,9 @@
+export function parseCookiesHeader(header: string | undefined): Record<string, string> {
+  if (!header) return {};
+  return header.split(";").reduce<Record<string, string>>((acc, pair) => {
+    const [k, ...vals] = pair.trim().split("=");
+    if (!k) return acc;
+    acc[k] = decodeURIComponent(vals.join("="));
+    return acc;
+  }, {});
+}

package/src/utils/cookies/SerializeCookie.ts

@@ -0,0 +1,15 @@
+import type { CookieOptions } from "../../types/http/response.type";
+
+export function serializeCookie(name: string, val: string, opts: CookieOptions = {}): string {
+  const encode = opts.encode ?? encodeURIComponent;
+  let str = `${name}=${encode(val)}`;
+  if (opts.maxAge != null && !Number.isNaN(Number(opts.maxAge)))
+    str += `; Max-Age=${Math.floor(Number(opts.maxAge))}`;
+  if (opts.domain) str += `; Domain=${opts.domain}`;
+  if (opts.path) str += `; Path=${opts.path}`;
+  if (opts.expires) str += `; Expires=${opts.expires.toUTCString()}`;
+  if (opts.httpOnly) str += `; HttpOnly`;
+  if (opts.secure) str += `; Secure`;
+  if (opts.sameSite) str += `; SameSite=${opts.sameSite}`;
+  return str;
+}

package/src/utils/validators/DTOValidator.ts

@@ -0,0 +1,30 @@
+const DTOS = new WeakMap<Function, Map<string, Array<{ index: number; dto: unknown }>>>();
+
+export function validateDto(dto: unknown): ParameterDecorator {
+  return (target, propertyKey, parameterIndex) => {
+    const ctor = typeof target === "function" ? (target as Function) : (target as any).constructor;
+
+    let map = DTOS.get(ctor);
+    if (!map) {
+      map = new Map();
+      DTOS.set(ctor, map);
+    }
+
+    const key = String(propertyKey);
+    const list = map.get(key) ?? [];
+
+    list.push({
+      index: parameterIndex,
+      dto,
+    });
+
+    map.set(key, list);
+  };
+}
+
+export function getDtoValidators(
+  ctor: Function,
+  propertyKey: string
+): Array<{ index: number; dto: unknown }> {
+  return DTOS.get(ctor)?.get(propertyKey) ?? [];
+}

package/src/utils/validators/SchemaValidator.ts

@@ -0,0 +1,37 @@
+import { HttpError } from "../../infra/utils/HttpError";
+import type { Schema } from "../../types/validations.type";
+
+function isSchemaObject(schema: Schema): schema is Record<string, Schema> {
+  return typeof schema === "object" && !Array.isArray(schema);
+}
+
+export function validateSchema(schema: Schema, data: unknown): void {
+  if (typeof data !== "object" || data === null) {
+    throw new HttpError(400, "Payload inválido");
+  }
+
+  if (!isSchemaObject(schema)) {
+    throw new Error("Schema inválido: deve ser um objeto no topo");
+  }
+
+  const obj = data as Record<string, unknown>;
+
+  for (const key of Object.keys(schema)) {
+    const rule = schema[key];
+    const val = obj[key];
+
+    if (!rule) continue;
+
+    if (typeof rule === "string") {
+      if (typeof val !== rule) {
+        throw new HttpError(400, `${key} deve ser ${rule}`);
+      }
+    } else if (Array.isArray(rule)) {
+      if (!Array.isArray(val)) {
+        throw new HttpError(400, `${key} deve ser array`);
+      }
+    } else if (isSchemaObject(rule)) {
+      validateSchema(rule, val);
+    }
+  }
+}