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

package/src/infrastructure/utils/error-handlers.ts

@@ -0,0 +1,51 @@
+/**
+ * Error Handling Utilities
+ */
+
+import { getErrorMessage } from "./error-extractors";
+
+/**
+ * Wraps an async function with error handling
+ */
+export async function withErrorHandling<T>(
+  operation: () => Promise<T>,
+  onError?: (error: Error) => void
+): Promise<{ data?: T; error?: Error }> {
+  try {
+    const data = await operation();
+    return { data };
+  } catch (error) {
+    const appError = error instanceof Error ? error : new Error(getErrorMessage(error));
+    onError?.(appError);
+    return { error: appError };
+  }
+}
+
+/**
+ * Safely executes a function and returns null on error
+ */
+export function safeExecute<T>(
+  operation: () => T,
+  fallback: T = null as T
+): T {
+  try {
+    return operation();
+  } catch {
+    return fallback;
+  }
+}
+
+/**
+ * Logs error with context
+ */
+export function logError(
+  error: unknown,
+  context?: string
+): void {
+  const message = getErrorMessage(error);
+  const contextPrefix = context ? `[${context}]` : "";
+
+  if (typeof console !== "undefined" && console.error) {
+    console.error(`${contextPrefix} Error:`, message, error);
+  }
+}

package/src/infrastructure/utils/error-handling.util.ts

@@ -1,190 +1,11 @@
 /**
- * Centralized Error Handling Utilities
+ * Centralized Error Handling Utilities - Barrel Export
  * Provides consistent error handling patterns across the application
  */
 
-export interface AppError extends Error {
-  code?: string;
-  statusCode?: number;
-  originalError?: unknown;
-}
-
-/**
- * Safely extracts error message from unknown error type
- */
-export function getErrorMessage(error: unknown): string {
-  if (error instanceof Error) {
-    return error.message;
-  }
-
-  if (typeof error === "string") {
-    return error;
-  }
-
-  if (error && typeof error === "object" && "message" in error) {
-    return String(error.message);
-  }
-
-  return "An unknown error occurred";
-}
-
-/**
- * Creates a standardized application error
- */
-export function createAppError(
-  message: string,
-  options: {
-    code?: string;
-    statusCode?: number;
-    originalError?: unknown;
-  } = {}
-): AppError {
-  const error = new Error(message) as AppError;
-  error.code = options.code;
-  error.statusCode = options.statusCode;
-  error.originalError = options.originalError;
-  return error;
-}
-
-/**
- * Wraps an async function with error handling
- */
-export async function withErrorHandling<T>(
-  operation: () => Promise<T>,
-  onError?: (error: Error) => void
-): Promise<{ data?: T; error?: Error }> {
-  try {
-    const data = await operation();
-    return { data };
-  } catch (error) {
-    const appError = error instanceof Error ? error : new Error(getErrorMessage(error));
-    onError?.(appError);
-    return { error: appError };
-  }
-}
-
-/**
- * Type guard to check if value is an Error
- */
-export function isError(value: unknown): value is Error {
-  return value instanceof Error;
-}
-
-/**
- * Type guard to check if value is an AppError
- */
-export function isAppError(value: unknown): value is AppError {
-  return isError(value) && "code" in value;
-}
-
-/**
- * Safely executes a function and returns null on error
- */
-export function safeExecute<T>(
-  operation: () => T,
-  fallback: T = null as T
-): T {
-  try {
-    return operation();
-  } catch {
-    return fallback;
-  }
-}
-
-/**
- * Logs error with context
- */
-export function logError(
-  error: unknown,
-  context?: string
-): void {
-  const message = getErrorMessage(error);
-  const contextPrefix = context ? `[${context}]` : "";
-
-  if (typeof console !== "undefined" && console.error) {
-    console.error(`${contextPrefix} Error:`, message, error);
-  }
-}
-
-/**
- * Checks if error is a network error
- */
-export function isNetworkError(error: unknown): boolean {
-  if (!isError(error)) {
-    return false;
-  }
-
-  const message = error.message.toLowerCase();
-  return (
-    message.includes("network") ||
-    message.includes("fetch") ||
-    message.includes("connection") ||
-    message.includes("timeout")
-  );
-}
-
-/**
- * Checks if error is a validation error
- */
-export function isValidationError(error: unknown): boolean {
-  if (isAppError(error)) {
-    return error.code?.toLowerCase().includes("validation") || false;
-  }
-  return false;
-}
-
-/**
- * Checks if error is an authentication error
- */
-export function isAuthError(error: unknown): boolean {
-  if (!isError(error)) {
-    return false;
-  }
-
-  const message = error.message.toLowerCase();
-  return (
-    message.includes("unauthorized") ||
-    message.includes("authentication") ||
-    message.includes("forbidden") ||
-    message.includes("token")
-  );
-}
-
-/**
- * Retry function with exponential backoff
- */
-export async function retryWithBackoff<T>(
-  operation: () => Promise<T>,
-  options: {
-    maxRetries?: number;
-    delayMs?: number;
-    backoffMultiplier?: number;
-    shouldRetry?: (error: Error) => boolean;
-  } = {}
-): Promise<T> {
-  const {
-    maxRetries = 3,
-    delayMs = 1000,
-    backoffMultiplier = 2,
-    shouldRetry = () => true,
-  } = options;
-
-  let lastError: Error | undefined;
-
-  for (let attempt = 0; attempt <= maxRetries; attempt++) {
-    try {
-      return await operation();
-    } catch (error) {
-      lastError = error instanceof Error ? error : new Error(getErrorMessage(error));
-
-      if (attempt === maxRetries || !shouldRetry(lastError)) {
-        throw lastError;
-      }
-
-      const delay = delayMs * Math.pow(backoffMultiplier, attempt);
-      await new Promise((resolve) => setTimeout(resolve, delay));
-    }
-  }
-
-  throw lastError!;
-}
+export type { AppError } from "./error-types";
+export { isError, isAppError } from "./error-types";
+export { getErrorMessage, createAppError } from "./error-extractors";
+export { withErrorHandling, safeExecute, logError } from "./error-handlers";
+export { isNetworkError, isValidationError, isAuthError } from "./error-classifiers";
+export { retryWithBackoff } from "./error-retry";

