@umituz/react-native-ai-generation-content 1.65.1 → 1.65.2

package/src/infrastructure/http/http-client.util.ts

@@ -1,167 +1,12 @@
 /**
- * HTTP Client Utilities
+ * HTTP Client Utilities - Barrel Export
  * Core HTTP request handling with error handling and retry logic
+ *
+ * Architecture:
+ * - Domain: HTTP methods, content types (constants)
+ * - Infrastructure: Request execution, response parsing, error handling
  */
 
-import { withErrorHandling, getErrorMessage, retryWithBackoff, isNetworkError } from "../utils/error-handling.util";
-import { env } from "../config/env.config";
-import type { RequestOptions, ApiResponse } from "./api-client.types";
-import { createTimeoutController } from "./timeout.util";
-
-/**
- * Makes an HTTP request with error handling and retry logic
- * @param url - Request URL
- * @param options - Request options
- * @returns API response with data or error
- */
-export async function fetchWithTimeout<T>(
-  url: string,
-  options: RequestOptions = {}
-): Promise<ApiResponse<T>> {
-  const {
-    timeout = env.apiDefaultTimeoutMs,
-    retries = 0,
-    headers = {},
-    ...fetchOptions
-  } = options;
-
-  const controller = createTimeoutController(timeout);
-
-  const operation = async (): Promise<T> => {
-    const response = await fetch(url, {
-      ...fetchOptions,
-      headers: {
-        "Content-Type": "application/json",
-        ...headers,
-      },
-      signal: controller?.signal,
-    });
-
-    if (!response.ok) {
-      const errorText = await response.text().catch(() => "Unknown error");
-      throw new Error(`HTTP ${response.status}: ${errorText}`);
-    }
-
-    const contentType = response.headers.get("content-type");
-    if (contentType?.includes("application/json")) {
-      return response.json();
-    }
-
-    return response.text() as T;
-  };
-
-  const result = await withErrorHandling(
-    async () => {
-      if (retries > 0) {
-        return retryWithBackoff(operation, {
-          maxRetries: retries,
-          delayMs: env.apiRetryDelayMs,
-          shouldRetry: (error) => isNetworkError(error),
-        });
-      }
-      return operation();
-    },
-    (error) => {
-      console.error("[API Client] Request failed:", error);
-    }
-  );
-
-  if (result.error) {
-    return {
-      data: null,
-      error: getErrorMessage(result.error),
-      status: 0,
-      headers: new Headers(),
-    };
-  }
-
-  return {
-    data: result.data ?? null,
-    error: null,
-    status: 200,
-    headers: new Headers(),
-  };
-}
-
-/**
- * Makes a GET request
- * @param url - Request URL
- * @param options - Request options
- * @returns API response
- */
-export async function get<T>(
-  url: string,
-  options: Omit<RequestOptions, "method" | "body"> = {}
-): Promise<ApiResponse<T>> {
-  return fetchWithTimeout<T>(url, { ...options, method: "GET" });
-}
-
-/**
- * Makes a POST request
- * @param url - Request URL
- * @param data - Request body data
- * @param options - Request options
- * @returns API response
- */
-export async function post<T>(
-  url: string,
-  data: unknown,
-  options: Omit<RequestOptions, "method"> = {}
-): Promise<ApiResponse<T>> {
-  return fetchWithTimeout<T>(url, {
-    ...options,
-    method: "POST",
-    body: JSON.stringify(data),
-  });
-}
-
-/**
- * Makes a PUT request
- * @param url - Request URL
- * @param data - Request body data
- * @param options - Request options
- * @returns API response
- */
-export async function put<T>(
-  url: string,
-  data: unknown,
-  options: Omit<RequestOptions, "method"> = {}
-): Promise<ApiResponse<T>> {
-  return fetchWithTimeout<T>(url, {
-    ...options,
-    method: "PUT",
-    body: JSON.stringify(data),
-  });
-}
-
-/**
- * Makes a DELETE request
- * @param url - Request URL
- * @param options - Request options
- * @returns API response
- */
-export async function del<T>(
-  url: string,
-  options: Omit<RequestOptions, "method" | "body"> = {}
-): Promise<ApiResponse<T>> {
-  return fetchWithTimeout<T>(url, { ...options, method: "DELETE" });
-}
-
-/**
- * Makes a PATCH request
- * @param url - Request URL
- * @param data - Request body data
- * @param options - Request options
- * @returns API response
- */
-export async function patch<T>(
-  url: string,
-  data: unknown,
-  options: Omit<RequestOptions, "method"> = {}
-): Promise<ApiResponse<T>> {
-  return fetchWithTimeout<T>(url, {
-    ...options,
-    method: "PATCH",
-    body: JSON.stringify(data),
-  });
-}
+export { HTTP_METHOD, HTTP_CONTENT_TYPE, DEFAULT_HEADERS, type HttpMethod } from "./http-methods.constants";
+export { fetchWithTimeout } from "./http-fetch-handler";
+export { get, post, put, del, patch } from "./http-client-methods";

