@umituz/react-native-ai-generation-content 1.90.1 → 1.90.3

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@umituz/react-native-ai-generation-content",
-  "version": "1.90.1",
+  "version": "1.90.3",
   "description": "Provider-agnostic AI generation orchestration for React Native with result preview components",
   "main": "src/index.ts",
   "types": "src/index.ts",
@@ -69,9 +69,6 @@
     "@gorhom/bottom-sheet": "^5.2.8",
     "@react-native-async-storage/async-storage": "^2.2.0",
     "@react-native-community/slider": "^5.1.1",
-    "@react-navigation/bottom-tabs": "^7.9.0",
-    "@react-navigation/native": "^7.1.26",
-    "@react-navigation/stack": "^7.6.13",
     "@tanstack/query-async-storage-persister": "^5.66.7",
     "@tanstack/react-query": "^5.66.7",
     "@tanstack/react-query-persist-client": "^5.66.7",

package/src/domain/interfaces/app-services-auth.interface.ts

@@ -0,0 +1,27 @@
+/**
+ * App Services - Auth Interface
+ * Authentication service interface
+ */
+
+/**
+ * Auth service interface
+ * Handles user authentication
+ */
+export interface IAuthService {
+  /**
+   * Get current user ID
+   * @returns User ID or null if not authenticated
+   */
+  getUserId: () => string | null;
+
+  /**
+   * Check if user is authenticated
+   */
+  isAuthenticated: () => boolean;
+
+  /**
+   * Require authenticated user - throws if not authenticated
+   * @returns User ID
+   */
+  requireAuth: () => string;
+}

package/src/domain/interfaces/app-services-composite.interface.ts

@@ -0,0 +1,29 @@
+/**
+ * App Services - Composite Interface
+ * Combined app services interface
+ */
+
+import type { INetworkService } from "./app-services.interface";
+import type { ICreditService } from "./app-services.interface";
+import type { IPaywallService } from "./app-services.interface";
+import type { IAuthService } from "./app-services-auth.interface";
+import type { IAnalyticsService } from "./app-services-optional.interface";
+import type { IFeatureUtils } from "./app-services-optional.interface";
+
+/**
+ * Combined app services interface
+ * Apps implement this to provide all required services
+ */
+export interface IAppServices {
+  readonly network: INetworkService;
+  readonly credits: ICreditService;
+  readonly paywall: IPaywallService;
+  readonly auth: IAuthService;
+  readonly analytics?: IAnalyticsService;
+  readonly featureUtils?: IFeatureUtils;
+}
+
+/**
+ * Partial app services for optional configuration
+ */
+export type PartialAppServices = Partial<IAppServices>;

package/src/domain/interfaces/app-services-optional.interface.ts

@@ -0,0 +1,42 @@
+/**
+ * App Services - Optional Interfaces
+ * Optional service interfaces (analytics, feature utils)
+ */
+
+/**
+ * Analytics event data
+ */
+interface AnalyticsEventData {
+  readonly [key: string]: string | number | boolean | null | undefined;
+}
+
+/**
+ * Analytics service interface (optional)
+ * Tracks events for analytics
+ */
+export interface IAnalyticsService {
+  /**
+   * Track an event
+   * @param event - Event name
+   * @param data - Event data
+   */
+  track: (event: string, data: AnalyticsEventData) => void;
+}
+
+/**
+ * Feature utils interface (optional)
+ * Provides utility functions for AI features
+ */
+export interface IFeatureUtils {
+  /**
+   * Select image from gallery
+   * @returns Image URI or null if cancelled
+   */
+  selectImage: () => Promise<string | null>;
+
+  /**
+   * Save video to device library
+   * @param uri - Video URI to save
+   */
+  saveVideo: (uri: string) => Promise<void>;
+}

package/src/domain/interfaces/app-services.interface.ts

@@ -78,82 +78,3 @@ export interface IPaywallService {
    */
   showPaywall: (requiredCredits: number) => void;
 }
-
-/**
- * Auth service interface
- * Handles user authentication
- */
-export interface IAuthService {
-  /**
-   * Get current user ID
-   * @returns User ID or null if not authenticated
-   */
-  getUserId: () => string | null;
-
-  /**
-   * Check if user is authenticated
-   */
-  isAuthenticated: () => boolean;
-
-  /**
-   * Require authenticated user - throws if not authenticated
-   * @returns User ID
-   */
-  requireAuth: () => string;
-}
-
-/**
- * Analytics event data
- */
-interface AnalyticsEventData {
-  readonly [key: string]: string | number | boolean | null | undefined;
-}
-
-/**
- * Analytics service interface (optional)
- * Tracks events for analytics
- */
-export interface IAnalyticsService {
-  /**
-   * Track an event
-   * @param event - Event name
-   * @param data - Event data
-   */
-  track: (event: string, data: AnalyticsEventData) => void;
-}
-
-/**
- * Feature utils interface (optional)
- * Provides utility functions for AI features
- */
-export interface IFeatureUtils {
-  /**
-   * Select image from gallery
-   * @returns Image URI or null if cancelled
-   */
-  selectImage: () => Promise<string | null>;
-
-  /**
-   * Save video to device library
-   * @param uri - Video URI to save
-   */
-  saveVideo: (uri: string) => Promise<void>;
-}
-
-/**
- * Combined app services interface
- * Apps implement this to provide all required services
- */
-export interface IAppServices {
-  readonly network: INetworkService;
-  readonly credits: ICreditService;
-  readonly paywall: IPaywallService;
-  readonly auth: IAuthService;
-  readonly analytics?: IAnalyticsService;
-  readonly featureUtils?: IFeatureUtils;
-}
-
-/**
- * Partial app services for optional configuration
- */
-export type PartialAppServices = Partial<IAppServices>;

