@umituz/web-cloudflare 1.4.4 → 1.4.6

package/src/domains/middleware/services/cache.service.ts

@@ -0,0 +1,93 @@
+/**
+ * Cache Service
+ * @description Caching middleware for Cloudflare Workers
+ */
+
+import type { CacheConfig } from '../entities';
+
+interface CacheEntry {
+  response: Response;
+  expires: number;
+}
+
+const cacheStore = new Map<string, CacheEntry>();
+
+/**
+ * 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/domains/middleware/services/cors.service.ts

@@ -0,0 +1,87 @@
+/**
+ * CORS Service
+ * @description Cross-Origin Resource Sharing middleware for Cloudflare Workers
+ */
+
+import type { CORSConfig } from '../entities';
+
+/**
+ * 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/domains/middleware/services/index.ts

@@ -0,0 +1,9 @@
+/**
+ * Middleware Services
+ * @description Middleware service implementations
+ */
+
+export { cors, addCorsHeaders } from './cors.service';
+export { cache, setCache, invalidateCache } from './cache.service';
+export { checkRateLimit } from './rate-limit.service';
+export { requireAuth, addUserContext } from './auth.service';

package/src/domains/middleware/services/rate-limit.service.ts

@@ -0,0 +1,93 @@
+/**
+ * Rate Limit Service
+ * @description Rate limiting middleware for Cloudflare Workers
+ */
+
+import type { RateLimitConfig } from '../entities';
+
+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/domains/middleware/types/index.ts

@@ -0,0 +1,5 @@
+/**
+ * Middleware Domain Types
+ */
+
+export * from './service.interface';

package/src/domains/middleware/types/service.interface.ts

@@ -0,0 +1,122 @@
+/**
+ * Middleware Service Interface
+ * @description Defines the contract for middleware operations
+ */
+
+import type {
+  CORSConfig,
+  CacheConfig,
+  RateLimitConfig,
+  AuthConfig,
+  SecurityHeadersConfig,
+  IPFilterConfig,
+  LogConfig,
+  HealthCheckConfig,
+  ErrorHandlerConfig,
+} from '../entities';
+
+export interface IMiddlewareService {
+  /**
+   * CORS middleware
+   */
+  cors(request: Request, config: CORSConfig): Promise<Response | null>;
+  addCorsHeaders(request: Request, response: Response, config: CORSConfig): Response;
+
+  /**
+   * Cache middleware
+   */
+  cache(request: Request, config: CacheConfig): Promise<Response | null>;
+  setCache(request: Request, response: Response, config: CacheConfig): void;
+  invalidateCache(pattern?: string): void;
+
+  /**
+   * Rate limit middleware
+   */
+  checkRateLimit(request: Request, config: RateLimitConfig): Promise<Response | null>;
+
+  /**
+   * Authentication middleware
+   */
+  requireAuth(request: Request, config: AuthConfig): Promise<Response | null>;
+  addUserContext(request: Request, user: {
+    id: string;
+    [key: string]: unknown;
+  }): Request;
+
+  /**
+   * Security headers
+   */
+  addSecurityHeaders(response: Response, config: SecurityHeadersConfig): Response;
+
+  /**
+   * Bot detection
+   */
+  detectBot(request: Request): Promise<{
+    isBot: boolean;
+    botType?: string;
+  }>;
+
+  /**
+   * Request logging
+   */
+  logRequest(request: Request, config: LogConfig): Promise<void>;
+
+  /**
+   * Response time tracking
+   */
+  trackResponseTime(handler: () => Promise<Response>): Promise<{
+    response: Response;
+    duration: number;
+  }>;
+
+  /**
+   * IP filter
+   */
+  checkIPFilter(request: Request, config: IPFilterConfig): Response | null;
+
+  /**
+   * Method override
+   */
+  methodOverride(request: Request): Request;
+
+  /**
+   * Request ID
+   */
+  addRequestID(request: Request): string;
+
+  /**
+   * Health check
+   */
+  healthCheck(
+    env: import('../../router').CloudflareEnv,
+    config?: HealthCheckConfig
+  ): Promise<Response>;
+
+  /**
+   * Error handling
+   */
+  handleMiddlewareError(error: Error, config: ErrorHandlerConfig): Response;
+
+  /**
+   * Conditional middleware
+   */
+  conditionalChainMiddleware(
+    condition: (request: Request) => boolean,
+    middleware: (request: Request) => Response | null
+  ): (request: Request) => Response | null;
+
+  /**
+   * Chain middleware
+   */
+  chainMiddleware(
+    ...middlewares: Array<(request: Request) => Response | null>
+  ): (request: Request) => Response | null;
+
+  /**
+   * Chain async middleware
+   */
+  chainAsyncMiddleware(
+    request: Request,
+    ...middlewares: Array<(request: Request) => Promise<Response | null>>
+  ): Promise<Response | null>;
+}

