@umituz/web-cloudflare 1.4.3 → 1.4.5

package/src/infrastructure/middleware/cache.ts

@@ -0,0 +1,95 @@
+/**
+ * Cache Middleware
+ * @description Caching middleware for Cloudflare Workers
+ */
+
+export interface CacheConfig {
+  enabled: boolean;
+  defaultTTL: number;
+  paths?: Record<string, number>;
+  prefix?: string;
+  bypassPaths?: string[];
+  respectHeaders?: boolean;
+}
+
+const cacheStore = new Map<string, { response: Response; expires: number }>();
+
+/**
+ * Cache middleware
+ */
+export async function cache(
+  request: Request,
+  config: CacheConfig
+): Promise<Response | null> {
+  if (!config.enabled) {
+    return null;
+  }
+
+  const url = new URL(request.url);
+  const cacheKey = `${config.prefix || 'cache'}:${url.pathname}${url.search}`;
+
+  // Check if path should bypass cache
+  if (config.bypassPaths?.some((path) => url.pathname.startsWith(path))) {
+    return null;
+  }
+
+  // Check cache
+  const cached = cacheStore.get(cacheKey);
+  if (cached && cached.expires > Date.now()) {
+    return cached.response;
+  }
+
+  return null;
+}
+
+/**
+ * Set cache
+ */
+export function setCache(
+  request: Request,
+  response: Response,
+  config: CacheConfig
+): void {
+  if (!config.enabled) {
+    return;
+  }
+
+  const url = new URL(request.url);
+  const cacheKey = `${config.prefix || 'cache'}:${url.pathname}${url.search}`;
+
+  // Determine TTL
+  let ttl = config.defaultTTL;
+  for (const [path, pathTTL] of Object.entries(config.paths || {})) {
+    if (url.pathname.startsWith(path)) {
+      ttl = pathTTL;
+      break;
+    }
+  }
+
+  // Don't cache if TTL is 0
+  if (ttl === 0) {
+    return;
+  }
+
+  // Cache the response
+  cacheStore.set(cacheKey, {
+    response: response.clone(),
+    expires: Date.now() + ttl * 1000,
+  });
+}
+
+/**
+ * Invalidate cache
+ */
+export function invalidateCache(pattern?: string): void {
+  if (!pattern) {
+    cacheStore.clear();
+    return;
+  }
+
+  for (const key of cacheStore.keys()) {
+    if (key.includes(pattern)) {
+      cacheStore.delete(key);
+    }
+  }
+}

package/src/infrastructure/middleware/cors.ts

@@ -0,0 +1,95 @@
+/**
+ * CORS Middleware
+ * @description Cross-Origin Resource Sharing middleware for Cloudflare Workers
+ */
+
+export interface CORSConfig {
+  enabled: boolean;
+  allowedOrigins: string[];
+  allowedMethods: string[];
+  allowedHeaders: string[];
+  exposedHeaders?: string[];
+  allowCredentials?: boolean;
+  maxAge?: number;
+}
+
+/**
+ * Add CORS headers to response
+ */
+export function addCorsHeaders(
+  request: Request,
+  response: Response,
+  config: CORSConfig
+): Response {
+  if (!config.enabled) {
+    return response;
+  }
+
+  const headers = new Headers(response.headers);
+  const origin = request.headers.get('Origin');
+
+  // Check if origin is allowed
+  const allowedOrigin = config.allowedOrigins.includes('*')
+    ? '*'
+    : config.allowedOrigins.includes(origin || '')
+    ? origin
+    : config.allowedOrigins[0];
+
+  headers.set('Access-Control-Allow-Origin', allowedOrigin);
+  headers.set('Access-Control-Allow-Methods', config.allowedMethods.join(', '));
+  headers.set('Access-Control-Allow-Headers', config.allowedHeaders.join(', '));
+
+  if (config.exposedHeaders) {
+    headers.set('Access-Control-Expose-Headers', config.exposedHeaders.join(', '));
+  }
+
+  if (config.allowCredentials) {
+    headers.set('Access-Control-Allow-Credentials', 'true');
+  }
+
+  if (config.maxAge) {
+    headers.set('Access-Control-Max-Age', config.maxAge.toString());
+  }
+
+  return new Response(response.body, {
+    status: response.status,
+    statusText: response.statusText,
+    headers,
+  });
+}
+
+/**
+ * CORS middleware
+ */
+export async function cors(
+  request: Request,
+  config: CORSConfig
+): Promise<Response | null> {
+  if (!config.enabled) {
+    return null;
+  }
+
+  // Handle preflight request
+  if (request.method === 'OPTIONS') {
+    const headers = new Headers();
+    const origin = request.headers.get('Origin');
+
+    const allowedOrigin = config.allowedOrigins.includes('*')
+      ? '*'
+      : config.allowedOrigins.includes(origin || '')
+      ? origin
+      : config.allowedOrigins[0];
+
+    headers.set('Access-Control-Allow-Origin', allowedOrigin);
+    headers.set('Access-Control-Allow-Methods', config.allowedMethods.join(', '));
+    headers.set('Access-Control-Allow-Headers', config.allowedHeaders.join(', '));
+
+    if (config.maxAge) {
+      headers.set('Access-Control-Max-Age', config.maxAge.toString());
+    }
+
+    return new Response(null, { headers });
+  }
+
+  return null;
+}

