@umituz/web-cloudflare 1.4.10 → 1.4.12

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@umituz/web-cloudflare",
-  "version": "1.4.10",
+  "version": "1.4.12",
   "description": "Comprehensive Cloudflare Workers & Pages 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",

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

@@ -18,6 +18,7 @@ export interface AnalyticsEvent {
   url: string;
   eventType: string;
   data?: Record<string, unknown>;
+  eventData?: Record<string, unknown>;
 }
 
 export interface AnalyticsData {
@@ -28,3 +29,16 @@ export interface AnalyticsData {
     uniqueVisitors: number;
   };
 }
+
+export interface AnalyticsPageviewEvent {
+  timestamp: number;
+  url: string;
+  title: string;
+  referrer?: string;
+  eventType: 'pageview';
+}
+
+export interface AnalyticsCustomEvent extends AnalyticsEvent {
+  eventName: string;
+  eventData?: Record<string, unknown>;
+}

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

@@ -30,6 +30,152 @@ export interface IncomingRequestCfProperties {
   requestPriority?: number;
 }
 
-export type { WorkerRequest as _WorkerRequest } from '../../domains/workers/entities';
-// Re-export WorkerRequest from workers domain
-export { WorkerRequest } from '../../domains/workers/entities';
+export interface WorkerRequest {
+  url: string;
+  method: string;
+  headers: Headers;
+  body?: ReadableStream | null;
+  json(): Promise<unknown>;
+  cf?: IncomingRequestCfProperties;
+}
+
+export interface CloudflareWorkerConfig extends WorkerConfig {
+  env?: {
+    KV?: Record<string, KVNamespace>;
+    R2?: Record<string, R2Bucket>;
+    D1?: Record<string, D1Database>;
+  };
+}
+
+// Workflow types
+export interface WorkflowStep<T = unknown> {
+  id: string;
+  name: string;
+  handler: string | ((input: T) => Promise<unknown>);
+  inputs?: Record<string, unknown>;
+  dependencies?: string[];
+  timeout?: number;
+  retryPolicy?: {
+    maxAttempts?: number;
+    backoffMs?: number;
+    backoffMultiplier?: number;
+    initialDelay?: number;
+    maxDelay?: number;
+  };
+}
+
+export interface WorkflowDefinition<TInput = unknown, TOutput = unknown> {
+  id?: string;
+  name: string;
+  description?: string;
+  version?: string;
+  steps: WorkflowStep<TInput>[];
+  execute?: (input: TInput) => Promise<TOutput>;
+  retryConfig?: {
+    maxRetries?: number;
+    backoffMultiplier?: number;
+    initialDelay?: number;
+    maxDelay?: number;
+  };
+}
+
+export interface WorkflowExecution {
+  id: string;
+  workflowId: string;
+  status: 'pending' | 'running' | 'completed' | 'failed' | 'retrying';
+  input: unknown;
+  inputs?: Record<string, unknown>;
+  output?: unknown;
+  outputs?: Record<string, unknown>;
+  startedAt: number;
+  completedAt?: number;
+  completedSteps: string[];
+  failedSteps: string[];
+  error?: Error | string;
+  retryCount: number;
+}
+
+export interface CloudflareWorkflowConfig {
+  kvBinding?: string;
+  d1Binding?: string;
+  maxExecutionTime?: number;
+}
+
+// Middleware config types
+export interface MiddlewareCORSConfig {
+  enabled?: boolean;
+  allowedOrigins: string[];
+  allowedMethods: string[];
+  allowedHeaders: string[];
+  exposedHeaders?: string[];
+  credentials?: boolean;
+  allowCredentials?: boolean;
+  maxAge?: number;
+}
+
+export interface MiddlewareCacheConfig {
+  enabled: boolean;
+  defaultTTL: number;
+  staleWhileRevalidate?: boolean;
+  prefix?: string;
+  bypassPaths?: string[];
+  paths?: Record<string, number>;
+}
+
+export interface MiddlewareRateLimitConfig {
+  enabled: boolean;
+  maxRequests: number;
+  window: number;
+  by?: 'ip' | 'user' | 'custom' | 'both';
+  keyGenerator?: (request: Request) => string;
+  customKeys?: string[];
+  whitelist?: string[];
+  response?: {
+    status: number;
+    body: string;
+    message?: string;
+    headers?: Record<string, string>;
+  };
+}
+
+export interface MiddlewareAuthConfig {
+  enabled?: boolean;
+  type: 'bearer' | 'basic' | 'custom' | 'apikey';
+  validate: (request: Request) => Promise<boolean>;
+  challenge?: (request: Request) => Response;
+  token?: string;
+  apiKeyHeader?: string;
+  apiKeyValue?: string;
+  username?: string;
+  password?: string;
+}
+
+export interface SecurityHeadersConfig {
+  contentSecurityPolicy?: string;
+  strictTransportSecurity?: string;
+  xFrameOptions?: string;
+  xContentTypeOptions?: 'nosniff' | string;
+}
+
+export interface IPFilterConfig {
+  allowed: string[];
+  blocked: string[];
+}
+
+export interface LogConfig {
+  enabled: boolean;
+  level: 'debug' | 'info' | 'warn' | 'error';
+  includeHeaders?: boolean;
+  includeBody?: boolean;
+}
+
+export interface HealthCheckConfig {
+  path: string;
+  methods: string[];
+  response: { status: number; body?: string };
+}
+
+export interface ErrorHandlerConfig {
+  includeStackTrace?: boolean;
+  sanitizeErrors?: boolean;
+}

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

