@morojs/moro 1.6.2 → 1.6.3

package/src/core/runtime/aws-lambda-adapter.ts

@@ -1,147 +0,0 @@
-// AWS Lambda runtime adapter
-import { BaseRuntimeAdapter } from './base-adapter.js';
-import { HttpRequest, HttpResponse } from '../../types/http.js';
-import { RuntimeHttpResponse } from '../../types/runtime.js';
-
-export interface LambdaEvent {
-  httpMethod: string;
-  path: string;
-  pathParameters?: Record<string, string> | null;
-  queryStringParameters?: Record<string, string> | null;
-  headers?: Record<string, string> | null;
-  multiValueHeaders?: Record<string, string[]> | null;
-  body?: string | null;
-  isBase64Encoded?: boolean;
-  requestContext?: {
-    identity?: {
-      sourceIp?: string;
-    };
-  };
-}
-
-export interface LambdaContext {
-  requestId: string;
-  functionName: string;
-  functionVersion: string;
-  invokedFunctionArn: string;
-  memoryLimitInMB: string;
-  awsRequestId: string;
-  logGroupName: string;
-  logStreamName: string;
-  getRemainingTimeInMillis(): number;
-}
-
-export interface LambdaResponse {
-  statusCode: number;
-  headers?: Record<string, string>;
-  multiValueHeaders?: Record<string, string[]>;
-  body: string;
-  isBase64Encoded?: boolean;
-}
-
-export class AWSLambdaAdapter extends BaseRuntimeAdapter {
-  readonly type = 'aws-lambda' as const;
-
-  async adaptRequest(event: LambdaEvent, context: LambdaContext): Promise<HttpRequest> {
-    const { pathname, query } = this.parseUrl(event.path);
-
-    // Merge query parameters from event
-    const mergedQuery = {
-      ...query,
-      ...(event.queryStringParameters || {}),
-    };
-
-    // Parse body
-    let body: any;
-    if (event.body) {
-      const contentType = event.headers?.['content-type'] || event.headers?.['Content-Type'] || '';
-      if (event.isBase64Encoded) {
-        body = Buffer.from(event.body, 'base64').toString();
-      } else {
-        body = event.body;
-      }
-      body = await this.parseBody(body, contentType);
-    }
-
-    const baseRequest = {
-      method: event.httpMethod,
-      url: event.path,
-      path: pathname,
-      query: mergedQuery,
-      body,
-      headers: event.headers || {},
-      ip: event.requestContext?.identity?.sourceIp || 'unknown',
-      params: event.pathParameters || {},
-      requestId: context.awsRequestId,
-      cookies: this.parseCookies(event.headers?.cookie || ''),
-      files: {},
-    } as Partial<HttpRequest>;
-
-    return this.enhanceRequest(baseRequest);
-  }
-
-  async adaptResponse(moroResponse: HttpResponse | RuntimeHttpResponse): Promise<LambdaResponse> {
-    const runtimeResponse = moroResponse as RuntimeHttpResponse;
-
-    let body = runtimeResponse.body;
-    const status = runtimeResponse.statusCode || 200;
-    const headers = runtimeResponse.headers || {};
-
-    // Convert body to string
-    if (typeof body === 'object' && body !== null) {
-      body = JSON.stringify(body);
-      headers['Content-Type'] = 'application/json';
-    } else if (body === null || body === undefined) {
-      body = '';
-    } else {
-      body = String(body);
-    }
-
-    return {
-      statusCode: status,
-      headers,
-      body,
-      isBase64Encoded: false,
-    };
-  }
-
-  createServer(handler: (req: HttpRequest, res: HttpResponse) => Promise<void>) {
-    // Return a Lambda-compatible handler function
-    return async (event: LambdaEvent, context: LambdaContext) => {
-      try {
-        const moroReq = await this.adaptRequest(event, context);
-        const moroRes = this.createMockResponse();
-
-        await handler(moroReq, moroRes as any);
-
-        return await this.adaptResponse(moroRes);
-      } catch (error) {
-        return {
-          statusCode: 500,
-          headers: { 'Content-Type': 'application/json' },
-          body: JSON.stringify({
-            success: false,
-            error: 'Internal server error',
-            message: error instanceof Error ? error.message : 'Unknown error',
-          }),
-        };
-      }
-    };
-  }
-
-  // Lambda doesn't have a listen method - it's event-driven
-  // listen method is optional in the interface
-
-  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/base-adapter.ts

@@ -1,130 +0,0 @@
-// Base runtime adapter with common functionality
-import { RuntimeAdapter, RuntimeType, RuntimeHttpResponse } from '../../types/runtime.js';
-import { HttpRequest, HttpResponse } from '../../types/http.js';
-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

@@ -1,152 +0,0 @@
-// Cloudflare Workers runtime adapter
-import { BaseRuntimeAdapter } from './base-adapter.js';
-import { HttpRequest, HttpResponse } from '../../types/http.js';
-import { RuntimeHttpResponse } from '../../types/runtime.js';
-
-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

@@ -1,62 +0,0 @@
-// Runtime adapters export
-export { BaseRuntimeAdapter } from './base-adapter.js';
-export { NodeRuntimeAdapter } from './node-adapter.js';
-export { VercelEdgeAdapter } from './vercel-edge-adapter.js';
-export { AWSLambdaAdapter } from './aws-lambda-adapter.js';
-export { CloudflareWorkersAdapter } from './cloudflare-workers-adapter.js';
-
-// Re-export types
-export type {
-  RuntimeType,
-  RuntimeAdapter,
-  RuntimeConfig,
-  RuntimeMoroOptions,
-  RuntimeHttpResponse,
-} from '../../types/runtime.js';
-
-// Re-export specific runtime types
-export type { LambdaEvent, LambdaContext, LambdaResponse } from './aws-lambda-adapter.js';
-export type { WorkersEnv, WorkersContext } from './cloudflare-workers-adapter.js';
-
-// Runtime factory functions
-import { NodeRuntimeAdapter } from './node-adapter.js';
-import { VercelEdgeAdapter } from './vercel-edge-adapter.js';
-import { AWSLambdaAdapter } from './aws-lambda-adapter.js';
-import { CloudflareWorkersAdapter } from './cloudflare-workers-adapter.js';
-import { RuntimeType, RuntimeAdapter } from '../../types/runtime.js';
-
-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

@@ -1,202 +0,0 @@
-// Node.js runtime adapter
-import { IncomingMessage, ServerResponse } from 'http';
-import { BaseRuntimeAdapter } from './base-adapter.js';
-import { HttpRequest, HttpResponse } from '../../types/http.js';
-import { RuntimeHttpResponse } from '../../types/runtime.js';
-import { MoroHttpServer } from '../http/http-server.js';
-
-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) {
-        if (!this.headersSent) {
-          const cookieString = `${name}=${value}`;
-          this.setHeader('Set-Cookie', cookieString);
-        }
-        return this;
-      };
-    }
-
-    if (!enhanced.clearCookie) {
-      enhanced.clearCookie = function (name: string, options?: any) {
-        if (!this.headersSent) {
-          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) {
-        if (!this.headersSent) {
-          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;
-  }
-}