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

package/src/domain/repositories/streaming.repository.ts

@@ -0,0 +1,41 @@
+/**
+ * Streaming Repository Interface
+ * Domain layer contract for streaming operations
+ */
+
+import type { GeminiContent, GeminiGenerationConfig } from "../entities";
+
+export interface StreamingRequest {
+  model: string;
+  contents: GeminiContent[];
+  onChunk: (text: string) => void;
+  generationConfig?: GeminiGenerationConfig;
+  signal?: AbortSignal;
+}
+
+export interface IStreamingRepository {
+  /**
+   * Stream text content from Gemini API
+   * @param request - Streaming request parameters
+   * @returns Complete generated text
+   * @throws GeminiError on API errors
+   */
+  stream(request: StreamingRequest): Promise<string>;
+
+  /**
+   * Stream text from a simple prompt
+   * @param model - Model name
+   * @param prompt - Text prompt
+   * @param onChunk - Callback for each chunk
+   * @param config - Optional generation config
+   * @param signal - Optional abort signal
+   * @returns Complete generated text
+   */
+  streamText(
+    model: string,
+    prompt: string,
+    onChunk: (text: string) => void,
+    config?: GeminiGenerationConfig,
+    signal?: AbortSignal
+  ): Promise<string>;
+}

package/src/domain/repositories/structured-text.repository.ts

@@ -0,0 +1,41 @@
+/**
+ * Structured Text Repository Interface
+ * Domain layer contract for structured JSON generation
+ */
+
+import type { GeminiContent, GeminiGenerationConfig } from "../entities";
+
+export interface StructuredGenerationRequest {
+  model: string;
+  prompt: string;
+  schema: Record<string, unknown>;
+  config?: Omit<GeminiGenerationConfig, "responseMimeType" | "responseSchema">;
+  signal?: AbortSignal;
+}
+
+export interface IStructuredTextRepository {
+  /**
+   * Generate structured JSON response from Gemini API
+   * @param request - Structured generation request
+   * @returns Parsed JSON response
+   * @throws GeminiError on API errors
+   */
+  generateStructured<T>(request: StructuredGenerationRequest): Promise<T>;
+
+  /**
+   * Generate structured JSON from contents
+   * @param model - Model name
+   * @param contents - Content array
+   * @param schema - JSON schema
+   * @param config - Optional generation config
+   * @param signal - Optional abort signal
+   * @returns Parsed JSON response
+   */
+  generateStructuredFromContents<T>(
+    model: string,
+    contents: GeminiContent[],
+    schema: Record<string, unknown>,
+    config?: GeminiGenerationConfig,
+    signal?: AbortSignal
+  ): Promise<T>;
+}

package/src/domain/repositories/text-generation.repository.ts

@@ -0,0 +1,38 @@
+/**
+ * Text Generation Repository Interface
+ * Domain layer contract for text generation operations
+ */
+
+import type { GeminiContent, GeminiGenerationConfig, GeminiResponse } from "../entities";
+
+export interface TextGenerationRequest {
+  model: string;
+  contents: GeminiContent[];
+  generationConfig?: GeminiGenerationConfig;
+  signal?: AbortSignal;
+}
+
+export interface ITextGenerationRepository {
+  /**
+   * Generate text content from Gemini API
+   * @param request - Generation request parameters
+   * @returns Generated response
+   * @throws GeminiError on API errors
+   */
+  generate(request: TextGenerationRequest): Promise<GeminiResponse>;
+
+  /**
+   * Generate simple text from a prompt
+   * @param model - Model name
+   * @param prompt - Text prompt
+   * @param config - Optional generation config
+   * @param signal - Optional abort signal
+   * @returns Generated text
+   */
+  generateText(
+    model: string,
+    prompt: string,
+    config?: GeminiGenerationConfig,
+    signal?: AbortSignal
+  ): Promise<string>;
+}

package/src/domain/services/validation.service.ts