package/src/infrastructure/http/http-fetch-handler.ts

@@ -0,0 +1,53 @@
+/**
+ * HTTP Fetch Handler
+ * Infrastructure: Orchestrates request execution with error handling
+ */
+
+import { withErrorHandling, getErrorMessage, retryWithBackoff, isNetworkError } from "../utils/error-handling.util";
+import { env } from "../config/env.config";
+import type { RequestOptions, ApiResponse } from "./api-client.types";
+import { executeRequest, isSuccessResponse, extractErrorMessage } from "./http-request-executor";
+import { parseResponse, createSuccessResponse, createErrorResponse } from "./http-response-parser";
+
+/**
+ * Fetches data with timeout, retry, and error handling
+ */
+export async function fetchWithTimeout<T>(
+  url: string,
+  options: RequestOptions = {}
+): Promise<ApiResponse<T>> {
+  const { retries = 0 } = options;
+
+  const operation = async (): Promise<T> => {
+    const response = await executeRequest<T>(url, options);
+
+    if (!isSuccessResponse(response)) {
+      const errorMessage = await extractErrorMessage(response);
+      throw new Error(errorMessage);
+    }
+
+    return parseResponse<T>(response);
+  };
+
+  const result = await withErrorHandling(
+    async () => {
+      if (retries > 0) {
+        return retryWithBackoff(operation, {
+          maxRetries: retries,
+          delayMs: env.apiRetryDelayMs,
+          shouldRetry: (error) => isNetworkError(error),
+        });
+      }
+      return operation();
+    },
+    (error) => {
+      console.error("[API Client] Request failed:", error);
+    }
+  );
+
+  if (result.error) {
+    return createErrorResponse(getErrorMessage(result.error));
+  }
+
+  return createSuccessResponse(result.data ?? null as T);
+}

package/src/infrastructure/http/http-methods.constants.ts

@@ -0,0 +1,23 @@
+/**
+ * HTTP Methods Constants
+ * Domain knowledge: Standard HTTP methods
+ */
+
+export const HTTP_METHOD = {
+  GET: "GET",
+  POST: "POST",
+  PUT: "PUT",
+  DELETE: "DELETE",
+  PATCH: "PATCH",
+} as const;
+
+export type HttpMethod = typeof HTTP_METHOD[keyof typeof HTTP_METHOD];
+
+export const HTTP_CONTENT_TYPE = {
+  JSON: "application/json",
+  TEXT: "text/plain",
+} as const;
+
+export const DEFAULT_HEADERS = {
+  "Content-Type": HTTP_CONTENT_TYPE.JSON,
+} as const;

package/src/infrastructure/http/http-request-executor.ts

@@ -0,0 +1,49 @@
+/**
+ * HTTP Request Executor
+ * Infrastructure: Handles low-level fetch operations
+ */
+
+import { env } from "../config/env.config";
+import { createTimeoutController } from "./timeout.util";
+import { DEFAULT_HEADERS } from "./http-methods.constants";
+import type { RequestOptions } from "./api-client.types";
+
+/**
+ * Executes HTTP request with timeout
+ */
+export async function executeRequest<T>(
+  url: string,
+  options: RequestOptions = {}
+): Promise<Response> {
+  const {
+    timeout = env.apiDefaultTimeoutMs,
+    headers = {},
+    ...fetchOptions
+  } = options;
+
+  const controller = createTimeoutController(timeout);
+
+  return fetch(url, {
+    ...fetchOptions,
+    headers: {
+      ...DEFAULT_HEADERS,
+      ...headers,
+    },
+    signal: controller?.signal,
+  });
+}
+
+/**
+ * Checks if response is successful
+ */
+export function isSuccessResponse(response: Response): boolean {
+  return response.ok;
+}
+
+/**
+ * Extracts error message from failed response
+ */
+export async function extractErrorMessage(response: Response): Promise<string> {
+  const errorText = await response.text().catch(() => "Unknown error");
+  return `HTTP ${response.status}: ${errorText}`;
+}

package/src/infrastructure/http/http-response-parser.ts

