@umituz/react-native-ai-fal-provider 2.0.37 → 2.0.39

package/src/infrastructure/utils/input-validator.util.ts

@@ -5,6 +5,19 @@
 
 import { isValidModelId, isValidPrompt } from "./type-guards.util";
 
+/**
+ * Basic HTML/Script tag sanitization (defense in depth)
+ * NOTE: This is sent to backend which should also sanitize,
+ * but we apply basic filtering as a precaution
+ */
+function sanitizeString(value: string): string {
+  // Remove potential script tags and HTML entities
+  return value
+    .replace(/<script\b[^<]*(?:(?!<\/script>)<[^<]*)*<\/script>/gi, '')
+    .replace(/<[^>]*>/g, '')
+    .trim();
+}
+
 export interface ValidationError {
   field: string;
   message: string;
@@ -42,23 +55,35 @@ export function validateInput(
     errors.push({ field: "input", message: "Input must be a non-empty object" });
   }
 
-  // Validate prompt if present
+  // Validate and sanitize prompt if present
   if (input.prompt !== undefined) {
     if (!isValidPrompt(input.prompt)) {
       errors.push({
         field: "prompt",
         message: "Prompt must be a non-empty string (max 5000 characters)",
       });
+    } else if (typeof input.prompt === "string") {
+      // Apply basic sanitization (defense in depth)
+      const sanitized = sanitizeString(input.prompt);
+      if (sanitized !== input.prompt) {
+        console.warn('[input-validator] Potentially unsafe content detected and sanitized in prompt');
+      }
     }
   }
 
-  // Validate negative_prompt if present
+  // Validate and sanitize negative_prompt if present
   if (input.negative_prompt !== undefined) {
     if (!isValidPrompt(input.negative_prompt)) {
       errors.push({
         field: "negative_prompt",
         message: "Negative prompt must be a non-empty string (max 5000 characters)",
       });
+    } else if (typeof input.negative_prompt === "string") {
+      // Apply basic sanitization (defense in depth)
+      const sanitized = sanitizeString(input.negative_prompt);
+      if (sanitized !== input.negative_prompt) {
+        console.warn('[input-validator] Potentially unsafe content detected and sanitized in negative_prompt');
+      }
     }
   }
 
@@ -79,7 +104,13 @@ export function validateInput(
           field,
           message: `${field} must be a string`,
         });
