@flexireact/core 2.2.0 → 2.4.0

package/core/edge/fetch-polyfill.ts

@@ -0,0 +1,247 @@
+/**
+ * Fetch API Polyfill for Universal Compatibility
+ * 
+ * Ensures Request, Response, Headers work everywhere
+ */
+
+// Use native Web APIs if available, otherwise polyfill
+const globalFetch = globalThis.fetch;
+const GlobalRequest = globalThis.Request;
+const GlobalResponse = globalThis.Response;
+const GlobalHeaders = globalThis.Headers;
+
+// Extended Request with FlexiReact helpers
+export class FlexiRequest extends GlobalRequest {
+  private _parsedUrl?: URL;
+  private _cookies?: Map<string, string>;
+  
+  constructor(input: RequestInfo | URL, init?: RequestInit) {
+    super(input, init);
+  }
+  
+  get pathname(): string {
+    if (!this._parsedUrl) {
+      this._parsedUrl = new URL(this.url);
+    }
+    return this._parsedUrl.pathname;
+  }
+  
+  get searchParams(): URLSearchParams {
+    if (!this._parsedUrl) {
+      this._parsedUrl = new URL(this.url);
+    }
+    return this._parsedUrl.searchParams;
+  }
+  
+  get cookies(): Map<string, string> {
+    if (!this._cookies) {
+      this._cookies = new Map();
+      const cookieHeader = this.headers.get('cookie');
+      if (cookieHeader) {
+        cookieHeader.split(';').forEach(cookie => {
+          const [name, ...rest] = cookie.trim().split('=');
+          if (name) {
+            this._cookies!.set(name, rest.join('='));
+          }
+        });
+      }
+    }
+    return this._cookies;
+  }
+  
+  cookie(name: string): string | undefined {
+    return this.cookies.get(name);
+  }
+  
+  // Parse JSON body
+  async jsonBody<T = any>(): Promise<T> {
+    return this.json();
+  }
+  
+  // Parse form data
+  async formBody(): Promise<FormData> {
+    return this.formData();
+  }
+  
+  // Get query param
+  query(name: string): string | null {
+    return this.searchParams.get(name);
+  }
+  
+  // Get all query params
+  queryAll(name: string): string[] {
+    return this.searchParams.getAll(name);
+  }
+}
+
+// Extended Response with FlexiReact helpers
+export class FlexiResponse extends GlobalResponse {
+  // Static helpers for common responses
+  
+  static json(data: any, init?: ResponseInit): FlexiResponse {
+    const headers = new Headers(init?.headers);
+    headers.set('Content-Type', 'application/json');
+    
+    return new FlexiResponse(JSON.stringify(data), {
+      ...init,
+      headers
+    });
+  }
+  
+  static html(html: string, init?: ResponseInit): FlexiResponse {
+    const headers = new Headers(init?.headers);
+    headers.set('Content-Type', 'text/html; charset=utf-8');
+    
+    return new FlexiResponse(html, {
+      ...init,
+      headers
+    });
+  }
+  
+  static text(text: string, init?: ResponseInit): FlexiResponse {
+    const headers = new Headers(init?.headers);
+    headers.set('Content-Type', 'text/plain; charset=utf-8');
+    
+    return new FlexiResponse(text, {
+      ...init,
+      headers
+    });
+  }
+  
+  static redirect(url: string, status: 301 | 302 | 303 | 307 | 308 = 307): FlexiResponse {
+    return new FlexiResponse(null, {
+      status,
+      headers: { Location: url }
+    });
+  }
+  
+  static notFound(message: string = 'Not Found'): FlexiResponse {
+    return new FlexiResponse(message, {
+      status: 404,
+      headers: { 'Content-Type': 'text/plain' }
+    });
+  }
+  
+  static error(message: string = 'Internal Server Error', status: number = 500): FlexiResponse {
+    return new FlexiResponse(message, {
+      status,
+      headers: { 'Content-Type': 'text/plain' }
+    });
+  }
+  
+  // Stream response
+  static stream(
+    stream: ReadableStream,
+    init?: ResponseInit
+  ): FlexiResponse {
+    return new FlexiResponse(stream, init);
+  }
+  
+  // Set cookie helper
+  withCookie(
+    name: string,
+    value: string,
+    options: {
+      maxAge?: number;
+      expires?: Date;
+      path?: string;
+      domain?: string;
+      secure?: boolean;
+      httpOnly?: boolean;
+      sameSite?: 'Strict' | 'Lax' | 'None';
+    } = {}
+  ): FlexiResponse {
+    const parts = [`${name}=${encodeURIComponent(value)}`];
+    
+    if (options.maxAge !== undefined) parts.push(`Max-Age=${options.maxAge}`);
+    if (options.expires) parts.push(`Expires=${options.expires.toUTCString()}`);
+    if (options.path) parts.push(`Path=${options.path}`);
+    if (options.domain) parts.push(`Domain=${options.domain}`);
+    if (options.secure) parts.push('Secure');
+    if (options.httpOnly) parts.push('HttpOnly');
+    if (options.sameSite) parts.push(`SameSite=${options.sameSite}`);
+    
+    const headers = new Headers(this.headers);
+    headers.append('Set-Cookie', parts.join('; '));
+    
+    return new FlexiResponse(this.body, {
+      status: this.status,
+      statusText: this.statusText,
+      headers
+    });
+  }
+  
+  // Add headers helper
+  withHeaders(newHeaders: Record<string, string>): FlexiResponse {
+    const headers = new Headers(this.headers);
+    Object.entries(newHeaders).forEach(([key, value]) => {
+      headers.set(key, value);
+    });
+    
+    return new FlexiResponse(this.body, {
+      status: this.status,
+      statusText: this.statusText,
+      headers
+    });
+  }
+}
+
+// Extended Headers
+export class FlexiHeaders extends GlobalHeaders {
+  // Get bearer token
+  getBearerToken(): string | null {
+    const auth = this.get('Authorization');
+    if (auth?.startsWith('Bearer ')) {
+      return auth.slice(7);
+    }
+    return null;
+  }
+  
+  // Get basic auth credentials
+  getBasicAuth(): { username: string; password: string } | null {
+    const auth = this.get('Authorization');
+    if (auth?.startsWith('Basic ')) {
+      try {
+        const decoded = atob(auth.slice(6));
+        const [username, password] = decoded.split(':');
+        return { username, password };
+      } catch {
+        return null;
+      }
+    }
+    return null;
+  }
+  
+  // Check content type
+  isJson(): boolean {
+    return this.get('Content-Type')?.includes('application/json') ?? false;
+  }
+  
+  isFormData(): boolean {
+    const ct = this.get('Content-Type') ?? '';
+    return ct.includes('multipart/form-data') || ct.includes('application/x-www-form-urlencoded');
+  }
+  
+  isHtml(): boolean {
+    return this.get('Accept')?.includes('text/html') ?? false;
+  }
+}
+
+// Export both native and extended versions
+export { 
+  FlexiRequest as Request,
+  FlexiResponse as Response,
+  FlexiHeaders as Headers
+};
+
+// Also export native versions for compatibility
+export const NativeRequest = GlobalRequest;
+export const NativeResponse = GlobalResponse;
+export const NativeHeaders = GlobalHeaders;
+
+export default {
+  Request: FlexiRequest,
+  Response: FlexiResponse,
+  Headers: FlexiHeaders,
+  fetch: globalFetch
+};