package/src/domains/background/infrastructure/services/job-poller-index.ts

@@ -0,0 +1,7 @@
+/**
+ * Job Poller Service
+ * Provider-agnostic job polling with exponential backoff
+ */
+
+export { pollJob } from "./job-poller.service";
+export type { PollJobOptions, PollJobResult } from "./job-poller.service";

package/src/domains/background/infrastructure/services/job-poller-utils.ts

@@ -0,0 +1,130 @@
+/**
+ * Job Poller Service - Utility Functions
+ */
+
+import { checkStatusForErrors, isJobComplete } from "../utils/status-checker.util";
+import { validateResult } from "../utils/result-validator.util";
+
+/**
+ * Wrap a promise with abort signal support
+ * Rejects if signal is aborted before promise resolves
+ */
+export function withAbortSignal<T>(
+  promise: Promise<T>,
+  signal: AbortSignal | undefined,
+  timeoutMs?: number,
+): Promise<T> {
+  if (!signal && !timeoutMs) {
+    return promise;
+  }
+
+  return new Promise<T>((resolve, reject) => {
+    // Handle abort signal
+    if (signal?.aborted) {
+      reject(new Error("Operation aborted"));
+      return;
+    }
+
+    let isResolved = false;
+    const abortHandler = () => {
+      if (isResolved) return;
+      isResolved = true;
+      if (timeoutId) clearTimeout(timeoutId);
+      reject(new Error("Operation aborted"));
+    };
+
+    signal?.addEventListener("abort", abortHandler, { once: true });
+
+    // Handle timeout
+    let timeoutId: ReturnType<typeof setTimeout> | undefined;
+    if (timeoutMs) {
+      timeoutId = setTimeout(() => {
+        if (isResolved) return;
+        isResolved = true;
+        signal?.removeEventListener("abort", abortHandler);
+        reject(new Error(`Operation timeout after ${timeoutMs}ms`));
+      }, timeoutMs);
+    }
+
+    promise
+      .then((result) => {
+        if (isResolved) return;
+        isResolved = true;
+        signal?.removeEventListener("abort", abortHandler);
+        if (timeoutId) clearTimeout(timeoutId);
+        resolve(result);
+      })
+      .catch((error) => {
+        if (isResolved) return;
+        isResolved = true;
+        signal?.removeEventListener("abort", abortHandler);
+        if (timeoutId) clearTimeout(timeoutId);
+        reject(error);
+      });
+  });
+}
+
+/**
+ * Validate request ID
+ */
+export function validateRequestId(requestId: string | undefined): { valid: boolean; error?: string } {
+  if (!requestId || typeof requestId !== "string" || requestId.trim() === "") {
+    return {
+      valid: false,
+      error: "Invalid requestId provided",
+    };
+  }
+  return { valid: true };
+}
+
+/**
+ * Validate model
+ */
+export function validateModel(model: string | undefined): { valid: boolean; error?: string } {
+  if (!model || typeof model !== "string" || model.trim() === "") {
+    return {
+      valid: false,
+      error: "Invalid model provided",
+    };
+  }
+  return { valid: true };
+}
+
+/**
+ * Log transient error during polling
+ */
+export function logTransientError(
+  attempt: number,
+  requestId: string,
+  model: string,
+  consecutiveErrors: number,
+  error: unknown
+): void {
+  if (__DEV__) {
+    console.warn("[JobPoller] Transient error during polling", {
+      attempt: attempt + 1,
+      requestId,
+      model,
+      consecutiveErrors,
+      error: error instanceof Error ? error.message : String(error),
+      code: (error as { code?: string })?.code,
+    });
+  }
+}
+
+/**
+ * Log max consecutive errors reached
+ */
+export function logMaxConsecutiveErrors(
+  maxConsecutiveErrors: number,
+  requestId: string,
+  model: string
+): void {
+  if (__DEV__) {
+    console.error("[JobPoller] Max consecutive errors reached", {
+      maxConsecutiveErrors,
+      requestId,
+      model,
+    });
+  }
+}

package/src/domains/background/infrastructure/utils/polling-interval.util.ts

@@ -4,7 +4,7 @@
  */
 
 import type { PollingConfig } from "../../../../domain/entities/polling.types";
-import { calculatePollingInterval as calculateInterval } from "../../../../shared/utils/calculations.util";
+import { calculatePollingInterval as calculateInterval } from "../../../../shared/utils/calculations";
 
 export interface IntervalOptions {
   attempt: number;

package/src/domains/background/presentation/hooks/use-background-generation.ts

@@ -2,7 +2,7 @@ import { useCallback, useRef, useState, useMemo } from "react";
 import { usePendingJobs } from "./use-pending-jobs";
 import { executeDirectGeneration, executeQueuedJob } from "../../infrastructure/executors/backgroundJobExecutor";
 import { DEFAULT_QUEUE_CONFIG } from "../../domain/entities/job.types";
-import { calculateFilteredCount } from "../../../../shared/utils/calculations.util";
+import { calculateFilteredCount } from "../../../../shared/utils/calculations";
 import type {
   UseBackgroundGenerationOptions,
   UseBackgroundGenerationReturn,

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/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,
+];