@umituz/web-cloudflare 1.4.5 → 1.4.7

package/src/{infrastructure/middleware/cache.ts → domains/middleware/services/cache.service.ts}

@@ -1,25 +1,27 @@
 /**
- * Cache Middleware
+ * Cache Service
  * @description Caching middleware for Cloudflare Workers
  */
 
-export interface CacheConfig {
-  enabled: boolean;
-  defaultTTL: number;
-  paths?: Record<string, number>;
-  prefix?: string;
-  bypassPaths?: string[];
-  respectHeaders?: boolean;
+import type { MiddlewareCacheConfig } from '../entities';
+
+// Type aliases for backwards compatibility
+export type { MiddlewareCacheConfig };
+export type CacheConfig = MiddlewareCacheConfig;
+
+interface CacheEntry {
+  response: Response;
+  expires: number;
 }
 
-const cacheStore = new Map<string, { response: Response; expires: number }>();
+const cacheStore = new Map<string, CacheEntry>();
 
 /**
  * Cache middleware
  */
 export async function cache(
   request: Request,
-  config: CacheConfig
+  config: MiddlewareCacheConfig
 ): Promise<Response | null> {
   if (!config.enabled) {
     return null;
@@ -48,7 +50,7 @@ export async function cache(
 export function setCache(
   request: Request,
   response: Response,
-  config: CacheConfig
+  config: MiddlewareCacheConfig
 ): void {
   if (!config.enabled) {
     return;

package/src/{infrastructure/middleware/cors.ts → domains/middleware/services/cors.service.ts}

@@ -1,17 +1,12 @@
 /**
- * CORS Middleware
+ * CORS Service
  * @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;
-}
+import type { MiddlewareCORSConfig } from '../entities';
+
+// Type alias for backwards compatibility
+export type CORSConfig = MiddlewareCORSConfig;
 
 /**
  * Add CORS headers to response
@@ -19,7 +14,7 @@ export interface CORSConfig {
 export function addCorsHeaders(
   request: Request,
   response: Response,
-  config: CORSConfig
+  config: MiddlewareCORSConfig
 ): Response {
   if (!config.enabled) {
     return response;
@@ -31,7 +26,7 @@ export function addCorsHeaders(
   // Check if origin is allowed
   const allowedOrigin = config.allowedOrigins.includes('*')
     ? '*'
-    : config.allowedOrigins.includes(origin || '')
+    : origin && config.allowedOrigins.includes(origin)
     ? origin
     : config.allowedOrigins[0];
 
@@ -63,7 +58,7 @@ export function addCorsHeaders(
  */
 export async function cors(
   request: Request,
-  config: CORSConfig
+  config: MiddlewareCORSConfig
 ): Promise<Response | null> {
   if (!config.enabled) {
     return null;
@@ -76,7 +71,7 @@ export async function cors(
 
     const allowedOrigin = config.allowedOrigins.includes('*')
       ? '*'
-      : config.allowedOrigins.includes(origin || '')
+      : origin && config.allowedOrigins.includes(origin)
       ? origin
       : config.allowedOrigins[0];
 

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/{infrastructure/middleware/rate-limit.ts → domains/middleware/services/rate-limit.service.ts}

@@ -1,21 +1,13 @@
 /**
- * Rate Limit Middleware
+ * Rate Limit Service
  * @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;
-  };
-}
+import type { MiddlewareRateLimitConfig } from '../entities';
+
+// Type aliases for backwards compatibility
+export type { MiddlewareRateLimitConfig };
+export type RateLimitConfig = MiddlewareRateLimitConfig;
 
 interface RateLimitEntry {
   count: number;
@@ -27,7 +19,7 @@ const rateLimitStore = new Map<string, RateLimitEntry>();
 /**
  * Get rate limit key
  */
-function getRateLimitKey(request: Request, config: RateLimitConfig): string {
+function getRateLimitKey(request: Request, config: MiddlewareRateLimitConfig): string {
   const parts: string[] = [];
 
   if (config.by === 'ip' || config.by === 'both') {
@@ -55,7 +47,7 @@ function getRateLimitKey(request: Request, config: RateLimitConfig): string {
  */
 export async function checkRateLimit(
   request: Request,
-  config: RateLimitConfig
+  config: MiddlewareRateLimitConfig
 ): Promise<Response | null> {
   if (!config.enabled) {
     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,128 @@
+/**
+ * Middleware Service Interface
+ * @description Defines the contract for middleware operations
+ */
+
+import type {
+  MiddlewareCORSConfig,
+  MiddlewareCacheConfig,
+  MiddlewareRateLimitConfig,
+  MiddlewareAuthConfig,
+  SecurityHeadersConfig,
+  IPFilterConfig,
+  LogConfig,
+  HealthCheckConfig,
+  ErrorHandlerConfig,
+} from '../entities';
+
+// Type aliases for backwards compatibility
+export type CORSConfig = MiddlewareCORSConfig;
+export type CacheConfig = MiddlewareCacheConfig;
+export type RateLimitConfig = MiddlewareRateLimitConfig;
+export type AuthConfig = MiddlewareAuthConfig;
+
+export interface IMiddlewareService {
+  /**
+   * CORS middleware
+   */
+  cors(request: Request, config: MiddlewareCORSConfig): Promise<Response | null>;
+  addCorsHeaders(request: Request, response: Response, config: MiddlewareCORSConfig): Response;
+
+  /**
+   * Cache middleware
+   */
+  cache(request: Request, config: MiddlewareCacheConfig): Promise<Response | null>;
+  setCache(request: Request, response: Response, config: MiddlewareCacheConfig): void;
+  invalidateCache(pattern?: string): void;
+
+  /**
+   * Rate limit middleware
+   */
+  checkRateLimit(request: Request, config: MiddlewareRateLimitConfig): Promise<Response | null>;
+
+  /**
+   * Authentication middleware
+   */
+  requireAuth(request: Request, config: MiddlewareAuthConfig): 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: Record<string, unknown>,
+    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/r2/services/r2.service.ts

@@ -3,7 +3,7 @@
  * @description Cloudflare R2 object storage operations
  */
 
-import type { R2Object, R2ListOptions, R2ListResult, R2PutOptions, R2PresignedURL } from "../entities";
+import type { R2Object, R2ListOptions, R2ListResult, R2PutOptions, R2PresignedURL } from "../../../domain/entities/r2.entity";
 import type { IR2Service } from "../../../domain/interfaces/services.interface";
 import { validationUtils } from "../../../infrastructure/utils";
 
@@ -51,8 +51,6 @@ class R2Service implements IR2Service {
       key: object.key,
       size: object.size,
       uploaded: object.uploaded,
-      httpMetadata: object.httpMetadata,
-      customMetadata: object.customMetadata,
     };
   }
 
@@ -70,7 +68,6 @@ class R2Service implements IR2Service {
     await bucket.put(key, data, {
       httpMetadata: options?.httpMetadata,
       customMetadata: options?.customMetadata,
-      checksum: options?.checksum,
     });
   }
 
@@ -94,9 +91,12 @@ class R2Service implements IR2Service {
     });
 
     return {
-      objects: listed.objects,
-      truncated: listed.truncated,
-      cursor: listed.cursor,
+      objects: listed.objects.map((obj) => ({
+        key: obj.key,
+        size: obj.size,
+        uploaded: obj.uploaded,
+      })),
+      cursor: (listed as any).cursor as string | undefined,
     };
   }
 
@@ -105,11 +105,11 @@ class R2Service implements IR2Service {
     // This would typically use the AWS SDK or custom signing logic
     // For now, return a placeholder
 
-    const expiresAt = new Date(Date.now() + expiresIn * 1000);
+    const expires = Date.now() + expiresIn * 1000;
 
     return {
-      url: `https://presigned-url-placeholder/${key}?expires=${expiresAt.getTime()}`,
-      expiresAt,
+      url: `https://presigned-url-placeholder/${key}?expires=${expires}`,
+      expires,
     };
   }
 
@@ -120,11 +120,11 @@ class R2Service implements IR2Service {
     const objectKey = key || `uploads/${Date.now()}-${file.name}`;
 
     await this.put(objectKey, file.stream(), {
-      ...options,
       httpMetadata: {
         contentType: file.type,
         ...options?.httpMetadata,
       },
+      customMetadata: options?.customMetadata,
     });
   }
 
@@ -134,10 +134,16 @@ class R2Service implements IR2Service {
       throw new Error(`Failed to fetch URL: ${response.statusText}`);
     }
 
-    await this.put(key, response.body, {
+    const body = response.body;
+    if (!body) {
+      throw new Error(`Failed to read response body`);
+    }
+
+    await this.put(key, body, {
       httpMetadata: {
         contentType: response.headers.get("Content-Type") || undefined,
       },
+      binding,
     });
   }
 
@@ -155,10 +161,12 @@ class R2Service implements IR2Service {
 
     await this.deleteMultiple(list.objects.map((obj) => obj.key), binding);
 
-    if (list.truncated && list.cursor) {
+    if (list.cursor) {
       await this.deletePrefix(prefix, binding);
     }
   }
 }
 
+// Export class and singleton instance
+export { R2Service };
 export const r2Service = new R2Service();

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

@@ -3,8 +3,24 @@
  * @description Cloudflare Worker configuration and types
  */
 
-export interface WorkerRequest extends Request {
+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 {

package/src/domains/workers/examples/worker.example.ts

@@ -3,7 +3,8 @@
  * @description Example worker using @umituz/web-cloudflare package
  */
 
-import { workersService, kvService, r2Service } from "@umituz/web-cloudflare";
+import { workersService, kvService } from "@umituz/web-cloudflare";
+import type { Env } from "../types";
 
 // Configure routes
 workersService.route("/", async () => {
@@ -11,14 +12,15 @@ workersService.route("/", async () => {
 });
 
 workersService.route("/api/hello", async (request) => {
-  const { name } = await request.json();
+  const data = await request.json() as { name?: string };
+  const name = data?.name || "World";
 
   return workersService.json({ message: `Hello, ${name}!` });
 });
 
-workersService.route("/api/cache/:key", async (request, env) => {
+workersService.route("/api/cache/:key", async (request, env?: Env) => {
   const url = new URL(request.url);
-  const key = url.pathname.split("/").pop();
+  const key = url.pathname.split("/").pop() || "";
 
   if (request.method === "GET") {
     const value = await kvService.get(key, env?.KV ? "KV" : undefined);
@@ -26,8 +28,8 @@ workersService.route("/api/cache/:key", async (request, env) => {
   }
 
   if (request.method === "POST") {
-    const { value } = await request.json();
-    await kvService.put(key, value, { ttl: 3600 });
+    const data = await request.json() as { value?: unknown };
+    await kvService.put(key, data.value || "", { ttl: 3600 });
     return workersService.json({ success: true });
   }
 
@@ -36,6 +38,6 @@ workersService.route("/api/cache/:key", async (request, env) => {
 
 // Export for Cloudflare Workers
 export default {
-  fetch: (request: Request, env: Env, ctx: ExecutionContext) =>
-    workersService.fetch(request, env, ctx),
+  fetch: (request: Request, env?: Env, ctx?: ExecutionContext) =>
+    workersService.fetch(request as any, env, ctx),
 };

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

@@ -3,7 +3,7 @@
  * @description Cloudflare Workers HTTP handler and routing
  */
 
-import type { WorkerRequest, WorkerResponse, WorkerConfig } from "../entities";
+import type { WorkerRequest, WorkerResponse, CloudflareWorkerConfig } from "../entities";
 import type { Env } from "../types";
 
 export interface WorkerFetchOptions {
@@ -61,9 +61,9 @@ class WorkersService {
    * Fetch handler
    */
   async fetch(request: WorkerRequest, env?: Env, ctx?: ExecutionContext): Promise<WorkerResponse> {
-    // Initialize cache
-    if (!this.cache && env) {
-      this.cache = caches.default;
+    // Initialize cache if available in Workers runtime
+    if (!this.cache && env && typeof caches !== 'undefined') {
+      this.cache = (caches as any).default;
     }
 
     // Try middleware
@@ -161,4 +161,6 @@ class WorkersService {
   }
 }
 
+// Export class and singleton instance
+export { WorkersService };
 export const workersService = new WorkersService();

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

@@ -18,6 +18,7 @@ export interface WorkflowStep {
     maxDelay: number;
   };
   dependencies?: string[];
+  inputs?: Record<string, unknown>;
 }
 
 /**
@@ -27,7 +28,14 @@ export interface WorkflowDefinition {
   id: string;
   name: string;
   description?: string;
+  version?: string;
   steps: WorkflowStep[];
+  retryConfig?: {
+    maxAttempts: number;
+    backoffMultiplier: number;
+    initialDelay: number;
+    maxDelay: number;
+  };
 }
 
 /**
@@ -36,13 +44,18 @@ export interface WorkflowDefinition {
 export interface WorkflowExecution {
   id: string;
   workflowId: string;
-  status: 'pending' | 'running' | 'completed' | 'failed';
+  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;
 }
 
 /**

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

@@ -7,12 +7,42 @@ import type {
   WorkflowDefinition,
   WorkflowExecution,
   WorkflowStep,
-  WorkflowInstanceState,
-  MediaProcessingWorkflow,
-  AIGenerationWorkflow,
-  BatchOperationWorkflow,
 } from '../entities';
 
+// Additional workflow types
+export type WorkflowInstanceState = 'pending' | 'running' | 'completed' | 'failed';
+
+export interface WorkflowStepState {
+  data: Record<string, unknown>;
+  status: WorkflowInstanceState;
+  completedAt?: number;
+}
+
+export interface MediaProcessingWorkflow {
+  type: 'media-processing';
+  input: {
+    url: string;
+    operations: Array<{ type: string; params: Record<string, unknown> }>;
+  };
+}
+
+export interface AIGenerationWorkflow {
+  type: 'ai-generation';
+  input: {
+    prompt: string;
+    model: string;
+    parameters?: Record<string, unknown>;
+  };
+}
+
+export interface BatchOperationWorkflow {
+  type: 'batch-operation';
+  input: {
+    items: Array<{ id: string; data: unknown }>;
+    operation: string;
+  };
+}
+
 export interface WorkflowServiceConfig {
   KV?: KVNamespace;
   D1?: D1Database;
@@ -73,6 +103,7 @@ export class WorkflowService {
       completedSteps: [],
       failedSteps: [],
       inputs,
+      input: inputs,
       startedAt: Date.now(),
       retryCount: 0,
     };
@@ -122,7 +153,7 @@ export class WorkflowService {
         execution.completedSteps.push(step.id);
 
         // Save step state for idempotency
-        await this.saveStepState(execution.id, step.id, stepResult);
+        await this.saveStepState(execution.id, step.id, { result: stepResult } as Record<string, unknown>);
 
       } catch (error) {
         stepStatus[step.id] = 'failed';
@@ -257,11 +288,10 @@ export class WorkflowService {
     data: Record<string, unknown>
   ): Promise<void> {
     if (this.kv) {
-      const state: WorkflowInstanceState = {
-        executionId,
-        stepId,
+      const state: WorkflowStepState = {
         data,
-        timestamp: Date.now(),
+        status: 'completed',
+        completedAt: Date.now(),
       };
       await this.kv.put(
         `step:${executionId}:${stepId}`,
@@ -276,7 +306,7 @@ export class WorkflowService {
   private async getStepState(
     executionId: string,
     stepId: string
-  ): Promise<WorkflowInstanceState | null> {
+  ): Promise<WorkflowStepState | null> {
     if (this.kv) {
       const data = await this.kv.get(`step:${executionId}:${stepId}`);
       return data ? JSON.parse(data) : null;
@@ -435,3 +465,6 @@ export const WORKFLOW_TEMPLATES: Record<string, Partial<WorkflowDefinition>> = {
     ],
   },
 };
+
+// Export singleton instance
+export const workflowService = new WorkflowService();