azurajs 3.0.1 → 3.0.2

package/src/plugins/SessionPlugin.ts

@@ -0,0 +1,98 @@
+import { randomBytes } from "node:crypto";
+import type { SessionOptions, PluginHandler, SessionStore } from "../types/plugins/plugin.type.js";
+
+class MemorySessionStore implements SessionStore {
+  private sessions = new Map<string, { data: Record<string, any>; expires: number }>();
+  private cleanupTimer: ReturnType<typeof setInterval>;
+
+  constructor() {
+    this.cleanupTimer = setInterval(() => {
+      const now = Date.now();
+      for (const [id, session] of this.sessions) {
+        if (now >= session.expires) this.sessions.delete(id);
+      }
+    }, 60_000);
+    if (this.cleanupTimer.unref) this.cleanupTimer.unref();
+  }
+
+  async get(id: string): Promise<Record<string, any> | null> {
+    const session = this.sessions.get(id);
+    if (!session) return null;
+    if (Date.now() >= session.expires) {
+      this.sessions.delete(id);
+      return null;
+    }
+    return session.data;
+  }
+
+  async set(id: string, data: Record<string, any>, maxAge: number): Promise<void> {
+    this.sessions.set(id, { data, expires: Date.now() + maxAge });
+  }
+
+  async destroy(id: string): Promise<void> {
+    this.sessions.delete(id);
+  }
+
+  async touch(id: string, maxAge: number): Promise<void> {
+    const session = this.sessions.get(id);
+    if (session) session.expires = Date.now() + maxAge;
+  }
+}
+
+function generateSessionId(): string {
+  return randomBytes(24).toString("hex");
+}
+
+export function SessionPlugin(options: SessionOptions): PluginHandler {
+  const {
+    secret: _secret,
+    name = "azura.sid",
+    maxAge = 86400_000,
+    secure = false,
+    httpOnly = true,
+    sameSite = "Lax",
+    store = new MemorySessionStore(),
+  } = options;
+
+  return async (ctx, next) => {
+    const { req, res } = ctx;
+
+    let sessionId = req.cookies[name];
+    let sessionData: Record<string, any> | null = null;
+
+    if (sessionId) {
+      sessionData = await store.get(sessionId);
+    }
+
+    if (!sessionData) {
+      sessionId = generateSessionId();
+      sessionData = {};
+    }
+
+    req.session = sessionData;
+
+    const originalEnd = res.end;
+    (res as any).end = async function (...args: any[]) {
+      await store.set(sessionId!, req.session ?? {}, maxAge);
+
+      const cookieParts = [
+        `${name}=${sessionId}`,
+        `Path=/`,
+        `Max-Age=${Math.floor(maxAge / 1000)}`,
+        `SameSite=${sameSite}`,
+      ];
+      if (httpOnly) cookieParts.push("HttpOnly");
+      if (secure) cookieParts.push("Secure");
+
+      const existing = res.getHeader("Set-Cookie");
+      const cookies = existing
+        ? [...(Array.isArray(existing) ? existing : [String(existing)]), cookieParts.join("; ")]
+        : [cookieParts.join("; ")];
+      res.setHeader("Set-Cookie", cookies);
+
+      return (originalEnd as any).apply(this, args);
+    };
+
+    next();
+  };
+}

package/src/plugins/StaticPlugin.ts