@@ -1,47 +1,10 @@
 /**
- * Analytics Entity
- * @description Cloudflare Web Analytics configuration and types
+ * Analytics Domain Entities
+ * Re-exports from central domain entities for consistency
  */
 
-export interface WebAnalyticsConfig {
-  readonly siteId: string;
-  readonly scriptUrl?: string;
-}
-
-export interface AnalyticsEvent {
-  readonly timestamp: number;
-  readonly url: string;
-  readonly eventType: "pageview" | "custom" | "outbound-link" | "timing";
-  readonly eventData?: Record<string, unknown>;
-}
-
-export interface AnalyticsPageviewEvent extends AnalyticsEvent {
-  readonly eventType: "pageview";
-  readonly title: string;
-  readonly referrer?: string;
-}
-
-export interface AnalyticsCustomEvent extends AnalyticsEvent {
-  readonly eventType: "custom";
-  readonly eventName: string;
-}
-
-export interface AnalyticsTimingEvent extends AnalyticsEvent {
-  readonly eventType: "timing";
-  readonly name: string;
-  readonly value: number;
-  readonly label?: string;
-}
-
-export interface WebAnalyticsData {
-  readonly siteId: string;
-  readonly events: readonly AnalyticsEvent[];
-  readonly metrics?: AnalyticsMetrics;
-}
-
-export interface AnalyticsMetrics {
-  readonly pageviews: number;
-  readonly uniqueVisitors: number;
-  readonly bounceRate?: number;
-  readonly avgSessionDuration?: number;
-}
+export type {
+  AnalyticsEvent,
+  AnalyticsPageviewEvent,
+  AnalyticsCustomEvent,
+} from '../../../domain/entities/analytics.entity';

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

@@ -1,37 +1,9 @@
 /**
- * D1 Entity
- * @description Cloudflare D1 database configuration and types
+ * D1 Domain Entities
+ * Re-exports from central domain entities for consistency
  */
 
-export interface D1DatabaseConfig {
-  readonly database: string;
-}
-
-export interface D1QueryResult<T = unknown> {
-  readonly results: readonly T[];
-  readonly success: boolean;
-  readonly meta?: D1QueryMeta;
-}
-
-export interface D1QueryMeta {
-  readonly duration: number;
-  readonly rows_read: number;
-  readonly rows_written: number;
-  readonly last_row_id?: number;
-  readonly changes: number;
-}
-
-export interface D1PreparedStatement {
-  readonly statement: string;
-  readonly params: readonly unknown[];
-}
-
-export interface D1BatchResult {
-  readonly success: boolean;
-  readonly results: readonly D1QueryResult[];
-}
-
-export interface D1TransactionOptions {
-  readonly rollbackOnError?: boolean;
-  readonly timeout?: number;
-}
+export type {
+  D1QueryResult,
+  D1BatchResult,
+} from '../../../domain/entities/d1.entity';

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