@@ -0,0 +1,157 @@
+/**
+ * Domain Validation Service
+ * Pure validation functions for domain entities
+ */
+
+import type { GeminiContent } from "../entities";
+
+export class ValidationError extends Error {
+  constructor(message: string) {
+    super(message);
+    this.name = "ValidationError";
+  }
+}
+
+export class ValidationService {
+  /**
+   * Validate prompt text
+   */
+  validatePrompt(prompt: string): void {
+    if (!prompt || typeof prompt !== "string") {
+      throw new ValidationError("Prompt must be a string");
+    }
+
+    const trimmed = prompt.trim();
+    if (trimmed.length < 3) {
+      throw new ValidationError("Prompt must be at least 3 characters");
+    }
+
+    if (trimmed.length > 100000) {
+      throw new ValidationError("Prompt too long (max 100k characters)");
+    }
+  }
+
+  /**
+   * Validate JSON schema object
+   */
+  validateSchema(schema: unknown): void {
+    if (!schema || typeof schema !== "object") {
+      throw new ValidationError("Schema must be an object");
+    }
+
+    if (Array.isArray(schema)) {
+      throw new ValidationError("Schema cannot be an array");
+    }
+
+    const keys = Object.keys(schema);
+    if (keys.length === 0) {
+      throw new ValidationError("Schema cannot be empty");
+    }
+
+    // Recursively validate nested schema properties
+    for (const value of Object.values(schema)) {
+      if (typeof value === "object" && value !== null) {
+        this.validateSchema(value);
+      }
+    }
+  }
+
+  /**
+   * Validate contents array
+   */
+  validateContents(contents: GeminiContent[]): void {
+    if (!Array.isArray(contents)) {
+      throw new ValidationError("Contents must be an array");
+    }
+
+    if (contents.length === 0) {
+      throw new ValidationError("Contents cannot be empty");
+    }
+
+    if (contents.length > 1000) {
+      throw new ValidationError("Too many content items (max 1000)");
+    }
+
+    // Validate each content item
+    for (const content of contents) {
+      this.validateContent(content);
+    }
+  }
+
+  /**
+   * Validate single content item
+   */
+  private validateContent(content: GeminiContent): void {
+    if (!content.role || typeof content.role !== "string") {
+      throw new ValidationError("Content role is required");
+    }
+
+    if (!content.parts || !Array.isArray(content.parts)) {
+      throw new ValidationError("Content parts must be an array");
+    }
+
+    if (content.parts.length === 0) {
+      throw new ValidationError("Content parts cannot be empty");
+    }
+
+    // Validate each part
+    for (const part of content.parts) {
+      const hasText = "text" in part && typeof part.text === "string" && part.text.length > 0;
+      const hasInlineData = "inlineData" in part && part.inlineData !== null;
+
+      if (!hasText && !hasInlineData) {
+        throw new ValidationError("Each part must have text or inlineData");
+      }
+    }
+  }
+
+  /**
+   * Validate model name
+   */
+  validateModelName(model: string): void {
+    if (!model || typeof model !== "string") {
+      throw new ValidationError("Model name is required");
+    }
+
+    if (!model.startsWith("gemini-")) {
+      throw new ValidationError("Model name must start with 'gemini-'");
+    }
+  }
+
+  /**
+   * Validate callback function
+   */
+  validateCallback(callback: unknown, name: string): void {
+    if (typeof callback !== "function") {
+      throw new ValidationError(`${name} must be a function`);
+    }
+  }
+
+  /**
+   * Validate generation config
+   */
+  validateConfig(config: unknown): void {
+    if (!config) return; // Config is optional
+
+    if (typeof config !== "object" || Array.isArray(config)) {
+      throw new ValidationError("Config must be an object");
+    }
+
+    // Validate temperature if present
+    const cfg = config as Record<string, unknown>;
+    if (cfg.temperature !== undefined) {
+      const temp = cfg.temperature as number;
+      if (typeof temp !== "number" || temp < 0 || temp > 2) {
+        throw new ValidationError("Temperature must be between 0 and 2");
+      }
+    }
+
+    // Validate max output tokens if present
+    if (cfg.maxOutputTokens !== undefined) {
+      const tokens = cfg.maxOutputTokens as number;
+      if (typeof tokens !== "number" || tokens < 1 || tokens > 8192) {
+        throw new ValidationError("maxOutputTokens must be between 1 and 8192");
+      }
+    }
+  }
+}