package/src/infrastructure/utils/error-message-extractor.util.ts

@@ -1,176 +1,14 @@
 /**
- * Error Message Extractor
+ * Error Message Extractor - Barrel Export
  * Extracts error messages from various API error formats
  */
 
-declare const __DEV__: boolean;
-
-/**
- * FAL API error detail item
- */
-interface FalErrorDetail {
-  readonly msg?: string;
-  readonly type?: string;
-  readonly loc?: string[];
-  readonly input?: string;
-  readonly url?: string;
-}
-
-/**
- * Error types for user-friendly messages
- */
-export const GenerationErrorType = {
-  CONTENT_POLICY: "content_policy",
-  VALIDATION: "validation",
-  NETWORK: "network",
-  TIMEOUT: "timeout",
-  RATE_LIMIT: "rate_limit",
-  QUOTA_EXCEEDED: "quota_exceeded",
-  UNKNOWN: "unknown",
-} as const;
-
-export type GenerationErrorTypeValue = typeof GenerationErrorType[keyof typeof GenerationErrorType];
-
-/**
- * Structured generation error
- */
-export interface GenerationError extends Error {
-  readonly errorType: GenerationErrorTypeValue;
-  readonly translationKey: string;
-}
-
-/**
- * Create a structured generation error
- */
-function createGenerationError(
-  type: GenerationErrorTypeValue,
-  message: string,
-): GenerationError {
-  const error = new Error(message) as GenerationError;
-  (error as { errorType: GenerationErrorTypeValue }).errorType = type;
-  (error as { translationKey: string }).translationKey = `error.generation.${type}`;
-  return error;
-}
-
-/**
- * Check if result contains a FAL API error response
- * FAL sometimes returns errors with COMPLETED status
- */
-export function checkFalApiError(result: unknown): void {
-  if (!result || typeof result !== "object") return;
-
-  const resultObj = result as { detail?: FalErrorDetail[] };
-
-  // FAL API error format: {detail: [{msg, type, loc}]}
-  if (Array.isArray(resultObj.detail) && resultObj.detail.length > 0) {
-    const firstError = resultObj.detail[0];
-    const errorType = firstError?.type || "unknown";
-    const errorMsg = firstError?.msg || "Unknown API error";
-
-    if (typeof __DEV__ !== "undefined" && __DEV__) {
-      console.error("[FalApiError] Detected error in result:", {
-        type: errorType,
-        message: errorMsg,
-      });
-    }
-
-    // Throw specific error based on type
-    if (errorType === "content_policy_violation") {
-      throw createGenerationError(GenerationErrorType.CONTENT_POLICY, errorMsg);
-    }
-
-    if (errorType === "validation_error" || errorType.includes("validation")) {
-      throw createGenerationError(GenerationErrorType.VALIDATION, errorMsg);
-    }
-
-    throw createGenerationError(GenerationErrorType.UNKNOWN, errorMsg);
-  }
-}
-
-/**
- * Check if error is a GenerationError with translation key
- */
-export function isGenerationError(error: unknown): error is GenerationError {
-  return error instanceof Error && "errorType" in error && "translationKey" in error;
-}
-
-/**
- * Get translation key from error (returns key if GenerationError, null otherwise)
- */
-export function getErrorTranslationKey(error: unknown): string | null {
-  if (isGenerationError(error)) {
-    return error.translationKey;
-  }
-
-  // Check for content policy in error message
-  const message = error instanceof Error ? error.message : String(error);
-  const lowerMessage = message.toLowerCase();
-
-  if (lowerMessage.includes("content_policy") || lowerMessage.includes("policy violation")) {
-    return `error.generation.${GenerationErrorType.CONTENT_POLICY}`;
-  }
-
-  if (lowerMessage.includes("rate limit") || lowerMessage.includes("429")) {
-    return `error.generation.${GenerationErrorType.RATE_LIMIT}`;
-  }
-
-  if (lowerMessage.includes("timeout") || lowerMessage.includes("timed out")) {
-    return `error.generation.${GenerationErrorType.TIMEOUT}`;
-  }
-
-  if (lowerMessage.includes("network") || lowerMessage.includes("connection")) {
-    return `error.generation.${GenerationErrorType.NETWORK}`;
-  }
-
-  return null;
-}
-
-/**
- * Extract error message from FAL API and other error formats
- * Supports: Error instances, FAL API errors, generic objects
- * Returns translation key if available, otherwise original message
- */
-export function extractErrorMessage(
-  error: unknown,
-  defaultMessage = "Processing failed",
-  debugPrefix?: string,
-): string {
-  // First check if this is a GenerationError with translation key
-  const translationKey = getErrorTranslationKey(error);
-  if (translationKey) {
-    if (typeof __DEV__ !== "undefined" && __DEV__ && debugPrefix) {
-      console.error(`[${debugPrefix}] Error (translation key):`, translationKey);
-    }
-    return translationKey;
-  }
-
-  let message = defaultMessage;
-
-  if (error instanceof Error) {
-    message = error.message;
-  } else if (typeof error === "object" && error !== null) {
-    const errObj = error as Record<string, unknown>;
-
-    // FAL API error format: {detail: [{msg, type, loc}]}
-    if (Array.isArray(errObj.detail) && errObj.detail[0]?.msg) {
-      const detailType = errObj.detail[0]?.type;
-      // Check for content policy in FAL API response
-      if (detailType === "content_policy_violation") {
-        return `error.generation.${GenerationErrorType.CONTENT_POLICY}`;
-      }
-      message = String(errObj.detail[0].msg);
-    } else if (errObj.detail) {
-      message = JSON.stringify(errObj.detail);
-    } else if (errObj.message) {
-      message = String(errObj.message);
-    } else if (errObj.msg) {
-      message = String(errObj.msg);
-    }
-  }
-
-  if (typeof __DEV__ !== "undefined" && __DEV__ && debugPrefix) {
-    console.error(`[${debugPrefix}] Error:`, message, error);
-  }
-
-  return message;
-}
+export type {
+  FalErrorDetail,
+  GenerationErrorTypeValue,
+  GenerationError,
+} from "./extraction-types";
+export { GenerationErrorType } from "./extraction-types";
+export { createGenerationError, isGenerationError } from "./error-factory";
+export { checkFalApiError } from "./fal-error-checker";
+export { extractErrorMessage, getErrorTranslationKey } from "./message-extractor";