package/src/infrastructure/middleware/index.ts

@@ -3,6 +3,23 @@
  * @description Comprehensive middleware for Cloudflare Workers
  */
 
+// ============================================================
+// Environment Types
+// ============================================================
+
+export interface CloudflareMiddlewareEnv {
+  KV?: KVNamespace;
+  R2?: R2Bucket;
+  D1?: D1Database;
+  DO?: Record<string, DurableObjectNamespace>;
+  QUEUE?: Record<string, Queue>;
+  AI?: any;
+  vars?: Record<string, string>;
+}
+
+// Type alias for backwards compatibility
+export type Env = CloudflareMiddlewareEnv;
+
 // Re-export existing middleware
 export { cors, addCorsHeaders } from './cors';
 export { cache, setCache, invalidateCache } from './cache';
@@ -300,7 +317,7 @@ export interface HealthCheckConfig {
 }
 
 export async function healthCheck(
-  env: Env,
+  env: CloudflareMiddlewareEnv,
   config?: HealthCheckConfig
 ): Promise<Response> {
   const checks: Record<string, boolean | string> = {
@@ -357,9 +374,9 @@ export function handleMiddlewareError(
 }
 
 /**
- * Conditional Middleware
+ * Conditional Middleware (Chain)
  */
-export function conditionalMiddleware(
+export function conditionalChainMiddleware(
   condition: (request: Request) => boolean,
   middleware: (request: Request) => Response | null
 ): (request: Request) => Response | null {

package/src/infrastructure/middleware/rate-limit.ts

@@ -0,0 +1,105 @@
+/**
+ * Rate Limit Middleware
+ * @description Rate limiting middleware for Cloudflare Workers
+ */
+
+export interface RateLimitConfig {
+  enabled: boolean;
+  maxRequests: number;
+  window: number;
+  by?: 'ip' | 'user' | 'both';
+  customKeys?: string[];
+  whitelist?: string[];
+  response?: {
+    status: number;
+    message: string;
+    retryAfter?: number;
+  };
+}
+
+interface RateLimitEntry {
+  count: number;
+  resetTime: number;
+}
+
+const rateLimitStore = new Map<string, RateLimitEntry>();
+
+/**
+ * Get rate limit key
+ */
+function getRateLimitKey(request: Request, config: RateLimitConfig): string {
+  const parts: string[] = [];
+
+  if (config.by === 'ip' || config.by === 'both') {
+    parts.push(request.headers.get('CF-Connecting-IP') || 'unknown');
+  }
+
+  if (config.by === 'user' || config.by === 'both') {
+    const auth = request.headers.get('Authorization');
+    if (auth) {
+      parts.push(auth.substring(0, 20));
+    }
+  }
+
+  if (config.customKeys) {
+    for (const key of config.customKeys) {
+      parts.push(request.headers.get(key) || '');
+    }
+  }
+
+  return parts.join(':') || 'default';
+}
+
+/**
+ * Check rate limit
+ */
+export async function checkRateLimit(
+  request: Request,
+  config: RateLimitConfig
+): Promise<Response | null> {
+  if (!config.enabled) {
+    return null;
+  }
+
+  const key = getRateLimitKey(request, config);
+
+  // Check whitelist
+  if (config.whitelist?.includes(key)) {
+    return null;
+  }
+
+  const now = Date.now();
+  const entry = rateLimitStore.get(key);
+
+  // Reset if window expired
+  if (!entry || now > entry.resetTime) {
+    rateLimitStore.set(key, {
+      count: 1,
+      resetTime: now + config.window * 1000,
+    });
+    return null;
+  }
+
+  // Increment count
+  entry.count++;
+
+  // Check if exceeded
+  if (entry.count > config.maxRequests) {
+    const retryAfter = Math.ceil((entry.resetTime - now) / 1000);
+    return new Response(
+      JSON.stringify({
+        error: config.response?.message || 'Rate limit exceeded',
+        retryAfter,
+      }),
+      {
+        status: config.response?.status || 429,
+        headers: {
+          'Content-Type': 'application/json',
+          'Retry-After': retryAfter.toString(),
+        },
+      }
+    );
+  }
+
+  return null;
+}

package/src/infrastructure/router/index.ts

@@ -5,6 +5,23 @@
 
 import { json, notFound, badRequest } from '../utils/helpers';
 
+// ============================================================
+// Environment Types
+// ============================================================
+
+export interface CloudflareEnv {
+  KV?: KVNamespace;
+  R2?: R2Bucket;
+  D1?: D1Database;
+  DO?: Record<string, DurableObjectNamespace>;
+  QUEUE?: Record<string, Queue>;
+  AI?: any;
+  vars?: Record<string, string>;
+}
+
+// Type alias for backwards compatibility
+export type Env = CloudflareEnv;
+
 // ============================================================
 // Route Handler Types
 // ============================================================
@@ -12,13 +29,13 @@ import { json, notFound, badRequest } from '../utils/helpers';
 export type RouteHandler = (
   request: Request,
   params?: Record<string, string>,
-  env?: Env,
+  env?: CloudflareEnv,
   ctx?: ExecutionContext
 ) => Promise<Response> | Response;
 
 export type Middleware = (
   request: Request,
-  env?: Env,
+  env?: CloudflareEnv,
   ctx?: ExecutionContext
 ) => Promise<Response | null> | Response | null;
 
@@ -147,7 +164,7 @@ export class Router {
    */
   async handle(
     request: Request,
-    env?: Env,
+    env?: CloudflareEnv,
     ctx?: ExecutionContext
   ): Promise<Response> {
     const url = new URL(request.url);
@@ -499,7 +516,12 @@ export async function body<T = unknown>(request: Request): Promise<T> {
  */
 export function query(request: Request): Record<string, string> {
   const url = new URL(request.url);
-  return Object.fromEntries(url.searchParams.entries());
+  const result: Record<string, string> = {};
+  // URLSearchParams.keys() is not available in Workers runtime
+  url.searchParams.forEach((value, key) => {
+    result[key] = value;
+  });
+  return result;
 }
 
 /**

package/src/infrastructure/utils/helpers.ts

@@ -19,7 +19,17 @@ export async function parseBody<T = unknown>(request: Request): Promise<T> {
 
   if (contentType.includes('application/x-www-form-urlencoded')) {
     const formData = await request.formData();
-    return Object.fromEntries(formData) as T;
+    const result: Record<string, unknown> = {};
+    // FormData.keys() is not available in Workers runtime
+    // Use alternative approach with for...of
+    const keys: string[] = [];
+    formData.forEach((value, key) => {
+      if (!keys.includes(key)) {
+        keys.push(key);
+      }
+      result[key] = value;
+    });
+    return result as T;
   }
 
   if (contentType.includes('text/')) {
@@ -297,16 +307,15 @@ export function generateCacheKey(request: Request, prefix?: string): string {
   const parts = [prefix || 'cache', url.pathname];
 
   // Add query params (sorted for consistency)
-  const sortedParams = Array.from(url.searchParams.entries()).sort(
-    ([a], [b]) => a.localeCompare(b)
-  );
+  const params: string[] = [];
+  // URLSearchParams.keys() is not available in Workers runtime
+  url.searchParams.forEach((value, key) => {
+    params.push(`${key}=${value}`);
+  });
+  params.sort();
 
-  if (sortedParams.length > 0) {
-    parts.push(
-      sortedParams
-        .map(([key, value]) => `${key}=${value}`)
-        .join('&')
-    );
+  if (params.length > 0) {
+    parts.push(params.join('&'));
   }
 
   // Add auth header if present (for user-specific caching)
@@ -479,7 +488,12 @@ export function buildURL(base: string, params: Record<string, string | number |
  */
 export function parseQueryParams(url: string): Record<string, string> {
   const params = new URL(url).searchParams;
-  return Object.fromEntries(params.entries());
+  const result: Record<string, string> = {};
+  // URLSearchParams.keys() is not available in Workers runtime
+  params.forEach((value, key) => {
+    result[key] = value;
+  });
+  return result;
 }
 
 /**

package/src/infrastructure/utils/utils.util.ts

@@ -115,12 +115,13 @@ export const transformUtils = {
    */
   async streamToBlob(stream: ReadableStream): Promise<Blob> {
     const reader = stream.getReader();
-    const chunks: Uint8Array[] = [];
+    const chunks: BlobPart[] = [];
 
     while (true) {
       const { done, value } = await reader.read();
       if (done) break;
-      chunks.push(value);
+      // Convert Uint8Array to BlobPart
+      chunks.push(value as BlobPart);
     }
 
     return new Blob(chunks);