@flexireact/core 3.0.1 → 3.0.2

package/core/edge/cache.ts

@@ -1,344 +0,0 @@
-/**
- * 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

@@ -1,247 +0,0 @@
-/**
- * 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
-};