@umituz/react-native-ai-generation-content 1.36.2 → 1.37.1

package/src/presentation/hooks/generation/moderation-handler.ts

@@ -0,0 +1,77 @@
+/**
+ * Moderation Handler
+ * Handles content moderation logic for generation
+ */
+
+import { createGenerationError, parseError, getAlertMessage } from "./errors";
+import type { GenerationError, ModerationCallbacks, AlertMessages } from "./types";
+
+export interface ModerationHandlerParams<TInput, TResult> {
+  readonly input: TInput;
+  readonly moderation: ModerationCallbacks | undefined;
+  readonly alertMessages: AlertMessages;
+  readonly isMountedRef: React.MutableRefObject<boolean>;
+  readonly isGeneratingRef: React.MutableRefObject<boolean>;
+  readonly setState: (state: { status: string; isGenerating: boolean; result: TResult | null; error: GenerationError | null }) => void;
+  readonly resetState: () => void;
+  readonly executeGeneration: (input: TInput) => Promise<TResult>;
+  readonly showError: (title: string, message: string) => void;
+  readonly onError?: (error: GenerationError) => void;
+  readonly handleLifecycleComplete: (status: "success" | "error", result?: TResult, error?: GenerationError) => void;
+}
+
+export async function handleModeration<TInput, TResult>(
+  params: ModerationHandlerParams<TInput, TResult>,
+): Promise<TResult | undefined> {
+  const {
+    input,
+    moderation,
+    alertMessages,
+    isMountedRef,
+    isGeneratingRef,
+    setState,
+    resetState,
+    executeGeneration,
+    showError,
+    onError,
+    handleLifecycleComplete,
+  } = params;
+
+  if (!moderation) {
+    return executeGeneration(input);
+  }
+
+  setState({ status: "moderating", isGenerating: true, result: null, error: null });
+  const moderationResult = await moderation.checkContent(input);
+
+  if (!moderationResult.allowed && moderationResult.warnings.length > 0) {
+    if (moderation.onShowWarning) {
+      moderation.onShowWarning(
+        moderationResult.warnings,
+        () => {
+          isGeneratingRef.current = false;
+          if (isMountedRef.current) resetState();
+        },
+        async () => {
+          try {
+            await executeGeneration(input);
+          } catch (err) {
+            const error = parseError(err);
+            if (isMountedRef.current) {
+              setState({ status: "error", isGenerating: false, result: null, error });
+            }
+            showError("Error", getAlertMessage(error, alertMessages));
+            onError?.(error);
+            handleLifecycleComplete("error", undefined, error);
+          } finally {
+            isGeneratingRef.current = false;
+          }
+        },
+      );
+      return undefined;
+    }
+    throw createGenerationError("policy", alertMessages.policyViolation);
+  }
+
+  return executeGeneration(input);
+}

package/src/presentation/hooks/generation/orchestrator.ts

@@ -1,22 +1,13 @@
 /**
  * Generation Orchestrator
- * Handles AI generation execution with:
- * - Network check
- * - Content moderation (optional)
- * - Credit deduction (after success)
- * - Error handling
- *
- * NOTE: Credit CHECK is handled by useFeatureGate before generation starts.
- * This orchestrator only DEDUCTS credits after successful generation.
- *
- * Progress is NOT tracked here - UI uses indeterminate progress bar with
- * time-based phase detection (see useGenerationPhase hook).
+ * Handles AI generation execution with network check, moderation, credit deduction, and error handling
  */
 
 import { useState, useCallback, useRef, useEffect } from "react";
 import { useOfflineStore, useAlert } from "@umituz/react-native-design-system";
 import { useDeductCredit } from "@umituz/react-native-subscription";
 import { createGenerationError, getAlertMessage, parseError } from "./errors";
