@umituz/react-native-ai-generation-content 1.41.12 → 1.42.0

package/package.json

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

package/src/domain/types/index.ts

@@ -0,0 +1,21 @@
+/**
+ * Domain Types
+ * Core type definitions for the AI generation content package
+ */
+
+export type {
+  Result,
+  Success,
+  Failure,
+} from "./result.types";
+
+export {
+  success,
+  failure,
+  isSuccess,
+  isFailure,
+  mapResult,
+  andThen,
+  unwrap,
+  unwrapOr,
+} from "./result.types";

package/src/domain/types/result.types.ts

@@ -0,0 +1,105 @@
+/**
+ * Result Type Pattern for Functional Error Handling
+ * Inspired by Rust's Result<T, E> type
+ *
+ * @see https://arg-software.medium.com/functional-error-handling-in-typescript-with-the-result-pattern-5b96a5abb6d3
+ */
+
+/**
+ * Success result containing a value of type T
+ */
+export interface Success<T> {
+  success: true;
+  value: T;
+}
+
+/**
+ * Failure result containing an error of type E
+ */
+export interface Failure<E> {
+  success: false;
+  error: E;
+}
+
+/**
+ * Result type that can be either Success or Failure
+ * Forces explicit error handling at compile time
+ */
+export type Result<T, E = string> = Success<T> | Failure<E>;
+
+/**
+ * Create a successful result
+ */
+export function success<T>(value: T): Success<T> {
+  return { success: true, value };
+}
+
+/**
+ * Create a failed result
+ */
+export function failure<E>(error: E): Failure<E> {
+  return { success: false, error };
+}
+
+/**
+ * Type guard to check if result is successful
+ */
+export function isSuccess<T, E>(result: Result<T, E>): result is Success<T> {
+  return result.success === true;
+}
+
+/**
+ * Type guard to check if result is a failure
+ */
+export function isFailure<T, E>(result: Result<T, E>): result is Failure<E> {
+  return result.success === false;
+}
+
+/**
+ * Map a successful result to a new value
+ * If result is failure, returns the failure unchanged
+ */
+export function mapResult<T, U, E>(
+  result: Result<T, E>,
+  fn: (value: T) => U,
+): Result<U, E> {
+  if (isSuccess(result)) {
+    return success(fn(result.value));
+  }
+  return result;
+}
+
+/**
+ * Chain async operations on Result types
+ * Similar to Promise.then() but for Result
+ */
+export async function andThen<T, U, E>(
+  result: Result<T, E>,
+  fn: (value: T) => Promise<Result<U, E>>,
+): Promise<Result<U, E>> {
+  if (isSuccess(result)) {
+    return fn(result.value);
+  }
+  return result;
+}
+
+/**
+ * Unwrap a result, throwing if it's a failure
+ * Use only when you're certain the result is successful
+ */
+export function unwrap<T, E>(result: Result<T, E>): T {
+  if (isSuccess(result)) {
+    return result.value;
+  }
+  throw new Error(`Called unwrap on a failure: ${String(result.error)}`);
+}
+
+/**
+ * Unwrap a result or return a default value
+ */
+export function unwrapOr<T, E>(result: Result<T, E>, defaultValue: T): T {
+  if (isSuccess(result)) {
+    return result.value;
+  }
+  return defaultValue;
+}

package/src/domains/access-control/hooks/useAIFeatureGate.ts

