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

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 (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
+}
+
+/**
+ * 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
@@ -117,38 +36,13 @@ export function getCategoryForCreation(creation: {
 
   // PRIORITY 2: Fallback to type-based (for known types)
   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/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";

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

@@ -0,0 +1,34 @@
+/**
+ * Processing Jobs Poller - Filters
+ * Filter functions for processing jobs
+ */
+
+import type { Creation } from "../../domain/entities/Creation";
+import { CREATION_STATUS } from "../../../../domain/constants/queue-status.constants";
+
+/**
+ * Filter processing jobs with valid IDs
+ */
+export function getProcessingJobIds(creations: Creation[]): string[] {
+  return creations
+    .filter((c) => c.status === CREATION_STATUS.PROCESSING && c.requestId && c.model)
+    .map((c) => c.id);
+}
+
+/**
+ * Filter processing jobs with valid IDs
+ */
+export function getProcessingJobs(creations: Creation[]): Creation[] {
+  return creations.filter(
+    (c) => c.status === CREATION_STATUS.PROCESSING && c.requestId && c.model,
+  );
+}
+
+/**
+ * Filter orphan jobs (processing but no requestId/model)
+ */
+export function getOrphanJobs(creations: Creation[]): Creation[] {
+  return creations.filter(
+    (c) => c.status === CREATION_STATUS.PROCESSING && !c.requestId && !c.model,
+  );
+}

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

@@ -0,0 +1,76 @@
+/**
+ * Processing Jobs Poller - Logger
+ * Logging utilities for job polling
+ */
+
+/**
+ * Log status check
+ */
+export function logStatusCheck(creationId: string): void {
+  if (typeof __DEV__ !== "undefined" && __DEV__) {
+    console.log("[ProcessingJobsPoller] Checking status:", creationId);
+  }
+}
+
+/**
+ * Log status result
+ */
+export function logStatusResult(creationId: string, status: string): void {
+  if (typeof __DEV__ !== "undefined" && __DEV__) {
+    console.log("[ProcessingJobsPoller] Status:", creationId, status);
+  }
+}
+
+/**
+ * Log completed job
+ */
+export function logJobCompleted(creationId: string, urls: unknown): void {
+  if (typeof __DEV__ !== "undefined" && __DEV__) {
+    console.log("[ProcessingJobsPoller] Completed:", creationId, urls);
+  }
+}
+
+/**
+ * Log no valid URI error
+ */
+export function logNoValidUri(creationId: string): void {
+  if (typeof __DEV__ !== "undefined" && __DEV__) {
+    console.error("[ProcessingJobsPoller] No valid URI in result:", creationId);
+  }
+}
+
+/**
+ * Log failed job
+ */
+export function logJobFailed(creationId: string): void {
+  if (typeof __DEV__ !== "undefined" && __DEV__) {
+    console.log("[ProcessingJobsPoller] Failed:", creationId);
+  }
+}
+
+/**
+ * Log poll error
+ */
+export function logPollError(creationId: string, error: unknown): void {
+  if (typeof __DEV__ !== "undefined" && __DEV__) {
+    console.error("[ProcessingJobsPoller] Poll error:", creationId, error);
+  }
+}
+
+/**
+ * Log orphan job timeout
+ */
+export function logOrphanTimeout(creationId: string): void {
+  if (typeof __DEV__ !== "undefined" && __DEV__) {
+    console.log("[ProcessingJobsPoller] Orphan job timed out, marking as failed:", creationId);
+  }
+}
+
+/**
+ * Log failed to clean up orphans
+ */
+export function logCleanupOrphansFailed(error: unknown): void {
+  if (typeof __DEV__ !== "undefined" && __DEV__) {
+    console.error("[ProcessingJobsPoller] Failed to clean up orphan jobs:", error);
+  }
+}

package/src/domains/creations/presentation/hooks/job-poller-utils.stale-handlers.ts

