@morojs/moro 1.0.0 → 1.0.2

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

@@ -1,32 +1,23 @@
 // Base runtime adapter with common functionality
-import {
-  RuntimeAdapter,
-  RuntimeType,
-  RuntimeHttpResponse,
-} from "../../types/runtime";
-import { HttpRequest, HttpResponse } from "../../types/http";
-import { randomBytes } from "crypto";
+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 adaptRequest(runtimeRequest: any, ...args: any[]): Promise<HttpRequest>;
   abstract adaptResponse(
     moroResponse: HttpResponse | RuntimeHttpResponse,
-    runtimeRequest: any,
+    runtimeRequest: any
   ): Promise<any>;
-  abstract createServer(
-    handler: (req: HttpRequest, res: HttpResponse) => Promise<void>,
-  ): 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");
+      .toString('hex')
+      .replace(/(.{8})(.{4})(.{4})(.{4})(.{12})/, '$1-$2-$3-$4-$5');
   }
 
   // Common request enhancement
@@ -35,7 +26,7 @@ export abstract class BaseRuntimeAdapter implements RuntimeAdapter {
 
     // Add common properties
     request.requestId = request.requestId || this.generateUUID();
-    request.ip = request.ip || "unknown";
+    request.ip = request.ip || 'unknown';
     request.params = request.params || {};
     request.query = request.query || {};
     request.cookies = request.cookies || {};
@@ -58,7 +49,7 @@ export abstract class BaseRuntimeAdapter implements RuntimeAdapter {
       },
 
       json: function (data: any) {
-        this.headers["Content-Type"] = "application/json";
+        this.headers['Content-Type'] = 'application/json';
         this.body = JSON.stringify(data);
         this.headersSent = true;
       },
@@ -71,24 +62,23 @@ export abstract class BaseRuntimeAdapter implements RuntimeAdapter {
       cookie: function (name: string, value: string, options?: any) {
         // Simple cookie implementation
         const cookieString = `${name}=${value}`;
-        this.headers["Set-Cookie"] = cookieString;
+        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`;
+        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.headers['Location'] = url;
         this.headersSent = true;
       },
 
       sendFile: async function (filePath: string) {
-        throw new Error("sendFile not implemented in this runtime");
+        throw new Error('sendFile not implemented in this runtime');
       },
     };
 
@@ -101,7 +91,7 @@ export abstract class BaseRuntimeAdapter implements RuntimeAdapter {
     query: Record<string, string>;
   } {
     try {
-      const urlObj = new URL(url, "http://localhost");
+      const urlObj = new URL(url, 'http://localhost');
       const query: Record<string, string> = {};
 
       urlObj.searchParams.forEach((value, key) => {
@@ -124,8 +114,8 @@ export abstract class BaseRuntimeAdapter implements RuntimeAdapter {
   protected async parseBody(body: any, contentType?: string): Promise<any> {
     if (!body) return undefined;
 
-    if (typeof body === "string") {
-      if (contentType?.includes("application/json")) {
+    if (typeof body === 'string') {
+      if (contentType?.includes('application/json')) {
         try {
           return JSON.parse(body);
         } catch {

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

@@ -1,7 +1,7 @@
 // Cloudflare Workers runtime adapter
-import { BaseRuntimeAdapter } from "./base-adapter";
-import { HttpRequest, HttpResponse } from "../../types/http";
-import { RuntimeHttpResponse } from "../../types/runtime";
+import { BaseRuntimeAdapter } from './base-adapter';
+import { HttpRequest, HttpResponse } from '../../types/http';
+import { RuntimeHttpResponse } from '../../types/runtime';
 
 export interface WorkersEnv {
   [key: string]: any;
@@ -13,26 +13,22 @@ export interface WorkersContext {
 }
 
 export class CloudflareWorkersAdapter extends BaseRuntimeAdapter {
-  readonly type = "cloudflare-workers" as const;
+  readonly type = 'cloudflare-workers' as const;
 
-  async adaptRequest(
-    request: Request,
-    env: WorkersEnv,
-    ctx: WorkersContext,
-  ): Promise<HttpRequest> {
+  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")) {
+    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")) {
+      } else if (contentType.includes('application/x-www-form-urlencoded')) {
         body = await request.formData();
         // Convert FormData to object
         const formObject: Record<string, any> = {};
@@ -60,8 +56,8 @@ export class CloudflareWorkersAdapter extends BaseRuntimeAdapter {
       headers,
       ip: this.getClientIP(headers, request),
       params: {},
-      requestId: "",
-      cookies: this.parseCookies(headers.cookie || ""),
+      requestId: '',
+      cookies: this.parseCookies(headers.cookie || ''),
       files: {},
       // Add Workers-specific context
       env,
@@ -71,9 +67,7 @@ export class CloudflareWorkersAdapter extends BaseRuntimeAdapter {
     return this.enhanceRequest(baseRequest);
   }
 
-  async adaptResponse(
-    moroResponse: HttpResponse | RuntimeHttpResponse,
-  ): Promise<Response> {
+  async adaptResponse(moroResponse: HttpResponse | RuntimeHttpResponse): Promise<Response> {
     const runtimeResponse = moroResponse as RuntimeHttpResponse;
 
     // Handle different response states
@@ -82,10 +76,7 @@ export class CloudflareWorkersAdapter extends BaseRuntimeAdapter {
     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"
-    ) {
+    if ('statusCode' in moroResponse && typeof moroResponse.statusCode === 'number') {
       status = moroResponse.statusCode;
     }
 
@@ -96,9 +87,9 @@ export class CloudflareWorkersAdapter extends BaseRuntimeAdapter {
     });
 
     // Handle different body types
-    if (typeof body === "object" && body !== null) {
+    if (typeof body === 'object' && body !== null) {
       body = JSON.stringify(body);
-      responseHeaders.set("Content-Type", "application/json");
+      responseHeaders.set('Content-Type', 'application/json');
     }
 
     return new Response(body, {
@@ -107,9 +98,7 @@ export class CloudflareWorkersAdapter extends BaseRuntimeAdapter {
     });
   }
 
-  createServer(
-    handler: (req: HttpRequest, res: HttpResponse) => Promise<void>,
-  ) {
+  createServer(handler: (req: HttpRequest, res: HttpResponse) => Promise<void>) {
     // Return a Cloudflare Workers-compatible handler function
     return async (request: Request, env: WorkersEnv, ctx: WorkersContext) => {
       try {
@@ -123,13 +112,13 @@ export class CloudflareWorkersAdapter extends BaseRuntimeAdapter {
         return new Response(
           JSON.stringify({
             success: false,
-            error: "Internal server error",
-            message: error instanceof Error ? error.message : "Unknown error",
+            error: 'Internal server error',
+            message: error instanceof Error ? error.message : 'Unknown error',
           }),
           {
             status: 500,
-            headers: { "Content-Type": "application/json" },
-          },
+            headers: { 'Content-Type': 'application/json' },
+          }
         );
       }
     };
@@ -138,26 +127,23 @@ export class CloudflareWorkersAdapter extends BaseRuntimeAdapter {
   // 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 {
+  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"
+      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("=");
+      cookieHeader.split(';').forEach(cookie => {
+        const [name, ...rest] = cookie.trim().split('=');
         if (name && rest.length > 0) {
-          cookies[name] = rest.join("=");
+          cookies[name] = rest.join('=');
         }
       });
     }

package/src/core/runtime/index.ts

@@ -1,9 +1,9 @@
 // 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";
+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 {
@@ -12,32 +12,28 @@ export type {
   RuntimeConfig,
   RuntimeMoroOptions,
   RuntimeHttpResponse,
-} from "../../types/runtime";
+} 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";
+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";
+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":
+    case 'node':
       return new NodeRuntimeAdapter();
-    case "vercel-edge":
+    case 'vercel-edge':
       return new VercelEdgeAdapter();
-    case "aws-lambda":
+    case 'aws-lambda':
       return new AWSLambdaAdapter();
-    case "cloudflare-workers":
+    case 'cloudflare-workers':
       return new CloudflareWorkersAdapter();
     default:
       throw new Error(`Unsupported runtime type: ${type}`);
@@ -45,30 +41,22 @@ export function createRuntimeAdapter(type: RuntimeType): RuntimeAdapter {
 }
 
 // Convenience functions for creating runtime-specific handlers
-export function createNodeHandler(
-  handler: (req: any, res: any) => Promise<void>,
-) {
+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>,
-) {
+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>,
-) {
+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>,
-) {
+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

@@ -1,19 +1,19 @@
 // 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";
+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;
+  readonly type = 'node' as const;
 
   async adaptRequest(req: IncomingMessage): Promise<HttpRequest> {
-    const { pathname, query } = this.parseUrl(req.url || "/");
+    const { pathname, query } = this.parseUrl(req.url || '/');
 
     // Parse body for POST/PUT/PATCH requests
     let body: any;
-    if (["POST", "PUT", "PATCH"].includes(req.method!)) {
+    if (['POST', 'PUT', 'PATCH'].includes(req.method!)) {
       body = await this.parseRequestBody(req);
     }
 
@@ -33,7 +33,7 @@ export class NodeRuntimeAdapter extends BaseRuntimeAdapter {
       body,
       ip: this.getClientIP(req),
       params: {},
-      requestId: "",
+      requestId: '',
       cookies: {},
       files: {},
     } as Partial<HttpRequest>;
@@ -43,84 +43,73 @@ export class NodeRuntimeAdapter extends BaseRuntimeAdapter {
 
   async adaptResponse(
     moroResponse: HttpResponse | RuntimeHttpResponse,
-    req: IncomingMessage,
+    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 {
+  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",
-              }),
-            );
-          }
+    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 {
+  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) => {
+      let body = '';
+      req.on('data', chunk => {
         body += chunk.toString();
       });
-      req.on("end", () => {
+      req.on('end', () => {
         try {
-          const contentType = req.headers["content-type"] || "";
+          const contentType = req.headers['content-type'] || '';
           resolve(this.parseBody(body, contentType));
         } catch (error) {
           reject(error);
         }
       });
-      req.on("error", reject);
+      req.on('error', reject);
     });
   }
 
   private getClientIP(req: IncomingMessage): string {
-    const forwarded = req.headers["x-forwarded-for"] as string;
+    const forwarded = req.headers['x-forwarded-for'] as string;
     if (forwarded) {
-      return forwarded.split(",")[0].trim();
+      return forwarded.split(',')[0].trim();
     }
-    return req.socket.remoteAddress || "unknown";
+    return req.socket.remoteAddress || 'unknown';
   }
 
   private enhanceResponse(res: ServerResponse): HttpResponse {
@@ -129,7 +118,7 @@ export class NodeRuntimeAdapter extends BaseRuntimeAdapter {
     // Add MoroJS response methods if they don't exist
     if (!enhanced.json) {
       enhanced.json = function (data: any) {
-        this.setHeader("Content-Type", "application/json");
+        this.setHeader('Content-Type', 'application/json');
         this.end(JSON.stringify(data));
       };
     }
@@ -150,17 +139,14 @@ export class NodeRuntimeAdapter extends BaseRuntimeAdapter {
     if (!enhanced.cookie) {
       enhanced.cookie = function (name: string, value: string, options?: any) {
         const cookieString = `${name}=${value}`;
-        this.setHeader("Set-Cookie", cookieString);
+        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`,
-        );
+        this.setHeader('Set-Cookie', `${name}=; expires=Thu, 01 Jan 1970 00:00:00 GMT`);
         return this;
       };
     }
@@ -168,15 +154,15 @@ export class NodeRuntimeAdapter extends BaseRuntimeAdapter {
     if (!enhanced.redirect) {
       enhanced.redirect = function (url: string, status?: number) {
         this.statusCode = status || 302;
-        this.setHeader("Location", url);
+        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");
+        const fs = await import('fs');
+        const path = await import('path');
 
         try {
           const data = await fs.promises.readFile(filePath);
@@ -184,23 +170,23 @@ export class NodeRuntimeAdapter extends BaseRuntimeAdapter {
 
           // 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",
+            '.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);
+          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");
+          this.end('File not found');
         }
       };
     }