mikroserve 0.0.1

package/lib/RateLimiter.js

@@ -0,0 +1,73 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+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 __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/RateLimiter.ts
+var RateLimiter_exports = {};
+__export(RateLimiter_exports, {
+  RateLimiter: () => RateLimiter
+});
+module.exports = __toCommonJS(RateLimiter_exports);
+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);
+    }
+  }
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  RateLimiter
+});

package/lib/RateLimiter.mjs

@@ -0,0 +1,6 @@
+import {
+  RateLimiter
+} from "./chunk-ZFBBESGU.mjs";
+export {
+  RateLimiter
+};

package/lib/Router.d.mts

@@ -0,0 +1,64 @@
+import http from 'node:http';
+import { Middleware, RouteHandler, Route, HandlerResponse } from './interfaces/index.mjs';
+
+/**
+ * Router class to manage routes and middleware
+ */
+declare class Router {
+    private routes;
+    private globalMiddlewares;
+    private pathPatterns;
+    /**
+     * Add a global middleware
+     */
+    use(middleware: Middleware): this;
+    /**
+     * Register a route with specified method
+     */
+    private register;
+    /**
+     * Register a GET route
+     */
+    get(path: string, ...handlers: (RouteHandler | Middleware)[]): this;
+    /**
+     * Register a POST route
+     */
+    post(path: string, ...handlers: (RouteHandler | Middleware)[]): this;
+    /**
+     * Register a PUT route
+     */
+    put(path: string, ...handlers: (RouteHandler | Middleware)[]): this;
+    /**
+     * Register a DELETE route
+     */
+    delete(path: string, ...handlers: (RouteHandler | Middleware)[]): this;
+    /**
+     * Register a PATCH route
+     */
+    patch(path: string, ...handlers: (RouteHandler | Middleware)[]): this;
+    /**
+     * Register an OPTIONS route
+     */
+    options(path: string, ...handlers: (RouteHandler | Middleware)[]): this;
+    /**
+     * Match a request to a route
+     */
+    match(method: string, path: string): {
+        route: Route;
+        params: Record<string, string>;
+    } | null;
+    /**
+     * Create a regex pattern for path matching
+     */
+    private createPathPattern;
+    /**
+     * Handle a request and find the matching route
+     */
+    handle(req: http.IncomingMessage, res: http.ServerResponse): Promise<HandlerResponse | null>;
+    /**
+     * Execute middleware chain and final handler
+     */
+    private executeMiddlewareChain;
+}
+
+export { Router };

package/lib/Router.d.ts

@@ -0,0 +1,64 @@
+import http from 'node:http';
+import { Middleware, RouteHandler, Route, HandlerResponse } from './interfaces/index.js';
+
+/**
+ * Router class to manage routes and middleware
+ */
+declare class Router {
+    private routes;
+    private globalMiddlewares;
+    private pathPatterns;
+    /**
+     * Add a global middleware
+     */
+    use(middleware: Middleware): this;
+    /**
+     * Register a route with specified method
+     */
+    private register;
+    /**
+     * Register a GET route
+     */
+    get(path: string, ...handlers: (RouteHandler | Middleware)[]): this;
+    /**
+     * Register a POST route
+     */
+    post(path: string, ...handlers: (RouteHandler | Middleware)[]): this;
+    /**
+     * Register a PUT route
+     */
+    put(path: string, ...handlers: (RouteHandler | Middleware)[]): this;
+    /**
+     * Register a DELETE route
+     */
+    delete(path: string, ...handlers: (RouteHandler | Middleware)[]): this;
+    /**
+     * Register a PATCH route
+     */
+    patch(path: string, ...handlers: (RouteHandler | Middleware)[]): this;
+    /**
+     * Register an OPTIONS route
+     */
+    options(path: string, ...handlers: (RouteHandler | Middleware)[]): this;
+    /**
+     * Match a request to a route
+     */
+    match(method: string, path: string): {
+        route: Route;
+        params: Record<string, string>;
+    } | null;
+    /**
+     * Create a regex pattern for path matching
+     */
+    private createPathPattern;
+    /**
+     * Handle a request and find the matching route
+     */
+    handle(req: http.IncomingMessage, res: http.ServerResponse): Promise<HandlerResponse | null>;
+    /**
+     * Execute middleware chain and final handler
+     */
+    private executeMiddlewareChain;
+}
+
+export { Router };

package/lib/Router.js

@@ -0,0 +1,224 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+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 __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/Router.ts
+var Router_exports = {};
+__export(Router_exports, {
+  Router: () => Router
+});
+module.exports = __toCommonJS(Router_exports);
+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();
+  }
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  Router
+});

package/lib/Router.mjs

@@ -0,0 +1,6 @@
+import {
+  Router
+} from "./chunk-KJT4SET2.mjs";
+export {
+  Router
+};