package/core/edge/handler.ts

@@ -0,0 +1,248 @@
+/**
+ * FlexiReact Universal Edge Handler
+ * 
+ * Single handler that works on all platforms:
+ * - Node.js (http.createServer)
+ * - Bun (Bun.serve)
+ * - Deno (Deno.serve)
+ * - Cloudflare Workers (fetch handler)
+ * - Vercel Edge (edge function)
+ */
+
+import { FlexiRequest, FlexiResponse } from './fetch-polyfill.js';
+import runtime, { detectRuntime } from './runtime.js';
+import { cache, CacheOptions } from './cache.js';
+
+// Handler context
+export interface EdgeContext {
+  runtime: typeof runtime;
+  cache: typeof cache;
+  env: Record<string, string | undefined>;
+  waitUntil: (promise: Promise<any>) => void;
+  passThroughOnException?: () => void;
+}
+
+// Route handler type
+export type EdgeHandler = (
+  request: FlexiRequest,
+  context: EdgeContext
+) => Promise<FlexiResponse> | FlexiResponse;
+
+// Middleware type
+export type EdgeMiddleware = (
+  request: FlexiRequest,
+  context: EdgeContext,
+  next: () => Promise<FlexiResponse>
+) => Promise<FlexiResponse> | FlexiResponse;
+
+// App configuration
+export interface EdgeAppConfig {
+  routes?: Map<string, EdgeHandler>;
+  middleware?: EdgeMiddleware[];
+  notFound?: EdgeHandler;
+  onError?: (error: Error, request: FlexiRequest) => FlexiResponse;
+  basePath?: string;
+}
+
+// Create universal edge app
+export function createEdgeApp(config: EdgeAppConfig = {}) {
+  const {
+    routes = new Map(),
+    middleware = [],
+    notFound = () => FlexiResponse.notFound(),
+    onError = (error) => FlexiResponse.error(error.message),
+    basePath = ''
+  } = config;
+
+  // Main fetch handler (Web Standard)
+  async function handleRequest(
+    request: Request,
+    env: Record<string, any> = {},
+    executionContext?: { waitUntil: (p: Promise<any>) => void; passThroughOnException?: () => void }
+  ): Promise<Response> {
+    const flexiRequest = new FlexiRequest(request.url, {
+      method: request.method,
+      headers: request.headers,
+      body: request.body,
+      // @ts-ignore - duplex is needed for streaming
+      duplex: 'half'
+    });
+
+    const context: EdgeContext = {
+      runtime,
+      cache,
+      env: env as Record<string, string | undefined>,
+      waitUntil: executionContext?.waitUntil || (() => {}),
+      passThroughOnException: executionContext?.passThroughOnException
+    };
+
+    try {
+      // Run middleware chain
+      const response = await runMiddleware(flexiRequest, context, middleware, async () => {
+        // Match route
+        const pathname = flexiRequest.pathname.replace(basePath, '') || '/';
+        
+        // Try exact match first
+        let handler = routes.get(pathname);
+        
+        // Try pattern matching
+        if (!handler) {
+          for (const [pattern, h] of routes) {
+            if (matchRoute(pathname, pattern)) {
+              handler = h;
+              break;
+            }
+          }
+        }
+        
+        if (handler) {
+          return await handler(flexiRequest, context);
+        }
+        
+        return await notFound(flexiRequest, context);
+      });
+
+      return response;
+    } catch (error: any) {
+      console.error('Edge handler error:', error);
+      return onError(error, flexiRequest);
+    }
+  }
+
+  // Run middleware chain
+  async function runMiddleware(
+    request: FlexiRequest,
+    context: EdgeContext,
+    middlewares: EdgeMiddleware[],
+    finalHandler: () => Promise<FlexiResponse>
+  ): Promise<FlexiResponse> {
+    let index = 0;
+
+    async function next(): Promise<FlexiResponse> {
+      if (index >= middlewares.length) {
+        return finalHandler();
+      }
+      const mw = middlewares[index++];
+      return mw(request, context, next);
+    }
+
+    return next();
+  }
+
+  // Simple route matching
+  function matchRoute(pathname: string, pattern: string): boolean {
+    // Exact match
+    if (pathname === pattern) return true;
+    
+    // Convert pattern to regex
+    const regexPattern = pattern
+      .replace(/\[\.\.\.(\w+)\]/g, '(?<$1>.+)') // [...slug] -> catch-all
+      .replace(/\[(\w+)\]/g, '(?<$1>[^/]+)'); // [id] -> dynamic segment
+    
+    const regex = new RegExp(`^${regexPattern}$`);
+    return regex.test(pathname);
+  }
+
+  // Return platform-specific exports
+  return {
+    // Web Standard fetch handler (Cloudflare, Vercel Edge, Deno)
+    fetch: handleRequest,
+    
+    // Cloudflare Workers
+    async scheduled(event: any, env: any, ctx: any) {
+      // Handle scheduled events
+    },
+    
+    // Add route
+    route(path: string, handler: EdgeHandler) {
+      routes.set(path, handler);
+      return this;
+    },
+    
+    // Add middleware
+    use(mw: EdgeMiddleware) {
+      middleware.push(mw);
+      return this;
+    },
+    
+    // Node.js adapter
+    toNodeHandler() {
+      return async (req: any, res: any) => {
+        const url = `http://${req.headers.host}${req.url}`;
+        const headers = new Headers();
+        Object.entries(req.headers).forEach(([key, value]) => {
+          if (typeof value === 'string') headers.set(key, value);
+        });
+
+        const body = ['GET', 'HEAD'].includes(req.method) ? undefined : req;
+        
+        const request = new Request(url, {
+          method: req.method,
+          headers,
+          body,
+          // @ts-ignore
+          duplex: 'half'
+        });
+
+        const response = await handleRequest(request, process.env);
+        
+        res.writeHead(response.status, Object.fromEntries(response.headers));
+        
+        if (response.body) {
+          const reader = response.body.getReader();
+          while (true) {
+            const { done, value } = await reader.read();
+            if (done) break;
+            res.write(value);
+          }
+        }
+        res.end();
+      };
+    },
+    
+    // Bun adapter
+    toBunHandler() {
+      return {
+        fetch: handleRequest,
+        port: parseInt(process.env.PORT || '3000', 10)
+      };
+    },
+    
+    // Deno adapter
+    toDenoHandler() {
+      return handleRequest;
+    },
+    
+    // Start server based on runtime
+    async listen(port: number = 3000) {
+      const rt = detectRuntime();
+      
+      switch (rt) {
+        case 'bun':
+          console.log(`🚀 FlexiReact Edge running on Bun at http://localhost:${port}`);
+          // @ts-ignore - Bun global
+          return Bun.serve({
+            port,
+            fetch: handleRequest
+          });
+        
+        case 'deno':
+          console.log(`🚀 FlexiReact Edge running on Deno at http://localhost:${port}`);
+          // @ts-ignore - Deno global
+          return Deno.serve({ port }, handleRequest);
+        
+        case 'node':
+        default:
+          const http = await import('http');
+          const server = http.createServer(this.toNodeHandler());
+          server.listen(port, () => {
+            console.log(`🚀 FlexiReact Edge running on Node.js at http://localhost:${port}`);
+          });
+          return server;
+      }
+    }
+  };
+}
+
+// Export default app creator
+export default createEdgeApp;