package/src/domain/value-objects/api-key.vo.ts

@@ -0,0 +1,55 @@
+/**
+ * API Key Value Object
+ * Encapsulates API key validation and formatting
+ */
+
+export class ApiKey {
+  private static readonly MIN_LENGTH = 10;
+  private static readonly PREFIX = "AIza";
+
+  private constructor(private readonly value: string) {}
+
+  /**
+   * Create a validated API key
+   * @throws Error if validation fails
+   */
+  static create(value: string): ApiKey {
+    const trimmed = value?.trim() || "";
+
+    if (trimmed.length < ApiKey.MIN_LENGTH) {
+      throw new Error(
+        `API key must be at least ${ApiKey.MIN_LENGTH} characters`
+      );
+    }
+
+    if (!trimmed.startsWith(ApiKey.PREFIX)) {
+      throw new Error(
+        `API key must start with "${ApiKey.PREFIX}"`
+      );
+    }
+
+    return new ApiKey(trimmed);
+  }
+
+  /**
+   * Get the API key value
+   */
+  getValue(): string {
+    return this.value;
+  }
+
+  /**
+   * Check if API key equals another
+   */
+  equals(other: ApiKey): boolean {
+    return this.value === other.value;
+  }
+
+  /**
+   * Get masked version for logging (e.g., "AIza...xyz")
+   */
+  toMasked(): string {
+    if (this.value.length <= 10) return "***";
+    return `${this.value.substring(0, 6)}...${this.value.substring(this.value.length - 3)}`;
+  }
+}

package/src/domain/value-objects/index.ts

@@ -0,0 +1,8 @@
+/**
+ * Domain Value Objects
+ * Immutable, self-validating value objects
+ */
+
+export { ApiKey } from "./api-key.vo";
+export { ModelName } from "./model-name.vo";
+export { Timeout } from "./timeout.vo";

package/src/domain/value-objects/model-name.vo.ts

@@ -0,0 +1,66 @@
+/**
+ * Model Name Value Object
+ * Encapsulates Gemini model name validation
+ */
+
+export class ModelName {
+  private static readonly PREFIX = "gemini-";
+
+  private constructor(private readonly value: string) {}
+
+  /**
+   * Create a validated model name
+   * @throws Error if validation fails
+   */
+  static create(value: string): ModelName {
+    const trimmed = value?.trim() || "";
+
+    if (!trimmed) {
+      throw new Error("Model name cannot be empty");
+    }
+
+    if (!trimmed.startsWith(ModelName.PREFIX)) {
+      throw new Error(
+        `Model name must start with "${ModelName.PREFIX}"`
+      );
+    }
+
+    return new ModelName(trimmed);
+  }
+
+  /**
+   * Get the model name value
+   */
+  getValue(): string {
+    return this.value;
+  }
+
+  /**
+   * Check if this is a Flash model (faster, cheaper)
+   */
+  isFlash(): boolean {
+    return this.value.includes("flash");
+  }
+
+  /**
+   * Check if this is a Pro model (higher quality)
+   */
+  isPro(): boolean {
+    return this.value.includes("pro");
+  }
+
+  /**
+   * Get model family (e.g., "gemini-2.5-flash" -> "2.5")
+   */
+  getVersion(): string {
+    const match = this.value.match(/gemini-([\d.]+)/);
+    return match ? match[1] : "unknown";
+  }
+
+  /**
+   * Check if model name equals another
+   */
+  equals(other: ModelName): boolean {
+    return this.value === other.value;
+  }
+}

