@umituz/react-native-ai-generation-content 1.83.98 → 1.84.0

package/package.json

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

package/src/exports/infrastructure.ts

@@ -15,7 +15,7 @@ export {
 
 // Services
 export {
-  providerRegistry, generationOrchestrator,
+  providerRegistry, resolveProvider, generationOrchestrator,
   executeImageFeature, hasImageFeatureSupport, executeVideoFeature, hasVideoFeatureSupport,
   submitVideoFeatureToQueue, executeMultiImageGeneration,
 } from "../infrastructure/services";
@@ -76,4 +76,8 @@ export {
   type GenerationModels,
   type GenerationConfigValue,
   type GenerationConfigProviderProps,
+  GenerationServicesProvider,
+  useGenerationServices,
+  type GenerationServicesValue,
+  type GenerationServicesProviderProps,
 } from "../infrastructure/providers";

package/src/exports/presentation.ts

@@ -9,7 +9,7 @@ export {
   useGenerationFlow, useAIFeatureCallbacks,
   useAIGenerateState, AIGenerateStep,
   useGenerationOrchestrator, useImageGeneration, useVideoGeneration, useDualImageGeneration,
-  useImagePicker,
+  useImagePicker, useImageGenerationExecutor,
   createGenerationError, getAlertMessage, parseError,
 } from "../presentation/hooks";
 export type {
@@ -24,6 +24,8 @@ export type {
   DualImageGenerationConfig, DualImageGenerationReturn,
   ImagePickerState, UseImagePickerOptions, UseImagePickerReturn,
   UploadedImage,
+  GenerationTarget, GenerationInput, AIImageResult,
+  ImageGenerationExecutorConfig, ImageGenerationExecutorReturn,
 } from "../presentation/hooks";
 
 // Components

package/src/infrastructure/providers/generation-services.provider.tsx

@@ -0,0 +1,60 @@
+/**
+ * Generation Services Provider
+ * Provides app-specific auth/credit/callback services to generation hooks.
+ * Apps wire their own implementations once in the provider tree.
+ */
+
+import React, {
+  createContext,
+  useContext,
+  useMemo,
+  type ReactNode,
+} from "react";
+
+export interface GenerationServicesValue {
+  /** Current authenticated user ID (null = not authenticated) */
+  readonly userId: string | undefined;
+  /** Deduct credits. Returns true if successful, false if insufficient. */
+  readonly deductCredits: (cost: number) => Promise<boolean>;
+  /** Refund credits on generation failure. */
+  readonly refundCredits: (cost: number) => Promise<void>;
+  /** Optional callback after successful generation (e.g. rating prompt) */
+  readonly onGenerationSuccess?: () => void;
+}
+
+export interface GenerationServicesProviderProps
+  extends GenerationServicesValue {
+  readonly children: ReactNode;
+}
+
+const GenerationServicesContext =
+  createContext<GenerationServicesValue | null>(null);
+
+export const GenerationServicesProvider: React.FC<
+  GenerationServicesProviderProps
+> = ({ userId, deductCredits, refundCredits, onGenerationSuccess, children }) => {
+  const value = useMemo<GenerationServicesValue>(
+    () => ({ userId, deductCredits, refundCredits, onGenerationSuccess }),
+    [userId, deductCredits, refundCredits, onGenerationSuccess],
+  );
+
+  return (
+    <GenerationServicesContext.Provider value={value}>
+      {children}
+    </GenerationServicesContext.Provider>
+  );
+};
+
+/**
+ * Access generation services from context.
+ * Must be used within GenerationServicesProvider.
+ */
+export const useGenerationServices = (): GenerationServicesValue => {
+  const context = useContext(GenerationServicesContext);
+  if (!context) {
+    throw new Error(
+      "useGenerationServices must be used within GenerationServicesProvider",
+    );
+  }
+  return context;
+};

package/src/infrastructure/providers/index.ts

@@ -10,3 +10,10 @@ export {
   type GenerationConfigValue,
   type GenerationConfigProviderProps,
 } from "./generation-config.provider";
+
+export {
+  GenerationServicesProvider,
+  useGenerationServices,
+  type GenerationServicesValue,
+  type GenerationServicesProviderProps,
+} from "./generation-services.provider";

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

@@ -47,6 +47,16 @@ export type {
   UseImagePickerReturn,
 } from "./useImagePicker";
 
+// Standalone image generation executor (Template Method Pattern)
+export { useImageGenerationExecutor } from "./useImageGenerationExecutor";
+export type {
+  GenerationTarget,
+  GenerationInput,
+  AIImageResult,
+  ImageGenerationExecutorConfig,
+  ImageGenerationExecutorReturn,
+} from "./useImageGenerationExecutor";
+
 // Error utilities
 export {
   createGenerationError,

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

@@ -0,0 +1,152 @@
+/**
+ * Image Generation Executor Hook (Template Method Pattern)
+ *
+ * Encapsulates the full generation lifecycle:
+ *   auth → credit deduction → provider resolution → AI generation → creation save → error/refund
+ *
+ * Consumers provide only domain-specific logic via config:
+ *   - buildInput: prompt, params, target (model + provider)
+ *   - buildMetadata: creation metadata
+ *
+ * Auth and credit services come from GenerationServicesProvider context.
+ */
+
+import { useState, useCallback, useMemo } from "react";
+import { useGenerationServices } from "../../../infrastructure/providers/generation-services.provider";
+import { resolveProvider } from "../../../infrastructure/services/provider-resolver";
+import { createCreationsRepository } from "../../../domains/creations/infrastructure/adapters";
+
+/** Target for generation: which model on which provider */
+export interface GenerationTarget {
+  readonly model: string;
+  readonly providerId: string;
+}
+
+/** Domain-specific generation input returned by buildInput */
+export interface GenerationInput {
+  /** Which model + provider to use */
+  readonly target: GenerationTarget;
+  /** The prompt (stored in creation record) */
+  readonly prompt: string;
+  /** Full params passed to provider.subscribe() */
+  readonly params: Record<string, unknown>;
+}
+
+/** Provider-agnostic AI image result */
+export interface AIImageResult {
+  readonly images: ReadonlyArray<{ readonly url: string }>;
+}
+
+/** Default credit cost for image generation */
+const DEFAULT_IMAGE_CREDIT_COST = 2;
+
+export interface ImageGenerationExecutorConfig<P> {
+  /** Creation type stored in Firestore (e.g. "aging", "retouch") */
+  readonly type: string;
+  /** Credit cost per generation. Defaults to 2. */
+  readonly creditCost?: number;
+  /** Whether to call onGenerationSuccess after completion */
+  readonly trackRating?: boolean;
+  /** Build AI generation input from domain-specific params. May be async. */
+  readonly buildInput: (params: P) => Promise<GenerationInput> | GenerationInput;
+  /** Build domain-specific metadata for the creation record */
+  readonly buildMetadata?: (params: P) => Record<string, unknown>;
+}
+
+export interface ImageGenerationExecutorReturn<P> {
+  readonly execute: (params: P) => Promise<string | null>;
+  readonly isLoading: boolean;
+  readonly error: string | null;
+}
+
+export function useImageGenerationExecutor<P>(
+  config: ImageGenerationExecutorConfig<P>,
+): ImageGenerationExecutorReturn<P> {
+  const { userId, deductCredits, refundCredits, onGenerationSuccess } =
+    useGenerationServices();
+  const repository = useMemo(
+    () => createCreationsRepository("creations"),
+    [],
+  );
+  const [error, setError] = useState<string | null>(null);
+  const [isLoading, setIsLoading] = useState(false);
+
+  const execute = useCallback(
+    async (params: P): Promise<string | null> => {
+      if (!userId) return null;
+
+      setError(null);
+      setIsLoading(true);
+      let deducted = false;
+      const cost = config.creditCost ?? DEFAULT_IMAGE_CREDIT_COST;
+
+      try {
+        const creditSuccess = await deductCredits(cost);
+        if (!creditSuccess) {
+          setError("Insufficient credits");
+          return null;
+        }
+        deducted = true;
+
+        const input = await config.buildInput(params);
+        const provider = resolveProvider(input.target.providerId);
+        const result = (await provider.subscribe(
+          input.target.model,
+          input.params,
+        )) as AIImageResult;
+
+        const imageUrl = result?.images?.[0]?.url;
+        if (!imageUrl) throw new Error("No image returned");
+
+        await repository.create(userId, {
+          id: `${Date.now()}-${Math.random().toString(36).slice(2, 9)}`,
+          type: config.type,
+          uri: imageUrl,
+          createdAt: new Date(),
+          isShared: false,
+          isFavorite: false,
+          status: "completed",
+          output: { imageUrl },
+          model: input.target.model,
+          prompt: input.prompt,
+          metadata: config.buildMetadata?.(params) ?? {},
+        });
+
+        if (config.trackRating && onGenerationSuccess) {
+          void onGenerationSuccess();
+        }
+
+        return imageUrl;
+      } catch (err) {
+        const message =
+          err instanceof Error ? err.message : "Generation failed";
+        setError(message);
+        if (deducted) {
+          try {
+            await refundCredits(cost);
+          } catch {
+            if (typeof __DEV__ !== "undefined" && __DEV__) {
+              console.error(`[${config.type}] Refund failed`);
+            }
+          }
+        }
+        if (typeof __DEV__ !== "undefined" && __DEV__) {
+          console.error(`[${config.type}]`, err);
+        }
+        return null;
+      } finally {
+        setIsLoading(false);
+      }
+    },
+    [
+      userId,
+      config,
+      deductCredits,
+      refundCredits,
+      repository,
+      onGenerationSuccess,
+    ],
+  );
+
+  return { execute, isLoading, error };
+}

package/src/presentation/hooks/index.ts

@@ -9,6 +9,7 @@ export {
   useVideoGeneration,
   useDualImageGeneration,
   useImagePicker,
+  useImageGenerationExecutor,
   createGenerationError,
   getAlertMessage,
   parseError,
@@ -33,6 +34,11 @@ export type {
   ImagePickerState,
   UseImagePickerOptions,
   UseImagePickerReturn,
+  GenerationTarget,
+  GenerationInput,
+  AIImageResult,
+  ImageGenerationExecutorConfig,
+  ImageGenerationExecutorReturn,
 } from "./generation";
 
 export { useGeneration } from "./use-generation";