@morojs/moro 1.0.0

package/src/core/runtime/base-adapter.ts

@@ -0,0 +1,140 @@
+// Base runtime adapter with common functionality
+import {
+  RuntimeAdapter,
+  RuntimeType,
+  RuntimeHttpResponse,
+} from "../../types/runtime";
+import { HttpRequest, HttpResponse } from "../../types/http";
+import { randomBytes } from "crypto";
+
+export abstract class BaseRuntimeAdapter implements RuntimeAdapter {
+  abstract readonly type: RuntimeType;
+
+  abstract adaptRequest(
+    runtimeRequest: any,
+    ...args: any[]
+  ): Promise<HttpRequest>;
+  abstract adaptResponse(
+    moroResponse: HttpResponse | RuntimeHttpResponse,
+    runtimeRequest: any,
+  ): Promise<any>;
+  abstract createServer(
+    handler: (req: HttpRequest, res: HttpResponse) => Promise<void>,
+  ): any;
+
+  // Generate UUID without external dependency
+  protected generateUUID(): string {
+    return randomBytes(16)
+      .toString("hex")
+      .replace(/(.{8})(.{4})(.{4})(.{4})(.{12})/, "$1-$2-$3-$4-$5");
+  }
+
+  // Common request enhancement
+  protected enhanceRequest(baseRequest: Partial<HttpRequest>): HttpRequest {
+    const request = baseRequest as HttpRequest;
+
+    // Add common properties
+    request.requestId = request.requestId || this.generateUUID();
+    request.ip = request.ip || "unknown";
+    request.params = request.params || {};
+    request.query = request.query || {};
+    request.cookies = request.cookies || {};
+    request.files = request.files || {};
+
+    return request;
+  }
+
+  // Common response enhancement
+  protected createMockResponse(): RuntimeHttpResponse {
+    const response: RuntimeHttpResponse = {
+      statusCode: 200,
+      headers: {},
+      body: null,
+      headersSent: false,
+
+      status: function (code: number) {
+        this.statusCode = code;
+        return this;
+      },
+
+      json: function (data: any) {
+        this.headers["Content-Type"] = "application/json";
+        this.body = JSON.stringify(data);
+        this.headersSent = true;
+      },
+
+      send: function (data: string | Buffer) {
+        this.body = data;
+        this.headersSent = true;
+      },
+
+      cookie: function (name: string, value: string, options?: any) {
+        // Simple cookie implementation
+        const cookieString = `${name}=${value}`;
+        this.headers["Set-Cookie"] = cookieString;
+        return this;
+      },
+
+      clearCookie: function (name: string, options?: any) {
+        this.headers["Set-Cookie"] =
+          `${name}=; expires=Thu, 01 Jan 1970 00:00:00 GMT`;
+        return this;
+      },
+
+      redirect: function (url: string, status?: number) {
+        this.statusCode = status || 302;
+        this.headers["Location"] = url;
+        this.headersSent = true;
+      },
+
+      sendFile: async function (filePath: string) {
+        throw new Error("sendFile not implemented in this runtime");
+      },
+    };
+
+    return response;
+  }
+
+  // Parse URL and query parameters
+  protected parseUrl(url: string): {
+    pathname: string;
+    query: Record<string, string>;
+  } {
+    try {
+      const urlObj = new URL(url, "http://localhost");
+      const query: Record<string, string> = {};
+
+      urlObj.searchParams.forEach((value, key) => {
+        query[key] = value;
+      });
+
+      return {
+        pathname: urlObj.pathname,
+        query,
+      };
+    } catch {
+      return {
+        pathname: url,
+        query: {},
+      };
+    }
+  }
+
+  // Parse body based on content type
+  protected async parseBody(body: any, contentType?: string): Promise<any> {
+    if (!body) return undefined;
+
+    if (typeof body === "string") {
+      if (contentType?.includes("application/json")) {
+        try {
+          return JSON.parse(body);
+        } catch {
+          return body;
+        }
+      }
+      return body;
+    }
+
+    return body;
+  }
+}

