@flexireact/core 2.3.0 → 2.5.0

package/core/edge/cache.ts

@@ -0,0 +1,344 @@
+/**
+ * FlexiReact Universal Cache System
+ * 
+ * Smart caching that works on:
+ * - Cloudflare Workers (Cache API + KV)
+ * - Vercel Edge (Edge Config + KV)
+ * - Deno (Deno KV)
+ * - Node.js/Bun (In-memory + File cache)
+ */
+
+import { detectRuntime } from './runtime.js';
+
+// Cache entry
+export interface CacheEntry<T = any> {
+  value: T;
+  expires: number; // timestamp
+  stale?: number; // stale-while-revalidate timestamp
+  tags?: string[];
+  etag?: string;
+}
+
+// Cache options
+export interface CacheOptions {
+  ttl?: number; // seconds
+  staleWhileRevalidate?: number; // seconds
+  tags?: string[];
+  key?: string;
+  revalidate?: number | false; // ISR-style revalidation
+}
+
+// Cache storage interface
+export interface CacheStorage {
+  get<T>(key: string): Promise<CacheEntry<T> | null>;
+  set<T>(key: string, entry: CacheEntry<T>): Promise<void>;
+  delete(key: string): Promise<void>;
+  deleteByTag(tag: string): Promise<void>;
+  clear(): Promise<void>;
+}
+
+// In-memory cache (fallback)
+class MemoryCache implements CacheStorage {
+  private store = new Map<string, CacheEntry>();
+  private tagIndex = new Map<string, Set<string>>();
+  
+  async get<T>(key: string): Promise<CacheEntry<T> | null> {
+    const entry = this.store.get(key);
+    if (!entry) return null;
+    
+    // Check expiration
+    if (entry.expires && entry.expires < Date.now()) {
+      // Check stale-while-revalidate
+      if (entry.stale && entry.stale > Date.now()) {
+        return { ...entry, value: entry.value as T };
+      }
+      this.store.delete(key);
+      return null;
+    }
+    
+    return { ...entry, value: entry.value as T };
+  }
+  
+  async set<T>(key: string, entry: CacheEntry<T>): Promise<void> {
+    this.store.set(key, entry);
+    
+    // Index by tags
+    if (entry.tags) {
+      entry.tags.forEach(tag => {
+        if (!this.tagIndex.has(tag)) {
+          this.tagIndex.set(tag, new Set());
+        }
+        this.tagIndex.get(tag)!.add(key);
+      });
+    }
+  }
+  
+  async delete(key: string): Promise<void> {
+    this.store.delete(key);
+  }
+  
+  async deleteByTag(tag: string): Promise<void> {
+    const keys = this.tagIndex.get(tag);
+    if (keys) {
+      keys.forEach(key => this.store.delete(key));
+      this.tagIndex.delete(tag);
+    }
+  }
+  
+  async clear(): Promise<void> {
+    this.store.clear();
+    this.tagIndex.clear();
+  }
+}
+
+// Cloudflare KV cache
+class CloudflareCache implements CacheStorage {
+  private kv: any;
+  
+  constructor(kv: any) {
+    this.kv = kv;
+  }
+  
+  async get<T>(key: string): Promise<CacheEntry<T> | null> {
+    try {
+      const data = await this.kv.get(key, 'json');
+      if (!data) return null;
+      
+      const entry = data as CacheEntry<T>;
+      if (entry.expires && entry.expires < Date.now()) {
+        if (entry.stale && entry.stale > Date.now()) {
+          return entry;
+        }
+        await this.kv.delete(key);
+        return null;
+      }
+      
+      return entry;
+    } catch {
+      return null;
+    }
+  }
+  
+  async set<T>(key: string, entry: CacheEntry<T>): Promise<void> {
+    const ttl = entry.expires ? Math.ceil((entry.expires - Date.now()) / 1000) : undefined;
+    await this.kv.put(key, JSON.stringify(entry), { expirationTtl: ttl });
+  }
+  
+  async delete(key: string): Promise<void> {
+    await this.kv.delete(key);
+  }
+  
+  async deleteByTag(tag: string): Promise<void> {
+    // KV doesn't support tag-based deletion natively
+    // Would need to maintain a tag index
+    console.warn('Tag-based deletion not fully supported in Cloudflare KV');
+  }
+  
+  async clear(): Promise<void> {
+    // KV doesn't support clear
+    console.warn('Clear not supported in Cloudflare KV');
+  }
+}
+
+// Deno KV cache
+class DenoKVCache implements CacheStorage {
+  private kv: any;
+  
+  constructor() {
+    // @ts-ignore - Deno global
+    this.kv = Deno.openKv();
+  }
+  
+  async get<T>(key: string): Promise<CacheEntry<T> | null> {
+    try {
+      const kv = await this.kv;
+      const result = await kv.get(['cache', key]);
+      if (!result.value) return null;
+      
+      const entry = result.value as CacheEntry<T>;
+      if (entry.expires && entry.expires < Date.now()) {
+        if (entry.stale && entry.stale > Date.now()) {
+          return entry;
+        }
+        await kv.delete(['cache', key]);
+        return null;
+      }
+      
+      return entry;
+    } catch {
+      return null;
+    }
+  }
+  
+  async set<T>(key: string, entry: CacheEntry<T>): Promise<void> {
+    const kv = await this.kv;
+    await kv.set(['cache', key], entry);
+  }
+  
+  async delete(key: string): Promise<void> {
+    const kv = await this.kv;
+    await kv.delete(['cache', key]);
+  }
+  
+  async deleteByTag(tag: string): Promise<void> {
+    // Would need tag index
+    console.warn('Tag-based deletion requires tag index in Deno KV');
+  }
+  
+  async clear(): Promise<void> {
+    // Would need to iterate all keys
+    console.warn('Clear requires iteration in Deno KV');
+  }
+}
+
+// Create cache based on runtime
+function createCacheStorage(options?: { kv?: any }): CacheStorage {
+  const runtime = detectRuntime();
+  
+  switch (runtime) {
+    case 'cloudflare':
+      if (options?.kv) {
+        return new CloudflareCache(options.kv);
+      }
+      return new MemoryCache();
+    
+    case 'deno':
+      return new DenoKVCache();
+    
+    case 'node':
+    case 'bun':
+    default:
+      return new MemoryCache();
+  }
+}
+
+// Main cache instance
+let cacheStorage: CacheStorage = new MemoryCache();
+
+// Initialize cache with platform-specific storage
+export function initCache(options?: { kv?: any }): void {
+  cacheStorage = createCacheStorage(options);
+}
+
+// Cache function wrapper (like React cache)
+export function cacheFunction<T extends (...args: any[]) => Promise<any>>(
+  fn: T,
+  options: CacheOptions = {}
+): T {
+  const { ttl = 60, staleWhileRevalidate = 0, tags = [] } = options;
+  
+  return (async (...args: any[]) => {
+    const key = options.key || `fn:${fn.name}:${JSON.stringify(args)}`;
+    
+    // Try cache first
+    const cached = await cacheStorage.get(key);
+    if (cached) {
+      // Check if stale and needs revalidation
+      if (cached.expires < Date.now() && cached.stale && cached.stale > Date.now()) {
+        // Return stale data, revalidate in background
+        queueMicrotask(async () => {
+          try {
+            const fresh = await fn(...args);
+            await cacheStorage.set(key, {
+              value: fresh,
+              expires: Date.now() + ttl * 1000,
+              stale: Date.now() + (ttl + staleWhileRevalidate) * 1000,
+              tags
+            });
+          } catch (e) {
+            console.error('Background revalidation failed:', e);
+          }
+        });
+      }
+      return cached.value;
+    }
+    
+    // Execute function
+    const result = await fn(...args);
+    
+    // Cache result
+    await cacheStorage.set(key, {
+      value: result,
+      expires: Date.now() + ttl * 1000,
+      stale: staleWhileRevalidate ? Date.now() + (ttl + staleWhileRevalidate) * 1000 : undefined,
+      tags
+    });
+    
+    return result;
+  }) as T;
+}
+
+// Unstable cache (Next.js compatible API)
+export function unstable_cache<T extends (...args: any[]) => Promise<any>>(
+  fn: T,
+  keyParts?: string[],
+  options?: { revalidate?: number | false; tags?: string[] }
+): T {
+  return cacheFunction(fn, {
+    key: keyParts?.join(':'),
+    ttl: typeof options?.revalidate === 'number' ? options.revalidate : 3600,
+    tags: options?.tags
+  });
+}
+
+// Revalidate by tag
+export async function revalidateTag(tag: string): Promise<void> {
+  await cacheStorage.deleteByTag(tag);
+}
+
+// Revalidate by path
+export async function revalidatePath(path: string): Promise<void> {
+  await cacheStorage.delete(`page:${path}`);
+}
+
+// Cache object for direct access
+export const cache = {
+  get: <T>(key: string) => cacheStorage.get<T>(key),
+  set: <T>(key: string, value: T, options: CacheOptions = {}) => {
+    const { ttl = 60, staleWhileRevalidate = 0, tags = [] } = options;
+    return cacheStorage.set(key, {
+      value,
+      expires: Date.now() + ttl * 1000,
+      stale: staleWhileRevalidate ? Date.now() + (ttl + staleWhileRevalidate) * 1000 : undefined,
+      tags
+    });
+  },
+  delete: (key: string) => cacheStorage.delete(key),
+  deleteByTag: (tag: string) => cacheStorage.deleteByTag(tag),
+  clear: () => cacheStorage.clear(),
+  
+  // Wrap function with caching
+  wrap: cacheFunction,
+  
+  // Next.js compatible
+  unstable_cache,
+  revalidateTag,
+  revalidatePath
+};
+
+// Request-level cache (per-request deduplication)
+const requestCache = new WeakMap<Request, Map<string, any>>();
+
+export function getRequestCache(request: Request): Map<string, any> {
+  if (!requestCache.has(request)) {
+    requestCache.set(request, new Map());
+  }
+  return requestCache.get(request)!;
+}
+
+// React-style cache for request deduplication
+export function reactCache<T extends (...args: any[]) => any>(fn: T): T {
+  const cache = new Map<string, any>();
+  
+  return ((...args: any[]) => {
+    const key = JSON.stringify(args);
+    if (cache.has(key)) {
+      return cache.get(key);
+    }
+    const result = fn(...args);
+    cache.set(key, result);
+    return result;
+  }) as T;
+}
+
+export default cache;

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
+};