@@ -1,48 +1,11 @@
 /**
- * Image Entity
- * @description Cloudflare Images configuration and types
+ * Images Domain Entities
+ * Re-exports from central domain entities for consistency
  */
 
-export interface ImageConfig {
-  readonly account: string;
-  readonly customDomain?: string;
-}
-
-export interface ImageVariant {
-  readonly variant: string;
-  readonly width?: number;
-  readonly height?: number;
-  readonly fit?: "scale-down" | "contain" | "cover" | "crop" | "pad";
-  readonly format?: "jpeg" | "png" | "gif" | "webp" | "avif";
-  readonly quality?: number;
-}
-
-export interface ImageUploadResult {
-  readonly id: string;
-  readonly filename: string;
-  readonly uploaded: Date;
-  readonly variants: readonly string[];
-  readonly requireSignedURLs: boolean;
-}
-
-export interface ImageUploadOptions {
-  readonly metadata?: Record<string, string>;
-  readonly requireSignedURLs?: boolean;
-  readonly variants?: readonly ImageVariant[];
-}
-
-export interface ImageTransformation {
-  readonly width?: number;
-  readonly height?: number;
-  readonly fit?: "scale-down" | "contain" | "cover" | "crop" | "pad";
-  readonly format?: "jpeg" | "png" | "gif" | "webp" | "avif";
-  readonly quality?: number;
-  readonly rotate?: number;
-  readonly flip?: boolean;
-  readonly flop?: boolean;
-}
-
-export interface SignedURL {
-  readonly url: string;
-  readonly expiresAt: Date;
-}
+export type {
+  ImageUploadResult,
+  ImageUploadOptions,
+  SignedURL,
+  ImageTransformation,
+} from '../../../domain/entities/image.entity';

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

@@ -1,34 +1,9 @@
 /**
- * KV Entity
- * @description Cloudflare KV configuration and types
+ * KV Domain Entities
+ * Re-exports from central domain entities for consistency
  */
 
-export interface KVNamespaceConfig {
-  readonly namespace: string;
-  readonly ttl?: number;
-}
-
-export interface KVEntry<T = unknown> {
-  readonly key: string;
-  readonly value: T;
-  readonly metadata?: Record<string, unknown>;
-  readonly expiration?: number;
-}
-
-export interface KVListOptions {
-  readonly limit?: number;
-  readonly cursor?: string;
-  readonly prefix?: string;
-}
-
-export interface KVListResult {
-  readonly keys: readonly KVKey[];
-  readonly list_complete: boolean;
-  readonly cursor?: string;
-}
-
-export interface KVKey {
-  readonly name: string;
-  readonly metadata?: Record<string, unknown>;
-  readonly expiration?: number;
-}
+export type {
+  KVListOptions,
+  KVListResult,
+} from '../../../domain/entities/kv.entity';

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

