@umituz/web-cloudflare 1.0.1

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

@@ -0,0 +1,191 @@
+/**
+ * D1 Service
+ * @description Cloudflare D1 database operations
+ */
+
+import type { D1QueryResult, D1BatchResult } from "../../../domain/entities/d1.entity";
+import type { ID1Service } from "../../../domain/interfaces/services.interface";
+
+export interface D1ExecOptions {
+  readonly binding?: string;
+}
+
+class D1Service implements ID1Service {
+  private databases: Map<string, D1Database> = new Map();
+
+  bindDatabase(name: string, database: D1Database): void {
+    this.databases.set(name, database);
+  }
+
+  private getDatabase(binding?: string): D1Database {
+    const name = binding || "default";
+    const database = this.databases.get(name);
+    if (!database) {
+      throw new Error(`D1 database "${name}" not bound`);
+    }
+    return database;
+  }
+
+  async query<T>(sql: string, params?: readonly unknown[], binding?: string): Promise<D1QueryResult<T>> {
+    const database = this.getDatabase(binding);
+
+    const stmt = database.prepare(sql);
+    const result = params ? await stmt.bind(...params).all() : await stmt.all();
+
+    return {
+      results: result.results as T[],
+      success: result.success,
+      meta: result.meta
+        ? {
+            duration: result.meta.duration,
+            rows_read: result.meta.rows_read,
+            rows_written: result.meta.rows_written,
+            last_row_id: result.meta.last_row_id,
+            changes: result.meta.changes,
+          }
+        : undefined,
+    };
+  }
+
+  async batch(
+    statements: readonly { sql: string; params?: readonly unknown[]; binding?: string }[]
+  ): Promise<D1BatchResult> {
+    // Group by binding
+    const grouped = new Map<string, D1PreparedStatement[]>();
+
+    for (const stmt of statements) {
+      const binding = stmt.binding || "default";
+      const database = this.getDatabase(binding);
+
+      if (!grouped.has(binding)) {
+        grouped.set(binding, []);
+      }
+
+      grouped.get(binding)!.push(database.prepare(stmt.sql));
+    }
+
+    // Note: D1 batch requires all statements to be from the same database
+    if (grouped.size > 1) {
+      throw new Error("Batch operations must be from the same database binding");
+    }
+
+    const [binding, statements] = Array.from(grouped.entries())[0];
+    const database = this.getDatabase(binding);
+
+    const results = await database.batch(statements as D1PreparedStatement[]);
+
+    return {
+      success: results.every((r) => r.success),
+      results: results.map((r) => ({
+        results: r.results,
+        success: r.success,
+        meta: r.meta,
+      })),
+    };
+  }
+
+  async execute<T>(sql: string, params?: readonly unknown[], binding?: string): Promise<D1QueryResult<T>> {
+    return this.query<T>(sql, params, binding);
+  }
+
+  /**
+   * Query helpers
+   */
+  async findOne<T>(sql: string, params?: readonly unknown[], binding?: string): Promise<T | null> {
+    const result = await this.query<T>(sql, params, binding);
+
+    return (result.results[0] as T) ?? null;
+  }
+
+  async insert<T>(
+    table: string,
+    data: Record<string, unknown>,
+    binding?: string
+  ): Promise<D1QueryResult<T>> {
+    const columns = Object.keys(data);
+    const values = Object.values(data);
+    const placeholders = values.map(() => "?").join(", ");
+
+    const sql = `INSERT INTO ${table} (${columns.join(", ")}) VALUES (${placeholders})`;
+
+    return this.query<T>(sql, values, binding);
+  }
+
+  async update<T>(
+    table: string,
+    data: Record<string, unknown>,
+    where: string,
+    whereParams: readonly unknown[] = [],
+    binding?: string
+  ): Promise<D1QueryResult<T>> {
+    const columns = Object.keys(data);
+    const values = Object.values(data);
+    const setClause = columns.map((col) => `${col} = ?`).join(", ");
+
+    const sql = `UPDATE ${table} SET ${setClause} WHERE ${where}`;
+    const params = [...values, ...whereParams];
+
+    return this.query<T>(sql, params, binding);
+  }
+
+  async delete(table: string, where: string, params?: readonly unknown[], binding?: string): Promise<D1QueryResult> {
+    const sql = `DELETE FROM ${table} WHERE ${where}`;
+
+    return this.query(sql, params, binding);
+  }
+
+  /**
+   * Schema helpers
+   */
+  async createTable(
+    table: string,
+    columns: Record<string, string>,
+    binding?: string
+  ): Promise<void> {
+    const columnDefs = Object.entries(columns)
+      .map(([name, type]) => `${name} ${type}`)
+      .join(", ");
+
+    const sql = `CREATE TABLE IF NOT EXISTS ${table} (${columnDefs})`;
+
+    await this.execute(sql, [], binding);
+  }
+
+  async dropTable(table: string, binding?: string): Promise<void> {
+    const sql = `DROP TABLE IF EXISTS ${table}`;
+
+    await this.execute(sql, [], binding);
+  }
+
+  async tableExists(table: string, binding?: string): Promise<boolean> {
+    const sql = `
+      SELECT name FROM sqlite_master
+      WHERE type='table' AND name=?
+    `;
+
+    const result = await this.query<{ name: string }>(sql, [table], binding);
+
+    return result.results.length > 0;
+  }
+
+  /**
+   * Transaction helpers
+   */
+  async runInTransaction<T>(
+    callback: (txn: D1Transaction) => Promise<T>,
+    binding?: string
+  ): Promise<T> {
+    const database = this.getDatabase(binding);
+
+    // Note: D1 doesn't have explicit transaction API
+    // Use batch operations or implement application-level logic
+
+    throw new Error("Transactions not yet implemented for D1");
+  }
+}
+
+interface D1Transaction {
+  query<T>(sql: string, params?: readonly unknown[]): Promise<D1QueryResult<T>>;
+}
+
+export const d1Service = new D1Service();

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

