@umituz/react-native-ai-generation-content 1.17.94 → 1.17.96

package/package.json

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

package/src/index.ts

@@ -216,7 +216,6 @@ export type {
   // Feature utils types
   ImageSelector,
   VideoSaver,
-  CreditChecker,
   AlertFunction,
   FeatureUtilsConfig,
   // Video helpers types
@@ -280,6 +279,7 @@ export type {
   UseGenerationCallbacksBuilderOptions,
   AIFeatureCallbacksConfig,
   AIFeatureCallbacks,
+  AIFeatureGenerationResult,
 } from "./presentation/hooks";
 
 // =============================================================================

package/src/infrastructure/utils/feature-utils.ts

@@ -1,85 +1,74 @@
 /**
  * Feature Utilities
- * Generic utilities for AI generation features
- * App provides implementations via dependency injection
+ * Uses ONLY configured app services - no alternatives
  */
 
-/**
- * Image selector function type
- */
-export type ImageSelector = () => Promise<string | null>;
+import { getAuthService, getCreditService, getPaywallService, isAppServicesConfigured } from "../config/app-services.config";
 
-/**
- * Video saver function type
- */
-export type VideoSaver = (uri: string) => Promise<void>;
+declare const __DEV__: boolean;
 
-/**
- * Credit checker function type
- */
-export type CreditChecker = (cost: number, featureName: string, type: string) => Promise<boolean>;
-
-/**
- * Alert function type
- */
+export type ImageSelector = () => Promise<string | null>;
+export type VideoSaver = (uri: string) => Promise<void>;
 export type AlertFunction = (title: string, message: string) => void;
 
-/**
- * Feature utilities configuration
- */
 export interface FeatureUtilsConfig {
   selectImage: ImageSelector;
   saveVideo: VideoSaver;
-  checkCredit: CreditChecker;
-  showSuccessAlert?: AlertFunction;
-  showErrorAlert?: AlertFunction;
 }
 
-/**
- * Prepare image from URI (generic passthrough)
- */
 export async function prepareImage(uri: string): Promise<string> {
   return uri;
 }
 
-/**
- * Create dev callbacks for logging
- */
 export function createDevCallbacks(featureName: string) {
   return {
     onSuccess: (result: unknown) => {
-      if (typeof __DEV__ !== "undefined" && __DEV__) {
-        // eslint-disable-next-line no-console
-        console.log(`[${featureName}] Success:`, result);
-      }
+      if (__DEV__) console.log(`[${featureName}] Success:`, result);
     },
     onError: (error: unknown) => {
-      if (typeof __DEV__ !== "undefined" && __DEV__) {
-        // eslint-disable-next-line no-console
-        console.error(`[${featureName}] Error:`, error);
-      }
+      if (__DEV__) console.error(`[${featureName}] Error:`, error);
     },
   };
 }
 
 /**
- * Create feature utils with injected dependencies
+ * Credit guard - ONLY uses configured app services
  */
+async function checkCreditGuard(cost: number, featureName: string): Promise<boolean> {
+  if (!isAppServicesConfigured()) {
+    throw new Error(`[${featureName}] App services not configured. Call configureAppServices() at startup.`);
+  }
+
+  const authService = getAuthService();
+  const creditService = getCreditService();
+  const paywallService = getPaywallService();
+
+  if (!authService.isAuthenticated()) {
+    if (__DEV__) console.log(`[${featureName}] Auth required`);
+    try {
+      authService.requireAuth();
+    } catch {
+      return false;
+    }
+    return false;
+  }
+
+  const hasCredits = await creditService.checkCredits(cost);
+  if (!hasCredits) {
+    if (__DEV__) console.log(`[${featureName}] Insufficient credits`);
+    paywallService.showPaywall(cost);
+    return false;
+  }
+
+  return true;
+}
+
 export function createFeatureUtils(config: FeatureUtilsConfig) {
   return {
     selectImage: config.selectImage,
     saveVideo: config.saveVideo,
-    checkCreditGuard: config.checkCredit,
+    checkCreditGuard,
     prepareImage,
     createDevCallbacks,
   };
 }
-
-/**
- * Hook factory for feature utilities
- */
-export function createUseFeatureUtils(config: FeatureUtilsConfig) {
-  return function useFeatureUtils() {
-    return createFeatureUtils(config);
-  };
-}

package/src/presentation/hooks/index.ts

@@ -57,4 +57,5 @@ export { useAIFeatureCallbacks } from "./useAIFeatureCallbacks";
 export type {
   AIFeatureCallbacksConfig,
   AIFeatureCallbacks,
+  AIFeatureGenerationResult,
 } from "./useAIFeatureCallbacks";

package/src/presentation/hooks/useAIFeatureCallbacks.ts

@@ -34,16 +34,19 @@ export interface AIFeatureCallbacksConfig<TRequest = unknown, TResult = unknown>
   onError?: (error: string) => void;
 }
 
+/**
+ * Discriminated union result type for generation
+ */
+export type AIFeatureGenerationResult =
+  | { success: true; imageUrls: string[] }
+  | { success: false; error: string };
+
 /**
  * Universal callbacks interface that maps to all feature-specific ones
  */
 export interface AIFeatureCallbacks<TRequest = unknown, TResult = unknown> {
   // TextToImageCallbacks compatible
-  executeGeneration: (request: TRequest) => Promise<{
-    success: boolean;
-    imageUrls?: string[];
-    error?: string;
-  }>;
+  executeGeneration: (request: TRequest) => Promise<AIFeatureGenerationResult>;
   calculateCost: (multiplier?: number, _model?: string | null) => number;
   canAfford: (cost: number) => boolean;
   isAuthenticated: () => boolean;
@@ -103,7 +106,7 @@ export function useAIFeatureCallbacks<TRequest = unknown, TResult = unknown>(
   );
 
   const executeGeneration = useCallback(
-    async (request: TRequest) => {
+    async (request: TRequest): Promise<AIFeatureGenerationResult> => {
       try {
         const result = await executor(request);
 
@@ -117,11 +120,10 @@ export function useAIFeatureCallbacks<TRequest = unknown, TResult = unknown>(
           onError?.(result.error);
         }
 
-        return {
-          success: result.success,
-          imageUrls: result.imageUrls,
-          error: result.error,
-        };
+        if (result.success) {
+          return { success: true, imageUrls: result.imageUrls ?? [] };
+        }
+        return { success: false, error: result.error ?? "Unknown error" };
       } catch (error) {
         const message = error instanceof Error ? error.message : String(error);
         onError?.(message);