@@ -0,0 +1,152 @@
+import { createReadStream, statSync, existsSync } from "node:fs";
+import { join, extname, resolve } from "node:path";
+import type { StaticOptions, PluginHandler } from "../types/plugins/plugin.type.js";
+
+const MIME_TYPES: Record<string, string> = {
+  ".html": "text/html; charset=utf-8",
+  ".htm": "text/html; charset=utf-8",
+  ".css": "text/css; charset=utf-8",
+  ".js": "application/javascript; charset=utf-8",
+  ".mjs": "application/javascript; charset=utf-8",
+  ".json": "application/json; charset=utf-8",
+  ".xml": "application/xml; charset=utf-8",
+  ".txt": "text/plain; charset=utf-8",
+  ".csv": "text/csv; charset=utf-8",
+  ".png": "image/png",
+  ".jpg": "image/jpeg",
+  ".jpeg": "image/jpeg",
+  ".gif": "image/gif",
+  ".svg": "image/svg+xml",
+  ".ico": "image/x-icon",
+  ".webp": "image/webp",
+  ".avif": "image/avif",
+  ".woff": "font/woff",
+  ".woff2": "font/woff2",
+  ".ttf": "font/ttf",
+  ".otf": "font/otf",
+  ".eot": "application/vnd.ms-fontobject",
+  ".mp4": "video/mp4",
+  ".webm": "video/webm",
+  ".mp3": "audio/mpeg",
+  ".ogg": "audio/ogg",
+  ".wav": "audio/wav",
+  ".pdf": "application/pdf",
+  ".zip": "application/zip",
+  ".gz": "application/gzip",
+  ".wasm": "application/wasm",
+  ".map": "application/json",
+};
+
+export function StaticPlugin(options: StaticOptions): PluginHandler {
+  const {
+    root,
+    prefix = "/",
+    index = ["index.html"],
+    dotfiles = "ignore",
+    maxAge = 0,
+    etag = true,
+    lastModified = true,
+    fallthrough = true,
+    immutable = false,
+  } = options;
+
+  const resolvedRoot = resolve(root);
+  const indexFiles = Array.isArray(index) ? index : [index];
+  const normalizedPrefix = prefix.endsWith("/") ? prefix.slice(0, -1) : prefix;
+
+  return (ctx, next) => {
+    const { req, res } = ctx;
+
+    if (req.method !== "GET" && req.method !== "HEAD") {
+      next();
+      return;
+    }
+
+    const path = req.pathname;
+    if (!path.startsWith(normalizedPrefix)) {
+      next();
+      return;
+    }
+
+    const relativePath = path.slice(normalizedPrefix.length) || "/";
+
+    if (relativePath.includes("..")) {
+      next();
+      return;
+    }
+
+    if (dotfiles !== "allow" && relativePath.split("/").some((s) => s.startsWith("."))) {
+      if (dotfiles === "deny") {
+        res.statusCode = 403;
+        res.end("Forbidden");
+        return;
+      }
+      next();
+      return;
+    }
+
+    let filePath = join(resolvedRoot, relativePath);
+
+    if (!existsSync(filePath)) {
+      if (fallthrough) { next(); return; }
+      res.statusCode = 404;
+      res.end("Not Found");
+      return;
+    }
+
+    let stat = statSync(filePath);
+
+    if (stat.isDirectory()) {
+      let found = false;
+      for (const idx of indexFiles) {
+        const candidate = join(filePath, idx);
+        if (existsSync(candidate)) {
+          filePath = candidate;
+          stat = statSync(filePath);
+          found = true;
+          break;
+        }
+      }
+      if (!found) {
+        if (fallthrough) { next(); return; }
+        res.statusCode = 404;
+        res.end("Not Found");
+        return;
+      }
+    }
+
+    const ext = extname(filePath).toLowerCase();
+    const contentType = MIME_TYPES[ext] ?? "application/octet-stream";
+
+    res.setHeader("Content-Type", contentType);
+    res.setHeader("Content-Length", stat.size);
+
+    if (lastModified) {
+      res.setHeader("Last-Modified", stat.mtime.toUTCString());
+    }
+
+    if (etag) {
+      const etagValue = `W/"${stat.size.toString(16)}-${stat.mtime.getTime().toString(16)}"`;
+      res.setHeader("ETag", etagValue);
+
+      const ifNoneMatch = req.headers["if-none-match"];
+      if (ifNoneMatch === etagValue) {
+        res.statusCode = 304;
+        res.end();
+        return;
+      }
+    }
+
+    let cacheControl = `public, max-age=${maxAge}`;
+    if (immutable) cacheControl += ", immutable";
+    res.setHeader("Cache-Control", cacheControl);
+
+    if (req.method === "HEAD") {
+      res.end();
+      return;
+    }
+
+    const stream = createReadStream(filePath);
+    stream.pipe(res);
+  };
+}