package/src/domain/value-objects/timeout.vo.ts

@@ -0,0 +1,69 @@
+/**
+ * Timeout Value Object
+ * Encapsulates timeout duration validation
+ */
+
+export class Timeout {
+  private static readonly MIN_MS = 1;
+  private static readonly MAX_MS = 300000; // 5 minutes
+
+  private constructor(private readonly valueMs: number) {}
+
+  /**
+   * Create a validated timeout in milliseconds
+   * @throws Error if validation fails
+   */
+  static create(milliseconds: number): Timeout {
+    const value = milliseconds ?? 30000; // Default 30s
+
+    if (value < Timeout.MIN_MS || value > Timeout.MAX_MS) {
+      throw new Error(
+        `Timeout must be between ${Timeout.MIN_MS}ms and ${Timeout.MAX_MS}ms`
+      );
+    }
+
+    return new Timeout(value);
+  }
+
+  /**
+   * Create timeout in seconds
+   */
+  static fromSeconds(seconds: number): Timeout {
+    return Timeout.create(seconds * 1000);
+  }
+
+  /**
+   * Get timeout in milliseconds
+   */
+  toMilliseconds(): number {
+    return this.valueMs;
+  }
+
+  /**
+   * Get timeout in seconds
+   */
+  toSeconds(): number {
+    return Math.round(this.valueMs / 1000);
+  }
+
+  /**
+   * Check if this is a short timeout (< 10s)
+   */
+  isShort(): boolean {
+    return this.valueMs < 10000;
+  }
+
+  /**
+   * Check if this is a long timeout (> 60s)
+   */
+  isLong(): boolean {
+    return this.valueMs > 60000;
+  }
+
+  /**
+   * Check if timeout equals another
+   */
+  equals(other: Timeout): boolean {
+    return this.valueMs === other.valueMs;
+  }
+}

package/src/index.ts

@@ -1,9 +1,17 @@
 /**
  * @umituz/react-native-ai-gemini-provider
  * Google Gemini AI provider for React Native applications
+ *
+ * Clean DDD Architecture - Production Ready
+ *
+ * @version 4.0.0
  */
 