@@ -0,0 +1,7 @@
+/**
+ * Cloudflare D1 Service
+ * Subpath: @umituz/web-cloudflare/d1
+ */
+
+export { D1Service, d1Service } from "./d1.service";
+export type { D1ExecOptions } from "./d1.service";

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

@@ -0,0 +1,227 @@
+/**
+ * Images Service
+ * @description Cloudflare Images operations
+ */
+
+import type { ImageUploadResult, ImageUploadOptions, ImageTransformation, SignedURL } from "../../../domain/entities/image.entity";
+import type { IImageService } from "../../../domain/interfaces/services.interface";
+import { validationUtils, transformUtils } from "../../utils";
+import { MAX_IMAGE_SIZE, ALLOWED_IMAGE_TYPES } from "../../constants";
+
+export interface ImagesClientOptions {
+  readonly accountId: string;
+  readonly apiToken: string;
+  readonly customDomain?: string;
+}
+
+class ImagesService implements IImageService {
+  private accountId: string | null = null;
+  private apiToken: string | null = null;
+  private customDomain: string | null = null;
+
+  initialize(options: ImagesClientOptions): void {
+    this.accountId = options.accountId;
+    this.apiToken = options.apiToken;
+    this.customDomain = options.customDomain ?? null;
+  }
+
+  private getAPIBaseURL(): string {
+    if (!this.accountId) {
+      throw new Error("ImagesService not initialized");
+    }
+
+    return `https://api.cloudflare.com/client/v4/accounts/${this.accountId}/images/v1`;
+  }
+
+  private getAuthHeaders(): HeadersInit {
+    if (!this.apiToken) {
+      throw new Error("ImagesService not initialized");
+    }
+
+    return {
+      Authorization: `Bearer ${this.apiToken}`,
+    };
+  }
+
+  async upload(file: File | Blob, options?: ImageUploadOptions): Promise<ImageUploadResult> {
+    // Validate file
+    if (file instanceof File) {
+      if (!validationUtils.isValidImageType(file.type)) {
+        throw new Error(`Invalid image type: ${file.type}`);
+      }
+
+      if (!validationUtils.isValidImageSize(file.size, MAX_IMAGE_SIZE)) {
+        throw new Error(`Image size exceeds maximum: ${MAX_IMAGE_SIZE}`);
+      }
+    }
+
+    // Prepare form data
+    const formData = new FormData();
+    formData.append("file", file);
+
+    if (options?.metadata) {
+      for (const [key, value] of Object.entries(options.metadata)) {
+        formData.append(`metadata[${key}]`, value);
+      }
+    }
+
+    if (options?.requireSignedURLs !== undefined) {
+      formData.append("requireSignedURLs", options.requireSignedURLs.toString());
+    }
+
+    // Upload
+    const response = await fetch(`${this.getAPIBaseURL()}/direct_upload`, {
+      method: "POST",
+      headers: this.getAuthHeaders(),
+      body: formData,
+    });
+
+    if (!response.ok) {
+      const error = await response.text();
+      throw new Error(`Upload failed: ${error}`);
+    }
+
+    const data = await response.json();
+
+    return {
+      id: data.result.id,
+      filename: data.result.filename,
+      uploaded: new Date(data.result.uploaded),
+      variants: data.result.variants,
+      requireSignedURLs: data.result.requireSignedURLs,
+    };
+  }
+
+  async getSignedURL(imageId: string, expiresIn = 3600): Promise<SignedURL> {
+    const expiresAt = new Date(Date.now() + expiresIn * 1000);
+
+    const response = await fetch(`${this.getAPIBaseURL()}/${imageId}`, {
+      method: "POST",
+      headers: {
+        ...this.getAuthHeaders(),
+        "Content-Type": "application/json",
+      },
+      body: JSON.stringify({
+        expiry: expiresAt.toISOString(),
+      }),
+    });
+
+    if (!response.ok) {
+      const error = await response.text();
+      throw new Error(`Failed to get signed URL: ${error}`);
+    }
+
+    const data = await response.json();
+
+    return {
+      url: data.result.signedURLs?.[0] || data.result.variants?.[0],
+      expiresAt,
+    };
+  }
+
+  async getTransformedURL(imageId: string, transform: ImageTransformation): Promise<string> {
+    if (this.customDomain) {
+      const baseURL = `https://${this.customDomain}/${imageId}`;
+      return transformUtils.generateTransformURL(baseURL, transform);
+    }
+
+    // Fallback to Cloudflare CDN URL
+    const baseURL = `https://imagedelivery.net/${this.accountId}/${imageId}/public`;
+    return transformUtils.generateTransformURL(baseURL, transform);
+  }
+
+  async delete(imageId: string): Promise<boolean> {
+    const response = await fetch(`${this.getAPIBaseURL()}/${imageId}`, {
+      method: "DELETE",
+      headers: this.getAuthHeaders(),
+    });
+
+    if (!response.ok) {
+      const error = await response.text();
+      throw new Error(`Delete failed: ${error}`);
+    }
+
+    return true;
+  }
+
+  /**
+   * List helpers
+   */
+  async listImages(options?: { page?: number; perPage?: number }): Promise<{
+    images: readonly ImageUploadResult[];
+    totalCount: number;
+  }> {
+    const params = new URLSearchParams();
+    if (options?.page) params.set("page", options.page.toString());
+    if (options?.perPage) params.set("per_page", options.perPage.toString());
+
+    const response = await fetch(`${this.getAPIBaseURL()}?${params}`, {
+      headers: this.getAuthHeaders(),
+    });
+
+    if (!response.ok) {
+      const error = await response.text();
+      throw new Error(`List failed: ${error}`);
+    }
+
+    const data = await response.json();
+
+    return {
+      images: data.result.images,
+      totalCount: data.result.totalCount,
+    };
+  }
+
+  /**
+   * Bulk operations
+   */
+  async uploadMultiple(files: readonly (File | Blob)[], options?: ImageUploadOptions): Promise<ImageUploadResult[]> {
+    const uploads = files.map((file) => this.upload(file, options));
+
+    return Promise.all(uploads);
+  }
+
+  async deleteMultiple(imageIds: readonly string[]): Promise<boolean> {
+    const deletions = imageIds.map((id) => this.delete(id));
+
+    await Promise.all(deletions);
+
+    return true;
+  }
+
+  /**
+   * Variant helpers
+   */
+  generateVariantURL(imageId: string, variant: string): string {
+    if (this.customDomain) {
+      return `https://${this.customDomain}/${imageId}/${variant}`;
+    }
+
+    return `https://imagedelivery.net/${this.accountId}/${imageId}/${variant}`;
+  }
+
+  /**
+   * Upload from URL
+   */
+  async uploadFromURL(
+    url: string,
+    filename: string,
+    options?: ImageUploadOptions
+  ): Promise<ImageUploadResult> {
+    // Fetch the image
+    const response = await fetch(url);
+    if (!response.ok) {
+      throw new Error(`Failed to fetch image: ${response.statusText}`);
+    }
+
+    const blob = await response.blob();
+
+    // Upload the blob
+    return this.upload(
+      new File([blob], filename, { type: blob.type || "image/jpeg" }),
+      options
+    );
+  }
+}
+
+export const imagesService = new ImagesService();

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