@@ -0,0 +1,52 @@
+/**
+ * Processing Jobs Poller - Stale Job Handlers
+ * Functions for handling stale jobs
+ */
+
+import type { Creation } from "../../domain/entities/Creation";
+import type { ICreationsRepository } from "../../domain/repositories/ICreationsRepository";
+import { CREATION_STATUS } from "../../../../domain/constants/queue-status.constants";
+import { DEFAULT_MAX_POLL_TIME_MS } from "../../../../infrastructure/constants/polling.constants";
+import { isOlderThan, calculateAgeMs } from "../../../../shared/utils/calculations";
+
+/**
+ * Check if job is stale (older than max poll time)
+ */
+export function isJobStale(creation: Creation): boolean {
+  return isOlderThan(creation.createdAt, DEFAULT_MAX_POLL_TIME_MS);
+}
+
+/**
+ * Log stale job detection
+ */
+export function logStaleJob(creationId: string): void {
+  if (typeof __DEV__ !== "undefined" && __DEV__) {
+    console.log("[ProcessingJobsPoller] Stale job detected, marking as failed:", creationId, {
+      ageMs: calculateAgeMs(creationId ? new Date() : new Date()),
+    });
+  }
+}
+
+/**
+ * Log failed to mark stale job
+ */
+export function logMarkStaleFailed(error: unknown): void {
+  if (typeof __DEV__ !== "undefined" && __DEV__) {
+    console.error("[ProcessingJobsPoller] Failed to mark stale job:", error);
+  }
+}
+
+/**
+ * Mark stale job as failed
+ */
+export async function markJobAsFailed(
+  repository: ICreationsRepository,
+  userId: string,
+  creation: Creation
+): Promise<void> {
+  await repository.update(userId, creation.id, {
+    status: CREATION_STATUS.FAILED,
+    metadata: { ...creation.metadata, error: "Generation timed out" },
+    completedAt: new Date(),
+  });
+}

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

@@ -0,0 +1,8 @@
+/**
+ * Processing Jobs Poller - Utility Functions
+ */
+
+export { getProcessingJobIds, getProcessingJobs, getOrphanJobs } from "./job-poller-utils.filters";
+export { isJobStale, logStaleJob, logMarkStaleFailed, markJobAsFailed } from "./job-poller-utils.stale-handlers";
+export { logStatusCheck, logStatusResult, logJobCompleted, logNoValidUri, logJobFailed, logPollError, logOrphanTimeout, logCleanupOrphansFailed } from "./job-poller-utils.logger";
+

package/src/domains/creations/presentation/screens/CreationsGalleryScreen.tsx

@@ -14,7 +14,7 @@ import { GalleryResultPreview } from "../components/GalleryResultPreview";
 import { GalleryScreenHeader } from "../components/GalleryScreenHeader";
 import { MEDIA_FILTER_OPTIONS, STATUS_FILTER_OPTIONS } from "../../domain/types/creation-filter";
 import { createFilterButtons, createItemTitle } from "../utils/filter-buttons.util";
-import { calculatePaginationSlice, calculateHasMore } from "../../../../shared/utils/calculations.util";
+import { calculatePaginationSlice, calculateHasMore } from "../../../../shared/utils/calculations";
 import type { Creation } from "../../domain/entities/Creation";
 import type { CreationsGalleryScreenProps } from "./creations-gallery.types";
 import { creationsGalleryStyles as styles } from "./creations-gallery.styles";

package/src/domains/creations/presentation-exports.ts

@@ -14,11 +14,11 @@ export type {
   BaseProcessingStartData,
   BaseProcessingResult,
 } from "./presentation/hooks/useCreationPersistence";
-export { useProcessingJobsPoller } from "./presentation/hooks/useProcessingJobsPoller";
+export { useProcessingJobsPoller } from "./presentation/hooks/job-poller-index";
 export type {
   UseProcessingJobsPollerConfig,
   UseProcessingJobsPollerReturn,
-} from "./presentation/hooks/useProcessingJobsPoller";
+} from "./presentation/hooks/job-poller-index";
 
 // Core Components
 export { CreationPreview } from "./presentation/components/CreationPreview";

package/src/domains/face-detection/domain/entities/FaceDetection.ts

@@ -1,17 +1,18 @@
 /**
  * Face Detection Types
+ * Uses shared kernel base types
  */
 
+import type { BaseFeatureState } from '../../../../shared-kernel/base-types';
+
 export interface FaceDetectionResult {
   hasFace: boolean;
   confidence: number;
   message: string;
 }
 
