@umituz/web-cloudflare 1.4.6 → 1.4.7

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

@@ -3,7 +3,11 @@
  * @description Rate limiting middleware for Cloudflare Workers
  */
 
-import type { RateLimitConfig } from '../entities';
+import type { MiddlewareRateLimitConfig } from '../entities';
+
+// Type aliases for backwards compatibility
+export type { MiddlewareRateLimitConfig };
+export type RateLimitConfig = MiddlewareRateLimitConfig;
 
 interface RateLimitEntry {
   count: number;
@@ -15,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') {
@@ -43,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/service.interface.ts

@@ -4,10 +4,10 @@
  */
 
 import type {
-  CORSConfig,
-  CacheConfig,
-  RateLimitConfig,
-  AuthConfig,
+  MiddlewareCORSConfig,
+  MiddlewareCacheConfig,
+  MiddlewareRateLimitConfig,
+  MiddlewareAuthConfig,
   SecurityHeadersConfig,
   IPFilterConfig,
   LogConfig,
@@ -15,29 +15,35 @@ import type {
   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: CORSConfig): Promise<Response | null>;
-  addCorsHeaders(request: Request, response: Response, config: CORSConfig): Response;
+  cors(request: Request, config: MiddlewareCORSConfig): Promise<Response | null>;
+  addCorsHeaders(request: Request, response: Response, config: MiddlewareCORSConfig): Response;
 
   /**
    * Cache middleware
    */
-  cache(request: Request, config: CacheConfig): Promise<Response | null>;
-  setCache(request: Request, response: Response, config: CacheConfig): void;
+  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: RateLimitConfig): Promise<Response | null>;
+  checkRateLimit(request: Request, config: MiddlewareRateLimitConfig): Promise<Response | null>;
 
   /**
    * Authentication middleware
    */
-  requireAuth(request: Request, config: AuthConfig): Promise<Response | null>;
+  requireAuth(request: Request, config: MiddlewareAuthConfig): Promise<Response | null>;
   addUserContext(request: Request, user: {
     id: string;
     [key: string]: unknown;
@@ -88,7 +94,7 @@ export interface IMiddlewareService {
    * Health check
    */
   healthCheck(
-    env: import('../../router').CloudflareEnv,
+    env: Record<string, unknown>,
     config?: HealthCheckConfig
   ): Promise<Response>;
 

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