@umituz/web-cloudflare 1.0.1

package/src/infrastructure/services/r2/r2.service.ts

@@ -0,0 +1,164 @@
+/**
+ * R2 Service
+ * @description Cloudflare R2 object storage operations
+ */
+
+import type { R2Object, R2ListOptions, R2ListResult, R2PutOptions, R2PresignedURL } from "../../../domain/entities/r2.entity";
+import type { IR2Service } from "../../../domain/interfaces/services.interface";
+import { validationUtils } from "../../utils";
+
+export interface R2UploadOptions extends R2PutOptions {
+  readonly binding?: string;
+}
+
+export interface R2CacheOptions {
+  readonly bucket: string;
+  readonly customDomain?: string;
+}
+
+class R2Service implements IR2Service {
+  private buckets: Map<string, R2Bucket> = new Map();
+  private customDomain: string | null = null;
+
+  initialize(options: R2CacheOptions): void {
+    this.customDomain = options.customDomain ?? null;
+  }
+
+  bindBucket(name: string, bucket: R2Bucket): void {
+    this.buckets.set(name, bucket);
+  }
+
+  private getBucket(binding?: string): R2Bucket {
+    const name = binding || "default";
+    const bucket = this.buckets.get(name);
+    if (!bucket) {
+      throw new Error(`R2 bucket "${name}" not bound`);
+    }
+    return bucket;
+  }
+
+  async get(key: string, binding?: string): Promise<R2Object | null> {
+    if (!validationUtils.isValidR2Key(key)) {
+      throw new Error(`Invalid R2 key: ${key}`);
+    }
+
+    const bucket = this.getBucket(binding);
+    const object = await bucket.get(key);
+
+    if (!object) return null;
+
+    return {
+      key: object.key,
+      size: object.size,
+      uploaded: object.uploaded,
+      httpMetadata: object.httpMetadata,
+      customMetadata: object.customMetadata,
+    };
+  }
+
+  async put(
+    key: string,
+    data: ReadableStream | ArrayBuffer | string,
+    options?: R2UploadOptions
+  ): Promise<void> {
+    if (!validationUtils.isValidR2Key(key)) {
+      throw new Error(`Invalid R2 key: ${key}`);
+    }
+
+    const bucket = this.getBucket(options?.binding);
+
+    await bucket.put(key, data, {
+      httpMetadata: options?.httpMetadata,
+      customMetadata: options?.customMetadata,
+      checksum: options?.checksum,
+    });
+  }
+
+  async delete(key: string, binding?: string): Promise<boolean> {
+    if (!validationUtils.isValidR2Key(key)) {
+      throw new Error(`Invalid R2 key: ${key}`);
+    }
+
+    const bucket = this.getBucket(binding);
+    await bucket.delete(key);
+
+    return true;
+  }
+
+  async list(options?: R2ListOptions & { binding?: string }): Promise<R2ListResult> {
+    const bucket = this.getBucket(options?.binding);
+    const listed = await bucket.list({
+      limit: options?.limit,
+      prefix: options?.prefix,
+      cursor: options?.cursor,
+    });
+
+    return {
+      objects: listed.objects,
+      truncated: listed.truncated,
+      cursor: listed.cursor,
+    };
+  }
+
+  async getPresignedURL(key: string, expiresIn = 3600, binding?: string): Promise<R2PresignedURL> {
+    // Note: R2 presigned URLs require AWS S3 signature
+    // This would typically use the AWS SDK or custom signing logic
+    // For now, return a placeholder
+
+    const expiresAt = new Date(Date.now() + expiresIn * 1000);
+
+    return {
+      url: `https://presigned-url-placeholder/${key}?expires=${expiresAt.getTime()}`,
+      expiresAt,
+    };
+  }
+
+  /**
+   * Upload helpers
+   */
+  async uploadFile(file: File, key?: string, options?: R2UploadOptions, binding?: string): Promise<void> {
+    const objectKey = key || `uploads/${Date.now()}-${file.name}`;
+
+    await this.put(objectKey, file.stream(), {
+      ...options,
+      httpMetadata: {
+        contentType: file.type,
+        ...options?.httpMetadata,
+      },
+    });
+  }
+
+  async uploadFromURL(url: string, key: string, binding?: string): Promise<void> {
+    const response = await fetch(url);
+    if (!response.ok) {
+      throw new Error(`Failed to fetch URL: ${response.statusText}`);
+    }
+
+    await this.put(key, response.body, {
+      httpMetadata: {
+        contentType: response.headers.get("Content-Type") || undefined,
+      },
+    });
+  }
+
+  /**
+   * Delete helpers
+   */
+  async deleteMultiple(keys: readonly string[], binding?: string): Promise<void> {
+    const bucket = this.getBucket(binding);
+
+    await Promise.all(keys.map((key) => bucket.delete(key)));
+  }
+
+  async deletePrefix(prefix: string, binding?: string): Promise<void> {
+    const list = await this.list({ prefix, binding });
+
+    await this.deleteMultiple(list.objects.map((obj) => obj.key), binding);
+
+    if (list.truncated && list.cursor) {
+      await this.deletePrefix(prefix, binding);
+    }
+  }
+}
+
+export const r2Service = new R2Service();