package/src/core/runtime/cloudflare-workers-adapter.ts

@@ -0,0 +1,166 @@
+// Cloudflare Workers runtime adapter
+import { BaseRuntimeAdapter } from "./base-adapter";
+import { HttpRequest, HttpResponse } from "../../types/http";
+import { RuntimeHttpResponse } from "../../types/runtime";
+
+export interface WorkersEnv {
+  [key: string]: any;
+}
+
+export interface WorkersContext {
+  waitUntil(promise: Promise<any>): void;
+  passThroughOnException(): void;
+}
+
+export class CloudflareWorkersAdapter extends BaseRuntimeAdapter {
+  readonly type = "cloudflare-workers" as const;
+
+  async adaptRequest(
+    request: Request,
+    env: WorkersEnv,
+    ctx: WorkersContext,
+  ): Promise<HttpRequest> {
+    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 if (contentType.includes("application/x-www-form-urlencoded")) {
+        body = await request.formData();
+        // Convert FormData to object
+        const formObject: Record<string, any> = {};
+        body.forEach((value: any, key: string) => {
+          formObject[key] = value;
+        });
+        body = formObject;
+      } 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, request),
+      params: {},
+      requestId: "",
+      cookies: this.parseCookies(headers.cookie || ""),
+      files: {},
+      // Add Workers-specific context
+      env,
+      ctx,
+    } 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 Cloudflare Workers-compatible handler function
+    return async (request: Request, env: WorkersEnv, ctx: WorkersContext) => {
+      try {
+        const moroReq = await this.adaptRequest(request, env, ctx);
+        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" },
+          },
+        );
+      }
+    };
+  }
+
+  // Cloudflare Workers 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>,
+    request: Request,
+  ): string {
+    // Cloudflare provides the real IP in CF-Connecting-IP header
+    return (
+      headers["cf-connecting-ip"] ||
+      headers["x-forwarded-for"]?.split(",")[0]?.trim() ||
+      headers["x-real-ip"] ||
+      "unknown"
+    );
+  }
+
+  private parseCookies(cookieHeader: string): Record<string, string> {
+    const cookies: Record<string, string> = {};
+    if (cookieHeader) {
+      cookieHeader.split(";").forEach((cookie) => {
+        const [name, ...rest] = cookie.trim().split("=");
+        if (name && rest.length > 0) {
+          cookies[name] = rest.join("=");
+        }
+      });
+    }
+    return cookies;
+  }
+}

package/src/core/runtime/index.ts