@@ -0,0 +1,53 @@
+/**
+ * HTTP Response Parser
+ * Infrastructure: Parses HTTP responses to typed data
+ */
+
+import { HTTP_CONTENT_TYPE } from "./http-methods.constants";
+
+/**
+ * Parses response based on content type
+ */
+export async function parseResponse<T>(response: Response): Promise<T> {
+  const contentType = response.headers.get("content-type");
+
+  if (contentType?.includes(HTTP_CONTENT_TYPE.JSON)) {
+    return response.json();
+  }
+
+  return response.text() as T;
+}
+
+/**
+ * Creates successful API response
+ */
+export function createSuccessResponse<T>(data: T): {
+  data: T;
+  error: null;
+  status: number;
+  headers: Headers;
+} {
+  return {
+    data,
+    error: null,
+    status: 200,
+    headers: new Headers(),
+  };
+}
+
+/**
+ * Creates error API response
+ */
+export function createErrorResponse(errorMessage: string): {
+  data: null;
+  error: string;
+  status: number;
+  headers: Headers;
+} {
+  return {
+    data: null,
+    error: errorMessage,
+    status: 0,
+    headers: new Headers(),
+  };
+}

package/src/infrastructure/orchestration/GenerationOrchestrator.ts

@@ -1,19 +1,13 @@
 /**
  * AI Generation Orchestrator
- * Single Responsibility: Orchestrate common AI generation business operations
- *
- * Generic orchestrator for 100+ apps with dependency injection
- * Handles: Network check, content moderation, credit processing, refunds
+ * Orchestrates AI generation business operations
  */
 
 import {
   contentModerationService,
   ContentPolicyViolationError,
 } from "../../domains/content-moderation";