package/src/plugins/TimeoutPlugin.ts

@@ -0,0 +1,33 @@
+import type { TimeoutOptions, PluginHandler } from "../types/plugins/plugin.type.js";
+
+export function TimeoutPlugin(options: TimeoutOptions): PluginHandler {
+  const {
+    timeout,
+    message = { error: { statusCode: 408, message: "Request Timeout" } },
+    statusCode = 408,
+  } = options;
+
+  return (ctx, next) => {
+    const { res } = ctx;
+    let timedOut = false;
+
+    const timer = setTimeout(() => {
+      timedOut = true;
+      if (!res.headersSent) {
+        res.statusCode = statusCode;
+        res.setHeader("Content-Type", typeof message === "string" ? "text/plain" : "application/json");
+        res.end(typeof message === "string" ? message : JSON.stringify(message));
+      }
+    }, timeout);
+
+    const originalEnd = res.end;
+    (res as any).end = function (...args: any[]) {
+      clearTimeout(timer);
+      if (!timedOut) {
+        return (originalEnd as any).apply(this, args);
+      }
+    };
+
+    next();
+  };
+}

package/src/plugins/index.ts

@@ -0,0 +1,18 @@
+export { CORSPlugin } from "./CORSPlugin.js";
+export { RateLimitPlugin } from "./RateLimitPlugin.js";
+export { HelmetPlugin } from "./HelmetPlugin.js";
+export { JWTPlugin, signJWT, verifyJWT } from "./JWTPlugin.js";
+export type { JWTPayload } from "./JWTPlugin.js";
+export { SessionPlugin } from "./SessionPlugin.js";
+export { CompressionPlugin } from "./CompressionPlugin.js";
+export { StaticPlugin } from "./StaticPlugin.js";
+export { ETagPlugin } from "./ETagPlugin.js";
+export { RequestIdPlugin } from "./RequestIdPlugin.js";
+export { TimeoutPlugin } from "./TimeoutPlugin.js";
+export { HealthCheckPlugin } from "./HealthCheckPlugin.js";
+export { CircuitBreakerPlugin } from "./CircuitBreakerPlugin.js";
+export { SSEPlugin, SSEManager } from "./SSEPlugin.js";
+export type { SSEClient } from "./SSEPlugin.js";
+export { ProxyPlugin } from "./ProxyPlugin.js";
+export { MultipartPlugin } from "./MultipartPlugin.js";
+export type { UploadedFile } from "./MultipartPlugin.js";

package/src/types/common.type.ts

@@ -0,0 +1,82 @@
+import type { IncomingMessage, ServerResponse } from "node:http";
+
+export interface AzuraRequest extends IncomingMessage {
+  pathname: string;
+  query: Record<string, string | string[]>;
+  params: Record<string, string>;
+  body: any;
+  cookies: Record<string, string>;
+  ip: string;
+  protocol: "http" | "https";
+  secure: boolean;
+  hostname: string;
+  requestId?: string;
+  startTime: bigint;
+  session?: Record<string, any>;
+  user?: any;
+  raw: IncomingMessage;
+}
+
+export interface CookieOptions {
+  maxAge?: number;
+  expires?: Date;
+  path?: string;
+  domain?: string;
+  secure?: boolean;
+  httpOnly?: boolean;
+  sameSite?: "Strict" | "Lax" | "None";
+  signed?: boolean;
+}
+
+export interface AzuraResponse extends ServerResponse {
+  status(code: number): AzuraResponse;
+  json(data: unknown): void;
+  send(body: string | Buffer): void;
+  html(body: string): void;
+  redirect(url: string, code?: number): void;
+  cookie(name: string, value: string, options?: CookieOptions): AzuraResponse;
+  clearCookie(name: string, options?: CookieOptions): AzuraResponse;
+  header(name: string, value: string | number | string[]): AzuraResponse;
+  type(contentType: string): AzuraResponse;
+  attachment(filename?: string): AzuraResponse;
+  download(path: string, filename?: string): void;
+  locals: Record<string, any>;
+  sent: boolean;
+}
+
+export type NextFunction = (err?: Error | unknown) => void;
+
+export type MiddlewareHandler = (
+  req: AzuraRequest,
+  res: AzuraResponse,
+  next: NextFunction,
+) => void | Promise<void>;
+
+export type RouteHandler = (
+  req: AzuraRequest,
+  res: AzuraResponse,
+  ...args: any[]
+) => any | Promise<any>;
+
+export type ErrorHandler = (
+  err: Error | unknown,
+  req: AzuraRequest,
+  res: AzuraResponse,
+  next: NextFunction,
+) => void | Promise<void>;
+
+export type HttpMethod =
+  | "GET"
+  | "POST"
+  | "PUT"
+  | "DELETE"
+  | "PATCH"
+  | "HEAD"
+  | "OPTIONS";
+
+export interface RouteMatch {
+  handler: RouteHandler;
+  params: Record<string, string>;
+  middlewares: MiddlewareHandler[];
+  meta?: Record<string, any>;
+}