package/src/infrastructure/services/workers/index.ts

@@ -0,0 +1,7 @@
+/**
+ * Cloudflare Workers Service
+ * Subpath: @umituz/web-cloudflare/workers
+ */
+
+export { WorkersService, workersService } from "./workers.service";
+export type { WorkerFetchOptions, WorkerRouteConfig, WorkersMiddleware } from "./workers.service";

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

@@ -0,0 +1,164 @@
+/**
+ * Workers Service
+ * @description Cloudflare Workers HTTP handler and routing
+ */
+
+import type { WorkerRequest, WorkerResponse, WorkerConfig } from "../../../domain/entities/worker.entity";
+import type { Env } from "../../../domain/interfaces/services.interface";
+
+export interface WorkerFetchOptions {
+  readonly cache?: CacheControls;
+  readonly cors?: CorsOptions;
+  readonly timeout?: number;
+}
+
+export interface CacheControls {
+  readonly maxAge?: number;
+  readonly immutable?: boolean;
+  readonly noCache?: boolean;
+}
+
+export interface CorsOptions {
+  readonly origins?: readonly string[];
+  readonly methods?: readonly string[];
+  readonly headers?: readonly string[];
+  readonly credentials?: boolean;
+}
+
+export interface WorkerRouteConfig {
+  readonly pattern: URLPattern;
+  readonly handler: (request: WorkerRequest, env?: Env) => Promise<WorkerResponse>;
+}
+
+export type WorkersMiddleware = (
+  request: WorkerRequest,
+  env?: Env
+) => Promise<WorkerResponse | null>;
+
+class WorkersService {
+  private routes: WorkerRouteConfig[] = [];
+  private middleware: WorkersMiddleware[] = [];
+  private cache: Cache | null = null;
+
+  /**
+   * Register a route
+   */
+  route(pattern: string, handler: WorkerRouteConfig["handler"]): void {
+    this.routes.push({
+      pattern: new URLPattern({ pathname: pattern }),
+      handler,
+    });
+  }
+
+  /**
+   * Add middleware
+   */
+  use(middleware: WorkersMiddleware): void {
+    this.middleware.push(middleware);
+  }
+
+  /**
+   * Fetch handler
+   */
+  async fetch(request: WorkerRequest, env?: Env, ctx?: ExecutionContext): Promise<WorkerResponse> {
+    // Initialize cache
+    if (!this.cache && env) {
+      this.cache = caches.default;
+    }
+
+    // Try middleware
+    for (const mw of this.middleware) {
+      const response = await mw(request, env);
+      if (response) return response;
+    }
+
+    // Match route
+    const url = new URL(request.url);
+    for (const route of this.routes) {
+      if (route.pattern.test(url)) {
+        return route.handler(request, env);
+      }
+    }
+
+    // 404
+    return new Response("Not Found", { status: 404 });
+  }
+
+  /**
+   * JSON response helper
+   */
+  json(data: unknown, status = 200): WorkerResponse {
+    return new Response(JSON.stringify(data), {
+      status,
+      headers: {
+        "Content-Type": "application/json",
+      },
+    });
+  }
+
+  /**
+   * Error response helper
+   */
+  error(message: string, status = 500): WorkerResponse {
+    return this.json({ error: message }, status);
+  }
+
+  /**
+   * CORS response helper
+   */
+  cors(options: CorsOptions = {}): WorkerResponse {
+    const headers = new Headers();
+
+    if (options.origins) {
+      const origin = options.origins.join(", ");
+      headers.set("Access-Control-Allow-Origin", origin);
+    }
+
+    if (options.methods) {
+      headers.set("Access-Control-Allow-Methods", options.methods.join(", "));
+    }
+
+    if (options.headers) {
+      headers.set("Access-Control-Allow-Headers", options.headers.join(", "));
+    }
+
+    if (options.credentials) {
+      headers.set("Access-Control-Allow-Credentials", "true");
+    }
+
+    return new Response(null, { headers });
+  }
+
+  /**
+   * Cache response helper
+   */
+  async cached(request: Request, ttl: number, fetcher: () => Promise<Response>): Promise<Response> {
+    if (!this.cache) return fetcher();
+
+    const cacheKey = new Request(request.url, request);
+    let response = await this.cache.match(cacheKey);
+
+    if (!response) {
+      response = await fetcher();
+      response = new Response(response.body, response);
+      response.headers.set("Cache-Control", `public, max-age=${ttl}`);
+      await this.cache.put(cacheKey, response.clone());
+    }
+
+    return response;
+  }
+
+  /**
+   * Redirect response helper
+   */
+  redirect(url: string, status = 302): WorkerResponse {
+    return new Response(null, {
+      status,
+      headers: {
+        Location: url,
+      },
+    });
+  }
+}
+
+export const workersService = new WorkersService();