-import type {
-  OrchestratorConfig,
-  GenerationMetadata,
-} from "./orchestrator.types";
+import type { OrchestratorConfig, GenerationMetadata } from "./orchestrator.types";
 import type { GenerationCapability } from "../../domain/entities/generation.types";
 import {
   NetworkUnavailableError,
@@ -21,8 +15,6 @@ import {
   AuthenticationRequiredError,
 } from "./orchestrator.errors";
 
-declare const __DEV__: boolean;
-
 export class GenerationOrchestrator {
   constructor(private config: OrchestratorConfig) {}
 
@@ -84,8 +76,7 @@ export class GenerationOrchestrator {
     const creditCost = this.calculateCreditCost(capability, metadata);
     const actualUserId = this.requireAuthenticatedUser();
 
-    const currentCredits =
-      await this.config.creditService.getBalance(actualUserId);
+    const currentCredits = await this.config.creditService.getBalance(actualUserId);
 
     if (currentCredits < creditCost) {
       this.config.paywallService.show(creditCost);
@@ -102,13 +93,9 @@ export class GenerationOrchestrator {
     const actualUserId = this.requireAuthenticatedUser();
     const creditCost = this.calculateCreditCost(capability, metadata);
 
-    const currentCredits =
-      await this.config.creditService.getBalance(actualUserId);
+    const currentCredits = await this.config.creditService.getBalance(actualUserId);
 
-    const success = await this.config.creditService.deduct(
-      actualUserId,
-      creditCost,
-    );
+    const success = await this.config.creditService.deduct(actualUserId, creditCost);
 
     if (!success) {
       this.config.paywallService.show(creditCost);
@@ -118,10 +105,7 @@ export class GenerationOrchestrator {
     return creditCost;
   }
 
-  async refundCreditsIfApplicable(
-    amount: number,
-    error: unknown,
-  ): Promise<void> {
+  async refundCreditsIfApplicable(amount: number, error: unknown): Promise<void> {
     if (amount <= 0) return;
 
     const isNonRefundable =
@@ -132,31 +116,12 @@ export class GenerationOrchestrator {
           error.message.toLowerCase().includes("cancelled") ||
           error.message.toLowerCase().includes("user cancel")));
 
-    if (typeof __DEV__ !== "undefined" && __DEV__) {
-      console.log("[GenerationOrchestrator] Refund check:", {
-        amount,
-        isNonRefundable,
-        errorType: error instanceof Error ? error.name : typeof error,
-        errorMessage: error instanceof Error ? error.message : String(error),
-      });
-    }
-
     if (!isNonRefundable) {
       try {
         const actualUserId = this.requireAuthenticatedUser();
-
-        if (typeof __DEV__ !== "undefined" && __DEV__) {
-          console.log("[GenerationOrchestrator] Refunding credits:", {
-            userId: actualUserId,
-            amount,
-          });
-        }
-
         await this.config.creditService.add(actualUserId, amount);
-      } catch (refundErr) {
-        if (typeof __DEV__ !== "undefined" && __DEV__) {
-          console.error("[GenerationOrchestrator] Refund failed:", refundErr);
-        }
+      } catch {
+        // Silently fail refund - non-critical operation
       }
     }
   }

package/src/infrastructure/utils/classifier-helpers.ts

@@ -0,0 +1,36 @@
+/**
+ * Error Classifier Helper Functions
+ */
+
+import type { AIErrorInfo } from "../../domain/entities";
+
+declare const __DEV__: boolean;
+
+export function matchesPatterns(message: string, patterns: readonly string[]): boolean {
+  const lowerMessage = message.toLowerCase();
+  return patterns.some((pattern) => lowerMessage.includes(pattern));
+}
+
+export function getStatusCode(error: unknown): number | undefined {
+  if (error && typeof error === "object") {
+    const err = error as Record<string, unknown>;
+    if (typeof err.status === "number") return err.status;
+    if (typeof err.statusCode === "number") return err.statusCode;
+    if (err.response && typeof err.response === "object") {
+      const resp = err.response as Record<string, unknown>;
+      if (typeof resp.status === "number") return resp.status;
+    }
+  }
+  return undefined;
+}
+
+export function logClassification(info: AIErrorInfo): AIErrorInfo {
+  if (typeof __DEV__ !== "undefined" && __DEV__) {
+    console.log("[ErrorClassifier] Classified as:", {
+      type: info.type,
+      messageKey: info.messageKey,
+      retryable: info.retryable,
+    });
+  }
+  return info;
+}

package/src/infrastructure/utils/content-validators.ts

@@ -0,0 +1,92 @@
+/**
+ * Content Validation Utilities
+ */
+
+import {
+  MAX_PROMPT_LENGTH,
+  MIN_PROMPT_LENGTH,
+  MAX_URL_LENGTH,
+  MIN_VIDEO_DURATION_SECONDS,
+  MAX_VIDEO_DURATION_SECONDS,
+} from "../constants/validation.constants";
+import type { ValidationResult } from "./validation-types";
+
+/**
+ * Validates text prompt length
+ */
+export function validatePrompt(prompt: string): ValidationResult {
+  if (!prompt || typeof prompt !== "string") {
+    return { isValid: false, error: "Prompt is required" };
+  }
+
+  if (prompt.length < MIN_PROMPT_LENGTH) {
+    return { isValid: false, error: "Prompt is too short" };
+  }
+
+  if (prompt.length > MAX_PROMPT_LENGTH) {
+    return { isValid: false, error: "Prompt is too long" };
+  }
+
+  return { isValid: true };
+}
+
+/**
+ * Validates URL format
+ */
+export function validateUrl(url: string): ValidationResult {
+  if (!url || typeof url !== "string") {
+    return { isValid: false, error: "URL is required" };
+  }
+
+  if (url.length > MAX_URL_LENGTH) {
+    return { isValid: false, error: "URL is too long" };
+  }
+
+  try {
+    new URL(url);
+    return { isValid: true };
+  } catch {
+    return { isValid: false, error: "Invalid URL format" };
+  }
+}
+
+/**
+ * Validates video duration
+ */
+export function validateVideoDuration(duration: number): ValidationResult {
+  if (typeof duration !== "number" || isNaN(duration)) {
+    return { isValid: false, error: "Duration must be a number" };
+  }
+
+  if (duration < MIN_VIDEO_DURATION_SECONDS) {
+    return {
+      isValid: false,
+      error: `Duration must be at least ${MIN_VIDEO_DURATION_SECONDS} seconds`,
+    };
+  }
+
+  if (duration > MAX_VIDEO_DURATION_SECONDS) {
+    return {
+      isValid: false,
+      error: `Duration must not exceed ${MAX_VIDEO_DURATION_SECONDS} seconds`,
+    };
+  }
+
+  return { isValid: true };
+}
+
+/**
+ * Validates email format
+ */
+export function validateEmail(email: string): ValidationResult {
+  if (!email || typeof email !== "string") {
+    return { isValid: false, error: "Email is required" };
+  }
+
+  const emailRegex = /^[^\s@]+@[^\s@]+\.[^\s@]+$/;
+  if (!emailRegex.test(email)) {
+    return { isValid: false, error: "Invalid email format" };
+  }
+
+  return { isValid: true };
+}

package/src/infrastructure/utils/domain-guards.ts

@@ -0,0 +1,22 @@
+/**
+ * Domain-Specific Type Guards
+ */
+
+import { hasProperty, isObject } from "./structure-guards";
+import { isNonEmptyString } from "./primitive-guards";
+
+/**
+ * Type guard for creation objects with output property
+ */
+export function isCreationWithOutput(
+  value: unknown
+): value is { output: unknown } {
+  return hasProperty(value, "output") && isObject(value.output);
+}
+
+/**
+ * Type guard for wizard data with id property
+ */
+export function isWizardData(value: unknown): value is { id: string } {
+  return hasProperty(value, "id") && isNonEmptyString(value.id);
+}