mikroserve 1.0.0 → 1.1.0

package/lib/MikroServe.js

@@ -74,7 +74,8 @@ var RateLimiter = class {
     const now = Date.now();
     const key = ip || "unknown";
     const entry = this.requests.get(key);
-    if (!entry || entry.resetTime < now) return Math.floor((now + this.windowMs) / 1e3);
+    if (!entry || entry.resetTime < now)
+      return Math.floor((now + this.windowMs) / 1e3);
     return Math.floor(entry.resetTime / 1e3);
   }
   cleanup() {
@@ -92,64 +93,70 @@ var Router = class {
   globalMiddlewares = [];
   pathPatterns = /* @__PURE__ */ new Map();
   /**
-   * Add a global middleware
+   * @description Add a global middleware.
    */
   use(middleware) {
     this.globalMiddlewares.push(middleware);
     return this;
   }
   /**
-   * Register a route with specified method
-   */
-  register(method, path, handler, middlewares = []) {
-    this.routes.push({ method, path, handler, middlewares });
-    this.pathPatterns.set(path, this.createPathPattern(path));
-    return this;
-  }
-  /**
-   * Register a GET route
+   * @description Register a GET route.
    */
   get(path, ...handlers) {
     const handler = handlers.pop();
     return this.register("GET", path, handler, handlers);
   }
   /**
-   * Register a POST route
+   * @description Register a POST route.
    */
   post(path, ...handlers) {
     const handler = handlers.pop();
     return this.register("POST", path, handler, handlers);
   }
   /**
-   * Register a PUT route
+   * @description Register a PUT route.
    */
   put(path, ...handlers) {
     const handler = handlers.pop();
     return this.register("PUT", path, handler, handlers);
   }
   /**
-   * Register a DELETE route
+   * @description Register a DELETE route.
    */
   delete(path, ...handlers) {
     const handler = handlers.pop();
     return this.register("DELETE", path, handler, handlers);
   }
   /**
-   * Register a PATCH route
+   * @description Register a PATCH route.
    */
   patch(path, ...handlers) {
     const handler = handlers.pop();
     return this.register("PATCH", path, handler, handlers);
   }
   /**
-   * Register an OPTIONS route
+   * @description Register a route for any HTTP method.
+   */
+  any(path, ...handlers) {
+    const handler = handlers.pop();
+    const middlewares = handlers;
+    this.register("GET", path, handler, middlewares);
+    this.register("POST", path, handler, middlewares);
+    this.register("PUT", path, handler, middlewares);
+    this.register("DELETE", path, handler, middlewares);
+    this.register("PATCH", path, handler, middlewares);
+    this.register("OPTIONS", path, handler, middlewares);
+    return this;
+  }
+  /**
+   * @description Register an OPTIONS route.
    */
   options(path, ...handlers) {
     const handler = handlers.pop();
     return this.register("OPTIONS", path, handler, handlers);
   }
   /**
-   * Match a request to a route
+   * @description Match a request to a route.
    */
   match(method, path) {
     for (const route of this.routes) {
@@ -167,22 +174,7 @@ var Router = class {
     return null;
   }
   /**
-   * Create a regex pattern for path matching
-   */
-  createPathPattern(path) {
-    const paramNames = [];
-    const pattern = path.replace(/\/:[^/]+/g, (match) => {
-      const paramName = match.slice(2);
-      paramNames.push(paramName);
-      return "/([^/]+)";
-    }).replace(/\/$/, "/?");
-    return {
-      pattern: new RegExp(`^${pattern}$`),
-      paramNames
-    };
-  }
-  /**
-   * Handle a request and find the matching route
+   * @description Handle a request and find the matching route.
    */
   async handle(req, res) {
     const method = req.method || "GET";
@@ -200,12 +192,11 @@ var Router = class {
       res,
       params,
       query,
-      // @ts-ignore
+      // @ts-expect-error
       body: req.body || {},
       headers: req.headers,
       path,
       state: {},
-      // Add the missing state property
       raw: () => res,
       binary: (content, contentType = "application/octet-stream", status = 200) => ({
         statusCode: status,
@@ -269,7 +260,6 @@ var Router = class {
             headers: { "Content-Type": "text/html" }
           }),
           form: (content) => ({
-            // Make sure form method is included here
             statusCode: code,
             body: content,
             headers: { "Content-Type": "application/x-www-form-urlencoded" }
@@ -287,7 +277,34 @@ var Router = class {
     return this.executeMiddlewareChain(context, middlewares, route.handler);
   }
   /**
-   * Execute middleware chain and final handler
+   * @description Register a route with specified method.
+   */
+  register(method, path, handler, middlewares = []) {
+    this.routes.push({ method, path, handler, middlewares });
+    this.pathPatterns.set(path, this.createPathPattern(path));
+    return this;
+  }
+  /**
+   * @description Create a regex pattern for path matching.
+   */
+  createPathPattern(path) {
+    const paramNames = [];
+    let pattern = path.replace(/\/:[^/]+/g, (match) => {
+      const paramName = match.slice(2);
+      paramNames.push(paramName);
+      return "/([^/]+)";
+    });
+    if (pattern.endsWith("/*")) {
+      pattern = `${pattern.slice(0, -2)}(?:/(.*))?`;
+      paramNames.push("wildcard");
+    } else pattern = pattern.replace(/\/$/, "/?");
+    return {
+      pattern: new RegExp(`^${pattern}$`),
+      paramNames
+    };
+  }
+  /**
+   * @description Execute middleware chain and final handler.
    */
   async executeMiddlewareChain(context, middlewares, finalHandler) {
     let currentIndex = 0;
@@ -316,6 +333,10 @@ var configDefaults = () => {
     sslKey: "",
     sslCa: "",
     debug: getTruthyValue(process.env.DEBUG) || false,
+    maxBodySize: 1024 * 1024,
+    // 1MB
+    requestTimeout: 3e4,
+    // 30 seconds
     rateLimit: {
       enabled: true,
       requestsPerMinute: 100
@@ -336,8 +357,18 @@ var baseConfig = (options) => ({
   options: [
     { flag: "--port", path: "port", defaultValue: defaults.port },
     { flag: "--host", path: "host", defaultValue: defaults.host },
-    { flag: "--https", path: "useHttps", defaultValue: defaults.useHttps, isFlag: true },
-    { flag: "--http2", path: "useHttp2", defaultValue: defaults.useHttp2, isFlag: true },
+    {
+      flag: "--https",
+      path: "useHttps",
+      defaultValue: defaults.useHttps,
+      isFlag: true
+    },
+    {
+      flag: "--http2",
+      path: "useHttp2",
+      defaultValue: defaults.useHttp2,
+      isFlag: true
+    },
     { flag: "--cert", path: "sslCert", defaultValue: defaults.sslCert },
     { flag: "--key", path: "sslKey", defaultValue: defaults.sslKey },
     { flag: "--ca", path: "sslCa", defaultValue: defaults.sslCa },
@@ -358,27 +389,148 @@ var baseConfig = (options) => ({
       defaultValue: defaults.allowedDomains,
       parser: import_mikroconf.parsers.array
     },
-    { flag: "--debug", path: "debug", defaultValue: defaults.debug, isFlag: true }
+    {
+      flag: "--debug",
+      path: "debug",
+      defaultValue: defaults.debug,
+      isFlag: true
+    },
+    {
+      flag: "--max-body-size",
+      path: "maxBodySize",
+      defaultValue: defaults.maxBodySize
+    },
+    {
+      flag: "--request-timeout",
+      path: "requestTimeout",
+      defaultValue: defaults.requestTimeout
+    }
   ],
   config: options
 });
 
+// src/utils/multipartParser.ts
+function parseMultipartFormData(body, contentType) {
+  const boundaryMatch = contentType.match(/boundary=(?:"([^"]+)"|([^;]+))/i);
+  if (!boundaryMatch) {
+    throw new Error("Invalid multipart/form-data: missing boundary");
+  }
+  const boundary = boundaryMatch[1] || boundaryMatch[2];
+  const boundaryBuffer = Buffer.from(`--${boundary}`);
+  const endBoundaryBuffer = Buffer.from(`--${boundary}--`);
+  const fields = {};
+  const files = {};
+  const parts = splitByBoundary(body, boundaryBuffer);
+  for (const part of parts) {
+    if (part.length === 0) continue;
+    if (part.equals(endBoundaryBuffer.subarray(boundaryBuffer.length)))
+      continue;
+    const parsed = parsePart(part);
+    if (!parsed) continue;
+    const { name, filename, contentType: partContentType, data } = parsed;
+    if (filename) {
+      const file = {
+        filename,
+        contentType: partContentType || "application/octet-stream",
+        data,
+        size: data.length
+      };
+      if (files[name]) {
+        if (Array.isArray(files[name])) {
+          files[name].push(file);
+        } else {
+          files[name] = [files[name], file];
+        }
+      } else {
+        files[name] = file;
+      }
+    } else {
+      const value = data.toString("utf8");
+      if (fields[name]) {
+        if (Array.isArray(fields[name])) {
+          fields[name].push(value);
+        } else {
+          fields[name] = [fields[name], value];
+        }
+      } else {
+        fields[name] = value;
+      }
+    }
+  }
+  return { fields, files };
+}
+function splitByBoundary(buffer, boundary) {
+  const parts = [];
+  let start = 0;
+  while (start < buffer.length) {
+    const index = buffer.indexOf(boundary, start);
+    if (index === -1) break;
+    if (start !== index) {
+      parts.push(buffer.subarray(start, index));
+    }
+    start = index + boundary.length;
+    if (start < buffer.length && buffer[start] === 13 && buffer[start + 1] === 10) {
+      start += 2;
+    }
+  }
+  return parts;
+}
+function parsePart(part) {
+  const doubleCRLF = Buffer.from("\r\n\r\n");
+  const headerEndIndex = part.indexOf(doubleCRLF);
+  if (headerEndIndex === -1) return null;
+  const headersBuffer = part.subarray(0, headerEndIndex);
+  const dataBuffer = part.subarray(headerEndIndex + 4);
+  const headers = headersBuffer.toString("utf8");
+  const headerLines = headers.split("\r\n");
+  let disposition = "";
+  let name = "";
+  let filename;
+  let contentType;
+  for (const line of headerLines) {
+    const lowerLine = line.toLowerCase();
+    if (lowerLine.startsWith("content-disposition:")) {
+      disposition = line.substring("content-disposition:".length).trim();
+      const nameMatch = disposition.match(/name="([^"]+)"/);
+      if (nameMatch) {
+        name = nameMatch[1];
+      }
+      const filenameMatch = disposition.match(/filename="([^"]+)"/);
+      if (filenameMatch) {
+        filename = filenameMatch[1];
+      }
+    } else if (lowerLine.startsWith("content-type:")) {
+      contentType = line.substring("content-type:".length).trim();
+    }
+  }
+  if (!name) return null;
+  let data = dataBuffer;
+  if (data.length >= 2 && data[data.length - 2] === 13 && data[data.length - 1] === 10) {
+    data = data.subarray(0, data.length - 2);
+  }
+  return { disposition, name, filename, contentType, data };
+}
+
 // src/MikroServe.ts
 var MikroServe = class {
   config;
   rateLimiter;
   router;
+  shutdownHandlers = [];
   /**
    * @description Creates a new MikroServe instance.
    */
   constructor(options) {
-    const config = new import_mikroconf2.MikroConf(baseConfig(options || {})).get();
+    const config = new import_mikroconf2.MikroConf(
+      baseConfig(options || {})
+    ).get();
     if (config.debug) console.log("Using configuration:", config);
     this.config = config;
     this.router = new Router();
     const requestsPerMinute = config.rateLimit.requestsPerMinute || configDefaults().rateLimit.requestsPerMinute;
     this.rateLimiter = new RateLimiter(requestsPerMinute, 60);
-    if (config.rateLimit.enabled === true) this.use(this.rateLimitMiddleware.bind(this));
+    if (config.rateLimit.enabled === true)
+      this.use(this.rateLimitMiddleware.bind(this));
   }
   /**
    * @description Register a global middleware.
@@ -422,6 +574,13 @@ var MikroServe = class {
     this.router.patch(path, ...handlers);
     return this;
   }
+  /**
+   * @description Register a route that responds to any HTTP method.
+   */
+  any(path, ...handlers) {
+    this.router.any(path, ...handlers);
+    return this;
+  }
   /**
    * @description Register an OPTIONS route.
    */
@@ -452,7 +611,9 @@ var MikroServe = class {
     const boundRequestHandler = this.requestHandler.bind(this);
     if (this.config.useHttp2) {
       if (!this.config.sslCert || !this.config.sslKey)
-        throw new Error("SSL certificate and key paths are required when useHttp2 is true");
+        throw new Error(
+          "SSL certificate and key paths are required when useHttp2 is true"
+        );
       try {
         const httpsOptions = {
           key: (0, import_node_fs.readFileSync)(this.config.sslKey),
@@ -462,12 +623,16 @@ var MikroServe = class {
         return import_node_http2.default.createSecureServer(httpsOptions, boundRequestHandler);
       } catch (error) {
         if (error.message.includes("key values mismatch"))
-          throw new Error(`SSL certificate and key do not match: ${error.message}`);
+          throw new Error(
+            `SSL certificate and key do not match: ${error.message}`
+          );
         throw error;
       }
     } else if (this.config.useHttps) {
       if (!this.config.sslCert || !this.config.sslKey)
-        throw new Error("SSL certificate and key paths are required when useHttps is true");
+        throw new Error(
+          "SSL certificate and key paths are required when useHttps is true"
+        );
       try {
         const httpsOptions = {
           key: (0, import_node_fs.readFileSync)(this.config.sslKey),
@@ -477,7 +642,9 @@ var MikroServe = class {
         return import_node_https.default.createServer(httpsOptions, boundRequestHandler);
       } catch (error) {
         if (error.message.includes("key values mismatch"))
-          throw new Error(`SSL certificate and key do not match: ${error.message}`);
+          throw new Error(
+            `SSL certificate and key do not match: ${error.message}`
+          );
         throw error;
       }
     }
@@ -488,12 +655,18 @@ var MikroServe = class {
    */
   async rateLimitMiddleware(context, next) {
     const ip = context.req.socket.remoteAddress || "unknown";
-    context.res.setHeader("X-RateLimit-Limit", this.rateLimiter.getLimit().toString());
+    context.res.setHeader(
+      "X-RateLimit-Limit",
+      this.rateLimiter.getLimit().toString()
+    );
     context.res.setHeader(
       "X-RateLimit-Remaining",
       this.rateLimiter.getRemainingRequests(ip).toString()
     );
-    context.res.setHeader("X-RateLimit-Reset", this.rateLimiter.getResetTime(ip).toString());
+    context.res.setHeader(
+      "X-RateLimit-Reset",
+      this.rateLimiter.getResetTime(ip).toString()
+    );
     if (!this.rateLimiter.isAllowed(ip)) {
       return {
         statusCode: 429,
@@ -580,44 +753,87 @@ var MikroServe = class {
     return new Promise((resolve, reject) => {
       const bodyChunks = [];
       let bodySize = 0;
-      const MAX_BODY_SIZE = 1024 * 1024;
-      let rejected = false;
+      const maxBodySize = this.config.maxBodySize;
+      let settled = false;
+      let timeoutId = null;
       const isDebug = this.config.debug;
       const contentType = req.headers["content-type"] || "";
       if (isDebug) {
         console.log("Content-Type:", contentType);
       }
+      if (this.config.requestTimeout > 0) {
+        timeoutId = setTimeout(() => {
+          if (!settled) {
+            settled = true;
+            if (isDebug) console.log("Request timeout exceeded");
+            reject(new Error("Request timeout"));
+          }
+        }, this.config.requestTimeout);
+      }
+      const cleanup = () => {
+        if (timeoutId) {
+          clearTimeout(timeoutId);
+          timeoutId = null;
+        }
+      };
       req.on("data", (chunk) => {
+        if (settled) {
+          return;
+        }
         bodySize += chunk.length;
-        if (isDebug) console.log(`Received chunk: ${chunk.length} bytes, total size: ${bodySize}`);
-        if (bodySize > MAX_BODY_SIZE && !rejected) {
-          rejected = true;
-          if (isDebug) console.log(`Body size exceeded limit: ${bodySize} > ${MAX_BODY_SIZE}`);
+        if (isDebug)
+          console.log(
+            `Received chunk: ${chunk.length} bytes, total size: ${bodySize}`
+          );
+        if (bodySize > maxBodySize) {
+          settled = true;
+          cleanup();
+          if (isDebug)
+            console.log(
+              `Body size exceeded limit: ${bodySize} > ${maxBodySize}`
+            );
           reject(new Error("Request body too large"));
           return;
         }
-        if (!rejected) bodyChunks.push(chunk);
+        bodyChunks.push(chunk);
       });
       req.on("end", () => {
-        if (rejected) return;
+        if (settled) return;
+        settled = true;
+        cleanup();
         if (isDebug) console.log(`Request body complete: ${bodySize} bytes`);
         try {
           if (bodyChunks.length > 0) {
-            const bodyString = Buffer.concat(bodyChunks).toString("utf8");
+            const bodyBuffer = Buffer.concat(bodyChunks);
             if (contentType.includes("application/json")) {
               try {
+                const bodyString = bodyBuffer.toString("utf8");
                 resolve(JSON.parse(bodyString));
               } catch (error) {
-                reject(new Error(`Invalid JSON in request body: ${error.message}`));
+                reject(
+                  new Error(`Invalid JSON in request body: ${error.message}`)
+                );
               }
             } else if (contentType.includes("application/x-www-form-urlencoded")) {
+              const bodyString = bodyBuffer.toString("utf8");
               const formData = {};
               new URLSearchParams(bodyString).forEach((value, key) => {
                 formData[key] = value;
               });
               resolve(formData);
+            } else if (contentType.includes("multipart/form-data")) {
+              try {
+                const parsed = parseMultipartFormData(bodyBuffer, contentType);
+                resolve(parsed);
+              } catch (error) {
+                reject(
+                  new Error(`Invalid multipart form data: ${error.message}`)
+                );
+              }
+            } else if (this.isBinaryContentType(contentType)) {
+              resolve(bodyBuffer);
             } else {
-              resolve(bodyString);
+              resolve(bodyBuffer.toString("utf8"));
             }
           } else {
             resolve({});
@@ -627,24 +843,61 @@ var MikroServe = class {
         }
       });
       req.on("error", (error) => {
-        if (!rejected) reject(new Error(`Error reading request body: ${error.message}`));
+        if (!settled) {
+          settled = true;
+          cleanup();
+          reject(new Error(`Error reading request body: ${error.message}`));
+        }
+      });
+      req.on("close", () => {
+        cleanup();
       });
     });
   }
+  /**
+   * @description Checks if a content type is binary.
+   */
+  isBinaryContentType(contentType) {
+    const binaryTypes = [
+      "application/octet-stream",
+      "application/pdf",
+      "application/zip",
+      "application/gzip",
+      "application/x-tar",
+      "application/x-rar-compressed",
+      "application/x-7z-compressed",
+      "image/",
+      "video/",
+      "audio/",
+      "application/vnd.ms-excel",
+      "application/vnd.openxmlformats-officedocument",
+      "application/msword",
+      "application/vnd.ms-powerpoint"
+    ];
+    return binaryTypes.some((type) => contentType.includes(type));
+  }
   /**
    * @description CORS middleware.
    */
   setCorsHeaders(res, req) {
     const origin = req.headers.origin;
     const { allowedDomains = ["*"] } = this.config;
-    if (!origin || allowedDomains.length === 0) res.setHeader("Access-Control-Allow-Origin", "*");
-    else if (allowedDomains.includes("*")) res.setHeader("Access-Control-Allow-Origin", "*");
+    if (!origin || allowedDomains.length === 0)
+      res.setHeader("Access-Control-Allow-Origin", "*");
+    else if (allowedDomains.includes("*"))
+      res.setHeader("Access-Control-Allow-Origin", "*");
     else if (allowedDomains.includes(origin)) {
       res.setHeader("Access-Control-Allow-Origin", origin);
       res.setHeader("Vary", "Origin");
     }
-    res.setHeader("Access-Control-Allow-Methods", "GET, POST, PUT, DELETE, PATCH, OPTIONS");
-    res.setHeader("Access-Control-Allow-Headers", "Content-Type, Authorization");
+    res.setHeader(
+      "Access-Control-Allow-Methods",
+      "GET, POST, PUT, DELETE, PATCH, OPTIONS"
+    );
+    res.setHeader(
+      "Access-Control-Allow-Headers",
+      "Content-Type, Authorization"
+    );
     res.setHeader("Access-Control-Max-Age", "86400");
   }
   /**
@@ -687,11 +940,15 @@ var MikroServe = class {
       else if (typeof response.body === "string") res.end(response.body);
       else res.end(JSON.stringify(response.body));
     } else {
-      console.warn("Unexpected response object type without writeHead/end methods");
+      console.warn(
+        "Unexpected response object type without writeHead/end methods"
+      );
       res.writeHead?.(response.statusCode, headers);
-      if (response.body === null || response.body === void 0) res.end?.();
+      if (response.body === null || response.body === void 0)
+        res.end?.();
       else if (response.isRaw) res.end?.(response.body);
-      else if (typeof response.body === "string") res.end?.(response.body);
+      else if (typeof response.body === "string")
+        res.end?.(response.body);
       else res.end?.(JSON.stringify(response.body));
     }
   }
@@ -702,15 +959,46 @@ var MikroServe = class {
     const shutdown = (error) => {
       console.log("Shutting down MikroServe server...");
       if (error) console.error("Error:", error);
+      this.cleanupShutdownHandlers();
       server.close(() => {
         console.log("Server closed successfully");
-        setImmediate(() => process.exit(error ? 1 : 0));
+        if (process.env.NODE_ENV !== "test" && process.env.VITEST !== "true") {
+          setImmediate(() => process.exit(error ? 1 : 0));
+        }
       });
     };
-    process.on("SIGINT", () => shutdown());
-    process.on("SIGTERM", () => shutdown());
-    process.on("uncaughtException", shutdown);
-    process.on("unhandledRejection", shutdown);
+    const sigintHandler = () => shutdown();
+    const sigtermHandler = () => shutdown();
+    const uncaughtExceptionHandler = (error) => shutdown(error);
+    const unhandledRejectionHandler = (error) => shutdown(error);
+    this.shutdownHandlers = [
+      sigintHandler,
+      sigtermHandler,
+      uncaughtExceptionHandler,
+      unhandledRejectionHandler
+    ];
+    process.on("SIGINT", sigintHandler);
+    process.on("SIGTERM", sigtermHandler);
+    process.on("uncaughtException", uncaughtExceptionHandler);
+    process.on("unhandledRejection", unhandledRejectionHandler);
+  }
+  /**
+   * @description Cleans up shutdown event listeners to prevent memory leaks.
+   */
+  cleanupShutdownHandlers() {
+    if (this.shutdownHandlers.length > 0) {
+      const [
+        sigintHandler,
+        sigtermHandler,
+        uncaughtExceptionHandler,
+        unhandledRejectionHandler
+      ] = this.shutdownHandlers;
+      process.removeListener("SIGINT", sigintHandler);
+      process.removeListener("SIGTERM", sigtermHandler);
+      process.removeListener("uncaughtException", uncaughtExceptionHandler);
+      process.removeListener("unhandledRejection", unhandledRejectionHandler);
+      this.shutdownHandlers = [];
+    }
   }
 };
 // Annotate the CommonJS export names for ESM import in node:

package/lib/MikroServe.mjs

@@ -1,10 +1,11 @@
 import {
   MikroServe
-} from "./chunk-TQN6BEGA.mjs";
-import "./chunk-ZFBBESGU.mjs";
-import "./chunk-GUYBTPZH.mjs";
-import "./chunk-YOHL3T54.mjs";
-import "./chunk-JJX5XRNB.mjs";
+} from "./chunk-C4IW4XUH.mjs";
+import "./chunk-OF5DEOIU.mjs";
+import "./chunk-7LU765PG.mjs";
+import "./chunk-ZT2UGCN5.mjs";
+import "./chunk-DMNHVQTU.mjs";
+import "./chunk-VLQ7ZZIU.mjs";
 export {
   MikroServe
 };

package/lib/RateLimiter.js

@@ -57,7 +57,8 @@ var RateLimiter = class {
     const now = Date.now();
     const key = ip || "unknown";
     const entry = this.requests.get(key);
-    if (!entry || entry.resetTime < now) return Math.floor((now + this.windowMs) / 1e3);
+    if (!entry || entry.resetTime < now)
+      return Math.floor((now + this.windowMs) / 1e3);
     return Math.floor(entry.resetTime / 1e3);
   }
   cleanup() {