@umituz/react-native-ai-gemini-provider 3.0.41 → 3.0.42

package/src/infrastructure/repositories/gemini-streaming.repository.impl.ts

@@ -0,0 +1,119 @@
+/**
+ * Gemini Streaming Repository Implementation
+ */
+
+import type { GeminiGenerationConfig } from "../../domain/entities";
+import type {
+  IStreamingRepository,
+  StreamingRequest,
+} from "../../domain/repositories/streaming.repository";
+import { ValidationService } from "../../domain/services/validation.service";
+import { ContentMapper } from "../mappers/content.mapper";
+import { BaseGeminiRepository } from "./base-gemini.repository";
+
+interface StreamChunk {
+  text(): string;
+}
+
+export class GeminiStreamingRepository
+  extends BaseGeminiRepository
+  implements IStreamingRepository
+{
+  constructor(
+    getModel: (name: string) => unknown,
+    validator: ValidationService,
+    contentMapper: ContentMapper
+  ) {
+    super(getModel as (name: string) => any, validator, contentMapper);
+  }
+
+  /**
+   * Stream text content
+   */
+  async stream(request: StreamingRequest): Promise<string> {
+    this.validator.validateCallback(request.onChunk, "onChunk");
+
+    return this.executeWithErrorHandling(async () => {
+      const { genModel, sdkContents, config, signal } =
+        this.prepareRequest(request);
+
+      const requestOptions = this.createRequestOptions(
+        sdkContents,
+        config
+      );
+
+      const result = signal
+        ? await (genModel as any).generateContentStream(
+            requestOptions,
+            { signal }
+          )
+        : await (genModel as any).generateContentStream(requestOptions);
+
+      return await this.processStream(
+        result.stream,
+        request.onChunk
+      );
+    }, "GeminiStreamingRepository.stream");
+  }
+
+  /**
+   * Stream simple text from prompt
+   */
+  async streamText(
+    model: string,
+    prompt: string,
+    onChunk: (text: string) => void,
+    config?: GeminiGenerationConfig,
+    signal?: AbortSignal
+  ): Promise<string> {
+    this.validator.validatePrompt(prompt);
+
+    const contents = [this.contentMapper.createTextContent(prompt, "user")];
+    return this.stream({
+      model,
+      contents,
+      onChunk,
+      generationConfig: config,
+      signal,
+    });
+  }
+
+  /**
+   * Process stream with chunk callback
+   */
+  private async processStream(
+    stream: AsyncIterable<StreamChunk>,
+    onChunk: (text: string) => void
+  ): Promise<string> {
+    let fullText = "";
+
+    for await (const chunk of stream) {
+      try {
+        const chunkText = chunk.text();
+        if (chunkText) {
+          fullText += chunkText;
+          this.safeCallChunk(onChunk, chunkText);
+        }
+      } catch (chunkError) {
+        // Chunk errors are critical (e.g., safety blocks)
+        throw chunkError;
+      }
+    }
+
+    return fullText;
+  }
+
+  /**
+   * Safely call chunk callback
+   */
+  private safeCallChunk(
+    callback: (text: string) => void,
+    text: string
+  ): void {
+    try {
+      callback(text);
+    } catch {
+      // Silently ignore callback errors
+    }
+  }
+}

package/src/infrastructure/repositories/gemini-structured-text.repository.impl.ts