package/src/infrastructure/utils/error-retry.ts

@@ -0,0 +1,44 @@
+/**
+ * Error Retry Utilities
+ */
+
+import { getErrorMessage } from "./error-extractors";
+
+/**
+ * Retry function with exponential backoff
+ */
+export async function retryWithBackoff<T>(
+  operation: () => Promise<T>,
+  options: {
+    maxRetries?: number;
+    delayMs?: number;
+    backoffMultiplier?: number;
+    shouldRetry?: (error: Error) => boolean;
+  } = {}
+): Promise<T> {
+  const {
+    maxRetries = 3,
+    delayMs = 1000,
+    backoffMultiplier = 2,
+    shouldRetry = () => true,
+  } = options;
+
+  let lastError: Error | undefined;
+
+  for (let attempt = 0; attempt <= maxRetries; attempt++) {
+    try {
+      return await operation();
+    } catch (error) {
+      lastError = error instanceof Error ? error : new Error(getErrorMessage(error));
+
+      if (attempt === maxRetries || !shouldRetry(lastError)) {
+        throw lastError;
+      }
+
+      const delay = delayMs * Math.pow(backoffMultiplier, attempt);
+      await new Promise((resolve) => setTimeout(resolve, delay));
+    }
+  }
+
+  throw lastError!;
+}

