@umituz/web-cloudflare 1.4.4 → 1.4.5

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@umituz/web-cloudflare",
-  "version": "1.4.4",
+  "version": "1.4.5",
   "description": "Comprehensive Cloudflare Workers integration with config-based patterns, middleware, router, workflows, and AI (Patch-only versioning: only z in x.y.z increments)",
   "main": "./src/index.ts",
   "types": "./src/index.ts",
@@ -75,6 +75,7 @@
     "typescript": ">=5.0.0"
   },
   "devDependencies": {
+    "@cloudflare/workers-types": "^4.20260317.1",
     "@types/node": "~22.13.10",
     "typescript": "~5.9.2"
   },

package/src/config/patterns.ts

@@ -3,8 +3,8 @@
  * @description Reusable configuration patterns for different use cases
  */
 
-import type { AIGatewayConfig } from '../infrastructure/domain/ai-gateway.entity';
-import type { WorkflowDefinition } from '../infrastructure/domain/workflows.entity';
+import type { AIGatewayConfig } from '../domains/ai-gateway/entities';
+import type { WorkflowDefinition } from '../domains/workflows/entities';
 import type { WorkerConfig } from './types';
 
 // ============================================================
@@ -106,6 +106,8 @@ export const saasConfig: Partial<WorkerConfig> = {
   },
   workflows: {
     enabled: true,
+    maxExecutionTime: 300,
+    defaultRetries: 2,
   },
 };
 
@@ -149,6 +151,8 @@ export const cdnConfig: Partial<WorkerConfig> = {
   },
   rateLimit: {
     enabled: false,
+    maxRequests: 0,
+    window: 0,
   },
   compression: {
     enabled: true,
@@ -194,7 +198,7 @@ export const aiFirstConfig: Partial<WorkerConfig> = {
           baseURL: 'https://api.openai.com/v1',
           apiKey: '',
           models: ['gpt-4', 'gpt-3.5-turbo'],
-          fallback: 'workers-ai',
+          fallbackProvider: 'workers-ai',
           weight: 1,
         },
       ],
@@ -206,6 +210,8 @@ export const aiFirstConfig: Partial<WorkerConfig> = {
   },
   workflows: {
     enabled: true,
+    maxExecutionTime: 600,
+    defaultRetries: 3,
   },
 };
 