@@ -0,0 +1,7 @@
+/**
+ * Cloudflare Images Service
+ * Subpath: @umituz/web-cloudflare/images
+ */
+
+export { ImagesService, imagesService } from "./images.service";
+export type { ImagesClientOptions } from "./images.service";

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

@@ -0,0 +1,7 @@
+/**
+ * Cloudflare KV Service
+ * Subpath: @umituz/web-cloudflare/kv
+ */
+
+export { KVService, kvService } from "./kv.service";
+export type { KVCacheOptions } from "./kv.service";

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

@@ -0,0 +1,116 @@
+/**
+ * KV Service
+ * @description Cloudflare KV key-value storage operations
+ */
+
+import type { KVEntry, KVListOptions, KVListResult } from "../../../domain/entities/kv.entity";
+import type { IKVService } from "../../../domain/interfaces/services.interface";
+import { validationUtils, cacheUtils } from "../../utils";
+
+export interface KVCacheOptions {
+  readonly namespace: string;
+  readonly defaultTTL?: number;
+}
+
+class KVService implements IKVService {
+  private namespaces: Map<string, KVNamespace> = new Map();
+  private defaultTTL: number = 3600;
+
+  initialize(options: KVCacheOptions): void {
+    // Namespaces are bound by Cloudflare at runtime
+    // This is just a reference to the binding name
+    this.defaultTTL = options.defaultTTL ?? 3600;
+  }
+
+  bindNamespace(name: string, namespace: KVNamespace): void {
+    this.namespaces.set(name, namespace);
+  }
+
+  private getNamespace(binding?: string): KVNamespace {
+    const name = binding || "default";
+    const namespace = this.namespaces.get(name);
+    if (!namespace) {
+      throw new Error(`KV namespace "${name}" not bound`);
+    }
+    return namespace;
+  }
+
+  async get<T>(key: string, binding?: string): Promise<T | null> {
+    if (!validationUtils.isValidKVKey(key)) {
+      throw new Error(`Invalid KV key: ${key}`);
+    }
+
+    const namespace = this.getNamespace(binding);
+    const value = await namespace.get(key, "json");
+
+    return (value as T) ?? null;
+  }
+
+  async put<T>(key: string, value: T, options?: { ttl?: number; binding?: string }): Promise<void> {
+    if (!validationUtils.isValidKVKey(key)) {
+      throw new Error(`Invalid KV key: ${key}`);
+    }
+
+    const namespace = this.getNamespace(options?.binding);
+    const ttl = options?.ttl ?? this.defaultTTL;
+
+    await namespace.put(key, JSON.stringify(value), {
+      expirationTtl: ttl,
+    });
+  }
+
+  async delete(key: string, binding?: string): Promise<boolean> {
+    if (!validationUtils.isValidKVKey(key)) {
+      throw new Error(`Invalid KV key: ${key}`);
+    }
+
+    const namespace = this.getNamespace(binding);
+    await namespace.delete(key);
+
+    return true;
+  }
+
+  async list(options?: KVListOptions & { binding?: string }): Promise<KVListResult> {
+    const namespace = this.getNamespace(options?.binding);
+    const list = await namespace.list({
+      limit: options?.limit,
+      cursor: options?.cursor,
+      prefix: options?.prefix,
+    });
+
+    return {
+      keys: list.keys,
+      list_complete: list.list_complete,
+      cursor: list.cursor,
+    };
+  }
+
+  /**
+   * Cache helpers
+   */
+  async getOrSet<T>(
+    key: string,
+    factory: () => Promise<T>,
+    options?: { ttl?: number; binding?: string }
+  ): Promise<T> {
+    const cached = await this.get<T>(key, options?.binding);
+    if (cached !== null) return cached;
+
+    const value = await factory();
+    await this.put(key, value, options);
+
+    return value;
+  }
+
+  async invalidatePattern(prefix: string, binding?: string): Promise<void> {
+    const list = await this.list({ prefix, binding });
+
+    await Promise.all(
+      list.keys.map(async (key) => {
+        await this.delete(key.name, binding);
+      })
+    );
+  }
+}
+
+export const kvService = new KVService();

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

@@ -0,0 +1,7 @@
+/**
+ * Cloudflare R2 Service
+ * Subpath: @umituz/web-cloudflare/r2
+ */
+
+export { R2Service, r2Service } from "./r2.service";
+export type { R2UploadOptions, R2CacheOptions } from "./r2.service";