@@ -1,106 +1,16 @@
 /**
  * Middleware Domain Entities
- * @description Middleware configuration and types for Cloudflare Workers
- */
-
-/**
- * CORS configuration
- */
-export interface MiddlewareCORSConfig {
-  enabled: boolean;
-  allowedOrigins: string[];
-  allowedMethods: string[];
-  allowedHeaders: string[];
-  exposedHeaders?: string[];
-  allowCredentials?: boolean;
-  maxAge?: number;
-}
-
-/**
- * Cache configuration
- */
-export interface MiddlewareCacheConfig {
-  enabled: boolean;
-  defaultTTL: number;
-  paths?: Record<string, number>;
-  prefix?: string;
-  bypassPaths?: string[];
-  respectHeaders?: boolean;
-}
-
-/**
- * Rate limit configuration
- */
-export interface MiddlewareRateLimitConfig {
-  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 MiddlewareAuthConfig {
-  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;
-}
+ * Re-exports from central domain entities for consistency
+ */
+
+export type {
+  MiddlewareCORSConfig,
+  MiddlewareCacheConfig,
+  MiddlewareRateLimitConfig,
+  MiddlewareAuthConfig,
+  SecurityHeadersConfig,
+  IPFilterConfig,
+  LogConfig,
+  HealthCheckConfig,
+  ErrorHandlerConfig,
+} from '../../../domain/entities/worker.entity';

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

@@ -34,21 +34,53 @@ export class PagesService implements IPagesService {
       compatibilityDate?: string;
     }
   ): Promise<{ success: boolean; data?: PagesProject; error?: string }> {
-    return this.nodeNotRequired();
+    const args = ['project', 'create', projectName];
+    if (options?.productionBranch) {
+      args.push('--production-branch', options.productionBranch);
+    }
+
+    const result = this.executeWranglerPages(args);
+    if (result.success) {
+      return {
+        success: true,
+        data: {
+          name: projectName,
+          production_branch: options?.productionBranch,
+        },
+      };
+    }
+    return { success: false, error: result.stderr };
   }
 
   /**
    * List all Pages projects
    */
   async listProjects(): Promise<{ success: boolean; data?: PagesProject[]; error?: string }> {
-    return this.nodeNotRequired();
+    const result = this.executeWranglerPages(['project', 'list']);
+    if (result.success) {
+      // Parse output to get project list
+      try {
+        const projects = this.parseProjectsList(result.stdout);
+        return { success: true, data: projects };
+      } catch {
+        return { success: true, data: [] };
+      }
+    }
+    return { success: false, error: result.stderr };
   }
 
   /**
    * Get project details
    */
   async getProject(projectName: string): Promise<{ success: boolean; data?: PagesProject; error?: string }> {
-    return this.nodeNotRequired();
+    const result = this.executeWranglerPages(['project', 'view', projectName]);
+    if (result.success) {
+      return {
+        success: true,
+        data: { name: projectName },
+      };
+    }
+    return { success: false, error: result.stderr };
   }
 
   /**
@@ -57,7 +89,39 @@ export class PagesService implements IPagesService {
   async deploy(
     options: PagesDeployOptions
   ): Promise<{ success: boolean; data?: PagesDeploymentResult; error?: string }> {
-    return this.nodeNotRequired();
+    const args = ['deploy', options.directory || 'dist', '--project-name', options.projectName];
+
+    if (options.branch) {
+      args.push('--branch', options.branch);
+    }
+
+    if (options.environment === 'preview') {
+      args.push('--branch', `preview-${Date.now()}`);
+    }
+
+    // Add environment variables
+    if (options.vars && Object.keys(options.vars).length > 0) {
+      Object.entries(options.vars).forEach(([key, value]) => {
+        args.push('--var', `${key}:${value}`);
+      });
+    }
+
+    const result = this.executeWranglerPages(args);
+    if (result.success) {
+      const url = this.extractDeploymentUrl(result.stdout);
+      return {
+        success: true,
+        data: {
+          deployment: {
+            id: Date.now().toString(),
+            project: options.projectName,
+            url: url || '',
+          },
+          url,
+        },
+      };
+    }
+    return { success: false, error: result.stderr };
   }
 
   /**
@@ -71,7 +135,23 @@ export class PagesService implements IPagesService {
       compatibilityFlags?: string[];
     }
   ): Promise<{ success: boolean; data?: PagesFunction; error?: string }> {
-    return this.nodeNotRequired();
+    const args = ['function', 'create', projectName, functionName];
+
+    if (options?.compatibilityDate) {
+      args.push('--compatibility-date', options.compatibilityDate);
+    }
+
+    const result = this.executeWranglerPages(args);
+    if (result.success) {
+      return {
+        success: true,
+        data: {
+          name: functionName,
+          compatibilityDate: options?.compatibilityDate,
+        },
+      };
+    }
+    return { success: false, error: result.stderr };
   }
 
   /**
@@ -80,7 +160,11 @@ export class PagesService implements IPagesService {
   async listDeployments(
     projectName: string
   ): Promise<{ success: boolean; data?: PagesDeployment[]; error?: string }> {
-    return this.nodeNotRequired();
+    const result = this.executeWranglerPages(['deployment', 'list', '--project-name', projectName]);
+    if (result.success) {
+      return { success: true, data: [] };
+    }
+    return { success: false, error: result.stderr };
   }
 
   /**
@@ -90,7 +174,24 @@ export class PagesService implements IPagesService {
     projectName: string,
     deploymentId: string
   ): Promise<{ success: boolean; data?: PagesDeployment; error?: string }> {
-    return this.nodeNotRequired();
+    const result = this.executeWranglerPages([
+      'deployment',
+      'view',
+      deploymentId,
+      '--project-name',
+      projectName,
+    ]);
+    if (result.success) {
+      return {
+        success: true,
+        data: {
+          id: deploymentId,
+          project: projectName,
+          url: '',
+        },
+      };
+    }
+    return { success: false, error: result.stderr };
   }
 
   /**
@@ -100,7 +201,17 @@ export class PagesService implements IPagesService {
     projectName: string,
     deploymentId: string
   ): Promise<{ success: boolean; error?: string }> {
-    return this.nodeNotRequired();
+    const result = this.executeWranglerPages([
+      'deployment',
+      'delete',
+      deploymentId,
+      '--project-name',
+      projectName,
+    ]);
+    if (result.success) {
+      return { success: true };
+    }
+    return { success: false, error: result.stderr };
   }
 
   /**
@@ -132,12 +243,29 @@ export class PagesService implements IPagesService {
     }
   }
 
-  private nodeNotRequired<T>(): never {
-    throw new Error(
-      'PagesService requires Node.js runtime. ' +
-      'This service only works in Node.js environment, not in Cloudflare Workers. ' +
-      'Use this service in build scripts or deployment tools only.'
-    );
+  /**
+   * Parse projects list output
+   */
+  private parseProjectsList(stdout: string): PagesProject[] {
+    const projects: PagesProject[] = [];
+    const lines = stdout.split('\n');
+    for (const line of lines) {
+      if (line.includes('│')) {
+        const parts = line.split('│').map((s) => s.trim());
+        if (parts.length >= 2 && parts[1]) {
+          projects.push({ name: parts[1] });
+        }
+      }
+    }
+    return projects;
+  }
+
+  /**
+   * Extract deployment URL from wrangler output
+   */
+  private extractDeploymentUrl(stdout: string): string | undefined {
+    const urlMatch = stdout.match(/https?:\/\/[^\s]+\.pages\.dev[^\s]*/);
+    return urlMatch ? urlMatch[0] : undefined;
   }
 }
 

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

