@umituz/react-native-ai-gemini-provider 2.1.5 → 2.1.7

package/src/infrastructure/services/gemini-text-generation.service.ts

@@ -1,16 +1,14 @@
-
-import { geminiClientCoreService } from "./gemini-client-core.service";
+import { BaseGeminiService } from "./base-gemini.service";
 import { extractTextFromResponse } from "../utils/gemini-data-transformer.util";
-import { toSdkContent, transformResponse, createTextContent } from "../utils/content-mapper.util";
+import { transformResponse, createTextContent } from "../utils/content-mapper.util";
 import { validatePrompt } from "../utils/validation.util";
-import { createGeminiError } from "../utils/error-mapper.util";
 import type {
   GeminiContent,
   GeminiGenerationConfig,
   GeminiResponse,
 } from "../../domain/entities";
 
-class GeminiTextGenerationService {
+class GeminiTextGenerationService extends BaseGeminiService {
   /**
    * Generate content (text, with optional images)
    *
@@ -23,24 +21,15 @@ class GeminiTextGenerationService {
     generationConfig?: GeminiGenerationConfig,
     signal?: AbortSignal,
   ): Promise<GeminiResponse> {
-    // Validate input
-    if (!contents || contents.length === 0) {
-      throw new Error("Contents array cannot be empty");
-    }
-
-    // Check for early abort
-    if (signal?.aborted) {
-      throw new Error("Request was aborted");
-    }
-
     try {
-      const genModel = geminiClientCoreService.getModel(model);
-      const sdkContents = toSdkContent(contents);
-
-      const requestOptions = {
-        contents: sdkContents as Parameters<typeof genModel.generateContent>[0] extends { contents: infer C } ? C : never,
+      const { genModel, sdkContents } = this.validateAndPrepare({
+        model,
+        contents,
         generationConfig,
-      };
+        signal,
+      });
+
+      const requestOptions = this.createRequestOptions(sdkContents, generationConfig);
 
       const result = signal
         ? await genModel.generateContent(requestOptions, { signal })
@@ -54,18 +43,7 @@ class GeminiTextGenerationService {
 
       return transformResponse(response);
     } catch (error) {
-      // Re-throw as GeminiError if it's an API error
-      if (error instanceof Error && error.name === "GeminiError") {
-        throw error;
-      }
-
-      // Check for abort error
-      if (error instanceof Error && error.name === "AbortError") {
-        throw new Error("Request was aborted");
-      }
-
-      // Wrap other errors
-      throw createGeminiError(error);
+      return this.handleError(error, "Request was aborted");
     }
   }
 

package/src/infrastructure/services/index.ts

@@ -1,15 +1,18 @@
 /**
- * Infrastructure Services
- * Text-only Gemini services
+ * Infrastructure Services - Internal Use Only
  */
 
-// Core services
+// Internal base classes
+export { BaseGeminiService } from "./base-gemini.service";
+export type { BaseRequestOptions } from "./base-gemini.service";
+
+// Internal services
 export { geminiClientCoreService } from "./gemini-client-core.service";
 export { geminiTextGenerationService } from "./gemini-text-generation.service";
 export { geminiStructuredTextService } from "./gemini-structured-text.service";
 export { geminiStreamingService } from "./gemini-streaming.service";
 
-// Provider
+// Main Provider - Public API
 export {
   geminiProviderService,
   GeminiProvider,

package/src/infrastructure/utils/async/index.ts

@@ -1,6 +1,5 @@
 /**
- * Async Utilities
- * Re-exports all async utility functions
+ * Async State Management - Internal Use Only
  */
 
 export {
@@ -9,11 +8,3 @@ export {
   type AsyncStateSetters,
   type AsyncStateConfig,
 } from "./execute-state.util";
-
-export {
-  createDebouncedAsync,
-} from "./debounce.util";
-
-export {
-  createMemoizedAsync,
-} from "./memoize.util";

package/src/infrastructure/utils/index.ts

@@ -1,30 +1,47 @@
-// Error handling
-export { mapGeminiError, isGeminiErrorRetryable, categorizeGeminiError, createGeminiError } from "./error-mapper.util";
+/**
+ * Utility Functions - Internal Use Only
+ * These are internal implementation details and should not be used directly by consumers
+ */
 
-// Data transformation
-export { extractTextFromResponse } from "./gemini-data-transformer.util";
-export { cleanJsonText, parseJsonResponse, safeParseJson, extractJsonFromText } from "./json-parser.util";
-export { toSdkContent, createTextContent, transformCandidate, transformResponse, extractTextFromParts } from "./content-mapper.util";
-
-// Performance
-export { measureAsync, measureSync, debounce, throttle, PerformanceTimer } from "./performance.util";
-export type { PerformanceMetrics } from "./performance.util";
-
-// Rate limiting
-export { RateLimiter } from "./rate-limiter.util";
-export type { RateLimiterOptions } from "./rate-limiter.util";
+// Error handling (internal)
+export {
+  mapGeminiError,
+  isGeminiErrorRetryable,
+  categorizeGeminiError,
+  createGeminiError
+} from "./error-mapper.util";
 
-// Retry logic
-export { retryWithBackoff, retryIf, retryWithFixedDelay, shouldRetryNetworkError, createRetryPredicate } from "./retry.util";
-export type { RetryOptions, RetryResult } from "./retry.util";
-
-// Validation
-export { validateModelName, validateApiKey, validateSchema, validatePrompt, validateTimeout, isValidObject, validateRequiredFields } from "./validation.util";
+// Data transformation (internal)
+export { extractTextFromResponse } from "./gemini-data-transformer.util";
+export {
+  cleanJsonText,
+  parseJsonResponse,
+  safeParseJson,
+  extractJsonFromText
+} from "./json-parser.util";
+export {
+  toSdkContent,
+  createTextContent,
+  transformCandidate,
+  transformResponse,
+  extractTextFromParts
+} from "./content-mapper.util";
 
-// Environment
-export { getRequiredEnv, getOptionalEnv, getEnvNumber, getEnvBoolean, loadGeminiEnv, getApiKeyFromEnv, isDevelopment, isDebugEnabled, validateEnv, getGeminiConfigFromEnv } from "./env.util";
-export type { EnvConfig } from "./env.util";
+// Validation (internal)
+export {
+  validateModelName,
+  validateApiKey,
+  validateSchema,
+  validatePrompt,
+  validateTimeout,
+  isValidObject,
+  validateRequiredFields
+} from "./validation.util";
 
-// Async state management
-export { executeWithState, createDebouncedAsync, createMemoizedAsync } from "./async";
-export type { AsyncStateCallbacks, AsyncStateSetters, AsyncStateConfig } from "./async";
+// Async state management (internal)
+export {
+  executeWithState,
+  type AsyncStateCallbacks,
+  type AsyncStateSetters,
+  type AsyncStateConfig
+} from "./async";

package/src/infrastructure/utils/stream-processor.util.ts

@@ -0,0 +1,156 @@
+/**
+ * Stream Processing Utilities
+ * Reusable stream handling logic
+ */
+
+export interface StreamChunk {
+  text: () => string;
+}
+
+export type ChunkCallback = (text: string) => void;
+export type ErrorLogger = (error: unknown, context?: string) => void;
+
+/**
+ * Process async stream with chunk callback
+ */
+export async function processStream(
+  stream: AsyncIterable<StreamChunk>,
+  onChunk: ChunkCallback,
+  onError?: ErrorLogger
+): Promise<string> {
+  let fullText = "";
+
+  for await (const chunk of stream) {
+    try {
+      const chunkText = chunk.text();
+      if (chunkText) {
+        fullText += chunkText;
+        safeCallChunk(onChunk, chunkText, onError);
+      }
+    } catch (chunkError) {
+      logError(onError, chunkError, "stream-chunk");
+    }
+  }
+
+  return fullText;
+}
+
+/**
+ * Safely call chunk callback without breaking the stream
+ */
+function safeCallChunk(
+  callback: ChunkCallback,
+  text: string,
+  onError?: ErrorLogger
+): void {
+  try {
+    callback(text);
+  } catch (callbackError) {
+    logError(onError, callbackError, "stream-callback");
+  }
+}
+
+/**
+ * Log error without breaking the stream
+ */
+function logError(
+  onError: ErrorLogger | undefined,
+  error: unknown,
+  context?: string
+): void {
+  if (onError) {
+    try {
+      onError(error, context);
+    } catch {
+      // Silently ignore logger errors
+    }
+  }
+}
+
+/**
+ * Create a buffered stream processor
+ * Accumulates chunks until a condition is met
+ */
+export class BufferedStreamProcessor {
+  private buffer = "";
+  private fullText = "";
+
+  constructor(
+    private onFlush: (text: string) => void,
+    private flushCondition: (buffer: string) => boolean = () => false
+  ) {}
+
+  /**
+   * Process a single chunk
+   */
+  processChunk(chunk: StreamChunk): void {
+    try {
+      const chunkText = chunk.text();
+      if (!chunkText) return;
+
+      this.buffer += chunkText;
+      this.fullText += chunkText;
+
+      if (this.flushCondition(this.buffer)) {
+        this.flush();
+      }
+    } catch (error) {
+      // Ignore chunk errors
+    }
+  }
+
+  /**
+   * Flush buffer to callback
+   */
+  flush(): void {
+    if (this.buffer) {
+      try {
+        this.onFlush(this.buffer);
+        this.buffer = "";
+      } catch {
+        // Ignore callback errors
+      }
+    }
+  }
+
+  /**
+   * Get accumulated full text
+   */
+  getFullText(): string {
+    return this.fullText;
+  }
+
+  /**
+   * Process entire stream
+   */
+  async processStream(stream: AsyncIterable<StreamChunk>): Promise<string> {
+    for await (const chunk of stream) {
+      this.processChunk(chunk);
+    }
+
+    // Flush remaining buffer
+    this.flush();
+
+    return this.fullText;
+  }
+}
+
+/**
+ * Common flush conditions
+ */
+export const flushConditions = {
+  /**
+   * Flush on newline
+   */
+  onNewline: (buffer: string): boolean => buffer.includes("\n"),
+
+  /**
+   * Flush when buffer reaches size
+   */
+  onSize: (size: number) => (buffer: string): boolean => buffer.length >= size,
+
+  /**
+   * Flush on pattern match
+   */
+  onPattern: (pattern: RegExp) => (buffer: string): boolean => pattern.test(buffer),
+};

package/src/infrastructure/utils/validation-composer.util.ts

@@ -0,0 +1,160 @@
+/**
+ * Validation Composers
+ * Composable validation rules for clean, reusable validation
+ */
+
+export type ValidationRule<T = unknown> = (value: T) => string | null;
+
+/**
+ * Compose multiple validation rules into one
+ */
+export function compose<T>(...rules: ValidationRule<T>[]): ValidationRule<T> {
+  return (value: T): string | null => {
+    for (const rule of rules) {
+      const error = rule(value);
+      if (error) return error;
+    }
+    return null;
+  };
+}
+
+/**
+ * Validate that value is not empty
+ */
+export function required(fieldName: string = "Field"): ValidationRule<string> {
+  return (value: string): string | null => {
+    if (!value || typeof value !== "string" || value.trim().length === 0) {
+      return `${fieldName} is required`;
+    }
+    return null;
+  };
+}
+
+/**
+ * Validate minimum length
+ */
+export function minLength(min: number, fieldName: string = "Field"): ValidationRule<string> {
+  return (value: string): string | null => {
+    if (value.trim().length < min) {
+      return `${fieldName} must be at least ${min} characters`;
+    }
+    return null;
+  };
+}
+
+/**
+ * Validate maximum length
+ */
+export function maxLength(max: number, fieldName: string = "Field"): ValidationRule<string> {
+  return (value: string): string | null => {
+    if (value.length > max) {
+      return `${fieldName} must be at most ${max} characters`;
+    }
+    return null;
+  };
+}
+
+/**
+ * Validate string starts with prefix
+ */
+export function startsWith(prefix: string, fieldName: string = "Field"): ValidationRule<string> {
+  return (value: string): string | null => {
+    if (!value.startsWith(prefix)) {
+      return `${fieldName} must start with "${prefix}"`;
+    }
+    return null;
+  };
+}
+
+/**
+ * Validate number is in range
+ */
+export function inRange(min: number, max: number, fieldName: string = "Value"): ValidationRule<number> {
+  return (value: number): string | null => {
+    if (typeof value !== "number" || value < min || value > max) {
+      return `${fieldName} must be between ${min} and ${max}`;
+    }
+    return null;
+  };
+}
+
+/**
+ * Validate object has required properties
+ */
+export function hasProperties(...props: string[]): ValidationRule<Record<string, unknown>> {
+  return (value: Record<string, unknown>): string | null => {
+    const missing = props.filter((prop) => !(prop in value) || value[prop] === undefined);
+    if (missing.length > 0) {
+      return `Missing required properties: ${missing.join(", ")}`;
+    }
+    return null;
+  };
+}
+
+/**
+ * Validate object structure (for schemas)
+ */
+export function isValidSchema(): ValidationRule<Record<string, unknown>> {
+  return compose(
+    (schema): string | null => {
+      if (!schema || typeof schema !== "object") {
+        return "Schema must be a non-empty object";
+      }
+      return null;
+    },
+    (schema): string | null => {
+      if (Object.keys(schema).length === 0) {
+        return "Schema must contain at least one property";
+      }
+      return null;
+    },
+    hasProperties("type"),
+    (schema): string | null => {
+      const schemaType = schema.type;
+      if (schemaType !== "object" && schemaType !== "array") {
+        return `Schema type must be "object" or "array", got "${String(schemaType)}"`;
+      }
+      return null;
+    },
+    (schema): string | null => {
+      if (schema.type === "object" && !("properties" in schema)) {
+        return 'Object schema must have a "properties" field';
+      }
+      return null;
+    }
+  );
+}
+
+/**
+ * Helper to validate and throw on error
+ */
+export function validateOrThrow<T>(value: T, rule: ValidationRule<T>): void {
+  const error = rule(value);
+  if (error) {
+    throw new Error(error);
+  }
+}
+
+/**
+ * Pre-built composite validators
+ */
+export const validators = {
+  apiKey: compose(
+    required("API key"),
+    minLength(10, "API key")
+  ),
+
+  modelName: compose(
+    required("Model name"),
+    startsWith("gemini-", "Model name")
+  ),
+
+  prompt: compose(
+    required("Prompt"),
+    minLength(3, "Prompt")
+  ),
+
+  timeout: inRange(1, 300000, "Timeout"),
+
+  schema: isValidSchema(),
+};

package/src/infrastructure/utils/validation.util.ts

@@ -1,32 +1,17 @@
 /**
- * Validation Utilities
- * Common validation logic for models, configurations, and inputs
+ * Validation Utilities (Legacy)
+ * Maintained for backward compatibility
+ * New code should use validation-composer.util.ts
  */
 
-/** Maximum timeout value (5 minutes) */
-const MAX_TIMEOUT_MS = 300000;
-
-/** Minimum prompt length */
-const MIN_PROMPT_LENGTH = 3;
+import { validateOrThrow, validators } from "./validation-composer.util";
 
 /**
  * Validate model name format
  * @throws Error if model name is invalid
  */
 export function validateModelName(modelName: string): void {
-  if (!modelName || typeof modelName !== "string" || modelName.trim().length === 0) {
-    const displayName: string = modelName === null ? "null" : typeof modelName;
-    throw new Error(
-      `Invalid model name: "${displayName}". Model name must be a non-empty string.`
-    );
-  }
-
-  // Check for valid model format (starts with gemini-)
-  if (!modelName.startsWith("gemini-")) {
-    throw new Error(
-      `Invalid model name: "${modelName}". Gemini models should start with "gemini-".`
-    );
-  }
+  validateOrThrow(modelName, validators.modelName);
 }
 
 /**
@@ -34,16 +19,7 @@ export function validateModelName(modelName: string): void {
  * @throws Error if API key is invalid
  */
 export function validateApiKey(apiKey: string): void {
-  if (!apiKey || typeof apiKey !== "string" || apiKey.trim().length === 0) {
-    throw new Error("API key must be a non-empty string");
-  }
-
-  // Gemini API keys typically start with "AIza"
-  // This is a soft validation - actual validation happens on the API side
-  const trimmedKey = apiKey.trim();
-  if (trimmedKey.length < 10) {
-    throw new Error("API key appears to be invalid (too short)");
-  }
+  validateOrThrow(apiKey, validators.apiKey);
 }
 
 /**
@@ -51,30 +27,7 @@ export function validateApiKey(apiKey: string): void {
  * @throws Error if schema is invalid
  */
 export function validateSchema(schema: Record<string, unknown>): void {
-  if (!schema || typeof schema !== "object") {
-    throw new Error("Schema must be a non-empty object");
-  }
-
-  if (Object.keys(schema).length === 0) {
-    throw new Error("Schema must contain at least one property");
-  }
-
-  // Basic structure validation - schema should have type
-  if (!("type" in schema)) {
-    throw new Error('Schema must have a "type" property (e.g., "object")');
-  }
-
-  const schemaType = schema.type;
-
-  if (schemaType !== "object" && schemaType !== "array") {
-    const typeStr = String(schemaType);
-    throw new Error(`Schema type must be "object" or "array", got "${typeStr}"`);
-  }
-
-  // If type is object, should have properties
-  if (schemaType === "object" && !("properties" in schema)) {
-    throw new Error('Object schema must have a "properties" field');
-  }
+  validateOrThrow(schema, validators.schema);
 }
 
 /**
@@ -82,13 +35,7 @@ export function validateSchema(schema: Record<string, unknown>): void {
  * @throws Error if prompt is invalid
  */
 export function validatePrompt(prompt: string): void {
-  if (!prompt || typeof prompt !== "string" || prompt.trim().length === 0) {
-    throw new Error("Prompt must be a non-empty string");
-  }
-
-  if (prompt.trim().length < MIN_PROMPT_LENGTH) {
-    throw new Error(`Prompt is too short (minimum ${MIN_PROMPT_LENGTH} characters)`);
-  }
+  validateOrThrow(prompt, validators.prompt);
 }
 
 /**
@@ -96,13 +43,7 @@ export function validatePrompt(prompt: string): void {
  * @throws Error if timeout is invalid
  */
 export function validateTimeout(timeout: number): void {
-  if (typeof timeout !== "number" || timeout <= 0) {
-    throw new Error("Timeout must be a positive number");
-  }
-
-  if (timeout > MAX_TIMEOUT_MS) {
-    throw new Error(`Timeout cannot exceed ${MAX_TIMEOUT_MS}ms (5 minutes)`);
-  }
+  validateOrThrow(timeout, validators.timeout);
 }
 
 /**

package/src/presentation/hooks/index.ts

@@ -1,6 +1,11 @@
 /**
- * Presentation Hooks
+ * React Hooks - Public API
  */
 
+// Internal - not exported from main index
+export { useOperationManager } from "./use-operation-manager";
+export type { OperationManager } from "./use-operation-manager";
+
+// Public API
 export { useGemini } from "./use-gemini";
 export type { UseGeminiOptions, UseGeminiReturn } from "./use-gemini";