+import { handleModeration } from "./moderation-handler";
 import type {
   GenerationStrategy,
   GenerationConfig,
@@ -27,26 +18,13 @@ import type {
 
 declare const __DEV__: boolean;
 
-const INITIAL_STATE = {
-  status: "idle" as const,
-  isGenerating: false,
-  result: null,
-  error: null,
-};
+const INITIAL_STATE = { status: "idle" as const, isGenerating: false, result: null, error: null };
 
 export const useGenerationOrchestrator = <TInput, TResult>(
   strategy: GenerationStrategy<TInput, TResult>,
   config: GenerationConfig,
 ): UseGenerationOrchestratorReturn<TInput, TResult> => {
-  const {
-    userId,
-    alertMessages,
-    onCreditsExhausted,
-    onSuccess,
-    onError,
-    moderation,
-    lifecycle,
-  } = config;
+  const { userId, alertMessages, onCreditsExhausted, onSuccess, onError, moderation, lifecycle } = config;
 
   if (typeof __DEV__ !== "undefined" && __DEV__) {
     console.log("[Orchestrator] Hook initialized:", { userId });
@@ -62,20 +40,14 @@ export const useGenerationOrchestrator = <TInput, TResult>(
 
   useEffect(() => {
     isMountedRef.current = true;
-    return () => {
-      isMountedRef.current = false;
-    };
+    return () => { isMountedRef.current = false; };
   }, []);
 
   const handleLifecycleComplete = useCallback(
     (status: "success" | "error", result?: TResult, error?: GenerationError) => {
       if (!lifecycle?.onComplete) return;
       const delay = lifecycle.completeDelay ?? 500;
-      setTimeout(() => {
-        if (isMountedRef.current) {
-          lifecycle.onComplete?.(status, result, error);
-        }
-      }, delay);
+      setTimeout(() => { if (isMountedRef.current) lifecycle.onComplete?.(status, result, error); }, delay);
     },
     [lifecycle],
   );
@@ -83,10 +55,7 @@ export const useGenerationOrchestrator = <TInput, TResult>(
   const executeGeneration = useCallback(
     async (input: TInput) => {
       setState((prev) => ({ ...prev, status: "generating" }));
-
-      if (typeof __DEV__ !== "undefined" && __DEV__) {
-        console.log("[Orchestrator] Starting generation");
-      }
+      if (typeof __DEV__ !== "undefined" && __DEV__) console.log("[Orchestrator] Starting generation");
 
       const result = await strategy.execute(input);
 
@@ -95,34 +64,19 @@ export const useGenerationOrchestrator = <TInput, TResult>(
         try {
           await strategy.save(result, userId);
         } catch (saveErr) {
-          throw createGenerationError(
-            "save",
-            alertMessages.saveFailed,
-            saveErr instanceof Error ? saveErr : undefined,
-          );
+          throw createGenerationError("save", alertMessages.saveFailed, saveErr instanceof Error ? saveErr : undefined);
         }
       }
 
-      const creditCost = strategy.getCreditCost();
-      const creditDeducted = await deductCredit(creditCost);
-      if (!creditDeducted) {
-        throw createGenerationError("credits", alertMessages.creditFailed);
-      }
+      const creditDeducted = await deductCredit(strategy.getCreditCost());
+      if (!creditDeducted) throw createGenerationError("credits", alertMessages.creditFailed);
 
-      if (isMountedRef.current) {
-        setState({ status: "success", isGenerating: false, result, error: null });
-      }
-
-      if (typeof __DEV__ !== "undefined" && __DEV__) {
-        console.log("[Orchestrator] Generation SUCCESS");
-      }
+      if (isMountedRef.current) setState({ status: "success", isGenerating: false, result, error: null });
+      if (typeof __DEV__ !== "undefined" && __DEV__) console.log("[Orchestrator] Generation SUCCESS");
 
-      if (alertMessages.success) {
-        showSuccess("Success", alertMessages.success);
-      }
+      if (alertMessages.success) showSuccess("Success", alertMessages.success);
       onSuccess?.(result);
       handleLifecycleComplete("success", result);
-
       return result;
     },
     [strategy, userId, alertMessages, deductCredit, showSuccess, onSuccess, handleLifecycleComplete],
@@ -130,63 +84,32 @@ export const useGenerationOrchestrator = <TInput, TResult>(
 
   const generate = useCallback(
     async (input: TInput) => {
-      if (typeof __DEV__ !== "undefined" && __DEV__) {
-        console.log("[Orchestrator] generate() called");
-      }
-
+      if (typeof __DEV__ !== "undefined" && __DEV__) console.log("[Orchestrator] generate() called");
       if (isGeneratingRef.current) return;
 
       isGeneratingRef.current = true;
       setState({ ...INITIAL_STATE, status: "checking", isGenerating: true });
 
       try {
-        if (!offlineStore.isOnline) {
-          throw createGenerationError("network", alertMessages.networkError);
-        }
-
-        if (moderation) {
-          setState((prev) => ({ ...prev, status: "moderating" }));
-          const moderationResult = await moderation.checkContent(input);
-
-          if (!moderationResult.allowed && moderationResult.warnings.length > 0) {
-            if (moderation.onShowWarning) {
-              moderation.onShowWarning(
-                moderationResult.warnings,
-                () => {
-                  isGeneratingRef.current = false;
-                  if (isMountedRef.current) setState(INITIAL_STATE);
-                },
-                async () => {
-                  try {
-                    await executeGeneration(input);
-                  } catch (err) {
-                    const error = parseError(err);
-                    if (isMountedRef.current) {
-                      setState({ status: "error", isGenerating: false, result: null, error });
-                    }
-                    showError("Error", getAlertMessage(error, alertMessages));
-                    onError?.(error);
-                    handleLifecycleComplete("error", undefined, error);
-                  } finally {
-                    isGeneratingRef.current = false;
-                  }
-                },
-              );
-              return;
-            }
-            throw createGenerationError("policy", alertMessages.policyViolation);
-          }
-        }
-
-        return await executeGeneration(input);
+        if (!offlineStore.isOnline) throw createGenerationError("network", alertMessages.networkError);
+
+        return await handleModeration({
+          input,
+          moderation,
+          alertMessages,
+          isMountedRef,
+          isGeneratingRef,
+          setState: (s) => setState(s as GenerationState<TResult>),
+          resetState: () => setState(INITIAL_STATE),
+          executeGeneration,
+          showError,
+          onError,
+          handleLifecycleComplete,
+        });
       } catch (err) {
         const error = parseError(err);
-        if (typeof __DEV__ !== "undefined" && __DEV__) {
-          console.log("[Orchestrator] Error:", error);
-        }
-        if (isMountedRef.current) {
-          setState({ status: "error", isGenerating: false, result: null, error });
-        }
+        if (typeof __DEV__ !== "undefined" && __DEV__) console.log("[Orchestrator] Error:", error);
+        if (isMountedRef.current) setState({ status: "error", isGenerating: false, result: null, error });
         showError("Error", getAlertMessage(error, alertMessages));
         onError?.(error);
         handleLifecycleComplete("error", undefined, error);
@@ -195,15 +118,7 @@ export const useGenerationOrchestrator = <TInput, TResult>(
         isGeneratingRef.current = false;
       }
     },
-    [
-      moderation,
-      alertMessages,
-      offlineStore.isOnline,
-      executeGeneration,
-      showError,
-      onError,
-      handleLifecycleComplete,
-    ],
+    [moderation, alertMessages, offlineStore.isOnline, executeGeneration, showError, onError, handleLifecycleComplete],
   );
 
   const reset = useCallback(() => {
@@ -211,12 +126,5 @@ export const useGenerationOrchestrator = <TInput, TResult>(
     isGeneratingRef.current = false;
   }, []);
 
-  return {
-    generate,
-    reset,
-    status: state.status,
-    isGenerating: state.isGenerating,
-    result: state.result,
-    error: state.error,
-  };
+  return { generate, reset, status: state.status, isGenerating: state.isGenerating, result: state.result, error: state.error };
 };