@umituz/react-native-ai-generation-content 1.90.9 → 1.90.11

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@umituz/react-native-ai-generation-content",
-  "version": "1.90.9",
+  "version": "1.90.11",
   "description": "Provider-agnostic AI generation orchestration for React Native with result preview components",
   "main": "src/index.ts",
   "types": "src/index.ts",

package/src/domains/content-moderation/infrastructure/services/moderators/image.moderator.ts

@@ -39,10 +39,10 @@ class ImageModerator extends BaseModerator {
     // Use shared URL validation
     const urlValidation = validateUrl(uri);
     if (!urlValidation.isValid) {
-      if (urlValidation.errors.required) {
+      if ('required' in urlValidation.errors) {
         return this.createViolation("empty-uri", "Image Validation", "empty URI");
       }
-      if (urlValidation.errors.pattern) {
+      if ('pattern' in urlValidation.errors) {
         return this.createViolation(
           "invalid-protocol",
           "Image Validation",
@@ -57,7 +57,7 @@ class ImageModerator extends BaseModerator {
     });
 
     if (!lengthValidation.isValid) {
-      if (lengthValidation.errors.maxLength) {
+      if ('maxLength' in lengthValidation.errors) {
         return this.createViolation(
           "uri-too-long",
           "Image Validation",

package/src/domains/content-moderation/infrastructure/services/moderators/text.moderator.ts

@@ -63,7 +63,7 @@ class TextModerator extends BaseModerator {
     });
 
     if (!stringValidation.isValid) {
-      if (stringValidation.errors.maxLength) {
+      if ('maxLength' in stringValidation.errors) {
         return this.createViolation("too-long", "Validation", "length exceeded");
       }
       return this.createViolation("empty-content", "Validation", "empty");

package/src/domains/content-moderation/infrastructure/services/moderators/video.moderator.ts

@@ -39,10 +39,10 @@ class VideoModerator extends BaseModerator {
     // Use shared URL validation
     const urlValidation = validateUrl(uri);
     if (!urlValidation.isValid) {
-      if (urlValidation.errors.required) {
+      if ('required' in urlValidation.errors) {
         return this.createViolation("empty-uri", "Video Validation", "empty URI");
       }
-      if (urlValidation.errors.pattern) {
+      if ('pattern' in urlValidation.errors) {
         return this.createViolation(
           "invalid-protocol",
           "Video Validation",
@@ -57,7 +57,7 @@ class VideoModerator extends BaseModerator {
     });
 
     if (!lengthValidation.isValid) {
-      if (lengthValidation.errors.maxLength) {
+      if ('maxLength' in lengthValidation.errors) {
         return this.createViolation(
           "uri-too-long",
           "Video Validation",

package/src/domains/content-moderation/infrastructure/services/moderators/voice.moderator.ts

@@ -40,7 +40,7 @@ class VoiceModerator extends BaseModerator {
     });
 
     if (!stringValidation.isValid) {
-      if (stringValidation.errors.maxLength) {
+      if ('maxLength' in stringValidation.errors) {
         return this.createViolation(
           "too-long",
           "Voice Validation",

package/src/domains/creations/domain/constants/creation-fields.constants.ts

@@ -53,7 +53,7 @@ export const CREATION_FIELDS = {
 } as const;
 
 /** Union type of all field names */
-type CreationFieldName =
+export type CreationFieldName =
   typeof CREATION_FIELDS[keyof typeof CREATION_FIELDS];
 
 /**

package/src/domains/creations/presentation/hooks/useCreationPersistence.ts

@@ -53,7 +53,8 @@ export function useCreationPersistence(
 
       const validation = runAllValidations(result.imageUrl, result.videoUrl);
       if (!validation.isValid) {
-        await markCreationAsFailed(repository, userId, result.creationId, validation.error!);
+        const firstError = Object.values(validation.errors)[0];
+        await markCreationAsFailed(repository, userId, result.creationId, firstError || "Validation failed");
         return;
       }
 

package/src/domains/image-to-video/presentation/hooks/useImageToVideoFeature.ts

@@ -41,14 +41,14 @@ export function useImageToVideoFeature(props: UseImageToVideoFeatureProps): UseI
   const orchestrator = useGenerationOrchestrator(strategy, {
     userId,
     alertMessages: DEFAULT_ALERT_MESSAGES,
-    onSuccess: (result: unknown) => {
+    onSuccess: async (result: unknown) => {
       const typedResult = result as { success: boolean; videoUrl?: string; thumbnailUrl?: string };
       if (typedResult.success && typedResult.videoUrl) {
         config.onProcessingComplete?.(typedResult);
         callbacks?.onGenerate?.(typedResult);
       }
     },
-    onError: (err) => {
+    onError: async (err) => {
       config.onError?.(err.message);
       callbacks?.onError?.(err.message);
     },

package/src/domains/text-to-image/presentation/hooks/useGeneration.ts

@@ -72,7 +72,7 @@ export function useGeneration(options: UseGenerationOptions): UseGenerationRetur
   const { generate, isGenerating, error } = useGenerationOrchestrator(strategy, {
     userId: userId ?? undefined,
     alertMessages: DEFAULT_ALERT_MESSAGES,
-    onSuccess: (result) => {
+    onSuccess: async (result) => {
       const imageUrls = result as string[];
       if (typeof __DEV__ !== "undefined" && __DEV__) {
         console.log("[TextToImage] Success! Generated", imageUrls.length, "image(s)");
@@ -80,7 +80,7 @@ export function useGeneration(options: UseGenerationOptions): UseGenerationRetur
       callbacks.onSuccess?.(imageUrls);
       onPromptCleared?.();
     },
-    onError: (err) => {
+    onError: async (err) => {
       if (typeof __DEV__ !== "undefined" && __DEV__) {
         console.log("[TextToImage] Error:", err.message);
       }

package/src/domains/text-to-video/presentation/hooks/useTextToVideoFeature.ts

@@ -71,8 +71,8 @@ export function useTextToVideoFeature(props: UseTextToVideoFeatureProps): UseTex
   const orchestrator = useGenerationOrchestrator(strategy, {
     userId,
     alertMessages: DEFAULT_ALERT_MESSAGES,
-    onSuccess: (result) => callbacks.onGenerate?.(result as TextToVideoResult),
-    onError: (err) => callbacks.onError?.(err.message),
+    onSuccess: async (result) => callbacks.onGenerate?.(result as TextToVideoResult),
+    onError: async (err) => callbacks.onError?.(err.message),
   });
 
   const setPrompt = useCallback((prompt: string) => {

package/src/infrastructure/validation/advanced-validator.ts

@@ -3,9 +3,8 @@
  * Complex validators for objects, arrays, and combined validations
  */
 
-import type { ValidationResult } from "./base-validator";
-import { validateString } from "./base-validator";
-import type { StringValidationOptions } from "./base-validator";
+import type { ValidationResult, StringValidationOptions } from "../../shared-kernel/infrastructure/validation";
+import { validateString } from "../../shared-kernel/infrastructure/validation";
 
 /**
  * Validates object structure
@@ -14,19 +13,19 @@ export function validateObject(
   input: unknown,
   requiredFields: readonly string[] = []
 ): ValidationResult {
-  const errors: string[] = [];
+  const errors: Record<string, string> = {};
 
   if (typeof input !== "object" || input === null) {
-    return { isValid: false, errors: ["Input must be an object"] };
+    return { isValid: false, errors: { input: "Input must be an object" } };
   }
 
   for (const field of requiredFields) {
     if (!(field in input)) {
-      errors.push(`Missing required field: ${field}`);
+      errors[field] = `Missing required field: ${field}`;
     }
   }
 
-  return { isValid: errors.length === 0, errors };
+  return { isValid: Object.keys(errors).length === 0, errors };
 }
 
 /**
@@ -40,18 +39,18 @@ export function validateArray(
     readonly itemType?: "string" | "number" | "object";
   } = {}
 ): ValidationResult {
-  const errors: string[] = [];
+  const errors: Record<string, string> = {};
 
   if (!Array.isArray(input)) {
-    return { isValid: false, errors: ["Input must be an array"] };
+    return { isValid: false, errors: { input: "Input must be an array" } };
   }
 
   if (options.minLength !== undefined && input.length < options.minLength) {
-    errors.push(`Array must have at least ${options.minLength} items`);
+    errors.minLength = `Array must have at least ${options.minLength} items`;
   }
 
   if (options.maxLength !== undefined && input.length > options.maxLength) {
-    errors.push(`Array must have at most ${options.maxLength} items`);
+    errors.maxLength = `Array must have at most ${options.maxLength} items`;
   }
 
   if (options.itemType) {
@@ -65,22 +64,28 @@ export function validateArray(
           : typeof item === "object" && item !== null;
 
       if (!isValidType) {
-        errors.push(`Item at index ${i} is not a ${options.itemType}`);
+        errors[`item_${i}`] = `Item at index ${i} is not a ${options.itemType}`;
       }
     }
   }
 
-  return { isValid: errors.length === 0, errors };
+  return { isValid: Object.keys(errors).length === 0, errors };
 }
 
 /**
  * Combines multiple validation results
  */
 export function combineValidationResults(
-  results: readonly ValidationResult[]
+  ...results: ValidationResult[]
 ): ValidationResult {
-  const allErrors = results.flatMap((r) => r.errors);
-  return { isValid: allErrors.length === 0, errors: allErrors };
+  const allErrors = results.reduce((acc, result) => {
+    return { ...acc, ...result.errors };
+  }, {} as Record<string, string>);
+
+  return {
+    isValid: Object.keys(allErrors).length === 0,
+    errors: allErrors,
+  };
 }
 
 /**

package/src/infrastructure/validation/base-validator.ts

@@ -3,89 +3,31 @@
  * Core validation functions for strings, numbers, URLs, emails, and base64
  */
 
-import type { ValidationResult, StringValidationOptions, NumericValidationOptions } from "./base-validator.types";
+import type { ValidationResult, StringValidationOptions, NumberValidationOptions } from "../../shared-kernel/infrastructure/validation";
+import { validateString, validateNumber } from "../../shared-kernel/infrastructure/validation";
 
 // Re-export types for convenience
-export type { ValidationResult, StringValidationOptions, NumericValidationOptions };
+export type { ValidationResult, StringValidationOptions, NumberValidationOptions } from "../../shared-kernel/infrastructure/validation";
 
-/**
- * Validates a string input against provided rules
- */
-export function validateString(
-  input: unknown,
-  options: StringValidationOptions = {}
-): ValidationResult {
-  const errors: string[] = [];
-
-  if (typeof input !== "string") {
-    return { isValid: false, errors: ["Input must be a string"] };
-  }
-
-  const value = options.trim !== false ? input.trim() : input;
-
-  if (options.minLength !== undefined && value.length < options.minLength) {
-    errors.push(`Input must be at least ${options.minLength} characters`);
-  }
-
-  if (options.maxLength !== undefined && value.length > options.maxLength) {
-    errors.push(`Input must be at most ${options.maxLength} characters`);
-  }
-
-  if (options.pattern && !options.pattern.test(value)) {
-    errors.push("Input format is invalid");
-  }
-
-  if (options.allowedCharacters && !options.allowedCharacters.test(value)) {
-    errors.push("Input contains invalid characters");
-  }
-
-  return { isValid: errors.length === 0, errors };
-}
-
-/**
- * Validates a numeric input
- */
-export function validateNumber(
-  input: unknown,
-  options: NumericValidationOptions = {}
-): ValidationResult {
-  const errors: string[] = [];
-
-  if (typeof input !== "number" || isNaN(input)) {
-    return { isValid: false, errors: ["Input must be a number"] };
-  }
-
-  if (options.integer && !Number.isInteger(input)) {
-    errors.push("Input must be an integer");
-  }
-
-  if (options.min !== undefined && input < options.min) {
-    errors.push(`Input must be at least ${options.min}`);
-  }
-
-  if (options.max !== undefined && input > options.max) {
-    errors.push(`Input must be at most ${options.max}`);
-  }
-
-  return { isValid: errors.length === 0, errors };
-}
+// Re-export validation functions for convenience
+export { validateString, validateNumber };
 
 /**
  * Validates URL format
  */
 export function validateURL(input: unknown): ValidationResult {
   if (typeof input !== "string") {
-    return { isValid: false, errors: ["URL must be a string"] };
+    return { isValid: false, errors: { type: "URL must be a string" } };
   }
 
   try {
     const url = new URL(input) as URL & { protocol: string };
     if (!["http:", "https:"].includes(url.protocol)) {
-      return { isValid: false, errors: ["Only HTTP and HTTPS protocols are allowed"] };
+      return { isValid: false, errors: { protocol: "Only HTTP and HTTPS protocols are allowed" } };
     }
-    return { isValid: true, errors: [] };
+    return { isValid: true, errors: {} };
   } catch {
-    return { isValid: false, errors: ["Invalid URL format"] };
+    return { isValid: false, errors: { format: "Invalid URL format" } };
   }
 }
 
@@ -94,15 +36,15 @@ export function validateURL(input: unknown): ValidationResult {
  */
 export function validateEmail(input: unknown): ValidationResult {
   if (typeof input !== "string") {
-    return { isValid: false, errors: ["Email must be a string"] };
+    return { isValid: false, errors: { type: "Email must be a string" } };
   }
 
   const emailRegex = /^[^\s@]+@[^\s@]+\.[^\s@]+$/;
   if (!emailRegex.test(input)) {
-    return { isValid: false, errors: ["Invalid email format"] };
+    return { isValid: false, errors: { format: "Invalid email format" } };
   }
 
-  return { isValid: true, errors: [] };
+  return { isValid: true, errors: {} };
 }
 
 /**
@@ -110,21 +52,21 @@ export function validateEmail(input: unknown): ValidationResult {
  */
 export function validateBase64(input: unknown): ValidationResult {
   if (typeof input !== "string") {
-    return { isValid: false, errors: ["Input must be a string"] };
+    return { isValid: false, errors: { type: "Input must be a string" } };
   }
 
   if (input.length === 0) {
-    return { isValid: false, errors: ["Base64 string cannot be empty"] };
+    return { isValid: false, errors: { length: "Base64 string cannot be empty" } };
   }
 
   const base64Regex = /^[A-Za-z0-9+/]*={0,2}$/;
   if (!base64Regex.test(input)) {
-    return { isValid: false, errors: ["Invalid base64 format"] };
+    return { isValid: false, errors: { format: "Invalid base64 format" } };
   }
 
   if (input.length % 4 !== 0) {
-    return { isValid: false, errors: ["Base64 string length must be a multiple of 4"] };
+    return { isValid: false, errors: { length: "Base64 string length must be a multiple of 4" } };
   }
 
-  return { isValid: true, errors: [] };
+  return { isValid: true, errors: {} };
 }

package/src/shared-kernel/infrastructure/validation/index.ts

@@ -2,18 +2,9 @@
  * Shared Validation Utilities
  */
 
-import type {
-  ValidationResult,
-  StringValidationOptions,
-  NumericValidationOptions,
-} from "../../../infrastructure/validation/base-validator.types";
-
-// Re-export types
-export type {
-  ValidationResult,
-  StringValidationOptions,
-  NumericValidationOptions,
-};
+// Export all from common-validators
+export * from "./common-validators";
+export * from "./common-validators.types";
 
 // Export functions from advanced-validator
 export { combineValidationResults } from "../../../infrastructure/validation/advanced-validator";
@@ -22,37 +13,6 @@ export { combineValidationResults } from "../../../infrastructure/validation/adv
 export { handleError } from "./error-handler";
 export { ErrorType } from "./error-handler.types";
 
-/**
- * Validate a string is not empty
- */
-export function validateString(value: string): ValidationResult {
-  if (typeof value !== 'string') {
-    return { isValid: false, errors: ['Value must be a string'] };
-  }
-
-  if (value.trim().length === 0) {
-    return { isValid: false, errors: ['String cannot be empty'] };
-  }
-
-  return { isValid: true, errors: [] };
-}
-
-/**
- * Validate URL format
- */
-export function validateUrl(url: string): ValidationResult {
-  if (typeof url !== 'string') {
-    return { isValid: false, errors: ['URL must be a string'] };
-  }
-
-  try {
-    new URL(url);
-    return { isValid: true, errors: [] };
-  } catch {
-    return { isValid: false, errors: ['Invalid URL format'] };
-  }
-}
-
 /**
  * Validate required fields in an object
  */