-export interface FaceValidationState {
+export interface FaceValidationState extends BaseFeatureState<FaceDetectionResult> {
   isValidating: boolean;
-  result: FaceDetectionResult | null;
-  error: string | null;
 }
 
 export interface FaceDetectionConfig {

package/src/domains/face-detection/presentation/hooks/useFaceDetection.ts

@@ -1,16 +1,18 @@
 /**
  * useFaceDetection Hook
  *
- * React hook for face detection functionality.
+ * React hook for face detection functionality using shared kernel.
  */
 
-import { useState, useCallback } from "react";
+import { useCallback } from "react";
 import type {
   FaceValidationState,
   FaceDetectionResult,
 } from "../../domain/entities/FaceDetection";
 import { analyzeImageForFace, type AIAnalyzerFunction } from "../../infrastructure/analyzers/faceAnalyzer";
 import { isValidFace } from "../../infrastructure/validators/faceValidator";
+import { useFeatureState } from "../../../../shared-kernel/application/hooks";
+import { handleError, ErrorType } from "../../../../shared-kernel/infrastructure/validation";
 
 interface UseFaceDetectionProps {
   aiAnalyzer: AIAnalyzerFunction;
@@ -24,38 +26,39 @@ interface UseFaceDetectionReturn {
   reset: () => void;
 }
 
-const initialState: FaceValidationState = {
-  isValidating: false,
-  result: null,
-  error: null,
-};
-
 export const useFaceDetection = ({ aiAnalyzer, model }: UseFaceDetectionProps): UseFaceDetectionReturn => {
-  const [state, setState] = useState<FaceValidationState>(initialState);
-
-  const validateImage = useCallback(async (base64Image: string) => {
-    setState({ isValidating: true, result: null, error: null });
+  const { state, actions } = useFeatureState<FaceDetectionResult>();
 
+  const validateImage = useCallback(async (base64Image: string): Promise<FaceDetectionResult> => {
     try {
+      actions.startProcessing();
+
       const result = await analyzeImageForFace(base64Image, aiAnalyzer, model);
-      setState({ isValidating: false, result, error: null });
+
+      actions.setSuccess(result);
       return result;
     } catch (error) {
-      const message =
-        error instanceof Error ? error.message : "Validation failed";
-      setState({ isValidating: false, result: null, error: message });
+      const appError = handleError(error, {
+        logErrors: true,
+        showUserMessage: true,
+      });
+
+      actions.setError(appError.message);
       throw error;
     }
-  }, [aiAnalyzer, model]);
+  }, [aiAnalyzer, model, actions]);
 
   const reset = useCallback(() => {
-    setState(initialState);
-  }, []);
+    actions.reset();
+  }, [actions]);
 
-  const isValid = state.result !== null && state.result !== undefined ? isValidFace(state.result) : false;
+  const isValid = state.output !== null ? isValidFace(state.output) : false;
 
   return {
-    state,
+    state: {
+      ...state,
+      isValidating: state.isProcessing,
+    },
     validateImage,
     isValid,
     reset,

package/src/domains/generation/infrastructure/couple-generation-builder/builder-couple-preparation.ts

@@ -0,0 +1,58 @@
+/**
+ * Couple Image Generation Builder - Preparation Phase
+ *
+ * Handles photo URI extraction and appearance analysis
+ */
+
+import { getAppearanceContext } from "./appearance-analysis";
+import { logBuilderStep } from "./utils";
+import type { CoupleGenerationInputParams } from "./types";
+
+export interface CouplePreparationResult {
+  photoUris: string[];
+  appearanceContext: string;
+}
+
+/**
+ * Prepare photo URIs and analyze appearance
+ */
+export async function prepareCoupleGeneration(
+  params: CoupleGenerationInputParams,
+  prefix: string = "[CoupleBuilder]",
+): Promise<CouplePreparationResult> {
+  const {
+    partner1PhotoUri,
+    partner2PhotoUri,
+    isCoupleMode,
+  } = params;
+
+  // 1. GET PHOTO URIs - Couple mode kontrolü
+  const photoUris =
+    isCoupleMode && partner2PhotoUri
+      ? [partner1PhotoUri, partner2PhotoUri]
+      : [partner1PhotoUri];
+
+  logBuilderStep(prefix, "STEP 1: PHOTO URIs", {
+    photoUrisCount: photoUris.length,
+    photo1: photoUris[0],
+    photo2: photoUris[1],
+  });
+
+  // 2. ANALYZE APPEARANCE - Wardrobe'daki gibi
+  logBuilderStep(prefix, "STEP 2: APPEARANCE ANALYSIS", {
+    photoCount: photoUris.length,
+    isCoupleMode
+  });
+
+  const appearanceContext = await getAppearanceContext(
+    photoUris,
+    isCoupleMode,
+  );
+
+  logBuilderStep(prefix, "Appearance Analysis Result", {
+    contextLength: appearanceContext.length,
+    contextPreview: appearanceContext.substring(0, 150),
+  });
+
+  return { photoUris, appearanceContext };
+}