-// Domain Types
+// ============================================================================
+// DOMAIN LAYER - Core business logic and types
+// ============================================================================
+
+// Domain Entities
 export type {
   GeminiConfig,
   GeminiGenerationConfig,
@@ -29,31 +37,108 @@ export {
   GeminiErrorType,
   GeminiError,
   GEMINI_MODELS,
-  DEFAULT_MODELS
+  DEFAULT_MODELS,
 } from "./domain/entities";
 
-// Services
-export { geminiClient } from "./infrastructure/services/GeminiClient";
+// Value Objects
+export { ApiKey, ModelName, Timeout } from "./domain/value-objects";
+
+// Domain Services
+export { ValidationService, ValidationError } from "./domain/services/validation.service";
+
+// Repository Interfaces
+export type {
+  ITextGenerationRepository,
+  TextGenerationRequest,
+} from "./domain/repositories/text-generation.repository";
+
+export type {
+  IStreamingRepository,
+  StreamingRequest,
+} from "./domain/repositories/streaming.repository";
+
+export type {
+  IStructuredTextRepository,
+  StructuredGenerationRequest,
+} from "./domain/repositories/structured-text.repository";
+
+// ============================================================================
+// APPLICATION LAYER - Use cases and orchestration
+// ============================================================================
+
+// Use Cases
 export {
-  createChatSession,
-  sendChatMessage,
-  buildChatHistory,
-  trimChatHistory,
-  type ChatSendResult,
-  type ChatHistoryMessage,
-  type SendChatMessageOptions,
-} from "./infrastructure/services/ChatSession";
-export { textGeneration } from "./infrastructure/services/TextGeneration";
-export { structuredText } from "./infrastructure/services/StructuredText";
-export { streaming } from "./infrastructure/services/Streaming";
-
-// React Hook
-export { useGemini } from "./presentation/hooks/useGemini";
-export type { UseGeminiOptions, UseGeminiReturn } from "./presentation/hooks/useGemini";
-
-// Provider Configuration & Factory
-export { ConfigBuilder, providerFactory } from "./providers/ProviderFactory";
+  GenerateTextUseCase,
+  StreamContentUseCase,
+  GenerateJSONUseCase,
+} from "./application/use-cases";
+
 export type {
-  ProviderConfig,
-  ProviderFactoryOptions,
-} from "./providers/ProviderFactory";
+  GenerateTextOptions,
+  GenerateTextResult,
+  StreamContentOptions,
+  GenerateJSONOptions,
+  GenerateJSONResult,
+} from "./application/use-cases";
+
+// Builders
+export { GeminiConfigBuilder } from "./application/builders";
+
+export type { GeminiConfigOptions } from "./application/builders";
+
+// Providers
+export { geminiProvider, GeminiProviderClass } from "./application/providers";
+
+export type { GeminiProvider } from "./application/providers";
+
+// ============================================================================
+// INFRASTRUCTURE LAYER - External integrations
+// ============================================================================
+
+// Mappers
+export {
+  ContentMapper,
+  ResponseMapper,
+  ErrorMapper,
+} from "./infrastructure/mappers";
+
+// SDK Adapter
+export {
+  GeminiSDKAdapter,
+  GeminiClient,
+  geminiClient,
+} from "./infrastructure/external";
+
+// Repository Implementations
+export {
+  BaseGeminiRepository,
+  GeminiTextRepository,
+  GeminiStreamingRepository,
+  GeminiStructuredTextRepository,
+} from "./infrastructure/repositories";
+
+// Utilities
+export { parseJsonResponse } from "./infrastructure/utils/json-parser.util";
+
+// ============================================================================
+// PRESENTATION LAYER - React hooks and providers
+// ============================================================================
+
+// React Hooks
+export { useGemini, useOperationManager } from "./presentation/hooks";
+
+export type {
+  UseGeminiOptions,
+  UseGeminiReturn,
+} from "./presentation/hooks";
+
+export type { OperationManager } from "./presentation/hooks/use-operation-manager.hook";
+
+// React Provider Component
+export {
+  GeminiProviderComponent,
+  useGeminiContext,
+  useGeminiInitializer,
+} from "./presentation/providers";
+
+export type { GeminiProviderProps } from "./presentation/providers";

package/src/infrastructure/external/gemini-client.singleton.ts

@@ -0,0 +1,49 @@
+/**
+ * Gemini Client Singleton
+ * Global access point for Gemini SDK adapter
+ */
+
+import { GeminiSDKAdapter } from "./gemini-sdk.adapter";
+
+let instance: GeminiSDKAdapter | null = null;
+
+export class GeminiClient {
+  private constructor() {}
+
+  /**
+   * Get the singleton instance
+   */
+  static getInstance(): GeminiSDKAdapter {
+    if (!instance) {
+      instance = new GeminiSDKAdapter();
+    }
+    return instance;
+  }
+
+  /**
+   * Export adapter class for type safety
+   */
+  static Adapter = GeminiSDKAdapter;
+
+  /**
+   * Initialize the client (convenience method)
+   */
+  static initialize(apiKey: string): void {
+    GeminiClient.getInstance().initialize(apiKey);
+  }
+
+  /**
+   * Reset the client (for testing)
+   */
+  static reset(): void {
+    if (instance) {
+      instance.reset();
+      instance = null;
+    }
+  }
+}
+
+/**
+ * Export a simpler interface for backward compatibility
+ */
+export const geminiClient = GeminiClient.getInstance();