@@ -0,0 +1,74 @@
+// Runtime adapters export
+export { BaseRuntimeAdapter } from "./base-adapter";
+export { NodeRuntimeAdapter } from "./node-adapter";
+export { VercelEdgeAdapter } from "./vercel-edge-adapter";
+export { AWSLambdaAdapter } from "./aws-lambda-adapter";
+export { CloudflareWorkersAdapter } from "./cloudflare-workers-adapter";
+
+// Re-export types
+export type {
+  RuntimeType,
+  RuntimeAdapter,
+  RuntimeConfig,
+  RuntimeMoroOptions,
+  RuntimeHttpResponse,
+} from "../../types/runtime";
+
+// Re-export specific runtime types
+export type {
+  LambdaEvent,
+  LambdaContext,
+  LambdaResponse,
+} from "./aws-lambda-adapter";
+export type { WorkersEnv, WorkersContext } from "./cloudflare-workers-adapter";
+
+// Runtime factory functions
+import { NodeRuntimeAdapter } from "./node-adapter";
+import { VercelEdgeAdapter } from "./vercel-edge-adapter";
+import { AWSLambdaAdapter } from "./aws-lambda-adapter";
+import { CloudflareWorkersAdapter } from "./cloudflare-workers-adapter";
+import { RuntimeType, RuntimeAdapter } from "../../types/runtime";
+
+export function createRuntimeAdapter(type: RuntimeType): RuntimeAdapter {
+  switch (type) {
+    case "node":
+      return new NodeRuntimeAdapter();
+    case "vercel-edge":
+      return new VercelEdgeAdapter();
+    case "aws-lambda":
+      return new AWSLambdaAdapter();
+    case "cloudflare-workers":
+      return new CloudflareWorkersAdapter();
+    default:
+      throw new Error(`Unsupported runtime type: ${type}`);
+  }
+}
+
+// Convenience functions for creating runtime-specific handlers
+export function createNodeHandler(
+  handler: (req: any, res: any) => Promise<void>,
+) {
+  const adapter = new NodeRuntimeAdapter();
+  return adapter.createServer(handler);
+}
+
+export function createEdgeHandler(
+  handler: (req: any, res: any) => Promise<void>,
+) {
+  const adapter = new VercelEdgeAdapter();
+  return adapter.createServer(handler);
+}
+
+export function createLambdaHandler(
+  handler: (req: any, res: any) => Promise<void>,
+) {
+  const adapter = new AWSLambdaAdapter();
+  return adapter.createServer(handler);
+}
+
+export function createWorkerHandler(
+  handler: (req: any, res: any) => Promise<void>,
+) {
+  const adapter = new CloudflareWorkersAdapter();
+  return adapter.createServer(handler);
+}

package/src/core/runtime/node-adapter.ts