package/core/edge/index.ts

@@ -0,0 +1,81 @@
+/**
+ * FlexiReact Edge Runtime
+ * 
+ * Universal edge runtime that works everywhere:
+ * - Node.js
+ * - Bun
+ * - Deno
+ * - Cloudflare Workers
+ * - Vercel Edge
+ * - Netlify Edge
+ */
+
+// Runtime detection and capabilities
+export {
+  detectRuntime,
+  getRuntimeCapabilities,
+  runtime as edgeRuntimeInfo,
+  type RuntimeEnvironment,
+  type RuntimeCapabilities
+} from './runtime.js';
+
+// Fetch polyfill with helpers
+export {
+  FlexiRequest,
+  FlexiResponse,
+  FlexiHeaders,
+  Request,
+  Response,
+  Headers,
+  NativeRequest,
+  NativeResponse,
+  NativeHeaders
+} from './fetch-polyfill.js';
+
+// Universal handler
+export {
+  createEdgeApp,
+  type EdgeContext,
+  type EdgeHandler,
+  type EdgeMiddleware,
+  type EdgeAppConfig
+} from './handler.js';
+
+// Smart caching
+export {
+  cache as smartCache,
+  initCache,
+  cacheFunction,
+  unstable_cache,
+  revalidateTag,
+  revalidatePath,
+  getRequestCache,
+  reactCache,
+  type CacheEntry,
+  type CacheOptions,
+  type CacheStorage
+} from './cache.js';
+
+// Partial Prerendering
+export {
+  dynamic,
+  staticComponent,
+  PPRBoundary,
+  PPRShell,
+  prerenderWithPPR,
+  streamPPR,
+  pprFetch,
+  PPRLoading,
+  getPPRStyles,
+  experimental_ppr,
+  type PPRConfig,
+  type PPRRenderResult,
+  type PPRPageConfig,
+  type GenerateStaticParams
+} from './ppr.js';
+
+// Default export
+export { default as edgeRuntime } from './runtime.js';
+export { default as edgeCache } from './cache.js';
+export { default as edgePPR } from './ppr.js';
+export { default as createApp } from './handler.js';