@@ -0,0 +1,108 @@
+/**
+ * Gemini Structured Text Repository Implementation
+ */
+
+import type { GeminiContent, GeminiGenerationConfig } from "../../domain/entities";
+import type {
+  IStructuredTextRepository,
+  StructuredGenerationRequest,
+} from "../../domain/repositories/structured-text.repository";
+import { ValidationService } from "../../domain/services/validation.service";
+import { ContentMapper } from "../mappers/content.mapper";
+import { ResponseMapper } from "../mappers/response.mapper";
+import { parseJsonResponse } from "../utils/json-parser.util";
+import { BaseGeminiRepository } from "./base-gemini.repository";
+
+export class GeminiStructuredTextRepository
+  extends BaseGeminiRepository
+  implements IStructuredTextRepository
+{
+  constructor(
+    getModel: (name: string) => unknown,
+    validator: ValidationService,
+    contentMapper: ContentMapper,
+    private readonly responseMapper: ResponseMapper
+  ) {
+    super(getModel as (name: string) => any, validator, contentMapper);
+  }
+
+  /**
+   * Generate structured JSON from prompt
+   */
+  async generateStructured<T>(
+    request: StructuredGenerationRequest
+  ): Promise<T> {
+    this.validator.validatePrompt(request.prompt);
+    this.validator.validateSchema(request.schema);
+
+    const generationConfig: GeminiGenerationConfig = {
+      ...request.config,
+      responseMimeType: "application/json",
+      responseSchema: request.schema as any,
+    };
+
+    const contents = [
+      this.contentMapper.createTextContent(request.prompt, "user"),
+    ];
+
+    return this.generateStructuredFromContents<T>(
+      request.model,
+      contents,
+      request.schema,
+      generationConfig,
+      request.signal
+    );
+  }
+
+  /**
+   * Generate structured JSON from contents
+   */
+  async generateStructuredFromContents<T>(
+    model: string,
+    contents: GeminiContent[],
+    schema: Record<string, unknown>,
+    config?: GeminiGenerationConfig,
+    signal?: AbortSignal
+  ): Promise<T> {
+    const generationConfig: GeminiGenerationConfig = {
+      ...config,
+      responseMimeType: "application/json",
+      responseSchema: schema as any,
+    };
+
+    return this.executeWithErrorHandling(async () => {
+      const { genModel, sdkContents, config: finalConfig } =
+        this.prepareRequest({
+          model,
+          contents,
+          generationConfig: generationConfig,
+          signal,
+        });
+
+      const requestOptions = this.createRequestOptions(
+        sdkContents,
+        finalConfig
+      );
+
+      const result = signal
+        ? await (genModel as any).generateContent(requestOptions, {
+            signal,
+          })
+        : await (genModel as any).generateContent(requestOptions);
+
+      if (!result.response) {
+        throw new Error("No response received from Gemini API");
+      }
+
+      const response = this.responseMapper.toDomain(result.response);
+      const candidates = response.candidates;
+
+      if (!candidates || candidates.length === 0) {
+        throw new Error("No candidates in response");
+      }
+
+      const text = this.responseMapper.extractText(response);
+      return parseJsonResponse<T>(text);
+    }, "GeminiStructuredTextRepository.generateStructuredFromContents");
+  }
+}

package/src/infrastructure/repositories/gemini-text.repository.impl.ts

@@ -0,0 +1,76 @@
+/**
+ * Gemini Text Generation Repository Implementation
+ */
+
+import type { GeminiGenerationConfig, GeminiResponse } from "../../domain/entities";
+import type {
+  ITextGenerationRepository,
+  TextGenerationRequest,
+} from "../../domain/repositories/text-generation.repository";
+import { ValidationService } from "../../domain/services/validation.service";
+import { ContentMapper } from "../mappers/content.mapper";
+import { ResponseMapper } from "../mappers/response.mapper";
+import { BaseGeminiRepository } from "./base-gemini.repository";
+
+export class GeminiTextRepository
+  extends BaseGeminiRepository
+  implements ITextGenerationRepository
+{
+  constructor(
+    getModel: (name: string) => unknown,
+    validator: ValidationService,
+    contentMapper: ContentMapper,
+    private readonly responseMapper: ResponseMapper
+  ) {
+    super(getModel as (name: string) => any, validator, contentMapper);
+  }
+
+  /**
+   * Generate text content
+   */
+  async generate(request: TextGenerationRequest): Promise<GeminiResponse> {
+    return this.executeWithErrorHandling(async () => {
+      const { genModel, sdkContents, config, signal } =
+        this.prepareRequest(request);
+
+      const requestOptions = this.createRequestOptions(
+        sdkContents,
+        config
+      );
+
+      const result = signal
+        ? await (genModel as any).generateContent(requestOptions, {
+            signal,
+          })
+        : await (genModel as any).generateContent(requestOptions);
+
+      if (!result.response) {
+        throw new Error("No response received from Gemini API");
+      }
+
+      return this.responseMapper.toDomain(result.response);
+    }, "GeminiTextRepository.generate");
+  }
+
+  /**
+   * Generate simple text from prompt
+   */
+  async generateText(
+    model: string,
+    prompt: string,
+    config?: GeminiGenerationConfig,
+    signal?: AbortSignal
+  ): Promise<string> {
+    this.validator.validatePrompt(prompt);
+
+    const contents = [this.contentMapper.createTextContent(prompt, "user")];
+    const response = await this.generate({
+      model,
+      contents,
+      generationConfig: config,
+      signal,
+    });
+
+    return this.responseMapper.extractText(response);
+  }
+}

