@umituz/web-cloudflare 1.4.4 → 1.4.6

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@umituz/web-cloudflare",
-  "version": "1.4.4",
+  "version": "1.4.6",
   "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",
@@ -17,8 +17,8 @@
     "./ai-gateway": "./src/domains/ai-gateway/index.ts",
     "./workers-ai": "./src/domains/ai-gateway/index.ts",
     "./wrangler": "./src/domains/wrangler/index.ts",
+    "./middleware": "./src/domains/middleware/index.ts",
     "./router": "./src/infrastructure/router/index.ts",
-    "./middleware": "./src/infrastructure/middleware/index.ts",
     "./utils": "./src/infrastructure/utils/helpers.ts",
     "./helpers": "./src/infrastructure/utils/helpers.ts",
     "./config": "./src/config/patterns.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/middleware/entities/index.ts

@@ -0,0 +1,106 @@
+/**
+ * Middleware Domain Entities
+ * @description Middleware configuration and types for Cloudflare Workers
+ */
+
+/**
+ * CORS configuration
+ */
+export interface CORSConfig {
+  enabled: boolean;
+  allowedOrigins: string[];
+  allowedMethods: string[];
+  allowedHeaders: string[];
+  exposedHeaders?: string[];
+  allowCredentials?: boolean;
+  maxAge?: number;
+}
+
+/**
+ * Cache configuration
+ */
+export interface CacheConfig {
+  enabled: boolean;
+  defaultTTL: number;
+  paths?: Record<string, number>;
+  prefix?: string;
+  bypassPaths?: string[];
+  respectHeaders?: boolean;
+}
+
+/**
+ * Rate limit configuration
+ */
+export interface RateLimitConfig {
+  enabled: boolean;
+  maxRequests: number;
+  window: number;
+  by?: 'ip' | 'user' | 'both';
+  customKeys?: string[];
+  whitelist?: string[];
+  response?: {
+    status: number;
+    message: string;
+    retryAfter?: number;
+  };
+}
+
+/**
+ * Authentication configuration
+ */
+export interface AuthConfig {
+  enabled: boolean;
+  type: 'bearer' | 'apikey' | 'basic';
+  token?: string;
+  apiKeyHeader?: string;
+  apiKeyValue?: string;
+  username?: string;
+  password?: string;
+}
+
+/**
+ * Security headers configuration
+ */
+export interface SecurityHeadersConfig {
+  frameGuard?: boolean;
+  contentTypeNosniff?: boolean;
+  xssProtection?: boolean;
+  strictTransportSecurity?: boolean;
+  referrerPolicy?: string;
+  contentSecurityPolicy?: string;
+}
+
+/**
+ * IP filter configuration
+ */
+export interface IPFilterConfig {
+  mode: 'whitelist' | 'blacklist';
+  ips: string[];
+  cidrs?: string[];
+}
+
+/**
+ * Log configuration
+ */
+export interface LogConfig {
+  level: 'debug' | 'info' | 'warn' | 'error';
+  includeHeaders?: boolean;
+  includeBody?: boolean;
+  sampleRate?: number;
+}
+
+/**
+ * Health check configuration
+ */
+export interface HealthCheckConfig {
+  uptime: number;
+  checks: Record<string, () => Promise<boolean>>;
+}
+
+/**
+ * Error handler configuration
+ */
+export interface ErrorHandlerConfig {
+  debug: boolean;
+  logger?: (error: Error) => void;
+}

package/src/domains/middleware/index.ts

@@ -0,0 +1,14 @@
+/**
+ * Middleware Domain
+ * @description Complete middleware integration for Cloudflare Workers
+ * Subpath: @umituz/web-cloudflare/middleware
+ */
+
+// Entities
+export * from './entities';
+
+// Types
+export * from './types';
+
+// Services
+export * from './services';

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

@@ -0,0 +1,110 @@
+/**
+ * Auth Service
+ * @description Authentication middleware for Cloudflare Workers
+ */
+
+import type { AuthConfig } from '../entities';
+
+/**
+ * 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,
+  });
+}