@@ -1,55 +1,12 @@
 /**
- * R2 Entity
- * @description Cloudflare R2 storage configuration and types
+ * R2 Domain Entities
+ * Re-exports from central domain entities for consistency
  */
 
-export interface R2BucketConfig {
-  readonly bucket: string;
-  readonly customDomain?: string;
-}
-
-export interface R2Object {
-  readonly key: string;
-  readonly size: number;
-  readonly uploaded: Date;
-  readonly httpMetadata?: R2HTTPMetadata;
-  readonly customMetadata?: Record<string, string>;
-}
-
-export interface R2HTTPMetadata {
-  readonly contentType?: string;
-  readonly cacheControl?: string;
-  readonly contentEncoding?: string;
-  readonly contentLanguage?: string;
-  readonly cacheExpiry?: Date;
-}
-
-export interface R2UploadResult {
-  readonly key: string;
-  readonly size: number;
-  readonly etag?: string;
-  readonly version?: string;
-}
-
-export interface R2ListOptions {
-  readonly limit?: number;
-  readonly prefix?: string;
-  readonly cursor?: string;
-}
-
-export interface R2ListResult {
-  readonly objects: readonly R2Object[];
-  readonly truncated: boolean;
-  readonly cursor?: string;
-}
-
-export interface R2PutOptions {
-  readonly httpMetadata?: R2HTTPMetadata;
-  readonly customMetadata?: Record<string, string>;
-  readonly checksum?: string;
-}
-
-export interface R2PresignedURL {
-  readonly url: string;
-  readonly expiresAt: Date;
-}
+export type {
+  R2Object,
+  R2ListOptions,
+  R2ListResult,
+  R2PutOptions,
+  R2PresignedURL,
+} from '../../../domain/entities/r2.entity';

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