package/src/infrastructure/repositories/index.ts

@@ -0,0 +1,10 @@
+/**
+ * Infrastructure Repository Implementations
+ */
+
+export { BaseGeminiRepository } from "./base-gemini.repository";
+export { GeminiTextRepository } from "./gemini-text.repository.impl";
+export { GeminiStreamingRepository } from "./gemini-streaming.repository.impl";
+export {
+  GeminiStructuredTextRepository,
+} from "./gemini-structured-text.repository.impl";

package/src/infrastructure/utils/index.ts

@@ -0,0 +1,6 @@
+/**
+ * Infrastructure Utilities
+ */
+
+export { parseJsonResponse } from "./json-parser.util";
+export { processStream } from "./stream-processor.util";

package/src/presentation/hooks/index.ts

@@ -0,0 +1,8 @@
+/**
+ * Presentation Hooks
+ */
+
+export { useGemini } from "./use-gemini.hook";
+export { useOperationManager } from "./use-operation-manager.hook";
+export type { UseGeminiOptions, UseGeminiReturn } from "./use-gemini.hook";
+export type { OperationManager } from "./use-operation-manager.hook";

package/src/presentation/hooks/use-gemini.hook.ts

@@ -0,0 +1,181 @@
+/**
+ * useGemini Hook
+ * React hook for Gemini operations using DDD architecture
+ */
+
+import { useState, useCallback, useMemo } from "react";
+import type { GeminiGenerationConfig } from "../../domain/entities";
+import { DEFAULT_MODELS } from "../../domain/entities";
+import { GenerateTextUseCase } from "../../application/use-cases/generate-text.use-case";
+import { StreamContentUseCase } from "../../application/use-cases/stream-content.use-case";
+import { GenerateJSONUseCase } from "../../application/use-cases/generate-json.use-case";
+import { geminiProvider } from "../../application/providers/gemini-provider";
+import { useOperationManager } from "./use-operation-manager.hook";
+
+export interface UseGeminiOptions {
+  model?: string;
+  generationConfig?: GeminiGenerationConfig;
+  onSuccess?: (result: string) => void;
+  onError?: (error: string) => void;
+}
+
+export interface UseGeminiReturn {
+  // Text generation
+  generate: (prompt: string) => Promise<void>;
+  // JSON generation
+  generateJSON: <T>(prompt: string, schema: Record<string, unknown>) => Promise<T | null>;
+  // Streaming
+  stream: (prompt: string, onChunk: (text: string) => void) => Promise<void>;
+  // State
+  result: string | null;
+  jsonResult: unknown;
+  isGenerating: boolean;
+  error: string | null;
+  // Actions
+  reset: () => void;
+  abort: () => void;
+}
+
+export function useGemini(options: UseGeminiOptions = {}): UseGeminiReturn {
+  const [result, setResult] = useState<string | null>(null);
+  const [jsonResult, setJsonResult] = useState<unknown>(null);
+  const [isGenerating, setIsGenerating] = useState(false);
+  const [error, setError] = useState<string | null>(null);
+
+  const { executeOperation, abort } = useOperationManager();
+
+  const model = options.model ?? DEFAULT_MODELS.TEXT;
+
+  // Generate text
+  const generate = useCallback(
+    async (prompt: string) => {
+      setIsGenerating(true);
+      setError(null);
+      setResult(null);
+
+      try {
+        const useCase = new GenerateTextUseCase(
+          geminiProvider.getTextRepository(),
+          geminiProvider.getValidator(),
+          geminiProvider.getContentMapper()
+        );
+
+        const text = await executeOperation(async (signal) => {
+          return useCase.executeSimple({
+            model,
+            prompt,
+            config: options.generationConfig,
+            signal,
+          });
+        });
+
+        setResult(text);
+        options.onSuccess?.(text);
+      } catch (err) {
+        const errorMessage = err instanceof Error ? err.message : "Generation failed";
+        setError(errorMessage);
+        options.onError?.(errorMessage);
+      } finally {
+        setIsGenerating(false);
+      }
+    },
+    [model, options.generationConfig, options.onSuccess, options.onError, executeOperation]
+  );
+
+  // Generate JSON
+  const generateJSON = useCallback(
+    async <T>(prompt: string, schema: Record<string, unknown>): Promise<T | null> => {
+      setIsGenerating(true);
+      setError(null);
+      setJsonResult(null);
+
+      try {
+        const useCase = new GenerateJSONUseCase(
+          geminiProvider.getStructuredTextRepository(),
+          geminiProvider.getValidator()
+        );
+
+        const data = await executeOperation(async (signal) => {
+          return useCase.executeSimple<T>({
+            model,
+            prompt,
+            schema,
+            config: options.generationConfig,
+            signal,
+          });
+        });
+
+        setJsonResult(data);
+        setResult(JSON.stringify(data, null, 2));
+        options.onSuccess?.(JSON.stringify(data, null, 2));
+
+        return data;
+      } catch (err) {
+        const errorMessage = err instanceof Error ? err.message : "Generation failed";
+        setError(errorMessage);
+        options.onError?.(errorMessage);
+        return null;
+      } finally {
+        setIsGenerating(false);
+      }
+    },
+    [model, options.generationConfig, options.onSuccess, options.onError, executeOperation]
+  );
+
+  // Stream content
+  const stream = useCallback(
+    async (prompt: string, onChunk: (text: string) => void) => {
+      setIsGenerating(true);
+      setError(null);
+      setResult(null);
+
+      try {
+        const useCase = new StreamContentUseCase(
+          geminiProvider.getStreamingRepository(),
+          geminiProvider.getValidator(),
+          geminiProvider.getContentMapper()
+        );
+
+        const text = await executeOperation(async (signal) => {
+          return useCase.execute({
+            model,
+            prompt,
+            onChunk,
+            config: options.generationConfig,
+            signal,
+          });
+        });
+
+        setResult(text);
+        options.onSuccess?.(text);
+      } catch (err) {
+        const errorMessage = err instanceof Error ? err.message : "Streaming failed";
+        setError(errorMessage);
+        options.onError?.(errorMessage);
+      } finally {
+        setIsGenerating(false);
+      }
+    },
+    [model, options.generationConfig, options.onSuccess, options.onError, executeOperation]
+  );
+
+  const reset = useCallback(() => {
+    abort();
+    setResult(null);
+    setJsonResult(null);
+    setIsGenerating(false);
+    setError(null);
+  }, [abort]);
+
+  return {
+    generate,
+    generateJSON,
+    stream,
+    result,
+    jsonResult,
+    isGenerating,
+    error,
+    reset,
+    abort,
+  };
+}