package/src/infrastructure/utils/error-types.ts

@@ -0,0 +1,23 @@
+/**
+ * Error Type Definitions and Guards
+ */
+
+export interface AppError extends Error {
+  code?: string;
+  statusCode?: number;
+  originalError?: unknown;
+}
+
+/**
+ * Type guard to check if value is an Error
+ */
+export function isError(value: unknown): value is Error {
+  return value instanceof Error;
+}
+
+/**
+ * Type guard to check if value is an AppError
+ */
+export function isAppError(value: unknown): value is AppError {
+  return isError(value) && "code" in value;
+}

package/src/infrastructure/utils/extraction-types.ts

@@ -0,0 +1,37 @@
+/**
+ * Error Extraction Type Definitions
+ */
+
+/**
+ * FAL API error detail item
+ */
+export interface FalErrorDetail {
+  readonly msg?: string;
+  readonly type?: string;
+  readonly loc?: string[];
+  readonly input?: string;
+  readonly url?: string;
+}
+
+/**
+ * Error types for user-friendly messages
+ */
+export const GenerationErrorType = {
+  CONTENT_POLICY: "content_policy",
+  VALIDATION: "validation",
+  NETWORK: "network",
+  TIMEOUT: "timeout",
+  RATE_LIMIT: "rate_limit",
+  QUOTA_EXCEEDED: "quota_exceeded",
+  UNKNOWN: "unknown",
+} as const;
+
+export type GenerationErrorTypeValue = typeof GenerationErrorType[keyof typeof GenerationErrorType];
+
+/**
+ * Structured generation error
+ */
+export interface GenerationError extends Error {
+  readonly errorType: GenerationErrorTypeValue;
+  readonly translationKey: string;
+}

package/src/infrastructure/utils/fal-error-checker.ts