-      } else if (value.length > 0) {
+      } else if (!value || value.trim().length === 0) {
+        // Explicitly check for empty/whitespace-only strings
+        errors.push({
+          field,
+          message: `${field} cannot be empty`,
+        });
+      } else {
         const isValidUrl = value.startsWith('http://') || value.startsWith('https://');
         const isValidBase64 = value.startsWith('data:image/');
         if (!isValidUrl && !isValidBase64) {

package/src/infrastructure/utils/parsers/index.ts

@@ -0,0 +1,10 @@
+/**
+ * Parser Utilities - Centralized Exports
+ * Re-exports all parser utilities from submodules
+ */
+
+export * from './json-parsers.util';
+export * from './object-validators.util';
+export * from './value-parsers.util';
+export * from './number-helpers.util';
+export * from './object-transformers.util';

package/src/infrastructure/utils/parsers/json-parsers.util.ts

@@ -0,0 +1,55 @@
+/**
+ * JSON Parser Utilities
+ * Safe JSON parsing and validation operations
+ */
+
+/**
+ * Safely parse JSON with fallback
+ */
+export function safeJsonParse<T = unknown>(
+  data: string,
+  fallback: T
+): T {
+  try {
+    return JSON.parse(data) as T;
+  } catch {
+    return fallback;
+  }
+}
+
+/**
+ * Safely parse JSON with null fallback
+ */
+export function safeJsonParseOrNull<T = unknown>(data: string): T | null {
+  try {
+    return JSON.parse(data) as T;
+  } catch {
+    return null;
+  }
+}
+
+/**
+ * Safely stringify object with fallback
+ */
+export function safeJsonStringify(
+  data: unknown,
+  fallback: string
+): string {
+  try {
+    return JSON.stringify(data);
+  } catch {
+    return fallback;
+  }
+}
+
+/**
+ * Check if string is valid JSON
+ */
+export function isValidJson(data: string): boolean {
+  try {
+    JSON.parse(data);
+    return true;
+  } catch {
+    return false;
+  }
+}

package/src/infrastructure/utils/parsers/number-helpers.util.ts

@@ -0,0 +1,19 @@
+/**
+ * Number Helper Utilities
+ * Number manipulation and formatting
+ */
+
+/**
+ * Clamp number between min and max
+ */
+export function clampNumber(value: number, min: number, max: number): number {
+  return Math.min(Math.max(value, min), max);
+}
+
+/**
+ * Round to decimal places
+ */
+export function roundToDecimals(value: number, decimals: number): number {
+  const multiplier = Math.pow(10, decimals);
+  return Math.round(value * multiplier) / multiplier;
+}

package/src/infrastructure/utils/parsers/object-transformers.util.ts

@@ -0,0 +1,67 @@
+/**
+ * Object Transformer Utilities
+ * Clone, merge, pick, and omit operations
+ */
+
+/**
+ * Deep clone object using JSON serialization
+ * NOTE: This has limitations:
+ * - Functions are not cloned
+ * - Dates become strings
+ * - Circular references will cause errors
+ * For complex objects, consider a dedicated cloning library
+ */
+export function deepClone<T>(data: T): T {
+  try {
+    // Try JSON clone first (fast path)
+    const serialized = JSON.stringify(data);
+    return JSON.parse(serialized) as T;
+  } catch (error) {
+    // Fallback for circular references or other JSON errors
+    console.warn(
+      '[object-transformers] deepClone failed, returning original:',
+      error instanceof Error ? error.message : String(error)
+    );
+    // Return original data if cloning fails
+    return data;
+  }
+}
+
+/**
+ * Merge objects with later objects overriding earlier ones
+ */
+export function mergeObjects<T extends Record<string, unknown>>(
+  ...objects: Partial<T>[]
+): T {
+  return Object.assign({}, ...objects) as T;
+}
+
+/**
+ * Pick specified properties from object
+ */
+export function pickProperties<T extends Record<string, unknown>, K extends keyof T>(
+  obj: T,
+  keys: readonly K[]
+): Pick<T, K> {
+  const result = {} as Pick<T, K>;
+  for (const key of keys) {
+    if (key in obj) {
+      result[key] = obj[key];
+    }
+  }
+  return result;
+}
+
+/**
+ * Omit specified properties from object
+ */
+export function omitProperties<T extends Record<string, unknown>, K extends keyof T>(
+  obj: T,
+  keys: readonly K[]
+): Omit<T, K> {
+  const result = { ...obj };
+  for (const key of keys) {
+    delete result[key];
+  }
+  return result as Omit<T, K>;
+}

package/src/infrastructure/utils/parsers/object-validators.util.ts

@@ -0,0 +1,38 @@
+/**
+ * Object Validator Utilities
+ * Runtime object structure validation
+ */
+
+/**
+ * Validate object structure
+ */
+export function validateObjectStructure<T extends Record<string, unknown>>(
+  data: unknown,
+  requiredKeys: readonly (keyof T)[]
+): data is T {
+  if (!data || typeof data !== "object") {
+    return false;
+  }
+
+  for (const key of requiredKeys) {
+    if (!(key in data)) {
+      return false;
+    }
+  }
+
+  return true;
+}
+
+/**
+ * Validate array of objects
+ */
+export function validateObjectArray<T>(
+  data: unknown,
+  validator: (item: unknown) => item is T
+): data is T[] {
+  if (!Array.isArray(data)) {
+    return false;
+  }
+
+  return data.every(validator);
+}

package/src/infrastructure/utils/parsers/value-parsers.util.ts

@@ -0,0 +1,45 @@
+/**
+ * Value Parser Utilities
+ * Parse primitive values with fallbacks
+ */
+
+/**
+ * Parse number with fallback
+ */
+export function parseNumber(value: unknown, fallback: number): number {
+  if (typeof value === "number") {
+    return value;
+  }
+
+  if (typeof value === "string") {
+    const parsed = Number.parseFloat(value);
+    return Number.isNaN(parsed) ? fallback : parsed;
+  }
+
+  return fallback;
+}
+
+/**
+ * Parse boolean with fallback
+ */
+export function parseBoolean(value: unknown, fallback: boolean): boolean {
+  if (typeof value === "boolean") {
+    return value;
+  }
+
+  if (typeof value === "string") {
+    const lower = value.toLowerCase().trim();
+    if (lower === "true" || lower === "yes" || lower === "1") {
+      return true;
+    }
+    if (lower === "false" || lower === "no" || lower === "0") {
+      return false;
+    }
+  }
+
+  if (typeof value === "number") {
+    return value !== 0;
+  }
+
+  return fallback;
+}

package/src/infrastructure/utils/type-guards/constants.ts

@@ -0,0 +1,10 @@
+/**
+ * Type Guard Constants
+ * Validation thresholds and limits
+ */
+
+export const MIN_BASE64_IMAGE_LENGTH = 100; // Minimum base64 length for meaningful image data
+export const MIN_MODEL_ID_LENGTH = 3; // Minimum model ID length
+export const MAX_PROMPT_LENGTH = 5000; // Maximum prompt length in characters
+export const MAX_TIMEOUT_MS = 600000; // Maximum timeout (10 minutes)
+export const MAX_RETRY_COUNT = 10; // Maximum retry attempts

package/src/infrastructure/utils/type-guards/index.ts

@@ -0,0 +1,8 @@
+/**
+ * Type Guards - Centralized Exports
+ * Re-exports all type guard utilities from submodules
+ */
+
+export * from './constants';
+export * from './model-type-guards.util';
+export * from './validation-guards.util';

package/src/infrastructure/utils/type-guards/model-type-guards.util.ts

@@ -0,0 +1,56 @@
+/**
+ * Model Type Guards
+ * Runtime type checking for model types
+ */
+
+import type { FalModelType } from "../../../domain/entities/fal.types";
+import type { ModelType } from "../../../domain/types/model-selection.types";
+import { FalErrorType } from "../../../domain/entities/error.types";
+
+/**
+ * Check if a string is a valid FalModelType
+ */
+export function isFalModelType(value: unknown): value is FalModelType {
+  const validTypes: ReadonlyArray<FalModelType> = [
+    "text-to-image",
+    "text-to-video",
+    "text-to-voice",
+    "image-to-video",
+    "image-to-image",
+    "text-to-text",
+  ];
+  return typeof value === "string" && validTypes.includes(value as FalModelType);
+}
+
+/**
+ * Check if a string is a valid ModelType
+ */
+export function isModelType(value: unknown): value is ModelType {
+  const validTypes: ReadonlyArray<ModelType> = [
+    "text-to-image",
+    "text-to-video",
+    "image-to-video",
+    "text-to-voice",
+  ];
+  return typeof value === "string" && validTypes.includes(value as ModelType);
+}
+
+/**
+ * Check if error is a FalErrorType
+ */
+export function isFalErrorType(value: unknown): value is FalErrorType {
+  const validTypes: ReadonlyArray<FalErrorType> = [
+    FalErrorType.NETWORK,
+    FalErrorType.TIMEOUT,
+    FalErrorType.API_ERROR,
+    FalErrorType.VALIDATION,
+    FalErrorType.IMAGE_TOO_SMALL,
+    FalErrorType.CONTENT_POLICY,
+    FalErrorType.RATE_LIMIT,
+    FalErrorType.AUTHENTICATION,
+    FalErrorType.QUOTA_EXCEEDED,
+    FalErrorType.MODEL_NOT_FOUND,
+    FalErrorType.UNKNOWN,
+  ];
+  return typeof value === "string" && validTypes.includes(value as FalErrorType);
+}

package/src/infrastructure/utils/type-guards/validation-guards.util.ts

@@ -0,0 +1,80 @@
+/**
+ * Validation Guards
+ * Runtime validation for values and formats
+ */
+
+import {
+  MIN_BASE64_IMAGE_LENGTH,
+  MIN_MODEL_ID_LENGTH,
+  MAX_PROMPT_LENGTH,
+  MAX_TIMEOUT_MS,
+  MAX_RETRY_COUNT,
+} from './constants';
+
+/**
+ * Validate base64 image string
+ */
+export function isValidBase64Image(value: unknown): boolean {
+  if (typeof value !== "string") {
+    return false;
+  }
+
+  // Check data URI prefix
+  if (value.startsWith("data:image/")) {
+    const base64Part = value.split("base64,")[1];
+    if (!base64Part) return false;
+    return base64Part.length >= MIN_BASE64_IMAGE_LENGTH;
+  }
+
+  // Check if it's a valid base64 string with minimum length
+  const base64Pattern = /^[A-Za-z0-9+/]+=*$/;
+  return base64Pattern.test(value) && value.length >= MIN_BASE64_IMAGE_LENGTH;
+}
+
+/**
+ * Validate API key format
+ */
+export function isValidApiKey(value: unknown): boolean {
+  return typeof value === "string" && value.length > 0;
+}
+
+/**
+ * Validate model ID format
+ */
+const MODEL_ID_PATTERN = /^[a-zA-Z0-9-_]+\/[a-zA-Z0-9-_.]+(\/[a-zA-Z0-9-_.]+)?$/;
+
+export function isValidModelId(value: unknown): boolean {
+  if (typeof value !== "string") {
+    return false;
+  }
+
+  return MODEL_ID_PATTERN.test(value) && value.length >= MIN_MODEL_ID_LENGTH;
+}
+
+/**
+ * Validate prompt string
+ */
+export function isValidPrompt(value: unknown): boolean {
+  return typeof value === "string" && value.trim().length > 0 && value.length <= MAX_PROMPT_LENGTH;
+}
+
+/**
+ * Validate timeout value
+ */
+export function isValidTimeout(value: unknown): boolean {
+  return typeof value === "number" && !isNaN(value) && isFinite(value) && value > 0 && value <= MAX_TIMEOUT_MS;
+}
+
+/**
+ * Validate retry count
+ */
+export function isValidRetryCount(value: unknown): boolean {
+  return (
+    typeof value === "number" &&
+    !isNaN(value) &&
+    isFinite(value) &&
+    Number.isInteger(value) &&
+    value >= 0 &&
+    value <= MAX_RETRY_COUNT
+  );
+}

package/src/infrastructure/utils/type-guards.util.ts

@@ -1,119 +1,9 @@
 /**
  * Type Guards and Validation Utilities
- * Runtime type checking and validation helpers
+ * @deprecated This file is now split into smaller modules for better maintainability.
+ * Import from './type-guards' submodules instead.
+ *
+ * This file re-exports all functions for backward compatibility.
  */
 
-import type { FalModelType } from "../../domain/entities/fal.types";
-import type { ModelType } from "../../domain/types/model-selection.types";
-import { FalErrorType } from "../../domain/entities/error.types";
-
-/**
- * Check if a string is a valid FalModelType
- */
-export function isFalModelType(value: unknown): value is FalModelType {
-  const validTypes: ReadonlyArray<FalModelType> = [
-    "text-to-image",
-    "text-to-video",
-    "text-to-voice",
-    "image-to-video",
-    "image-to-image",
-    "text-to-text",
-  ];
-  return typeof value === "string" && validTypes.includes(value as FalModelType);
-}
-
-/**
- * Check if a string is a valid ModelType
- */
-export function isModelType(value: unknown): value is ModelType {
-  const validTypes: ReadonlyArray<ModelType> = [
-    "text-to-image",
-    "text-to-video",
-    "image-to-video",
-    "text-to-voice",
-  ];
-  return typeof value === "string" && validTypes.includes(value as ModelType);
-}
-
-/**
- * Check if error is a FalErrorType
- */
-export function isFalErrorType(value: unknown): value is FalErrorType {
-  const validTypes: ReadonlyArray<FalErrorType> = [
-    FalErrorType.NETWORK,
-    FalErrorType.TIMEOUT,
-    FalErrorType.API_ERROR,
-    FalErrorType.VALIDATION,
-    FalErrorType.IMAGE_TOO_SMALL,
-    FalErrorType.CONTENT_POLICY,
-    FalErrorType.RATE_LIMIT,
-    FalErrorType.AUTHENTICATION,
-    FalErrorType.QUOTA_EXCEEDED,
-    FalErrorType.MODEL_NOT_FOUND,
-    FalErrorType.UNKNOWN,
-  ];
-  return typeof value === "string" && validTypes.includes(value as FalErrorType);
-}
-
-/**
- * Validate base64 image string
- */
-export function isValidBase64Image(value: unknown): boolean {
-  if (typeof value !== "string") {
-    return false;
-  }
-
-  // Check data URI prefix
-  if (value.startsWith("data:image/")) {
-    const base64Part = value.split("base64,")[1];
-    if (!base64Part) return false;
-    // Base64 should be at least 100 chars (meaningful image data)
-    return base64Part.length >= 100;
-  }
-
-  // Check if it's a valid base64 string with minimum length
-  const base64Pattern = /^[A-Za-z0-9+/]+=*$/;
-  // Minimum 100 characters for meaningful base64 image data
-  return base64Pattern.test(value) && value.length >= 100;
-}
-
-/**
- * Validate API key format
- */
-export function isValidApiKey(value: unknown): boolean {
-  return typeof value === "string" && value.length > 0;
-}
-
-/**
- * Validate model ID format
- */
-const MODEL_ID_PATTERN = /^[a-zA-Z0-9-_]+\/[a-zA-Z0-9-_.]+(\/[a-zA-Z0-9-_.]+)?$/;
-
-export function isValidModelId(value: unknown): boolean {
-  if (typeof value !== "string") {
-    return false;
-  }
-
-  return MODEL_ID_PATTERN.test(value) && value.length >= 3;
-}
-
-/**
- * Validate prompt string
- */
-export function isValidPrompt(value: unknown): boolean {
-  return typeof value === "string" && value.trim().length > 0 && value.length <= 5000;
-}
-
-/**
- * Validate timeout value
- */
-export function isValidTimeout(value: unknown): boolean {
-  return typeof value === "number" && !isNaN(value) && isFinite(value) && value > 0 && value <= 600000; // Max 10 minutes
-}
-
-/**
- * Validate retry count
- */
-export function isValidRetryCount(value: unknown): boolean {
-  return typeof value === "number" && !isNaN(value) && isFinite(value) && Number.isInteger(value) && value >= 0 && value <= 10;
-}
+export * from './type-guards';

package/src/presentation/hooks/use-fal-generation.ts

@@ -60,18 +60,29 @@ export function useFalGeneration<T = unknown>(
   }, [options]);
 
   useEffect(() => {
-    stateManagerRef.current = new FalGenerationStateManager<T>({
+    const stateManager = new FalGenerationStateManager<T>({
       onProgress: (status) => {
         optionsRef.current?.onProgress?.(status);
       },
     });
 
-    stateManagerRef.current.setIsMounted(true);
+    stateManager.setIsMounted(true);
+    stateManagerRef.current = stateManager;
 
     return () => {
-      stateManagerRef.current?.setIsMounted(false);
+      // Ensure we have a valid reference before cleanup
+      if (stateManagerRef.current) {
+        stateManagerRef.current.setIsMounted(false);
+        stateManagerRef.current = null;
+      }
+
+      // Cancel any running requests
       if (falProvider.hasRunningRequest()) {
-        falProvider.cancelCurrentRequest();
+        try {
+          falProvider.cancelCurrentRequest();
+        } catch (error) {
+          console.warn('[useFalGeneration] Error cancelling request on unmount:', error);
+        }
       }
     };
   }, []); // Empty deps - only run on mount/unmount

package/src/presentation/hooks/use-models.ts

@@ -35,20 +35,37 @@ export function useModels(props: UseModelsProps): UseModelsReturn {
   const [isLoading, setIsLoading] = useState(true);
   const [error, setError] = useState<string | null>(null);
 
-  const loadModels = useCallback(() => {
+  // Direct effect - no intermediate callback needed
+  useEffect(() => {
     setIsLoading(true);
     setError(null);
 
-    const selectionData = falModelsService.getModelSelectionData(type, config);
-    setModels(selectionData.models);
-    setSelectedModel(selectionData.selectedModel);
+    try {
+      const selectionData = falModelsService.getModelSelectionData(type, config);
+      setModels(selectionData.models);
+      setSelectedModel(selectionData.selectedModel);
+    } catch (err) {
+      setError(err instanceof Error ? err.message : 'Failed to load models');
+    } finally {
+      setIsLoading(false);
+    }
+  }, [type, config]); // Direct dependencies
 
-    setIsLoading(false);
-  }, [type, config]);
+  // Separate refresh callback for manual reloads
+  const loadModels = useCallback(() => {
+    setIsLoading(true);
+    setError(null);
 
-  useEffect(() => {
-    loadModels();
-  }, [loadModels]);
+    try {
+      const selectionData = falModelsService.getModelSelectionData(type, config);
+      setModels(selectionData.models);
+      setSelectedModel(selectionData.selectedModel);
+    } catch (err) {
+      setError(err instanceof Error ? err.message : 'Failed to load models');
+    } finally {
+      setIsLoading(false);
+    }
+  }, [type, config]);
 
   const selectModel = useCallback(
     (modelId: string) => {