package/src/presentation/hooks/use-operation-manager.hook.ts

@@ -0,0 +1,67 @@
+/**
+ * Operation Manager Hook
+ * Manages abort controllers and operation tracking
+ */
+
+import { useRef, useCallback, useEffect } from "react";
+
+export interface OperationManager {
+  executeOperation: <T>(
+    operation: (signal: AbortSignal) => Promise<T>
+  ) => Promise<T>;
+  abort: () => void;
+  isOperationActive: () => boolean;
+}
+
+export function useOperationManager(): OperationManager {
+  const abortControllerRef = useRef<AbortController | null>(null);
+  const isActiveRef = useRef(false);
+
+  const abort = useCallback(() => {
+    if (abortControllerRef.current) {
+      abortControllerRef.current.abort();
+      abortControllerRef.current = null;
+    }
+    isActiveRef.current = false;
+  }, []);
+
+  const executeOperation = useCallback(
+    async <T>(operation: (signal: AbortSignal) => Promise<T>): Promise<T> => {
+      // Abort any existing operation
+      abort();
+
+      // Create new controller
+      const controller = new AbortController();
+      abortControllerRef.current = controller;
+      isActiveRef.current = true;
+
+      try {
+        return await operation(controller.signal);
+      } finally {
+        // Clean up only if still active
+        if (abortControllerRef.current === controller) {
+          abortControllerRef.current = null;
+          isActiveRef.current = false;
+        }
+      }
+    },
+    [abort]
+  );
+
+  const isOperationActive = useCallback((): boolean => {
+    return isActiveRef.current;
+  }, []);
+
+  // Cleanup on unmount
+  useEffect(() => {
+    return () => {
+      abort();
+    };
+  }, [abort]);
+
+  return {
+    executeOperation,
+    abort,
+    isOperationActive,
+  };
+}