package/src/types/config.type.ts

@@ -0,0 +1,57 @@
+import type {
+  CORSOptions,
+  RateLimitOptions,
+  HelmetOptions,
+  JWTOptions,
+  SessionOptions,
+  CompressionOptions,
+  StaticOptions,
+  HealthCheckOptions,
+  CircuitBreakerOptions,
+} from "./plugins/plugin.type.js";
+
+export interface AzuraConfig {
+  environment?: "development" | "production" | "test";
+  server?: ServerConfig;
+  logging?: LoggingConfig;
+  plugins?: PluginsConfig;
+  debug?: boolean;
+}
+
+export interface ServerConfig {
+  port?: number;
+  host?: string;
+  cluster?: boolean;
+  clusterInstances?: number;
+  https?: HttpsConfig | false;
+  keepAliveTimeout?: number;
+  headersTimeout?: number;
+  maxHeaderSize?: number;
+  requestTimeout?: number;
+}
+
+export interface HttpsConfig {
+  key: string;
+  cert: string;
+  ca?: string;
+}
+
+export interface LoggingConfig {
+  enabled?: boolean;
+  level?: "debug" | "info" | "warn" | "error" | "silent";
+  timestamp?: boolean;
+  colors?: boolean;
+  requestLogging?: boolean;
+}
+
+export interface PluginsConfig {
+  cors?: CORSOptions & { enabled?: boolean };
+  rateLimit?: RateLimitOptions & { enabled?: boolean };
+  helmet?: HelmetOptions & { enabled?: boolean };
+  jwt?: JWTOptions & { enabled?: boolean };
+  session?: SessionOptions & { enabled?: boolean };
+  compression?: CompressionOptions & { enabled?: boolean };
+  static?: StaticOptions & { enabled?: boolean };
+  healthCheck?: HealthCheckOptions & { enabled?: boolean };
+  circuitBreaker?: CircuitBreakerOptions & { enabled?: boolean };
+}

package/{dist/chunk-OWUGAI5V.mjs → src/types/http/status.ts}