package/src/domains/workers/entities/index.ts

@@ -11,7 +11,7 @@ export interface WorkerResponse extends Response {
   waitUntil?: (promise: Promise<unknown>) => void;
 }
 
-export interface WorkerConfig {
+export interface CloudflareWorkerConfig {
   readonly name: string;
   readonly routes?: string[];
   readonly schedule?: string;

package/src/domains/workflows/entities/index.ts

@@ -0,0 +1,60 @@
+/**
+ * Workflows Domain Entities
+ * @description Workflow orchestration entities for Cloudflare Workers
+ */
+
+/**
+ * Workflow step definition
+ */
+export interface WorkflowStep {
+  id: string;
+  name: string;
+  handler: string;
+  timeout?: number;
+  retryPolicy?: {
+    maxAttempts: number;
+    backoffMultiplier: number;
+    initialDelay: number;
+    maxDelay: number;
+  };
+  dependencies?: string[];
+}
+
+/**
+ * Workflow definition
+ */
+export interface WorkflowDefinition {
+  id: string;
+  name: string;
+  description?: string;
+  steps: WorkflowStep[];
+}
+
+/**
+ * Workflow execution state
+ */
+export interface WorkflowExecution {
+  id: string;
+  workflowId: string;
+  status: 'pending' | 'running' | 'completed' | 'failed';
+  currentStep?: string;
+  startedAt: number;
+  completedAt?: number;
+  input: unknown;
+  output?: unknown;
+  error?: string;
+}
+
+/**
+ * Workflow config
+ */
+export interface CloudflareWorkflowConfig {
+  enabled: boolean;
+  maxExecutionTime: number;
+  defaultRetries: number;
+  workflows?: Record<string, WorkflowDefinition>;
+  storage?: 'kv' | 'd1';
+}
+
+// Type alias for compatibility
+export type WorkflowConfig = CloudflareWorkflowConfig;

package/src/domains/wrangler/entities/index.ts

@@ -132,9 +132,9 @@ export interface WorkerVersionInfo {
 }
 
 /**
- * Analytics data
+ * Wrangler analytics data
  */
-export interface AnalyticsData {
+export interface WranglerAnalyticsData {
   requests?: number;
   errors?: number;
   statusCodes?: Record<string, number>;

package/src/domains/wrangler/services/wrangler.service.ts

@@ -118,6 +118,14 @@ export class WranglerService implements IWranglerService {
     }
   }
 
+  /**
+   * Convert string result to void result
+   */
+  private asVoidResult(result: WranglerResult<string>): WranglerResult<void> {
+    const { data, ...rest } = result;
+    return rest;
+  }
+
   // ==================== Authentication ====================
 
   async login(options?: WranglerCommandOptions): Promise<WranglerResult<AuthInfo>> {
@@ -132,7 +140,7 @@ export class WranglerService implements IWranglerService {
   }
 
   async logout(options?: WranglerCommandOptions): Promise<WranglerResult<void>> {
-    return this.execute(['logout'], options);
+    return this.asVoidResult(await this.execute(['logout'], options));
   }
 
   async whoami(options?: WranglerCommandOptions): Promise<WranglerResult<AuthInfo>> {
@@ -158,7 +166,7 @@ export class WranglerService implements IWranglerService {
     if (template) {
       args.push('--template', template);
     }
-    return this.execute(args, options);
+    return this.asVoidResult(await this.execute(args, options));
   }
 
   async dev(
@@ -237,7 +245,7 @@ export class WranglerService implements IWranglerService {
     value: string,
     options?: WranglerCommandOptions
   ): Promise<WranglerResult<void>> {
-    return this.execute(['kv:key', 'put', '--namespace-id', namespaceId, key, value], options);
+    return this.asVoidResult(await this.execute(['kv:key', 'put', '--namespace-id', namespaceId, key, value], options));
   }
 
   async kvKeyGet(
@@ -253,7 +261,7 @@ export class WranglerService implements IWranglerService {
     key: string,
     options?: WranglerCommandOptions
   ): Promise<WranglerResult<void>> {
-    return this.execute(['kv:key', 'delete', '--namespace-id', namespaceId, key], options);
+    return this.asVoidResult(await this.execute(['kv:key', 'delete', '--namespace-id', namespaceId, key], options));
   }
 
   // ==================== R2 Operations ====================
@@ -289,7 +297,7 @@ export class WranglerService implements IWranglerService {
     bucketName: string,
     options?: WranglerCommandOptions
   ): Promise<WranglerResult<void>> {
-    return this.execute(['r2', 'bucket', 'delete', bucketName], options);
+    return this.asVoidResult(await this.execute(['r2', 'bucket', 'delete', bucketName], options));
   }
 
   async r2ObjectPut(
@@ -298,7 +306,7 @@ export class WranglerService implements IWranglerService {
     file: string,
     options?: WranglerCommandOptions
   ): Promise<WranglerResult<void>> {
-    return this.execute(['r2', 'object', 'put', bucketName, key, '--file', file], options);
+    return this.asVoidResult(await this.execute(['r2', 'object', 'put', bucketName, key, '--file', file], options));
   }
 
   // ==================== D1 Operations ====================
@@ -412,7 +420,7 @@ export class WranglerService implements IWranglerService {
     secretName: string,
     options?: WranglerCommandOptions
   ): Promise<WranglerResult<void>> {
-    return this.execute(['secret', 'delete', secretName], options);
+    return this.asVoidResult(await this.execute(['secret', 'delete', secretName], options));
   }
 
   // ==================== Monitoring ====================
@@ -446,7 +454,7 @@ export class WranglerService implements IWranglerService {
     versionId: string,
     options?: WranglerCommandOptions
   ): Promise<WranglerResult<void>> {
-    return this.execute(['versions', 'rollback', '--version-id', versionId], options);
+    return this.asVoidResult(await this.execute(['versions', 'rollback', '--version-id', versionId], options));
   }
 
   // ==================== Generic Command Execution ====================

package/src/domains/wrangler/types/service.interface.ts

@@ -12,8 +12,8 @@ import type {
   D1DatabaseInfo,
   SecretInfo,
   WorkerVersionInfo,
-  AnalyticsData,
-} from '../entities/wrangler.entity';
+  WranglerAnalyticsData,
+} from '../entities';
 
 export interface IWranglerService {
   // Authentication

package/src/index.ts

@@ -35,10 +35,10 @@ export * from "./domains/kv";
 export * from "./domains/images";
 export * from "./domains/analytics";
 export * from "./domains/workflows";
+export * from "./domains/middleware";
 
-// Infrastructure - Router, Middleware, Utils
+// Infrastructure - Router, Utils
 export * from "./infrastructure/router";
-export * from "./infrastructure/middleware";
 export * from "./infrastructure/utils/helpers";
 export * from "./infrastructure/constants";
 

package/src/infrastructure/middleware/index.ts

@@ -1,13 +1,28 @@
 /**
  * Cloudflare Middleware Collection
  * @description Comprehensive middleware for Cloudflare Workers
+ * @deprecated Import from '@umituz/web-cloudflare/middleware' instead
  */
 
-// Re-export existing middleware
-export { cors, addCorsHeaders } from './cors';
-export { cache, setCache, invalidateCache } from './cache';
-export { checkRateLimit } from './rate-limit';
-export { requireAuth, addUserContext } from './auth';
+// Re-export from middleware domain
+export * from '../../domains/middleware';
+
+// ============================================================
+// Environment Types (kept for backwards compatibility)
+// ============================================================
+
+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;
 
 // ============================================================
 // New Middleware
@@ -300,7 +315,7 @@ export interface HealthCheckConfig {
 }
 
 export async function healthCheck(
-  env: Env,
+  env: CloudflareMiddlewareEnv,
   config?: HealthCheckConfig
 ): Promise<Response> {
   const checks: Record<string, boolean | string> = {
@@ -357,9 +372,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 {