mikroserve 0.0.1

package/lib/index.js

@@ -0,0 +1,623 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  MikroServe: () => MikroServe
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/MikroServe.ts
+var import_node_fs = require("fs");
+var import_node_http = __toESM(require("http"));
+var import_node_https = __toESM(require("https"));
+
+// src/RateLimiter.ts
+var RateLimiter = class {
+  requests = /* @__PURE__ */ new Map();
+  limit;
+  windowMs;
+  constructor(limit = 100, windowSeconds = 60) {
+    this.limit = limit;
+    this.windowMs = windowSeconds * 1e3;
+    setInterval(() => this.cleanup(), this.windowMs);
+  }
+  getLimit() {
+    return this.limit;
+  }
+  isAllowed(ip) {
+    const now = Date.now();
+    const key = ip || "unknown";
+    let entry = this.requests.get(key);
+    if (!entry || entry.resetTime < now) {
+      entry = { count: 0, resetTime: now + this.windowMs };
+      this.requests.set(key, entry);
+    }
+    entry.count++;
+    return entry.count <= this.limit;
+  }
+  getRemainingRequests(ip) {
+    const now = Date.now();
+    const key = ip || "unknown";
+    const entry = this.requests.get(key);
+    if (!entry || entry.resetTime < now) return this.limit;
+    return Math.max(0, this.limit - entry.count);
+  }
+  getResetTime(ip) {
+    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);
+    return Math.floor(entry.resetTime / 1e3);
+  }
+  cleanup() {
+    const now = Date.now();
+    for (const [key, entry] of this.requests.entries()) {
+      if (entry.resetTime < now) this.requests.delete(key);
+    }
+  }
+};
+
+// src/Router.ts
+var import_node_url = require("url");
+var Router = class {
+  routes = [];
+  globalMiddlewares = [];
+  pathPatterns = /* @__PURE__ */ new Map();
+  /**
+   * 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
+   */
+  get(path, ...handlers) {
+    const handler = handlers.pop();
+    return this.register("GET", path, handler, handlers);
+  }
+  /**
+   * Register a POST route
+   */
+  post(path, ...handlers) {
+    const handler = handlers.pop();
+    return this.register("POST", path, handler, handlers);
+  }
+  /**
+   * Register a PUT route
+   */
+  put(path, ...handlers) {
+    const handler = handlers.pop();
+    return this.register("PUT", path, handler, handlers);
+  }
+  /**
+   * Register a DELETE route
+   */
+  delete(path, ...handlers) {
+    const handler = handlers.pop();
+    return this.register("DELETE", path, handler, handlers);
+  }
+  /**
+   * Register a PATCH route
+   */
+  patch(path, ...handlers) {
+    const handler = handlers.pop();
+    return this.register("PATCH", path, handler, handlers);
+  }
+  /**
+   * Register an OPTIONS route
+   */
+  options(path, ...handlers) {
+    const handler = handlers.pop();
+    return this.register("OPTIONS", path, handler, handlers);
+  }
+  /**
+   * Match a request to a route
+   */
+  match(method, path) {
+    for (const route of this.routes) {
+      if (route.method !== method) continue;
+      const pathPattern = this.pathPatterns.get(route.path);
+      if (!pathPattern) continue;
+      const match = pathPattern.pattern.exec(path);
+      if (!match) continue;
+      const params = {};
+      pathPattern.paramNames.forEach((name, index) => {
+        params[name] = match[index + 1] || "";
+      });
+      return { route, params };
+    }
+    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
+   */
+  async handle(req, res) {
+    const method = req.method || "GET";
+    const url = new import_node_url.URL(req.url || "/", `http://${req.headers.host}`);
+    const path = url.pathname;
+    const matched = this.match(method, path);
+    if (!matched) return null;
+    const { route, params } = matched;
+    const query = {};
+    url.searchParams.forEach((value, key) => {
+      query[key] = value;
+    });
+    const context = {
+      req,
+      res,
+      params,
+      query,
+      // @ts-ignore
+      body: req.body || {},
+      headers: req.headers,
+      path,
+      state: {},
+      // Add the missing state property
+      text: (content, status = 200) => ({
+        statusCode: status,
+        body: content,
+        headers: { "Content-Type": "text/plain" }
+      }),
+      form: (content, status = 200) => ({
+        statusCode: status,
+        body: content,
+        headers: { "Content-Type": "application/x-www-form-urlencoded" }
+      }),
+      json: (content, status = 200) => ({
+        statusCode: status,
+        body: content,
+        headers: { "Content-Type": "application/json" }
+      }),
+      html: (content, status = 200) => ({
+        statusCode: status,
+        body: content,
+        headers: { "Content-Type": "text/html" }
+      }),
+      redirect: (url2, status = 302) => ({
+        statusCode: status,
+        body: null,
+        headers: { Location: url2 }
+      }),
+      status: function(code) {
+        return {
+          text: (content) => ({
+            statusCode: code,
+            body: content,
+            headers: { "Content-Type": "text/plain" }
+          }),
+          json: (data) => ({
+            statusCode: code,
+            body: data,
+            headers: { "Content-Type": "application/json" }
+          }),
+          html: (content) => ({
+            statusCode: code,
+            body: content,
+            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" }
+          }),
+          redirect: (url2, redirectStatus = 302) => ({
+            statusCode: redirectStatus,
+            body: null,
+            headers: { Location: url2 }
+          }),
+          status: (updatedCode) => this.status(updatedCode)
+        };
+      }
+    };
+    const middlewares = [...this.globalMiddlewares, ...route.middlewares];
+    return this.executeMiddlewareChain(context, middlewares, route.handler);
+  }
+  /**
+   * Execute middleware chain and final handler
+   */
+  async executeMiddlewareChain(context, middlewares, finalHandler) {
+    let currentIndex = 0;
+    const next = async () => {
+      if (currentIndex < middlewares.length) {
+        const middleware = middlewares[currentIndex++];
+        return middleware(context, next);
+      }
+      return finalHandler(context);
+    };
+    return next();
+  }
+};
+
+// src/MikroServe.ts
+var MikroServe = class {
+  config;
+  rateLimiter;
+  router;
+  useHttps;
+  sslCert;
+  sslKey;
+  sslCa;
+  debug;
+  /**
+   * @description Creates a new MikroServe instance.
+   * @param config - Server configuration options
+   */
+  constructor(config) {
+    this.config = config;
+    const { useHttps, sslCa, sslCert, sslKey, debug } = config;
+    const requestsPerMinute = config.rateLimit?.requestsPerMinute || 50;
+    this.rateLimiter = new RateLimiter(requestsPerMinute, 60);
+    this.router = new Router();
+    this.useHttps = useHttps || false;
+    this.sslCert = sslCert;
+    this.sslKey = sslKey;
+    this.sslCa = sslCa;
+    this.debug = debug || false;
+    if (config.rateLimit?.enabled !== false) this.use(this.rateLimitMiddleware.bind(this));
+  }
+  /**
+   * Register a global middleware
+   */
+  use(middleware) {
+    this.router.use(middleware);
+    return this;
+  }
+  /**
+   * Register a GET route
+   */
+  get(path, ...handlers) {
+    this.router.get(path, ...handlers);
+    return this;
+  }
+  /**
+   * Register a POST route
+   */
+  post(path, ...handlers) {
+    this.router.post(path, ...handlers);
+    return this;
+  }
+  /**
+   * Register a PUT route
+   */
+  put(path, ...handlers) {
+    this.router.put(path, ...handlers);
+    return this;
+  }
+  /**
+   * Register a DELETE route
+   */
+  delete(path, ...handlers) {
+    this.router.delete(path, ...handlers);
+    return this;
+  }
+  /**
+   * Register a PATCH route
+   */
+  patch(path, ...handlers) {
+    this.router.patch(path, ...handlers);
+    return this;
+  }
+  /**
+   * Register an OPTIONS route
+   */
+  options(path, ...handlers) {
+    this.router.options(path, ...handlers);
+    return this;
+  }
+  /**
+   * Creates an HTTP/HTTPS server, sets up graceful shutdown, and starts listening.
+   * @returns Running HTTP/HTTPS server
+   */
+  start() {
+    const server = this.createServer();
+    const { port = 3e3, host = "localhost" } = this.config;
+    this.setupGracefulShutdown(server);
+    server.listen(port, host, () => {
+      const address = server.address();
+      const protocol = this.useHttps ? "https" : "http";
+      console.log(
+        `MikroServe running at ${protocol}://${address.address !== "::" ? address.address : "localhost"}:${address.port}`
+      );
+    });
+    return server;
+  }
+  /**
+   * Creates and configures a server instance without starting it.
+   * @returns Configured HTTP or HTTPS server instance
+   */
+  createServer() {
+    const boundRequestHandler = this.requestHandler.bind(this);
+    if (this.useHttps) {
+      if (!this.sslCert || !this.sslKey)
+        throw new Error("SSL certificate and key paths are required when useHttps is true");
+      try {
+        const httpsOptions = {
+          key: (0, import_node_fs.readFileSync)(this.sslKey),
+          cert: (0, import_node_fs.readFileSync)(this.sslCert),
+          ...this.sslCa ? { ca: (0, import_node_fs.readFileSync)(this.sslCa) } : {}
+        };
+        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 error;
+      }
+    }
+    return import_node_http.default.createServer(boundRequestHandler);
+  }
+  /**
+   * Rate limiting middleware
+   */
+  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-Remaining",
+      this.rateLimiter.getRemainingRequests(ip).toString()
+    );
+    context.res.setHeader("X-RateLimit-Reset", this.rateLimiter.getResetTime(ip).toString());
+    if (!this.rateLimiter.isAllowed(ip)) {
+      return {
+        statusCode: 429,
+        body: {
+          error: "Too Many Requests",
+          message: "Rate limit exceeded, please try again later"
+        },
+        headers: { "Content-Type": "application/json" }
+      };
+    }
+    return next();
+  }
+  /**
+   * Request handler for HTTP and HTTPS servers.
+   */
+  async requestHandler(req, res) {
+    const start = Date.now();
+    const method = req.method || "UNKNOWN";
+    const url = req.url || "/unknown";
+    try {
+      this.setCorsHeaders(res, req);
+      this.setSecurityHeaders(res, this.useHttps);
+      if (this.debug) console.log(`${method} ${url}`);
+      if (req.method === "OPTIONS") {
+        res.statusCode = 204;
+        res.end();
+        return;
+      }
+      try {
+        req.body = await this.parseBody(req);
+      } catch (error) {
+        if (this.debug) {
+          console.error("Body parsing error:", error.message);
+        }
+        return this.respond(res, {
+          statusCode: 400,
+          body: {
+            error: "Bad Request",
+            message: error.message
+          }
+        });
+      }
+      const result = await this.router.handle(req, res);
+      if (result) return this.respond(res, result);
+      return this.respond(res, {
+        statusCode: 404,
+        body: {
+          error: "Not Found",
+          message: "The requested endpoint does not exist"
+        }
+      });
+    } catch (error) {
+      console.error("Server error:", error);
+      return this.respond(res, {
+        statusCode: 500,
+        body: {
+          error: "Internal Server Error",
+          message: this.debug ? error.message : "An unexpected error occurred"
+        }
+      });
+    } finally {
+      if (this.debug) {
+        this.logDuration(start, method, url);
+      }
+    }
+  }
+  /**
+   * Writes out a clean log to represent the duration of the request.
+   */
+  logDuration(start, method, url) {
+    const duration = Date.now() - start;
+    console.log(`${method} ${url} completed in ${duration}ms`);
+  }
+  /**
+   * Parses the request body based on content type.
+   * @param req - HTTP request object
+   * @returns Promise resolving to the parsed body
+   * @throws Will throw if body cannot be parsed
+   */
+  /**
+   * Parses the request body based on content type.
+   * @param req - HTTP request object
+   * @returns Promise resolving to the parsed body
+   * @throws Will throw if body cannot be parsed
+   */
+  async parseBody(req) {
+    return new Promise((resolve, reject) => {
+      const bodyChunks = [];
+      let bodySize = 0;
+      const MAX_BODY_SIZE = 1024 * 1024;
+      let rejected = false;
+      const contentType = req.headers["content-type"] || "";
+      if (this.debug) {
+        console.log("Content-Type:", contentType);
+      }
+      req.on("data", (chunk) => {
+        bodySize += chunk.length;
+        if (this.debug)
+          console.log(`Received chunk: ${chunk.length} bytes, total size: ${bodySize}`);
+        if (bodySize > MAX_BODY_SIZE && !rejected) {
+          rejected = true;
+          if (this.debug) console.log(`Body size exceeded limit: ${bodySize} > ${MAX_BODY_SIZE}`);
+          reject(new Error("Request body too large"));
+          return;
+        }
+        if (!rejected) bodyChunks.push(chunk);
+      });
+      req.on("end", () => {
+        if (rejected) return;
+        if (this.debug) console.log(`Request body complete: ${bodySize} bytes`);
+        try {
+          if (bodyChunks.length > 0) {
+            const bodyString = Buffer.concat(bodyChunks).toString("utf8");
+            if (contentType.includes("application/json")) {
+              try {
+                resolve(JSON.parse(bodyString));
+              } catch (error) {
+                reject(new Error(`Invalid JSON in request body: ${error.message}`));
+              }
+            } else if (contentType.includes("application/x-www-form-urlencoded")) {
+              const formData = {};
+              new URLSearchParams(bodyString).forEach((value, key) => {
+                formData[key] = value;
+              });
+              resolve(formData);
+            } else {
+              resolve(bodyString);
+            }
+          } else {
+            resolve({});
+          }
+        } catch (error) {
+          reject(new Error(`Invalid request body: ${error}`));
+        }
+      });
+      req.on("error", (error) => {
+        if (!rejected) reject(new Error(`Error reading request body: ${error.message}`));
+      });
+    });
+  }
+  /**
+   * CORS middleware
+   */
+  // Update the setCorsHeaders method in MikroServe class to handle allowed domains
+  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", "*");
+    } 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-Max-Age", "86400");
+  }
+  /**
+   * Set security headers
+   */
+  setSecurityHeaders(res, isHttps = false) {
+    res.setHeader("X-Content-Type-Options", "nosniff");
+    res.setHeader("X-Frame-Options", "DENY");
+    res.setHeader(
+      "Content-Security-Policy",
+      "default-src 'self'; script-src 'self'; object-src 'none'"
+    );
+    if (isHttps) res.setHeader("Strict-Transport-Security", "max-age=31536000; includeSubDomains");
+    res.setHeader("X-XSS-Protection", "1; mode=block");
+  }
+  /**
+   * Sends a response with appropriate headers.
+   * @param res - HTTP response object
+   * @param response - Response data and status code
+   */
+  respond(res, response) {
+    const headers = {
+      ...response.headers || {}
+    };
+    res.writeHead(response.statusCode, headers);
+    if (response.body === null || response.body === void 0) res.end();
+    else if (typeof response.body === "string") res.end(response.body);
+    else res.end(JSON.stringify(response.body));
+  }
+  /**
+   * Sets up graceful shutdown handlers for a server.
+   * @param server - The HTTP/HTTPS server to add shutdown handlers to
+   */
+  setupGracefulShutdown(server) {
+    const shutdown = (error) => {
+      console.log("Shutting down MikroServe server...");
+      if (error) console.error("Error:", error);
+      server.close(() => {
+        console.log("Server closed successfully");
+        setImmediate(() => {
+          process.exit(error ? 1 : 0);
+        });
+      });
+    };
+    process.on("SIGINT", () => shutdown());
+    process.on("SIGTERM", () => shutdown());
+    process.on("uncaughtException", shutdown);
+    process.on("unhandledRejection", shutdown);
+  }
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  MikroServe
+});

package/lib/index.mjs

@@ -0,0 +1,8 @@
+import {
+  MikroServe
+} from "./chunk-GGGGATKH.mjs";
+import "./chunk-ZFBBESGU.mjs";
+import "./chunk-KJT4SET2.mjs";
+export {
+  MikroServe
+};