@@ -1,51 +1,10 @@
 /**
- * Worker Entity
- * @description Cloudflare Worker configuration and types
+ * Workers Domain Entities
+ * Re-exports from central domain entities for consistency
  */
 
-export interface WorkerRequest {
-  url: string;
-  method: string;
-  headers: Headers;
-  body?: ReadableStream | null;
-  cf?: IncomingRequestCfProperties;
-  cache?: RequestCache;
-  credentials?: RequestCredentials;
-  integrity?: string;
-  mode?: RequestMode;
-  redirect?: RequestRedirect;
-  referrer?: string;
-  referrerPolicy?: ReferrerPolicy;
-  json(): Promise<unknown>;
-  text(): Promise<string>;
-  arrayBuffer(): Promise<ArrayBuffer>;
-  blob(): Promise<Blob>;
-  formData(): Promise<FormData>;
-}
-
-export interface WorkerResponse extends Response {
-  waitUntil?: (promise: Promise<unknown>) => void;
-}
-
-export interface CloudflareWorkerConfig {
-  readonly name: string;
-  readonly routes?: string[];
-  readonly schedule?: string;
-  readonly bindings?: WorkerBindings;
-}
-
-export interface WorkerBindings {
-  readonly kv?: Record<string, KVNamespace>;
-  readonly r2?: Record<string, R2Bucket>;
-  readonly d1?: Record<string, D1Database>;
-  readonly env?: Record<string, string>;
-}
-
-export interface IncomingRequestCfProperties {
-  readonly colo?: string;
-  readonly country?: string;
-  readonly httpProtocol?: string;
-  readonly requestPriority?: string;
-  readonly tlsVersion?: string;
-  readonly tlsCipher?: string;
-}
+export type {
+  WorkerRequest,
+  WorkerResponse,
+  CloudflareWorkerConfig,
+} from '../../../domain/entities/worker.entity';

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

@@ -1,73 +1,11 @@
 /**
  * Workflows Domain Entities
- * @description Workflow orchestration entities for Cloudflare Workers
+ * Re-exports from central domain entities for consistency
  */
 