@@ -215,13 +221,18 @@ export const aiFirstConfig: Partial<WorkerConfig> = {
 export const minimalConfig: Partial<WorkerConfig> = {
   cache: {
     enabled: false,
+    defaultTTL: 0,
   },
   rateLimit: {
     enabled: false,
+    maxRequests: 0,
+    window: 0,
   },
   cors: {
     enabled: true,
     allowedOrigins: ['*'],
+    allowedMethods: ['GET', 'POST', 'PUT', 'DELETE', 'OPTIONS'],
+    allowedHeaders: ['*'],
   },
 };
 
@@ -234,26 +245,34 @@ export const minimalConfig: Partial<WorkerConfig> = {
  */
 export function mergeConfigs<T extends Record<string, any>>(
   base: T,
-  ...overrides: Partial<T>[]
+  ...overrides: Array<Partial<Record<string, any>>>
 ): T {
   return overrides.reduce((acc, override) => {
     return deepMerge(acc, override);
   }, base);
 }
 
-function deepMerge<T>(target: T, source: Partial<T>): T {
-  const output = { ...target } as T;
+function deepMerge<T extends Record<string, any>>(
+  target: T,
+  source: Partial<Record<string, any>>
+): T {
+  const output = { ...target };
 
   if (isObject(target) && isObject(source)) {
     Object.keys(source).forEach((key) => {
-      if (isObject(source[key as keyof T])) {
+      const sourceValue = source[key];
+      const targetValue = target[key as keyof T];
+
+      if (isObject(sourceValue)) {
         if (!(key in target)) {
-          Object.assign(output, { [key]: source[key as keyof T] });
+          (output as any)[key] = sourceValue;
+        } else if (isObject(targetValue)) {
+          (output as any)[key] = deepMerge(targetValue, sourceValue);
         } else {
-          (output as any)[key] = deepMerge(target[key as keyof T], source[key as keyof T]);
+          (output as any)[key] = sourceValue;
         }
       } else {
-        Object.assign(output, { [key]: source[key as keyof T] });
+        (output as any)[key] = sourceValue;
       }
     });
   }
@@ -261,7 +280,7 @@ function deepMerge<T>(target: T, source: Partial<T>): T {
   return output;
 }
 
-function isObject(item: unknown): item is Record<string, unknown> {
+function isObject(item: unknown): item is Record<string, any> {
   return Boolean(item && typeof item === 'object' && !Array.isArray(item));
 }
 
@@ -316,52 +335,52 @@ export class ConfigBuilder {
   }
 
   withCache(config: Partial<NonNullable<WorkerConfig['cache']>>): ConfigBuilder {
-    this.config.cache = { ...this.config.cache, ...config };
+    this.config.cache = this.config.cache ? { ...this.config.cache, ...config } : config as NonNullable<WorkerConfig['cache']>;
     return this;
   }
 
   withRateLimit(config: Partial<NonNullable<WorkerConfig['rateLimit']>>): ConfigBuilder {
-    this.config.rateLimit = { ...this.config.rateLimit, ...config };
+    this.config.rateLimit = this.config.rateLimit ? { ...this.config.rateLimit, ...config } : config as NonNullable<WorkerConfig['rateLimit']>;
     return this;
   }
 
   withAI(config: Partial<NonNullable<WorkerConfig['ai']>>): ConfigBuilder {
-    this.config.ai = { ...this.config.ai, ...config };
+    this.config.ai = this.config.ai ? { ...this.config.ai, ...config } : config as NonNullable<WorkerConfig['ai']>;
     return this;
   }
 
   withWorkflows(config: Partial<NonNullable<WorkerConfig['workflows']>>): ConfigBuilder {
-    this.config.workflows = { ...this.config.workflows, ...config };
+    this.config.workflows = this.config.workflows ? { ...this.config.workflows, ...config } : config as NonNullable<WorkerConfig['workflows']>;
     return this;
   }
 
   withCORS(config: Partial<NonNullable<WorkerConfig['cors']>>): ConfigBuilder {
-    this.config.cors = { ...this.config.cors, ...config };
+    this.config.cors = this.config.cors ? { ...this.config.cors, ...config } : config as NonNullable<WorkerConfig['cors']>;
     return this;
   }
 
   withAnalytics(config: Partial<NonNullable<WorkerConfig['analytics']>>): ConfigBuilder {
-    this.config.analytics = { ...this.config.analytics, ...config };
+    this.config.analytics = this.config.analytics ? { ...this.config.analytics, ...config } : config as NonNullable<WorkerConfig['analytics']>;
     return this;
   }
 
   withCompression(config: Partial<NonNullable<WorkerConfig['compression']>>): ConfigBuilder {
-    this.config.compression = { ...this.config.compression, ...config };
+    this.config.compression = this.config.compression ? { ...this.config.compression, ...config } : config as NonNullable<WorkerConfig['compression']>;
     return this;
   }
 
   withImageOptimization(config: Partial<NonNullable<WorkerConfig['imageOptimization']>>): ConfigBuilder {
-    this.config.imageOptimization = { ...this.config.imageOptimization, ...config };
+    this.config.imageOptimization = this.config.imageOptimization ? { ...this.config.imageOptimization, ...config } : config as NonNullable<WorkerConfig['imageOptimization']>;
     return this;
   }
 
   withQueues(config: Partial<NonNullable<WorkerConfig['queues']>>): ConfigBuilder {
-    this.config.queues = { ...this.config.queues, ...config };
+    this.config.queues = this.config.queues ? { ...this.config.queues, ...config } : config as NonNullable<WorkerConfig['queues']>;
     return this;
   }
 
   withScheduledTasks(config: Partial<NonNullable<WorkerConfig['scheduledTasks']>>): ConfigBuilder {
-    this.config.scheduledTasks = { ...this.config.scheduledTasks, ...config };
+    this.config.scheduledTasks = this.config.scheduledTasks ? { ...this.config.scheduledTasks, ...config } : config as NonNullable<WorkerConfig['scheduledTasks']>;
     return this;
   }
 
@@ -449,9 +468,9 @@ export function getEnvironmentConfig(
   switch (environment) {
     case 'development':
       return mergeConfigs(minimalConfig, {
-        cache: { enabled: false },
-        rateLimit: { enabled: false },
-        cors: { allowedOrigins: ['*'] },
+        cache: { enabled: false, defaultTTL: 0 },
+        rateLimit: { enabled: false, maxRequests: 0, window: 0 },
+        cors: { enabled: true, allowedOrigins: ['*'], allowedMethods: ['GET', 'POST', 'PUT', 'DELETE', 'OPTIONS'], allowedHeaders: ['*'] },
       });
 
     case 'staging':

package/src/domain/entities/analytics.entity.ts

@@ -0,0 +1,30 @@
+/**
+ * Analytics Entity
+ * @description Basic Analytics entity placeholder
+ */
+
+export interface AnalyticsEntity {
+  siteId: string;
+  eventCount: number;
+}
+
+export interface AnalyticsConfig {
+  siteId: string;
+  scriptUrl?: string;
+}
+
+export interface AnalyticsEvent {
+  timestamp: number;
+  url: string;
+  eventType: string;
+  data?: Record<string, unknown>;
+}
+
+export interface AnalyticsData {
+  siteId: string;
+  events: AnalyticsEvent[];
+  metrics?: {
+    pageviews: number;
+    uniqueVisitors: number;
+  };
+}

package/src/domain/entities/d1.entity.ts

@@ -0,0 +1,27 @@
+/**
+ * D1 Entity
+ * @description Basic D1 entity placeholder
+ */
+
+export interface D1Entity {
+  databaseId: string;
+  name: string;
+}
+
+export interface D1DatabaseConfig {
+  name: string;
+  migrations?: string[];
+}
+
+export interface D1QueryResult<T = unknown> {
+  rows: T[];
+  meta?: {
+    duration: number;
+    changes?: number;
+  };
+}
+
+export interface D1BatchResult<T = unknown> {
+  success: boolean;
+  results?: D1QueryResult<T>[];
+}

package/src/domain/entities/image.entity.ts

@@ -0,0 +1,48 @@
+/**
+ * Image Entity
+ * @description Basic Image entity placeholder
+ */
+
+export interface ImageEntity {
+  id: string;
+  url: string;
+  variant?: string;
+}
+
+export interface ImageConfig {
+  formats?: Array<'webp' | 'avif' | 'jpeg' | 'png'>;
+  quality?: number;
+}
+
+export interface ImageVariant {
+  width: number;
+  height: number;
+  format: string;
+  url: string;
+}
+
+export interface ImageUploadResult {
+  id: string;
+  url: string;
+  variants: ImageVariant[];
+}
+
+export interface ImageUploadOptions {
+  format?: 'webp' | 'avif' | 'jpeg' | 'png';
+  quality?: number;
+  width?: number;
+  height?: number;
+}
+
+export interface ImageTransformation {
+  width?: number;
+  height?: number;
+  fit?: 'contain' | 'cover' | 'fill';
+  format?: 'webp' | 'avif' | 'jpeg' | 'png';
+  quality?: number;
+}
+
+export interface SignedURL {
+  url: string;
+  expires: number;
+}

package/src/domain/entities/kv.entity.ts

@@ -0,0 +1,37 @@
+/**
+ * KV Entity
+ * @description Basic KV entity placeholder
+ */
+
+export interface KVEntity {
+  namespaceId: string;
+  key: string;
+  value: string;
+}
+
+export interface KVNamespaceConfig {
+  id: string;
+  ttl?: number;
+}
+
+export interface KVEntry {
+  key: string;
+  value: string;
+  metadata?: Record<string, unknown>;
+}
+
+export interface KVListOptions {
+  limit?: number;
+  cursor?: string;
+  prefix?: string;
+}
+
+export interface KVListResult {
+  keys: KVEntry[];
+  cursor?: string;
+}
+
+export interface KVKey {
+  name: string;
+  metadata?: Record<string, unknown>;
+}

package/src/domain/entities/r2.entity.ts

@@ -0,0 +1,49 @@
+/**
+ * R2 Entity
+ * @description Basic R2 entity placeholder
+ */
+
+export interface R2Entity {
+  bucketName: string;
+  key: string;
+}
+
+export interface R2BucketConfig {
+  name: string;
+  location?: string;
+}
+
+export interface R2Object {
+  key: string;
+  size: number;
+  uploaded: Date;
+}
+
+export interface R2UploadResult {
+  key: string;
+  etag?: string;
+}
+
+export interface R2ListOptions {
+  limit?: number;
+  cursor?: string;
+  prefix?: string;
+}
+
+export interface R2ListResult {
+  objects: R2Object[];
+  cursor?: string;
+}
+
+export interface R2PutOptions {
+  customMetadata?: Record<string, string>;
+  httpMetadata?: {
+    contentType?: string;
+    cacheControl?: string;
+  };
+}
+
+export interface R2PresignedURL {
+  url: string;
+  expires: number;
+}

package/src/domain/entities/worker.entity.ts

@@ -0,0 +1,35 @@
+/**
+ * Worker Entity
+ * @description Basic Worker entity placeholder
+ */
+
+export interface WorkerEntity {
+  id: string;
+  name: string;
+}
+
+export interface WorkerConfig {
+  name: string;
+  routes?: string[];
+  schedule?: string;
+  bindings?: Record<string, unknown>;
+}
+
+export interface WorkerResponse {
+  status: number;
+  body?: BodyInit | null;
+}
+
+export interface IncomingRequestCfProperties {
+  colo?: string;
+  country?: string;
+  httpProtocol?: string;
+  tlsVersion?: string;
+  tlsCipher?: string;
+  asn?: number;
+  requestPriority?: number;
+}
+
+export type { WorkerRequest as _WorkerRequest } from '../../domains/workers/entities';
+// Re-export WorkerRequest from workers domain
+export { WorkerRequest } from '../../domains/workers/entities';

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

@@ -3,7 +3,7 @@
  * @description Cloudflare Web Analytics configuration and types
  */
 
-export interface AnalyticsConfig {
+export interface WebAnalyticsConfig {
   readonly siteId: string;
   readonly scriptUrl?: string;
 }
@@ -33,7 +33,7 @@ export interface AnalyticsTimingEvent extends AnalyticsEvent {
   readonly label?: string;
 }
 
-export interface AnalyticsData {
+export interface WebAnalyticsData {
   readonly siteId: string;
   readonly events: readonly AnalyticsEvent[];
   readonly metrics?: AnalyticsMetrics;

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/infrastructure/middleware/auth.ts

@@ -0,0 +1,118 @@
+/**
+ * Auth Middleware
+ * @description Authentication middleware for Cloudflare Workers
+ */
+
+export interface AuthConfig {
+  enabled: boolean;
+  type: 'bearer' | 'apikey' | 'basic';
+  token?: string;
+  apiKeyHeader?: string;
+  apiKeyValue?: string;
+  username?: string;
+  password?: string;
+}
+
+/**
+ * Require authentication
+ */
+export async function requireAuth(
+  request: Request,
+  config: AuthConfig
+): Promise<Response | null> {
+  if (!config.enabled) {
+    return null;
+  }
+
+  const authHeader = request.headers.get('Authorization');
+
+  if (!authHeader) {
+    return new Response(
+      JSON.stringify({ error: 'Missing authorization header' }),
+      {
+        status: 401,
+        headers: { 'Content-Type': 'application/json' },
+      }
+    );
+  }
+
+  switch (config.type) {
+    case 'bearer':
+      if (!authHeader.startsWith('Bearer ')) {
+        return new Response(
+          JSON.stringify({ error: 'Invalid authorization type' }),
+          {
+            status: 401,
+            headers: { 'Content-Type': 'application/json' },
+          }
+        );
+      }
+      const token = authHeader.substring(7);
+      if (token !== config.token) {
+        return new Response(
+          JSON.stringify({ error: 'Invalid token' }),
+          {
+            status: 401,
+            headers: { 'Content-Type': 'application/json' },
+          }
+        );
+      }
+      break;
+
+    case 'apikey':
+      const apiKey = request.headers.get(config.apiKeyHeader || 'X-API-Key');
+      if (apiKey !== config.apiKeyValue) {
+        return new Response(
+          JSON.stringify({ error: 'Invalid API key' }),
+          {
+            status: 401,
+            headers: { 'Content-Type': 'application/json' },
+          }
+        );
+      }
+      break;
+
+    case 'basic':
+      if (!authHeader.startsWith('Basic ')) {
+        return new Response(
+          JSON.stringify({ error: 'Invalid authorization type' }),
+          {
+            status: 401,
+            headers: { 'Content-Type': 'application/json' },
+          }
+        );
+      }
+      const credentials = atob(authHeader.substring(6));
+      const [username, password] = credentials.split(':');
+      if (username !== config.username || password !== config.password) {
+        return new Response(
+          JSON.stringify({ error: 'Invalid credentials' }),
+          {
+            status: 401,
+            headers: { 'Content-Type': 'application/json' },
+          }
+        );
+      }
+      break;
+  }
+
+  return null;
+}
+
+/**
+ * Add user context to request
+ */
+export function addUserContext(request: Request, user: {
+  id: string;
+  [key: string]: unknown;
+}): Request {
+  const headers = new Headers(request.headers);
+  headers.set('X-User-ID', user.id);
+  headers.set('X-User-Context', JSON.stringify(user));
+
+  return new Request(request.url, {
+    method: request.method,
+    headers,
+    body: request.body,
+  });
+}

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);