@@ -0,0 +1,44 @@
+/**
+ * FAL API Error Checker
+ */
+
+import type { FalErrorDetail } from "./extraction-types";
+import { GenerationErrorType } from "./extraction-types";
+import { createGenerationError } from "./error-factory";
+
+declare const __DEV__: boolean;
+
+/**
+ * Check if result contains a FAL API error response
+ * FAL sometimes returns errors with COMPLETED status
+ */
+export function checkFalApiError(result: unknown): void {
+  if (!result || typeof result !== "object") return;
+
+  const resultObj = result as { detail?: FalErrorDetail[] };
+
+  // FAL API error format: {detail: [{msg, type, loc}]}
+  if (Array.isArray(resultObj.detail) && resultObj.detail.length > 0) {
+    const firstError = resultObj.detail[0];
+    const errorType = firstError?.type || "unknown";
+    const errorMsg = firstError?.msg || "Unknown API error";
+
+    if (typeof __DEV__ !== "undefined" && __DEV__) {
+      console.error("[FalApiError] Detected error in result:", {
+        type: errorType,
+        message: errorMsg,
+      });
+    }
+
+    // Throw specific error based on type
+    if (errorType === "content_policy_violation") {
+      throw createGenerationError(GenerationErrorType.CONTENT_POLICY, errorMsg);
+    }
+
+    if (errorType === "validation_error" || errorType.includes("validation")) {
+      throw createGenerationError(GenerationErrorType.VALIDATION, errorMsg);
+    }
+
+    throw createGenerationError(GenerationErrorType.UNKNOWN, errorMsg);
+  }
+}

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

@@ -0,0 +1,64 @@
+/**
+ * General Validation Utilities
+ */
+
+import type { ValidationResult } from "./validation-types";
+
+/**
+ * Validates that a value is not empty
+ */
+export function validateNotEmpty(value: unknown, fieldName = "Value"): ValidationResult {
+  if (value === null || value === undefined) {
+    return { isValid: false, error: `${fieldName} is required` };
+  }
+
+  if (typeof value === "string" && value.trim().length === 0) {
+    return { isValid: false, error: `${fieldName} cannot be empty` };
+  }
+
+  if (Array.isArray(value) && value.length === 0) {
+    return { isValid: false, error: `${fieldName} cannot be empty` };
+  }
+
+  return { isValid: true };
+}
+
+/**
+ * Validates numeric range
+ */
+export function validateNumericRange(
+  value: number,
+  options: {
+    min?: number;
+    max?: number;
+    fieldName?: string;
+  }
+): ValidationResult {
+  const { min, max, fieldName = "Value" } = options;
+
+  if (typeof value !== "number" || isNaN(value)) {
+    return { isValid: false, error: `${fieldName} must be a number` };
+  }
+
+  if (min !== undefined && value < min) {
+    return { isValid: false, error: `${fieldName} must be at least ${min}` };
+  }
+
+  if (max !== undefined && value > max) {
+    return { isValid: false, error: `${fieldName} must not exceed ${max}` };
+  }
+
+  return { isValid: true };
+}
+
+/**
+ * Combines multiple validation results
+ */
+export function combineValidations(...results: ValidationResult[]): ValidationResult {
+  for (const result of results) {
+    if (!result.isValid) {
+      return result;
+    }
+  }
+  return { isValid: true };
+}

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

@@ -0,0 +1,39 @@
+/**
+ * ID Validation Utilities
+ */
+
+import {
+  MAX_USER_ID_LENGTH,
+  MAX_CREATION_ID_LENGTH,
+} from "../constants/validation.constants";
+import type { ValidationResult } from "./validation-types";
+
+/**
+ * Validates user ID
+ */
+export function validateUserId(userId: string): ValidationResult {
+  if (!userId || typeof userId !== "string") {
+    return { isValid: false, error: "User ID is required" };
+  }
+
+  if (userId.length > MAX_USER_ID_LENGTH) {
+    return { isValid: false, error: "User ID is too long" };
+  }
+
+  return { isValid: true };
+}
+
+/**
+ * Validates creation ID
+ */
+export function validateCreationId(creationId: string): ValidationResult {
+  if (!creationId || typeof creationId !== "string") {
+    return { isValid: false, error: "Creation ID is required" };
+  }
+
+  if (creationId.length > MAX_CREATION_ID_LENGTH) {
+    return { isValid: false, error: "Creation ID is too long" };
+  }
+
+  return { isValid: true };
+}