@morojs/moro 1.0.0

package/src/core/runtime/vercel-edge-adapter.ts

@@ -0,0 +1,125 @@
+// Vercel Edge runtime adapter
+import { BaseRuntimeAdapter } from "./base-adapter";
+import { HttpRequest, HttpResponse } from "../../types/http";
+import { RuntimeHttpResponse } from "../../types/runtime";
+
+export class VercelEdgeAdapter extends BaseRuntimeAdapter {
+  readonly type = "vercel-edge" as const;
+
+  async adaptRequest(request: Request): Promise<HttpRequest> {
+    const url = new URL(request.url);
+    const { pathname, query } = this.parseUrl(request.url);
+
+    // Parse body for POST/PUT/PATCH requests
+    let body: any;
+    if (["POST", "PUT", "PATCH"].includes(request.method)) {
+      const contentType = request.headers.get("content-type") || "";
+      if (contentType.includes("application/json")) {
+        try {
+          body = await request.json();
+        } catch {
+          body = await request.text();
+        }
+      } else {
+        body = await request.text();
+      }
+    }
+
+    // Convert Headers to plain object
+    const headers: Record<string, string> = {};
+    request.headers.forEach((value, key) => {
+      headers[key] = value;
+    });
+
+    const baseRequest = {
+      method: request.method,
+      url: request.url,
+      path: pathname,
+      query,
+      body,
+      headers,
+      ip: this.getClientIP(headers),
+      params: {},
+      requestId: "",
+      cookies: {},
+      files: {},
+    } as Partial<HttpRequest>;
+
+    return this.enhanceRequest(baseRequest);
+  }
+
+  async adaptResponse(
+    moroResponse: HttpResponse | RuntimeHttpResponse,
+  ): Promise<Response> {
+    const runtimeResponse = moroResponse as RuntimeHttpResponse;
+
+    // Handle different response states
+    let body = runtimeResponse.body;
+    let status = runtimeResponse.statusCode || 200;
+    const headers = runtimeResponse.headers || {};
+
+    // If it's a real HttpResponse, we need to extract the data differently
+    if (
+      "statusCode" in moroResponse &&
+      typeof moroResponse.statusCode === "number"
+    ) {
+      status = moroResponse.statusCode;
+    }
+
+    // Convert headers to Headers object
+    const responseHeaders = new Headers();
+    Object.entries(headers).forEach(([key, value]) => {
+      responseHeaders.set(key, value);
+    });
+
+    // Handle different body types
+    if (typeof body === "object" && body !== null) {
+      body = JSON.stringify(body);
+      responseHeaders.set("Content-Type", "application/json");
+    }
+
+    return new Response(body, {
+      status,
+      headers: responseHeaders,
+    });
+  }
+
+  createServer(
+    handler: (req: HttpRequest, res: HttpResponse) => Promise<void>,
+  ) {
+    // Return a Vercel Edge-compatible handler function
+    return async (request: Request) => {
+      try {
+        const moroReq = await this.adaptRequest(request);
+        const moroRes = this.createMockResponse();
+
+        await handler(moroReq, moroRes as any);
+
+        return await this.adaptResponse(moroRes);
+      } catch (error) {
+        return new Response(
+          JSON.stringify({
+            success: false,
+            error: "Internal server error",
+            message: error instanceof Error ? error.message : "Unknown error",
+          }),
+          {
+            status: 500,
+            headers: { "Content-Type": "application/json" },
+          },
+        );
+      }
+    };
+  }
+
+  // Vercel Edge doesn't have a listen method - it's handled by the platform
+  // listen method is optional in the interface
+
+  private getClientIP(headers: Record<string, string>): string {
+    return (
+      headers["x-forwarded-for"]?.split(",")[0]?.trim() ||
+      headers["x-real-ip"] ||
+      "unknown"
+    );
+  }
+}

package/src/core/utilities/circuit-breaker.ts

@@ -0,0 +1,46 @@
+// src/core/circuit-breaker.ts
+export class CircuitBreaker {
+  private failures = 0;
+  private lastFailTime = 0;
+  private state: "CLOSED" | "OPEN" | "HALF_OPEN" = "CLOSED";
+
+  constructor(
+    private options: {
+      failureThreshold: number;
+      resetTimeout: number;
+      monitoringPeriod: number;
+    },
+  ) {}
+
+  async execute<T>(fn: () => Promise<T>): Promise<T> {
+    if (this.state === "OPEN") {
+      if (Date.now() - this.lastFailTime < this.options.resetTimeout) {
+        throw new Error("Circuit breaker is OPEN");
+      }
+      this.state = "HALF_OPEN";
+    }
+
+    try {
+      const result = await fn();
+      this.onSuccess();
+      return result;
+    } catch (error) {
+      this.onFailure();
+      throw error;
+    }
+  }
+
+  private onSuccess() {
+    this.failures = 0;
+    this.state = "CLOSED";
+  }
+
+  private onFailure() {
+    this.failures++;
+    this.lastFailTime = Date.now();
+
+    if (this.failures >= this.options.failureThreshold) {
+      this.state = "OPEN";
+    }
+  }
+}