@umituz/react-native-ai-generation-content 1.90.2 → 1.90.4

package/src/domains/content-moderation/index.ts

@@ -38,19 +38,13 @@ export type {
 // INFRASTRUCTURE LAYER - Services
 // =============================================================================
 
-export {
-  contentModerationService,
-  patternMatcherService,
-  textModerator,
-  imageModerator,
-  videoModerator,
-  voiceModerator,
-  BaseModerator,
-} from "./infrastructure/services";
-
-export type {
-  PatternMatch,
-} from "./infrastructure/services";
+export { contentModerationService } from "./infrastructure/services/content-moderation.service";
+export { patternMatcherService, type PatternMatch } from "./infrastructure/services/pattern-matcher.service";
+export { textModerator } from "./infrastructure/services/moderators/text.moderator";
+export { imageModerator } from "./infrastructure/services/moderators/image.moderator";
+export { videoModerator } from "./infrastructure/services/moderators/video.moderator";
+export { voiceModerator } from "./infrastructure/services/moderators/voice.moderator";
+export { BaseModerator } from "./infrastructure/services/moderators/base.moderator";
 
 // =============================================================================
 // INFRASTRUCTURE LAYER - Rules

package/src/domains/content-moderation/infrastructure/services/content-moderation.service.ts

@@ -17,7 +17,7 @@ import { imageModerator } from "./moderators/image.moderator";
 import { videoModerator } from "./moderators/video.moderator";
 import { voiceModerator } from "./moderators/voice.moderator";
 import { rulesRegistry } from "../rules/rules-registry";
-import { calculateConfidenceScore } from "../../../../shared/utils/calculations.util";
+import { calculateConfidenceScore } from "../../../../shared/utils/calculations";
 
 
 interface ServiceConfig {

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

@@ -1,11 +1,12 @@
 /**
  * Image Content Moderator
- * Validates and moderates image URIs
+ * Validates and moderates image URIs using shared validation utilities
  */
 
 import type { Violation } from "../../../domain/entities/moderation.types";
 import { BaseModerator, type ModerationResult } from "./base.moderator";
 import { DEFAULT_PROTOCOLS, DEFAULT_MAX_URI_LENGTH } from "../../constants/moderation.constants";
+import { validateUrl, validateString, validateRequiredFields } from "../../../../../shared-kernel/infrastructure/validation";
 
 class ImageModerator extends BaseModerator {
   private allowedProtocols: readonly string[] = DEFAULT_PROTOCOLS;
@@ -29,18 +30,43 @@ class ImageModerator extends BaseModerator {
   }
 
   private validate(uri: string): Violation | null {
-    if (!uri || typeof uri !== "string") {
+    // Use shared validation utilities
+    const requiredValidation = validateRequiredFields({ uri }, ['uri']);
+    if (!requiredValidation.isValid) {
       return this.createViolation("empty-uri", "Image Validation", "empty URI");
     }
 
-    if (uri.length > this.maxUriLength) {
-      return this.createViolation(
-        "uri-too-long",
-        "Image Validation",
-        "URI too long"
-      );
+    // Use shared URL validation
+    const urlValidation = validateUrl(uri);
+    if (!urlValidation.isValid) {
+      if (urlValidation.errors.required) {
+        return this.createViolation("empty-uri", "Image Validation", "empty URI");
+      }
+      if (urlValidation.errors.pattern) {
+        return this.createViolation(
+          "invalid-protocol",
+          "Image Validation",
+          "invalid protocol"
+        );
+      }
+    }
+
+    // Use shared string validation for length
+    const lengthValidation = validateString(uri, {
+      maxLength: this.maxUriLength,
+    });
+
+    if (!lengthValidation.isValid) {
+      if (lengthValidation.errors.maxLength) {
+        return this.createViolation(
+          "uri-too-long",
+          "Image Validation",
+          "URI too long"
+        );
+      }
     }
 
+    // Custom protocol check
     if (!this.hasValidProtocol(uri)) {
       return this.createViolation(
         "invalid-protocol",

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

@@ -1,6 +1,6 @@
 /**
  * Text Content Moderator
- * Validates and moderates text content
+ * Validates and moderates text content using shared validation utilities
  */
 
 import type { Violation } from "../../../domain/entities/moderation.types";
@@ -10,6 +10,7 @@ import { BaseModerator, type ModerationResult } from "./base.moderator";
 import { DEFAULT_MAX_TEXT_LENGTH } from "../../constants/moderation.constants";
 import { containsMaliciousPatterns } from "../../utils/content-security.util";
 import { containsPromptInjection } from "../../utils/prompt-injection.util";
+import { validateString, validateRequiredFields } from "../../../../../shared-kernel/infrastructure/validation";
 
 
 class TextModerator extends BaseModerator {
@@ -50,12 +51,22 @@ class TextModerator extends BaseModerator {
   }
 
   private validate(content: string): Violation | null {
-    if (!content || typeof content !== "string") {
+    // Use shared validation utilities
+    const requiredValidation = validateRequiredFields({ content }, ['content']);
+    if (!requiredValidation.isValid) {
       return this.createViolation("empty-content", "Validation", "empty");
     }
 
-    if (content.length > this.maxLength) {
-      return this.createViolation("too-long", "Validation", "length exceeded");
+    const stringValidation = validateString(content, {
+      required: true,
+      maxLength: this.maxLength,
+    });
+
+    if (!stringValidation.isValid) {
+      if (stringValidation.errors.maxLength) {
+        return this.createViolation("too-long", "Validation", "length exceeded");
+      }
+      return this.createViolation("empty-content", "Validation", "empty");
     }
 
     if (this.containsMaliciousCode(content)) {

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

@@ -1,11 +1,12 @@
 /**
  * Video Content Moderator
- * Validates and moderates video URIs
+ * Validates and moderates video URIs using shared validation utilities
  */
 
 import type { Violation } from "../../../domain/entities/moderation.types";
 import { BaseModerator, type ModerationResult } from "./base.moderator";
 import { VIDEO_PROTOCOLS, DEFAULT_MAX_URI_LENGTH } from "../../constants/moderation.constants";
+import { validateUrl, validateString, validateRequiredFields } from "../../../../../shared-kernel/infrastructure/validation";
 
 class VideoModerator extends BaseModerator {
   private allowedProtocols: readonly string[] = VIDEO_PROTOCOLS;
@@ -29,18 +30,43 @@ class VideoModerator extends BaseModerator {
   }
 
   private validate(uri: string): Violation | null {
-    if (!uri || typeof uri !== "string") {
+    // Use shared validation utilities
+    const requiredValidation = validateRequiredFields({ uri }, ['uri']);
+    if (!requiredValidation.isValid) {
       return this.createViolation("empty-uri", "Video Validation", "empty URI");
     }
 
-    if (uri.length > this.maxUriLength) {
-      return this.createViolation(
-        "uri-too-long",
-        "Video Validation",
-        "URI too long"
-      );
+    // Use shared URL validation
+    const urlValidation = validateUrl(uri);
+    if (!urlValidation.isValid) {
+      if (urlValidation.errors.required) {
+        return this.createViolation("empty-uri", "Video Validation", "empty URI");
+      }
+      if (urlValidation.errors.pattern) {
+        return this.createViolation(
+          "invalid-protocol",
+          "Video Validation",
+          "invalid protocol"
+        );
+      }
+    }
+
+    // Use shared string validation for length
+    const lengthValidation = validateString(uri, {
+      maxLength: this.maxUriLength,
+    });
+
+    if (!lengthValidation.isValid) {
+      if (lengthValidation.errors.maxLength) {
+        return this.createViolation(
+          "uri-too-long",
+          "Video Validation",
+          "URI too long"
+        );
+      }
     }
 
+    // Custom protocol check
     if (!this.hasValidProtocol(uri)) {
       return this.createViolation(
         "invalid-protocol",

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

@@ -1,6 +1,6 @@
 /**
  * Voice Content Moderator
- * Validates and moderates voice/TTS text content
+ * Validates and moderates voice/TTS text content using shared validation utilities
  */
 
 import type { Violation } from "../../../domain/entities/moderation.types";
@@ -8,6 +8,7 @@ import { patternMatcherService } from "../pattern-matcher.service";
 import { rulesRegistry } from "../../rules/rules-registry";
 import { BaseModerator, type ModerationResult } from "./base.moderator";
 import { env } from "../../../../../infrastructure/config/env.config";
+import { validateString, validateRequiredFields } from "../../../../../shared-kernel/infrastructure/validation";
 
 class VoiceModerator extends BaseModerator {
   private maxLength = env.moderationVoiceMaxLength;
@@ -27,16 +28,26 @@ class VoiceModerator extends BaseModerator {
   }
 
   private validate(text: string): Violation | null {
-    if (!text || typeof text !== "string") {
+    // Use shared validation utilities
+    const requiredValidation = validateRequiredFields({ text }, ['text']);
+    if (!requiredValidation.isValid) {
       return this.createViolation("empty-text", "Voice Validation", "empty");
     }
 
-    if (text.length > this.maxLength) {
-      return this.createViolation(
-        "too-long",
-        "Voice Validation",
-        "length exceeded"
-      );
+    const stringValidation = validateString(text, {
+      required: true,
+      maxLength: this.maxLength,
+    });
+
+    if (!stringValidation.isValid) {
+      if (stringValidation.errors.maxLength) {
+        return this.createViolation(
+          "too-long",
+          "Voice Validation",
+          "length exceeded"
+        );
+      }
+      return this.createViolation("empty-text", "Voice Validation", "empty");
     }
 
     return null;

package/src/domains/content-moderation/infrastructure/services/pattern-matcher.service.ts

@@ -113,8 +113,7 @@ class PatternMatcherService {
       const regex = new RegExp(escaped, "gi");
       return regex.test(content);
     } catch {
-      // Fallback to simple includes if regex fails
-      return content.toLowerCase().includes(searchTerm.toLowerCase());
+      return false;
     }
   }
 

package/src/domains/creations/domain/types/creation-categories.constants.ts

@@ -0,0 +1,57 @@
+/**
+ * Creation Categories - Constants
+ * Constants for creation type categories
+ */
+
+import type { CreationTypeId } from "./creation-types";
+
+/**
+ * Image-related creation types
+ */
+export const IMAGE_CREATION_TYPES: CreationTypeId[] = [
+  "text-to-image",
+  "imagine",
+  "wardrobe",
+  "historical-wardrobe",
+  "upscale",
+  "remove-background",
+  "photo-restore",
+  "inpainting",
+  "style-transfer",
+  "colorization",
+  "face-swap",
+  "object-removal",
+  "background-replacement",
+  "ai-brush",
+  "hd-touch-up",
+  "anime-selfie",
+  "aging",
+  "headshot",
+  "retouch",
+  "magic-edit",
+  "color-grading",
+  "art-style",
+  "mood-filter",
+  "face-expression",
+  "scene-composer",
+  "ai-background",
+  "effects",
+];
+
+/**
+ * Video-related creation types (core types only)
+ * NOTE: All other video types (scenarios, etc.)
+ * are dynamically determined by output content via isVideoUrl()
+ */
+export const VIDEO_CREATION_TYPES: CreationTypeId[] = [
+  "text-to-video",
+  "image-to-video",
+];
+
+/**
+ * All creation types
+ */
+export const ALL_CREATION_TYPES: CreationTypeId[] = [
+  ...IMAGE_CREATION_TYPES,
+  ...VIDEO_CREATION_TYPES,
+];

package/src/domains/creations/domain/types/creation-categories.helpers.ts

@@ -0,0 +1,67 @@
+/**
+ * Creation Categories - Helpers
+ * Helper functions for creation type categorization
+ */
+
+import type { CreationTypeId, CreationCategory } from "./creation-types";
+import { IMAGE_CREATION_TYPES, VIDEO_CREATION_TYPES } from "./creation-categories.constants";
+
+/**
+ * Get creation types for a category
+ */
+export function getTypesForCategory(
+  category: CreationCategory
+): CreationTypeId[] {
+  switch (category) {
+    case "image":
+      return IMAGE_CREATION_TYPES;
+    case "video":
+      return VIDEO_CREATION_TYPES;
+    case "all":
+      return [...IMAGE_CREATION_TYPES, ...VIDEO_CREATION_TYPES];
+    default:
+      return [...IMAGE_CREATION_TYPES, ...VIDEO_CREATION_TYPES];
+  }
+}
+
+/**
+ * Get category for a creation type
+ */
+export function getCategoryForType(type: CreationTypeId): CreationCategory {
+  if (IMAGE_CREATION_TYPES.includes(type)) {
+    return "image";
+  }
+  if (VIDEO_CREATION_TYPES.includes(type)) {
+    return "video";
+  }
+  return "image";
+}
+
+/**
+ * Check if a type belongs to a category
+ */
+export function isTypeInCategory(
+  type: CreationTypeId,
+  category: CreationCategory
+): boolean {
+  if (category === "all") {
+    return true;
+  }
+  return getTypesForCategory(category).includes(type);
+}
+
+/**
+ * Check if creation type is video
+ */
+export function isVideoCreationType(type?: string): boolean {
+  if (!type) return false;
+  return VIDEO_CREATION_TYPES.includes(type as CreationTypeId);
+}
+
+/**
+ * Check if creation type is image
+ */
+export function isImageCreationType(type?: string): boolean {
+  if (!type) return false;
+  return IMAGE_CREATION_TYPES.includes(type as CreationTypeId);
+}

package/src/domains/creations/domain/types/creation-categories.ts

@@ -3,89 +3,8 @@
  * Maps creation types to categories for filtering and organization
  */
 
-import type { CreationTypeId, CreationCategory } from "./creation-types";
-
-/**
- * Image-related creation types
- */
-export const IMAGE_CREATION_TYPES: CreationTypeId[] = [
-  "text-to-image",
-  "imagine",
-  "wardrobe",
-  "historical-wardrobe",
-  "upscale",
-  "remove-background",
-  "photo-restore",
-  "inpainting",
-  "style-transfer",
-  "colorization",
-  "face-swap",
-  "object-removal",
-  "background-replacement",
-  "ai-brush",
-  "hd-touch-up",
-  "anime-selfie",
-  "aging",
-  "headshot",
-  "retouch",
-  "magic-edit",
-  "color-grading",
-  "art-style",
-  "mood-filter",
-  "face-expression",
-  "scene-composer",
-  "ai-background",
-  "effects",
-];
-
-/**
- * Video-related creation types (core types only)
- * NOTE: All other video types (scenarios, etc.)
- * are dynamically determined by output content via isVideoUrl()
- */
-export const VIDEO_CREATION_TYPES: CreationTypeId[] = [
-  "text-to-video",
-  "image-to-video",
-];
-
-/**
- * All creation types
- */
-export const ALL_CREATION_TYPES: CreationTypeId[] = [
-  ...IMAGE_CREATION_TYPES,
-  ...VIDEO_CREATION_TYPES,
-];
-
-/**
- * Get creation types for a category
- */
-export function getTypesForCategory(
-  category: CreationCategory
-): CreationTypeId[] {
-  switch (category) {
-    case "image":
-      return IMAGE_CREATION_TYPES;
-    case "video":
-      return VIDEO_CREATION_TYPES;
-    case "all":
-      return ALL_CREATION_TYPES;
-    default:
-      return ALL_CREATION_TYPES;
-  }
-}
-
-/**
- * Get category for a creation type (type-based fallback only)
- */
-export function getCategoryForType(type: CreationTypeId): CreationCategory {
-  if (IMAGE_CREATION_TYPES.includes(type)) {
-    return "image";
-  }
-  if (VIDEO_CREATION_TYPES.includes(type)) {
-    return "video";
-  }
-  return "image"; // Default fallback
-}
+import type { CreationCategory } from "./creation-types";
+import { getCategoryForType } from "./creation-categories.helpers";
 
 /**
  * Get category for a creation based on its output content
@@ -106,7 +25,7 @@ export function getCategoryForCreation(creation: {
   };
   uri?: string;
 }): CreationCategory {
-  // PRIORITY 1: Check output field names (most reliable)
+  // Check output field names
   if (creation.output?.videoUrl) {
     return "video";
   }
@@ -115,40 +34,14 @@ export function getCategoryForCreation(creation: {
     return "image";
   }
 
-  // PRIORITY 2: Fallback to type-based (for known types)
+  // Use type-based categorization
   if (creation.type) {
-    return getCategoryForType(creation.type as CreationTypeId);
+    return getCategoryForType(creation.type as import("./creation-types").CreationTypeId);
   }
 
-  // Final fallback
   return "image";
 }
 
-/**
- * Check if a type belongs to a category
- */
-export function isTypeInCategory(
-  type: CreationTypeId,
-  category: CreationCategory
-): boolean {
-  if (category === "all") {
-    return true;
-  }
-  return getTypesForCategory(category).includes(type);
-}
-
-/**
- * Check if creation type is video
- */
-export function isVideoCreationType(type?: string): boolean {
-  if (!type) return false;
-  return VIDEO_CREATION_TYPES.includes(type as CreationTypeId);
-}
+export { IMAGE_CREATION_TYPES, VIDEO_CREATION_TYPES, ALL_CREATION_TYPES } from "./creation-categories.constants";
+export { getTypesForCategory, getCategoryForType, isTypeInCategory, isVideoCreationType, isImageCreationType } from "./creation-categories.helpers";
 
-/**
- * Check if creation type is image
- */
-export function isImageCreationType(type?: string): boolean {
-  if (!type) return false;
-  return IMAGE_CREATION_TYPES.includes(type as CreationTypeId);
-}

package/src/domains/creations/domain/utils/creation-display.util.ts

@@ -37,7 +37,7 @@ export function getTypeTextKey(type: CreationTypeId): string {
 }
 
 /**
- * Get formatted type text (fallback)
+ * Get formatted type text
  */
 export function getTypeText(type: CreationTypeId): string {
   return type.split("-").map(word =>

package/src/domains/creations/domain/utils/status-helpers.ts

@@ -49,7 +49,7 @@ export function getStatusTextKey(status: CreationStatus): string {
 }
 
 /**
- * Get default status text (fallback)
+ * Get default status text
  */
 export function getStatusText(status: CreationStatus): string {
   switch (status) {

package/src/domains/creations/presentation/hooks/creation-validators.ts

@@ -1,7 +1,7 @@
 /**
  * Creation Validation Utilities
  *
- * Centralized validation logic for creation persistence.
+ * Centralized validation logic for creation persistence using shared kernel.
  * Keeps validation rules separate from hook logic.
  *
  * @module CreationValidators
@@ -13,12 +13,7 @@ import {
   CREATION_FIELDS,
 } from "../../domain/constants";
 import type { ICreationsRepository } from "../../domain/repositories/ICreationsRepository";
-
-
-interface ValidationResult {
-  isValid: boolean;
-  error?: string;
-}
+import { validateUrl, validateString, combineValidationResults, type ValidationResult } from "../../../../shared-kernel/infrastructure/validation";
 
 /**
  * Validates that at least one URL is present
@@ -30,10 +25,10 @@ function validateHasUrl(
   if (!imageUrl && !videoUrl) {
     return {
       isValid: false,
-      error: "No output URL provided",
+      errors: { urls: "No output URL provided" },
     };
   }
-  return { isValid: true };
+  return { isValid: true, errors: {} };
 }
 
 /**
@@ -47,42 +42,49 @@ function validateUriProtocol(uri: string): ValidationResult {
   if (!hasValidProtocol) {
     return {
       isValid: false,
-      error: `Invalid URI protocol. Expected one of: ${CREATION_VALIDATION.VALID_URI_PROTOCOLS.join(", ")}`,
+      errors: {
+        protocol: `Invalid URI protocol. Expected one of: ${CREATION_VALIDATION.VALID_URI_PROTOCOLS.join(", ")}`
+      },
     };
   }
 
-  return { isValid: true };
+  return { isValid: true, errors: {} };
 }
 
 /**
- * Validates URI length
- */
-function validateUriLength(uri: string): ValidationResult {
-  if (uri.length > CREATION_VALIDATION.MAX_URI_LENGTH) {
-    return {
-      isValid: false,
-      error: `URI length (${uri.length}) exceeds maximum (${CREATION_VALIDATION.MAX_URI_LENGTH})`,
-    };
-  }
-
-  return { isValid: true };
-}
-
-/**
- * Runs all validations and returns first error
+ * Runs all validations using shared kernel utilities
  */
 export function runAllValidations(
   imageUrl?: string,
   videoUrl?: string
 ): ValidationResult {
-  const urlCheck = validateHasUrl(imageUrl, videoUrl);
-  if (!urlCheck.isValid) return urlCheck;
+  // Check that at least one URL is present
+  const hasUrlCheck = validateHasUrl(imageUrl, videoUrl);
+  if (!hasUrlCheck.isValid) return hasUrlCheck;
 
   const uri = imageUrl || videoUrl || "";
+
+  // Use shared URL validation
+  const urlValidation = validateUrl(uri);
+  if (!urlValidation.isValid) return urlValidation;
+
+  // Use shared string validation for length
+  const lengthValidation = validateString(uri, {
+    maxLength: CREATION_VALIDATION.MAX_URI_LENGTH,
+  });
+  if (!lengthValidation.isValid) return lengthValidation;
+
+  // Validate protocol
   const protocolCheck = validateUriProtocol(uri);
   if (!protocolCheck.isValid) return protocolCheck;
 
-  return validateUriLength(uri);
+  // Combine all results
+  return combineValidationResults(
+    hasUrlCheck,
+    urlValidation,
+    lengthValidation,
+    protocolCheck
+  );
 }
 
 /**

package/src/domains/creations/presentation/hooks/job-poller-index.ts

@@ -0,0 +1,10 @@
+/**
+ * Processing Jobs Poller Hook
+ * Polls queue status for "processing" creations and updates Firestore when complete
+ */
+
+export { useProcessingJobsPoller } from "./useProcessingJobsPoller";
+export type {
+  UseProcessingJobsPollerConfig,
+  UseProcessingJobsPollerReturn,
+} from "./useProcessingJobsPoller";