@@ -0,0 +1,210 @@
+// Node.js runtime adapter
+import { IncomingMessage, ServerResponse } from "http";
+import { BaseRuntimeAdapter } from "./base-adapter";
+import { HttpRequest, HttpResponse } from "../../types/http";
+import { RuntimeHttpResponse } from "../../types/runtime";
+import { MoroHttpServer } from "../http/http-server";
+
+export class NodeRuntimeAdapter extends BaseRuntimeAdapter {
+  readonly type = "node" as const;
+
+  async adaptRequest(req: IncomingMessage): Promise<HttpRequest> {
+    const { pathname, query } = this.parseUrl(req.url || "/");
+
+    // Parse body for POST/PUT/PATCH requests
+    let body: any;
+    if (["POST", "PUT", "PATCH"].includes(req.method!)) {
+      body = await this.parseRequestBody(req);
+    }
+
+    const baseRequest = {
+      // Copy IncomingMessage properties we need
+      method: req.method!,
+      url: req.url!,
+      headers: req.headers as Record<string, string>,
+      httpVersion: req.httpVersion,
+      httpVersionMajor: req.httpVersionMajor,
+      httpVersionMinor: req.httpVersionMinor,
+      socket: req.socket,
+
+      // Add MoroJS-specific properties
+      path: pathname,
+      query,
+      body,
+      ip: this.getClientIP(req),
+      params: {},
+      requestId: "",
+      cookies: {},
+      files: {},
+    } as Partial<HttpRequest>;
+
+    return this.enhanceRequest(baseRequest);
+  }
+
+  async adaptResponse(
+    moroResponse: HttpResponse | RuntimeHttpResponse,
+    req: IncomingMessage,
+  ): Promise<ServerResponse> {
+    // For Node.js, we typically work with the actual ServerResponse
+    // This method is mainly for converting mock responses back to real ones
+    return moroResponse as any;
+  }
+
+  createServer(
+    handler: (req: HttpRequest, res: HttpResponse) => Promise<void>,
+  ): MoroHttpServer {
+    const httpServer = new MoroHttpServer();
+
+    // Replace the default request handler with our runtime-aware handler
+    const originalServer = httpServer.getServer();
+    originalServer.removeAllListeners("request");
+
+    originalServer.on(
+      "request",
+      async (req: IncomingMessage, res: ServerResponse) => {
+        try {
+          const moroReq = await this.adaptRequest(req);
+          const moroRes = this.enhanceResponse(res);
+
+          await handler(moroReq, moroRes);
+        } catch (error) {
+          if (!res.headersSent) {
+            res.statusCode = 500;
+            res.setHeader("Content-Type", "application/json");
+            res.end(
+              JSON.stringify({
+                success: false,
+                error: "Internal server error",
+                message:
+                  error instanceof Error ? error.message : "Unknown error",
+              }),
+            );
+          }
+        }
+      },
+    );
+
+    return httpServer;
+  }
+
+  listen(
+    server: MoroHttpServer,
+    port: number,
+    host?: string,
+    callback?: () => void,
+  ): void {
+    server.listen(port, host as any, callback);
+  }
+
+  // Helper methods
+  private async parseRequestBody(req: IncomingMessage): Promise<any> {
+    return new Promise((resolve, reject) => {
+      let body = "";
+      req.on("data", (chunk) => {
+        body += chunk.toString();
+      });
+      req.on("end", () => {
+        try {
+          const contentType = req.headers["content-type"] || "";
+          resolve(this.parseBody(body, contentType));
+        } catch (error) {
+          reject(error);
+        }
+      });
+      req.on("error", reject);
+    });
+  }
+
+  private getClientIP(req: IncomingMessage): string {
+    const forwarded = req.headers["x-forwarded-for"] as string;
+    if (forwarded) {
+      return forwarded.split(",")[0].trim();
+    }
+    return req.socket.remoteAddress || "unknown";
+  }
+
+  private enhanceResponse(res: ServerResponse): HttpResponse {
+    const enhanced = res as any;
+
+    // Add MoroJS response methods if they don't exist
+    if (!enhanced.json) {
+      enhanced.json = function (data: any) {
+        this.setHeader("Content-Type", "application/json");
+        this.end(JSON.stringify(data));
+      };
+    }
+
+    if (!enhanced.status) {
+      enhanced.status = function (code: number) {
+        this.statusCode = code;
+        return this;
+      };
+    }
+
+    if (!enhanced.send) {
+      enhanced.send = function (data: string | Buffer) {
+        this.end(data);
+      };
+    }
+
+    if (!enhanced.cookie) {
+      enhanced.cookie = function (name: string, value: string, options?: any) {
+        const cookieString = `${name}=${value}`;
+        this.setHeader("Set-Cookie", cookieString);
+        return this;
+      };
+    }
+
+    if (!enhanced.clearCookie) {
+      enhanced.clearCookie = function (name: string, options?: any) {
+        this.setHeader(
+          "Set-Cookie",
+          `${name}=; expires=Thu, 01 Jan 1970 00:00:00 GMT`,
+        );
+        return this;
+      };
+    }
+
+    if (!enhanced.redirect) {
+      enhanced.redirect = function (url: string, status?: number) {
+        this.statusCode = status || 302;
+        this.setHeader("Location", url);
+        this.end();
+      };
+    }
+
+    if (!enhanced.sendFile) {
+      enhanced.sendFile = async function (filePath: string) {
+        const fs = await import("fs");
+        const path = await import("path");
+
+        try {
+          const data = await fs.promises.readFile(filePath);
+          const ext = path.extname(filePath);
+
+          // Basic content type detection
+          const contentTypes: Record<string, string> = {
+            ".html": "text/html",
+            ".js": "application/javascript",
+            ".css": "text/css",
+            ".json": "application/json",
+            ".png": "image/png",
+            ".jpg": "image/jpeg",
+            ".jpeg": "image/jpeg",
+            ".gif": "image/gif",
+            ".svg": "image/svg+xml",
+          };
+
+          const contentType = contentTypes[ext] || "application/octet-stream";
+          this.setHeader("Content-Type", contentType);
+          this.end(data);
+        } catch (error) {
+          this.statusCode = 404;
+          this.end("File not found");
+        }
+      };
+    }
+
+    return enhanced;
+  }
+}