@@ -1,51 +1,49 @@
-// src/types/http/status.ts
-var HttpStatus = {
-  OK: 200,
-  CREATED: 201,
-  ACCEPTED: 202,
-  NO_CONTENT: 204,
-  MOVED_PERMANENTLY: 301,
-  FOUND: 302,
-  NOT_MODIFIED: 304,
-  BAD_REQUEST: 400,
-  UNAUTHORIZED: 401,
-  FORBIDDEN: 403,
-  NOT_FOUND: 404,
-  METHOD_NOT_ALLOWED: 405,
-  CONFLICT: 409,
-  GONE: 410,
-  UNPROCESSABLE_ENTITY: 422,
-  TOO_MANY_REQUESTS: 429,
-  INTERNAL_SERVER_ERROR: 500,
-  NOT_IMPLEMENTED: 501,
-  BAD_GATEWAY: 502,
-  SERVICE_UNAVAILABLE: 503,
-  GATEWAY_TIMEOUT: 504
-};
-var HttpStatusText = {
-  200: "OK",
-  201: "Created",
-  202: "Accepted",
-  204: "No Content",
-  301: "Moved Permanently",
-  302: "Found",
-  304: "Not Modified",
-  400: "Bad Request",
-  401: "Unauthorized",
-  403: "Forbidden",
-  404: "Not Found",
-  405: "Method Not Allowed",
-  409: "Conflict",
-  410: "Gone",
-  422: "Unprocessable Entity",
-  429: "Too Many Requests",
-  500: "Internal Server Error",
-  501: "Not Implemented",
-  502: "Bad Gateway",
-  503: "Service Unavailable",
-  504: "Gateway Timeout"
-};
-
-export { HttpStatus, HttpStatusText };
-//# sourceMappingURL=chunk-OWUGAI5V.mjs.map
-//# sourceMappingURL=chunk-OWUGAI5V.mjs.map
+export const HttpStatus = {
+  OK: 200,
+  CREATED: 201,
+  ACCEPTED: 202,
+  NO_CONTENT: 204,
+  MOVED_PERMANENTLY: 301,
+  FOUND: 302,
+  NOT_MODIFIED: 304,
+  BAD_REQUEST: 400,
+  UNAUTHORIZED: 401,
+  FORBIDDEN: 403,
+  NOT_FOUND: 404,
+  METHOD_NOT_ALLOWED: 405,
+  CONFLICT: 409,
+  GONE: 410,
+  UNPROCESSABLE_ENTITY: 422,
+  TOO_MANY_REQUESTS: 429,
+  INTERNAL_SERVER_ERROR: 500,
+  NOT_IMPLEMENTED: 501,
+  BAD_GATEWAY: 502,
+  SERVICE_UNAVAILABLE: 503,
+  GATEWAY_TIMEOUT: 504,
+} as const;
+
+export type HttpStatusCode = (typeof HttpStatus)[keyof typeof HttpStatus];
+
+export const HttpStatusText: Record<number, string> = {
+  200: "OK",
+  201: "Created",
+  202: "Accepted",
+  204: "No Content",
+  301: "Moved Permanently",
+  302: "Found",
+  304: "Not Modified",
+  400: "Bad Request",
+  401: "Unauthorized",
+  403: "Forbidden",
+  404: "Not Found",
+  405: "Method Not Allowed",
+  409: "Conflict",
+  410: "Gone",
+  422: "Unprocessable Entity",
+  429: "Too Many Requests",
+  500: "Internal Server Error",
+  501: "Not Implemented",
+  502: "Bad Gateway",
+  503: "Service Unavailable",
+  504: "Gateway Timeout",
+};

package/src/types/index.ts

@@ -0,0 +1,55 @@
+export type {
+  AzuraRequest,
+  AzuraResponse,
+  NextFunction,
+  MiddlewareHandler,
+  RouteHandler,
+  ErrorHandler,
+  HttpMethod,
+  RouteMatch,
+  CookieOptions,
+} from "./common.type.js";
+
+export type {
+  RouteDefinition,
+  RouteMeta,
+  ParameterMeta,
+  ResponseMeta,
+  ParamType,
+  ParamMetadata,
+  ControllerMetadata,
+  RouteMetadata,
+} from "./routes.type.js";
+
+export type {
+  AzuraConfig,
+  ServerConfig,
+  LoggingConfig,
+  PluginsConfig,
+} from "./config.type.js";
+
+export { HttpStatus, HttpStatusText } from "./http/status.js";
+export type { HttpStatusCode } from "./http/status.js";
+
+export type {
+  PluginContext,
+  PluginHandler,
+  PluginFactory,
+  PluginDefinition,
+  CORSOptions,
+  RateLimitOptions,
+  HelmetOptions,
+  JWTOptions,
+  SessionOptions,
+  CompressionOptions,
+  StaticOptions,
+  ETagOptions,
+  RequestIdOptions,
+  TimeoutOptions,
+  HealthCheckOptions,
+  CircuitBreakerOptions,
+  CircuitBreakerState,
+  ProxyOptions,
+  SSEOptions,
+  MultipartOptions,
+} from "./plugins/plugin.type.js";