package/src/presentation/index.ts

@@ -0,0 +1,10 @@
+/**
+ * Presentation Layer
+ * React hooks and providers
+ */
+
+// Hooks
+export * from "./hooks";
+
+// Providers
+export * from "./providers";

package/src/presentation/providers/gemini-provider.tsx

@@ -0,0 +1,93 @@
+/**
+ * Gemini Provider Component
+ * React context provider for Gemini services
+ */
+
+import React, { createContext, useContext, useMemo, type ReactNode } from "react";
+import { GeminiConfigBuilder } from "../../application/builders/config-builder";
+import { geminiProvider } from "../../application/providers/gemini-provider";
+import type { GeminiConfig } from "../../domain/entities";
+
+interface GeminiContextValue {
+  isInitialized: boolean;
+  initialize: (config: GeminiConfig) => void;
+  reset: () => void;
+}
+
+const GeminiContext = createContext<GeminiContextValue | undefined>(undefined);
+
+export interface GeminiProviderProps {
+  children: ReactNode;
+  config?: GeminiConfig;
+}
+
+export function GeminiProviderComponent({
+  children,
+  config: initialConfig,
+}: GeminiProviderProps) {
+  const [isInitialized, setIsInitialized] = React.useState(false);
+
+  const initialize = React.useCallback((config: GeminiConfig) => {
+    geminiProvider.initialize(config);
+    setIsInitialized(true);
+  }, []);
+
+  const reset = React.useCallback(() => {
+    // Reset using the class directly
+    const { GeminiProviderClass } = require("../../application/providers");
+    GeminiProviderClass.reset();
+    setIsInitialized(false);
+  }, []);
+
+  // Initialize with config if provided
+  React.useEffect(() => {
+    if (initialConfig && !isInitialized) {
+      initialize(initialConfig);
+    }
+  }, [initialConfig, isInitialized, initialize]);
+
+  const value = useMemo(
+    () => ({
+      isInitialized,
+      initialize,
+      reset,
+    }),
+    [isInitialized, initialize, reset]
+  );
+
+  return <GeminiContext.Provider value={value}>{children}</GeminiContext.Provider>;
+}
+
+/**
+ * Hook to access Gemini context
+ */
+export function useGeminiContext(): GeminiContextValue {
+  const context = useContext(GeminiContext);
+  if (!context) {
+    throw new Error("useGeminiContext must be used within GeminiProvider");
+  }
+  return context;
+}
+
+/**
+ * Convenience hook to initialize with builder
+ */
+export function useGeminiInitializer() {
+  const { initialize, isInitialized } = useGeminiContext();
+
+  const initWithBuilder = React.useCallback(
+    (builderOrConfig: GeminiConfigBuilder | GeminiConfig) => {
+      const config =
+        builderOrConfig instanceof GeminiConfigBuilder
+          ? builderOrConfig.build()
+          : builderOrConfig;
+      initialize(config);
+    },
+    [initialize]
+  );
+
+  return {
+    initialize: initWithBuilder,
+    isInitialized,
+  };
+}

package/src/presentation/providers/index.ts

@@ -0,0 +1,10 @@
+/**
+ * Presentation Providers
+ */
+
+export {
+  GeminiProviderComponent,
+  useGeminiContext,
+  useGeminiInitializer,
+} from "./gemini-provider";
+export type { GeminiProviderProps } from "./gemini-provider";