-/**
- * 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[];
-  inputs?: Record<string, unknown>;
-}
-
-/**
- * Workflow definition
- */
-export interface WorkflowDefinition {
-  id: string;
-  name: string;
-  description?: string;
-  version?: string;
-  steps: WorkflowStep[];
-  retryConfig?: {
-    maxAttempts: number;
-    backoffMultiplier: number;
-    initialDelay: number;
-    maxDelay: number;
-  };
-}
-
-/**
- * Workflow execution state
- */
-export interface WorkflowExecution {
-  id: string;
-  workflowId: string;
-  status: 'pending' | 'running' | 'completed' | 'failed' | 'retrying';
-  currentStep?: string;
-  startedAt: number;
-  completedAt?: number;
-  input: unknown;
-  output?: unknown;
-  outputs?: Record<string, unknown>;
-  error?: string;
-  completedSteps: string[];
-  failedSteps: string[];
-  inputs: Record<string, unknown>;
-  retryCount: number;
-}
-
-/**
- * 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;
+export type {
+  WorkflowStep,
+  WorkflowDefinition,
+  WorkflowExecution,
+  CloudflareWorkflowConfig,
+} from '../../../domain/entities/worker.entity';

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

@@ -167,10 +167,13 @@ export class WorkflowService {
           execution.status = 'retrying';
           await this.saveExecution(execution);
 
-          // Exponential backoff
+          // Exponential backoff with defaults
+          const initialDelay = retryPolicy.initialDelay ?? 1000;
+          const backoffMultiplier = retryPolicy.backoffMultiplier ?? 2;
+          const maxDelay = retryPolicy.maxDelay ?? 30000;
           const delay = Math.min(
-            retryPolicy.initialDelay * Math.pow(retryPolicy.backoffMultiplier, execution.retryCount),
-            retryPolicy.maxDelay
+            initialDelay * Math.pow(backoffMultiplier, execution.retryCount),
+            maxDelay
           );
           await this.sleep(delay);
 
@@ -202,7 +205,8 @@ export class WorkflowService {
   ): Promise<unknown> {
     // This would call the actual handler function
     // For now, simulate execution
-    const handler = this.getHandler(step.handler);
+    const handlerId = typeof step.handler === 'string' ? step.handler : 'anonymous';
+    const handler = this.getHandler(handlerId);
     if (!handler) {
       throw new Error(`Handler ${step.handler} not found`);
     }

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

@@ -16,6 +16,9 @@ import type {
   D1DatabaseInfo,
   SecretInfo,
   WorkerVersionInfo,
+  PagesProjectInfo,
+  PagesDeploymentInfo,
+  PagesDeployOptions,
 } from '../entities';
 import type { IWranglerService } from '../types/service.interface';
 
@@ -144,8 +147,8 @@ export class WranglerService implements IWranglerService {
     return this.nodeNotAvailable<void>();
   }
 
-  // Tail logs
-  async tail(_options?: WranglerCommandOptions & { format?: "json" | "pretty" }): Promise<WranglerResult<void>> {
+  // Monitoring
+  async tail(_options?: WranglerCommandOptions & { format?: 'pretty' | 'json' }): Promise<WranglerResult<void>> {
     return this.nodeNotAvailable<void>();
   }
 
@@ -163,6 +166,23 @@ export class WranglerService implements IWranglerService {
     return this.nodeNotAvailable<string>();
   }
 
+  // Pages operations
+  async pagesProjectCreate(_projectName: string, _options?: WranglerCommandOptions & { productionBranch?: string }): Promise<WranglerResult<PagesProjectInfo>> {
+    return this.nodeNotAvailable<PagesProjectInfo>();
+  }
+
+  async pagesProjectList(_options?: WranglerCommandOptions): Promise<WranglerResult<PagesProjectInfo[]>> {
+    return this.nodeNotAvailable<PagesProjectInfo[]>();
+  }
+
+  async pagesDeploy(_options: PagesDeployOptions & WranglerCommandOptions): Promise<WranglerResult<PagesDeploymentInfo>> {
+    return this.nodeNotAvailable<PagesDeploymentInfo>();
+  }
+
+  async pagesFunctionCreate(_projectName: string, _functionName: string, _options?: WranglerCommandOptions): Promise<WranglerResult<void>> {
+    return this.nodeNotAvailable<void>();
+  }
+
   private nodeNotAvailable<T>(): never {
     throw new Error(
       'WranglerService requires Node.js runtime. ' +

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

@@ -55,6 +55,10 @@ export interface IWranglerService {
     value: string,
     options?: WranglerCommandOptions
   ): Promise<WranglerResult<void>>;
+  kvKeyList(
+    namespaceId: string,
+    options?: WranglerCommandOptions
+  ): Promise<WranglerResult<string[]>>;
   kvKeyGet(
     namespaceId: string,
     key: string,

package/src/infrastructure/middleware/index.ts

@@ -27,47 +27,24 @@ export interface CloudflareMiddlewareEnv {
 export type Env = CloudflareMiddlewareEnv;
 
 // ============================================================
-// New Middleware
+// Additional Middleware Functions
 // ============================================================
 
 /**
  * Compression Middleware
+ * Note: Cloudflare handles compression automatically at the edge
  */
 export async function compression(
   request: Request,
   response: Response
 ): Promise<Response> {
-  const acceptEncoding = request.headers.get('Accept-Encoding') || '';
-  const contentType = response.headers.get('Content-Type') || '';
-
-  // Check if client accepts compression
-  if (!acceptEncoding.includes('gzip') && !acceptEncoding.includes('br')) {
-    return response;
-  }
-
-  // Check if content type is compressible
-  const compressibleTypes = [
-    'text/',
-    'application/json',
-    'application/javascript',
-    'application/xml',
-    'application/xhtml+xml',
-  ];
-
-  const isCompressible = compressibleTypes.some((type) =>
-    contentType.includes(type)
-  );
-
-  if (!isCompressible) {
-    return response;
-  }
-
-  // Return original response (Cloudflare handles compression automatically)
+  // Cloudflare automatically handles compression
   return response;
 }
 
 /**
  * Security Headers Middleware
+ * @deprecated Use addSecurityHeaders from '@umituz/web-cloudflare/middleware' instead
  */
 export interface SecurityHeadersConfig {
   frameGuard?: boolean;
@@ -155,6 +132,7 @@ export async function detectBot(request: Request): Promise<{
 
 /**
  * Request Logging Middleware
+ * @deprecated Use LogConfig from '@umituz/web-cloudflare/middleware' instead
  */
 export interface LogConfig {
   level: 'debug' | 'info' | 'warn' | 'error';
@@ -212,14 +190,22 @@ export async function trackResponseTime(
   const response = await handler();
   const duration = Date.now() - start;
 
-  // Add timing header
-  response.headers.set('X-Response-Time', `${duration}ms`);
+  // Create new response with timing header since Response headers are immutable
+  const headers = new Headers(response.headers);
+  headers.set('X-Response-Time', `${duration}ms`);
+
+  const newResponse = new Response(response.body, {
+    status: response.status,
+    statusText: response.statusText,
+    headers,
+  });
 
-  return { response, duration };
+  return { response: newResponse, duration };
 }
 
 /**
  * IP Filter Middleware
+ * @deprecated Use IPFilterConfig from '@umituz/web-cloudflare/middleware' instead
  */
 export interface IPFilterConfig {
   mode: 'whitelist' | 'blacklist';
@@ -261,7 +247,6 @@ export function methodOverride(request: Request): Request {
   const overrideMethod = method || bodyMethod;
 
   if (overrideMethod && ['PUT', 'PATCH', 'DELETE'].includes(overrideMethod.toUpperCase())) {
-    // Return modified request
     return new Request(request.url, {
       method: overrideMethod.toUpperCase(),
       headers: request.headers,
@@ -282,48 +267,32 @@ export function addRequestID(request: Request): string {
     return existingID;
   }
 
-  const requestID = crypto.randomUUID();
-  return requestID;
+  return crypto.randomUUID();
 }
 
 /**
- * Response Time Middleware
+ * Current Time Endpoint
  */
-export function responseTime(): Response {
-  const response = new Response(JSON.stringify({ time: Date.now() }), {
+export function getCurrentTimeResponse(): Response {
+  return new Response(JSON.stringify({ time: Date.now() }), {
     headers: { 'Content-Type': 'application/json' },
   });
-  return response;
 }
 
 /**
  * Health Check Middleware
+ * @deprecated Use HealthCheckConfig from '@umituz/web-cloudflare/middleware' instead
  */
 export interface HealthCheckConfig {
-  uptime: number;
-  checks: Record<string, () => Promise<boolean>>;
+  uptime?: number;
+  checks?: Record<string, () => Promise<boolean>>;
 }
 
 export async function healthCheck(
   env: CloudflareMiddlewareEnv,
   config?: HealthCheckConfig
 ): Promise<Response> {
-  // Get uptime if available (Node.js only)
-  let uptime = 0;
-  if (config?.uptime !== undefined) {
-    uptime = config.uptime;
-  } else {
-    // Try to get process uptime in Node.js environment
-    try {
-      // @ts-ignore - process is not available in Workers runtime
-      if (typeof process !== 'undefined' && process?.uptime) {
-        // @ts-ignore
-        uptime = process.uptime();
-      }
-    } catch {
-      uptime = 0;
-    }
-  }
+  let uptime = config?.uptime ?? 0;
 
   const checks: Record<string, boolean | string> = {
     healthy: true,
@@ -348,15 +317,16 @@ export async function healthCheck(
 
 /**
  * Error Handling Middleware
+ * @deprecated Use ErrorHandlerConfig from '@umituz/web-cloudflare/middleware' instead
  */
 export interface ErrorHandlerConfig {
-  debug: boolean;
+  debug?: boolean;
   logger?: (error: Error) => void;
 }
 
 export function handleMiddlewareError(
   error: Error,
-  config: ErrorHandlerConfig = { debug: false }
+  config: ErrorHandlerConfig = {}
 ): Response {
   if (config.logger) {
     config.logger(error);