@@ -41,7 +41,7 @@ import type {
 export function useAIFeatureGate(
   options: AIFeatureGateOptions,
 ): AIFeatureGateReturn {
-  const { creditCost, featureName, onSuccess, onError } = options;
+  const { creditCost, onSuccess, onError } = options;
 
   // Auth state
   const { isAuthenticated: rawIsAuthenticated, isAnonymous } = useAuth();

package/src/features/image-to-video/infrastructure/services/image-to-video-executor.ts

@@ -1,22 +1,10 @@
 /**
  * Image-to-Video Executor
- * Provider-agnostic image-to-video execution using active AI provider
- * Uses progress mapper for consistent progress reporting
+ * Provider-agnostic image-to-video execution using Template Method pattern
  */
 
-import { providerRegistry } from "../../../../infrastructure/services";
-
-/** Map job status to progress percentage */
-const getProgressFromJobStatus = (status: string): number => {
-  switch (status.toLowerCase()) {
-    case "queued": return 10;
-    case "in_queue": return 15;
-    case "processing": return 50;
-    case "in_progress": return 60;
-    case "completed": return 100;
-    default: return 30;
-  }
-};
+import { BaseExecutor } from "../../../../infrastructure/executors/base-executor";
+import { isSuccess, type Result } from "../../../../domain/types/result.types";
 import type {
   ImageToVideoRequest,
   ImageToVideoResult,
@@ -24,8 +12,9 @@ import type {
   ImageToVideoResultExtractor,
 } from "../../domain/types";
 
-declare const __DEV__: boolean;
-
+/**
+ * Options for image-to-video execution
+ */
 export interface ExecuteImageToVideoOptions {
   model: string;
   buildInput: ImageToVideoInputBuilder;
@@ -33,9 +22,40 @@ export interface ExecuteImageToVideoOptions {
   onProgress?: (progress: number) => void;
 }
 
+/**
+ * Extracted result structure from provider response
+ */
+interface ExtractedVideoResult {
+  videoUrl?: string;
+  thumbnailUrl?: string;
+}
+
+/**
+ * Map job status to progress percentage
+ */
+const getProgressFromJobStatus = (status: string): number => {
+  switch (status.toLowerCase()) {
+    case "queued":
+      return 10;
+    case "in_queue":
+      return 15;
+    case "processing":
+      return 50;
+    case "in_progress":
+      return 60;
+    case "completed":
+      return 100;
+    default:
+      return 30;
+  }
+};
+
+/**
+ * Default extractor for image-to-video results
+ */
 function defaultExtractResult(
   result: unknown,
-): { videoUrl?: string; thumbnailUrl?: string } | undefined {
+): ExtractedVideoResult | undefined {
   if (typeof result !== "object" || result === null) return undefined;
 
   const r = result as Record<string, unknown>;
@@ -58,108 +78,116 @@ function defaultExtractResult(
   return undefined;
 }
 
-export async function executeImageToVideo(
-  request: ImageToVideoRequest,
-  options: ExecuteImageToVideoOptions,
-): Promise<ImageToVideoResult> {
-  if (typeof __DEV__ !== "undefined" && __DEV__) {
-     
-    console.log("[ImageToVideoExecutor] executeImageToVideo() called");
-  }
-
-  const provider = providerRegistry.getActiveProvider();
-
-  if (!provider) {
-    if (typeof __DEV__ !== "undefined" && __DEV__) {
-       
-      console.error("[ImageToVideoExecutor] No AI provider configured");
-    }
-    return { success: false, error: "No AI provider configured" };
+/**
+ * Image-to-Video Executor using Template Method pattern
+ * Eliminates code duplication through BaseExecutor
+ */
+class ImageToVideoExecutor extends BaseExecutor<
+  ImageToVideoRequest,
+  ImageToVideoResult,
+  ExtractedVideoResult
+> {
+  constructor() {
+    super("ImageToVideo");
   }
 
-  if (!provider.isInitialized()) {
-    if (typeof __DEV__ !== "undefined" && __DEV__) {
-       
-      console.error("[ImageToVideoExecutor] AI provider not initialized");
+  protected validateRequest(
+    request: ImageToVideoRequest,
+  ): string | undefined {
+    if (!request.imageBase64) {
+      return "Image base64 is required";
     }
-    return { success: false, error: "AI provider not initialized" };
-  }
-
-  if (!request.imageBase64) {
-    return { success: false, error: "Image base64 is required" };
+    return undefined;
   }
 
-  const { model, buildInput, extractResult, onProgress } = options;
-
-  if (typeof __DEV__ !== "undefined" && __DEV__) {
-     
-    console.log(`[ImageToVideoExecutor] Provider: ${provider.providerId}, Model: ${model}`);
-  }
-
-  try {
-    onProgress?.(5);
-
-    if (typeof __DEV__ !== "undefined" && __DEV__) {
-       
-      console.log("[ImageToVideoExecutor] Starting provider.subscribe()...");
-    }
-
-    // Build input directly - let buildInput handle base64 format
-    const input = buildInput(request.imageBase64, request.motionPrompt, request.options);
+  protected async executeProvider(
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    provider: any,
+    model: string,
+    input: unknown,
+    onProgress?: (progress: number) => void,
+  ): Promise<unknown> {
+    this.logInfo("Starting provider.subscribe()...");
 
     // Use subscribe for video generation (long-running operation with queue)
-    // subscribe provides progress updates unlike run()
+    // Provider reports real progress via onQueueUpdate callback
     const result = await provider.subscribe(model, input, {
-      onQueueUpdate: (status) => {
-        if (typeof __DEV__ !== "undefined" && __DEV__) {
-           
-          console.log("[ImageToVideoExecutor] Queue status:", status.status, "position:", status.queuePosition);
-        }
-        // Map provider status to progress using centralized mapper
+      onQueueUpdate: (status: { status: string; queuePosition?: number }) => {
+        this.logInfo(
+          `Queue status: ${status.status}, position: ${status.queuePosition}`,
+        );
+        // Map provider status to progress
         const progress = getProgressFromJobStatus(status.status);
         onProgress?.(progress);
       },
       timeoutMs: 300000, // 5 minutes timeout for video generation
     });
 
-    if (typeof __DEV__ !== "undefined" && __DEV__) {
-       
-      console.log("[ImageToVideoExecutor] Subscribe resolved, result keys:", result ? Object.keys(result as object) : "null");
-    }
-
-    if (typeof __DEV__ !== "undefined" && __DEV__) {
-       
-      console.log("[ImageToVideoExecutor] provider.subscribe() completed");
-    }
-
-    const extractor = extractResult || defaultExtractResult;
-    const extracted = extractor(result);
-    onProgress?.(100);
+    this.logInfo(
+      `Subscribe resolved, result keys: ${result ? Object.keys(result as object) : "null"}`,
+    );
+    return result;
+  }
 
+  protected validateExtractedResult(
+    extracted: ExtractedVideoResult | undefined,
+  ): string | undefined {
     if (!extracted?.videoUrl) {
-      if (typeof __DEV__ !== "undefined" && __DEV__) {
-         
-        console.error("[ImageToVideoExecutor] No video URL in response");
-      }
-      return { success: false, error: "No video in response" };
+      return "No video in response";
     }
+    return undefined;
+  }
 
+  protected transformResult(
+    extracted: ExtractedVideoResult,
+  ): ImageToVideoResult {
     return {
       success: true,
       videoUrl: extracted.videoUrl,
       thumbnailUrl: extracted.thumbnailUrl,
     };
-  } catch (error) {
-    const message = error instanceof Error ? error.message : String(error);
-    if (typeof __DEV__ !== "undefined" && __DEV__) {
-       
-      console.error("[ImageToVideoExecutor] Error:", message);
-    }
-    return { success: false, error: message };
+  }
+
+  protected getDefaultExtractor(): (
+    result: unknown,
+  ) => ExtractedVideoResult | undefined {
+    return defaultExtractResult;
   }
 }
 
+// Singleton instance
+const executor = new ImageToVideoExecutor();
+
+/**
+ * Execute image-to-video generation
+ * Public API maintained for backwards compatibility
+ */
+export async function executeImageToVideo(
+  request: ImageToVideoRequest,
+  options: ExecuteImageToVideoOptions,
+): Promise<ImageToVideoResult> {
+  const result: Result<ImageToVideoResult, string> = await executor.execute(
+    request,
+    {
+      model: options.model,
+      buildInput: (req) =>
+        options.buildInput(req.imageBase64!, req.motionPrompt, req.options),
+      extractResult: options.extractResult,
+      onProgress: options.onProgress,
+    },
+  );
+
+  // Convert Result<T, E> back to legacy format for backwards compatibility
+  if (isSuccess(result)) {
+    return result.value;
+  }
+  return { success: false, error: result.error };
+}
+
+/**
+ * Check if image-to-video is supported
+ * Public API maintained for backwards compatibility
+ */
 export function hasImageToVideoSupport(): boolean {
-  const provider = providerRegistry.getActiveProvider();
-  return provider !== null && provider.isInitialized();
+  return executor.hasSupport();
 }

package/src/features/text-to-image/infrastructure/services/text-to-image-executor.ts

@@ -1,9 +1,10 @@
 /**
  * Text-to-Image Executor
- * Provider-agnostic text-to-image execution using active AI provider
+ * Provider-agnostic text-to-image execution using Template Method pattern
  */
 
-import { providerRegistry } from "../../../../infrastructure/services";
+import { BaseExecutor } from "../../../../infrastructure/executors/base-executor";
+import { isSuccess, type Result } from "../../../../domain/types/result.types";
 import type {
   TextToImageRequest,
   TextToImageResult,
@@ -11,8 +12,9 @@ import type {
   TextToImageResultExtractor,
 } from "../../domain/types";
 
-declare const __DEV__: boolean;
-
+/**
+ * Options for text-to-image execution
+ */
 export interface ExecuteTextToImageOptions {
   model: string;
   buildInput: TextToImageInputBuilder;
@@ -20,6 +22,17 @@ export interface ExecuteTextToImageOptions {
   onProgress?: (progress: number) => void;
 }
 
+/**
+ * Extracted result structure from provider response
+ */
+interface ExtractedImageResult {
+  imageUrl?: string;
+  imageUrls?: string[];
+}
+
+/**
+ * Extract images from provider response object
+ */
 function extractImagesFromObject(
   obj: Record<string, unknown>,
 ): string[] | null {
@@ -40,9 +53,12 @@ function extractImagesFromObject(
   return null;
 }
 
+/**
+ * Default extractor for text-to-image results
+ */
 function defaultExtractResult(
   result: unknown,
-): { imageUrl?: string; imageUrls?: string[] } | undefined {
+): ExtractedImageResult | undefined {
   if (typeof result !== "object" || result === null) {
     return undefined;
   }
@@ -84,64 +100,93 @@ function defaultExtractResult(
   return undefined;
 }
 
-export async function executeTextToImage(
-  request: TextToImageRequest,
-  options: ExecuteTextToImageOptions,
-): Promise<TextToImageResult> {
-  const provider = providerRegistry.getActiveProvider();
-
-  if (!provider) {
-    return { success: false, error: "No AI provider configured" };
-  }
-
-  if (!provider.isInitialized()) {
-    return { success: false, error: "AI provider not initialized" };
+/**
+ * Text-to-Image Executor using Template Method pattern
+ * Eliminates code duplication through BaseExecutor
+ */
+class TextToImageExecutor extends BaseExecutor<
+  TextToImageRequest,
+  TextToImageResult,
+  ExtractedImageResult
+> {
+  constructor() {
+    super("TextToImage");
   }
 
-  if (!request.prompt) {
-    return { success: false, error: "Prompt is required" };
+  protected validateRequest(request: TextToImageRequest): string | undefined {
+    if (!request.prompt) {
+      return "Prompt is required";
+    }
+    return undefined;
   }
 
-  const { model, buildInput, extractResult, onProgress } = options;
-
-  if (typeof __DEV__ !== "undefined" && __DEV__) {
-     
-    console.log(`[TextToImage] Provider: ${provider.providerId}, Model: ${model}`);
+  protected async executeProvider(
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    provider: any,
+    model: string,
+    input: unknown,
+  ): Promise<unknown> {
+    return provider.run(model, input);
   }
 
-  try {
-    onProgress?.(10);
-
-    const input = buildInput(request.prompt, request.options);
-    onProgress?.(20);
-
-    const result = await provider.run(model, input);
-    onProgress?.(90);
-
-    const extractor = extractResult || defaultExtractResult;
-    const extracted = extractor(result);
-    onProgress?.(100);
-
+  protected validateExtractedResult(
+    extracted: ExtractedImageResult | undefined,
+  ): string | undefined {
     if (!extracted?.imageUrl) {
-      return { success: false, error: "No image in response" };
+      return "No image in response";
     }
+    return undefined;
+  }
 
+  protected transformResult(
+    extracted: ExtractedImageResult,
+  ): TextToImageResult {
     return {
       success: true,
       imageUrl: extracted.imageUrl,
       imageUrls: extracted.imageUrls,
     };
-  } catch (error) {
-    const message = error instanceof Error ? error.message : String(error);
-    if (typeof __DEV__ !== "undefined" && __DEV__) {
-       
-      console.error("[TextToImage] Error:", message);
-    }
-    return { success: false, error: message };
+  }
+
+  protected getDefaultExtractor(): (
+    result: unknown,
+  ) => ExtractedImageResult | undefined {
+    return defaultExtractResult;
   }
 }
 
+// Singleton instance
+const executor = new TextToImageExecutor();
+
+/**
+ * Execute text-to-image generation
+ * Public API maintained for backwards compatibility
+ */
+export async function executeTextToImage(
+  request: TextToImageRequest,
+  options: ExecuteTextToImageOptions,
+): Promise<TextToImageResult> {
+  const result: Result<TextToImageResult, string> = await executor.execute(
+    request,
+    {
+      model: options.model,
+      buildInput: (req) => options.buildInput(req.prompt, req.options),
+      extractResult: options.extractResult,
+      onProgress: options.onProgress,
+    },
+  );
+
+  // Convert Result<T, E> back to legacy format for backwards compatibility
+  if (isSuccess(result)) {
+    return result.value;
+  }
+  return { success: false, error: result.error };
+}
+
+/**
+ * Check if text-to-image is supported
+ * Public API maintained for backwards compatibility
+ */
 export function hasTextToImageSupport(): boolean {
-  const provider = providerRegistry.getActiveProvider();
-  return provider !== null && provider.isInitialized();
+  return executor.hasSupport();
 }

package/src/features/text-to-video/infrastructure/services/text-to-video-executor.ts

@@ -1,9 +1,10 @@
 /**
  * Text-to-Video Executor
- * Single Responsibility: Execute text-to-video using active AI provider
+ * Provider-agnostic text-to-video execution using Template Method pattern
  */
 
-import { providerRegistry } from "../../../../infrastructure/services";
+import { BaseExecutor } from "../../../../infrastructure/executors/base-executor";
+import { isSuccess, type Result } from "../../../../domain/types/result.types";
 import type {
   TextToVideoRequest,
   TextToVideoResult,
@@ -13,6 +14,9 @@ import type {
 
 declare const __DEV__: boolean;
 
+/**
+ * Options for text-to-video execution
+ */
 export interface ExecuteTextToVideoOptions {
   model: string;
   buildInput: TextToVideoInputBuilder;
@@ -20,9 +24,20 @@ export interface ExecuteTextToVideoOptions {
   onProgress?: (progress: number) => void;
 }
 
+/**
+ * Extracted result structure from provider response
+ */
+interface ExtractedVideoResult {
+  videoUrl?: string;
+  thumbnailUrl?: string;
+}
+
+/**
+ * Default extractor for text-to-video results
+ */
 function defaultExtractResult(
   result: unknown,
-): { videoUrl?: string; thumbnailUrl?: string } | undefined {
+): ExtractedVideoResult | undefined {
   if (typeof result !== "object" || result === null) return undefined;
 
   const r = result as Record<string, unknown>;
@@ -45,97 +60,108 @@ function defaultExtractResult(
   return undefined;
 }
 
-export async function executeTextToVideo(
-  request: TextToVideoRequest,
-  options: ExecuteTextToVideoOptions,
-): Promise<TextToVideoResult> {
-  if (typeof __DEV__ !== "undefined" && __DEV__) {
-     
-    console.log("[TextToVideoExecutor] executeTextToVideo() called");
-  }
-
-  const provider = providerRegistry.getActiveProvider();
-
-  if (!provider) {
-    if (typeof __DEV__ !== "undefined" && __DEV__) {
-       
-      console.error("[TextToVideoExecutor] No AI provider configured");
-    }
-    return { success: false, error: "No AI provider configured" };
+/**
+ * Text-to-Video Executor using Template Method pattern
+ * Eliminates code duplication through BaseExecutor
+ */
+class TextToVideoExecutor extends BaseExecutor<
+  TextToVideoRequest,
+  TextToVideoResult,
+  ExtractedVideoResult
+> {
+  constructor() {
+    super("TextToVideo");
   }
 
-  if (!provider.isInitialized()) {
-    if (typeof __DEV__ !== "undefined" && __DEV__) {
-       
-      console.error("[TextToVideoExecutor] AI provider not initialized");
+  protected validateRequest(request: TextToVideoRequest): string | undefined {
+    if (!request.prompt) {
+      return "Prompt is required";
     }
-    return { success: false, error: "AI provider not initialized" };
-  }
-
-  if (!request.prompt) {
-    return { success: false, error: "Prompt is required" };
-  }
-
-  const { model, buildInput, extractResult, onProgress } = options;
-
-  if (typeof __DEV__ !== "undefined" && __DEV__) {
-     
-    console.log(`[TextToVideoExecutor] Provider: ${provider.providerId}, Model: ${model}`);
+    return undefined;
   }
 
-  try {
-    onProgress?.(5);
-    if (typeof __DEV__ !== "undefined" && __DEV__) {
-       
-      console.log("[TextToVideoExecutor] Starting provider.run()...");
-    }
-
-    const input = buildInput(request.prompt, request.options);
+  protected async executeProvider(
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    provider: any,
+    model: string,
+    input: unknown,
+    onProgress?: (progress: number) => void,
+  ): Promise<unknown> {
+    this.logInfo("Starting provider.run()...");
 
+    // Provider reports real progress via callback
     const result = await provider.run(model, input, {
-      onProgress: (progressInfo) => {
+      onProgress: (progressInfo: { progress: number }) => {
         const progressValue = progressInfo.progress;
         if (typeof __DEV__ !== "undefined" && __DEV__) {
-           
-          console.log("[TextToVideoExecutor] Progress:", progressValue);
+          console.log("[TextToVideo] Progress:", progressValue);
         }
         onProgress?.(progressValue);
       },
     });
 
-    if (typeof __DEV__ !== "undefined" && __DEV__) {
-       
-      console.log("[TextToVideoExecutor] provider.run() completed", result);
-    }
-
-    const extractor = extractResult || defaultExtractResult;
-    const extracted = extractor(result);
-    onProgress?.(100);
+    this.logInfo("provider.run() completed");
+    return result;
+  }
 
+  protected validateExtractedResult(
+    extracted: ExtractedVideoResult | undefined,
+  ): string | undefined {
     if (!extracted?.videoUrl) {
-      if (typeof __DEV__ !== "undefined" && __DEV__) {
-         
-        console.error("[TextToVideoExecutor] No video URL in response");
-      }
-      return { success: false, error: "No video in response" };
+      return "No video in response";
     }
+    return undefined;
+  }
 
+  protected transformResult(
+    extracted: ExtractedVideoResult,
+  ): TextToVideoResult {
     return {
       success: true,
       videoUrl: extracted.videoUrl,
       thumbnailUrl: extracted.thumbnailUrl,
     };
-  } catch (error) {
-    const message = error instanceof Error ? error.message : String(error);
-    if (typeof __DEV__ !== "undefined" && __DEV__) {
-       
-      console.error("[TextToVideoExecutor] Error:", message);
-    }
-    return { success: false, error: message };
+  }
+
+  protected getDefaultExtractor(): (
+    result: unknown,
+  ) => ExtractedVideoResult | undefined {
+    return defaultExtractResult;
   }
 }
 
+// Singleton instance
+const executor = new TextToVideoExecutor();
+
+/**
+ * Execute text-to-video generation
+ * Public API maintained for backwards compatibility
+ */
+export async function executeTextToVideo(
+  request: TextToVideoRequest,
+  options: ExecuteTextToVideoOptions,
+): Promise<TextToVideoResult> {
+  const result: Result<TextToVideoResult, string> = await executor.execute(
+    request,
+    {
+      model: options.model,
+      buildInput: (req) => options.buildInput(req.prompt, req.options),
+      extractResult: options.extractResult,
+      onProgress: options.onProgress,
+    },
+  );
+
+  // Convert Result<T, E> back to legacy format for backwards compatibility
+  if (isSuccess(result)) {
+    return result.value;
+  }
+  return { success: false, error: result.error };
+}
+
+/**
+ * Check if text-to-video is supported
+ * Public API maintained for backwards compatibility
+ */
 export function hasTextToVideoSupport(): boolean {
-  const provider = providerRegistry.getActiveProvider();
-  return provider !== null && provider.isInitialized();
+  return executor.hasSupport();
 }

package/src/index.ts

@@ -5,6 +5,18 @@
 
 if (typeof __DEV__ !== "undefined" && __DEV__) console.log("📍 [LIFECYCLE] @umituz/react-native-ai-generation-content/index.ts - Module loading");
 
+// Result Type Pattern - Functional error handling
+export type {
+  Result, Success, Failure,
+} from "./domain/types";
+export {
+  success, failure, isSuccess, isFailure, mapResult, andThen, unwrap, unwrapOr,
+} from "./domain/types";
+
+// Base Executor - Template Method Pattern
+export { BaseExecutor } from "./infrastructure/executors";
+export type { BaseExecutorOptions } from "./infrastructure/executors";
+
 export type {
   AIProviderConfig, IAIProvider, JobSubmission, JobStatus, AIJobStatusType, AILogEntry,
   SubscribeOptions, RunOptions, ImageFeatureType, VideoFeatureType, ImageFeatureInputData,

package/src/infrastructure/executors/base-executor.ts

@@ -0,0 +1,169 @@
+/**
+ * BaseExecutor - Template Method Pattern
+ * Eliminates code duplication across 8+ executor implementations
+ *
+ * @see https://refactoring.guru/design-patterns/template-method/typescript/example
+ *
+ * Template Method Pattern defines skeleton of algorithm in base class,
+ * letting subclasses override specific steps without changing structure.
+ */
+
+import { providerRegistry } from "../services";
+import { failure, success, type Result } from "../../domain/types/result.types";
+
+declare const __DEV__: boolean;
+
+/**
+ * Base options that all executors share
+ */
+export interface BaseExecutorOptions<TInput, TOutput> {
+  model: string;
+  buildInput: (request: TInput) => unknown;
+  extractResult?: (result: unknown) => TOutput | undefined;
+  onProgress?: (progress: number) => void;
+}
+
+/**
+ * Abstract base class for all AI feature executors
+ * Implements Template Method pattern for execution flow
+ */
+export abstract class BaseExecutor<TRequest, TResult, TOutput> {
+  protected readonly logPrefix: string;
+
+  constructor(logPrefix: string) {
+    this.logPrefix = logPrefix;
+  }
+
+  /**
+   * Template Method - defines the execution algorithm skeleton
+   * This is the main method that orchestrates the execution flow
+   */
+  public async execute(
+    request: TRequest,
+    options: BaseExecutorOptions<TRequest, TOutput>,
+  ): Promise<Result<TResult, string>> {
+    // Step 1: Get provider
+    const provider = providerRegistry.getActiveProvider();
+    if (!provider) {
+      this.logError("No AI provider configured");
+      return failure("No AI provider configured");
+    }
+
+    // Step 2: Check initialization
+    if (!provider.isInitialized()) {
+      this.logError("AI provider not initialized");
+      return failure("AI provider not initialized");
+    }
+
+    // Step 3: Validate request (subclass-specific)
+    const validationError = this.validateRequest(request);
+    if (validationError) {
+      this.logError(validationError);
+      return failure(validationError);
+    }
+
+    // Step 4: Log execution start
+    this.logInfo(`Provider: ${provider.providerId}, Model: ${options.model}`);
+
+    // Step 5: Execute with error handling
+    try {
+      // Build input
+      const input = options.buildInput(request);
+
+      // Execute provider call (subclass-specific)
+      // Provider handles all progress reporting via callbacks
+      const providerResult = await this.executeProvider(
+        provider,
+        options.model,
+        input,
+        options.onProgress,
+      );
+
+      // Extract result
+      const extractor = options.extractResult || this.getDefaultExtractor();
+      const extracted = extractor(providerResult);
+
+      // Validate extracted result (subclass-specific)
+      const resultValidationError = this.validateExtractedResult(extracted);
+      if (resultValidationError) {
+        this.logError(resultValidationError);
+        return failure(resultValidationError);
+      }
+
+      // Transform to final result (subclass-specific)
+      return success(this.transformResult(extracted as TOutput));
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      this.logError(`Error: ${message}`);
+      return failure(message);
+    }
+  }
+
+  /**
+   * Check if feature is supported by current provider
+   */
+  public hasSupport(): boolean {
+    const provider = providerRegistry.getActiveProvider();
+    return provider !== null && provider.isInitialized();
+  }
+
+  // ==================== Abstract Methods (Must Override) ====================
+
+  /**
+   * Validate the incoming request
+   * Return error message if invalid, undefined if valid
+   */
+  protected abstract validateRequest(request: TRequest): string | undefined;
+
+  /**
+   * Execute the provider call (run or subscribe)
+   * Subclasses implement their specific provider interaction
+   */
+  protected abstract executeProvider(
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    provider: any,
+    model: string,
+    input: unknown,
+    onProgress?: (progress: number) => void,
+  ): Promise<unknown>;
+
+  /**
+   * Validate the extracted result
+   * Return error message if invalid, undefined if valid
+   */
+  protected abstract validateExtractedResult(
+    extracted: TOutput | undefined,
+  ): string | undefined;
+
+  /**
+   * Transform extracted output to final result type
+   */
+  protected abstract transformResult(extracted: TOutput): TResult;
+
+  /**
+   * Get default result extractor for this executor type
+   */
+  protected abstract getDefaultExtractor(): (
+    result: unknown,
+  ) => TOutput | undefined;
+
+  // ==================== Utility Methods ====================
+
+  /**
+   * Log info message (development only)
+   */
+  protected logInfo(message: string): void {
+    if (typeof __DEV__ !== "undefined" && __DEV__) {
+      console.log(`[${this.logPrefix}] ${message}`);
+    }
+  }
+
+  /**
+   * Log error message (development only)
+   */
+  protected logError(message: string): void {
+    if (typeof __DEV__ !== "undefined" && __DEV__) {
+      console.error(`[${this.logPrefix}] ${message}`);
+    }
+  }
+}

package/src/infrastructure/executors/index.ts

@@ -0,0 +1,7 @@
+/**
+ * Executors
+ * Base executor abstraction for AI features
+ */
+
+export { BaseExecutor } from "./base-executor";
+export type { BaseExecutorOptions } from "./base-executor";