@umituz/react-native-ai-pruna-provider 1.0.64 → 1.0.65

package/src/domain/services/error-mapper.domain-service.ts

@@ -0,0 +1,204 @@
+/**
+ * Error Mapper Domain Service
+ * Maps raw errors to domain-specific error types
+ */
+
+import { PrunaErrorType } from "../entities/error.types";
+import type { PrunaErrorInfo } from "../entities/error.types";
+
+export class ErrorMapperService {
+  static mapError(error: unknown): PrunaErrorInfo {
+    const originalMessage = this.extractMessage(error);
+    const errorName = error instanceof Error ? error.name : undefined;
+    const stack = error instanceof Error ? error.stack : undefined;
+    const statusCode = (error as Error & { statusCode?: number }).statusCode;
+
+    // Check for specific error types
+    if (error instanceof Error && error.name === 'AbortError') {
+      return this.buildError(
+        PrunaErrorType.CANCELLED,
+        "Request cancelled by user",
+        false,
+        originalMessage,
+        errorName,
+        stack,
+        statusCode
+      );
+    }
+
+    // HTTP status code mapping
+    if (statusCode !== undefined) {
+      return this.mapStatusCode(statusCode, originalMessage, errorName, stack);
+    }
+
+    // Message pattern matching
+    return this.mapByMessage(originalMessage, errorName, stack);
+  }
+
+  static isRetryable(error: PrunaErrorInfo): boolean {
+    return error.retryable;
+  }
+
+  private static mapStatusCode(
+    statusCode: number,
+    message: string,
+    errorName?: string,
+    stack?: string
+  ): PrunaErrorInfo {
+    const statusMap: Record<number, { type: PrunaErrorType; messageKey: string; retryable: boolean }> = {
+      400: { type: PrunaErrorType.VALIDATION, messageKey: "error.validation", retryable: false },
+      401: { type: PrunaErrorType.AUTHENTICATION, messageKey: "error.auth", retryable: false },
+      402: { type: PrunaErrorType.QUOTA_EXCEEDED, messageKey: "error.quota", retryable: false },
+      403: { type: PrunaErrorType.AUTHENTICATION, messageKey: "error.auth", retryable: false },
+      404: { type: PrunaErrorType.MODEL_NOT_FOUND, messageKey: "error.model_not_found", retryable: false },
+      422: { type: PrunaErrorType.VALIDATION, messageKey: "error.validation", retryable: false },
+      429: { type: PrunaErrorType.RATE_LIMIT, messageKey: "error.rate_limit", retryable: true },
+    };
+
+    const mapped = statusMap[statusCode];
+    if (mapped) {
+      return this.buildError(
+        mapped.type,
+        mapped.messageKey,
+        mapped.retryable,
+        message,
+        errorName,
+        stack,
+        statusCode
+      );
+    }
+
+    // Server errors (5xx)
+    if (statusCode >= 500 && statusCode <= 504) {
+      return this.buildError(
+        PrunaErrorType.API_ERROR,
+        "error.api",
+        true,
+        message,
+        errorName,
+        stack,
+        statusCode
+      );
+    }
+
+    return this.buildError(
+      PrunaErrorType.UNKNOWN,
+      "error.unknown",
+      false,
+      message,
+      errorName,
+      stack,
+      statusCode
+    );
+  }
+
+  private static mapByMessage(
+    message: string,
+    errorName?: string,
+    stack?: string
+  ): PrunaErrorInfo {
+    const msg = message.toLowerCase();
+
+    // Network errors
+    if (this.matchesAny(msg, ["network", "fetch", "econnrefused", "enotfound"])) {
+      return this.buildError(
+        PrunaErrorType.NETWORK,
+        "error.network",
+        true,
+        message,
+        errorName,
+        stack
+      );
+    }
+
+    // Timeout errors
+    if (this.matchesAny(msg, ["timeout", "timed out", "polling attempts reached"])) {
+      return this.buildError(
+        PrunaErrorType.POLLING_TIMEOUT,
+        "error.timeout",
+        true,
+        message,
+        errorName,
+        stack
+      );
+    }
+
+    // File upload errors
+    if (msg.includes("file upload")) {
+      return this.buildError(
+        PrunaErrorType.FILE_UPLOAD,
+        "error.file_upload",
+        true,
+        message,
+        errorName,
+        stack
+      );
+    }
+
+    // Validation errors
+    if (this.matchesAny(msg, ["prompt is required", "image is required", "invalid"])) {
+      return this.buildError(
+        PrunaErrorType.VALIDATION,
+        "error.validation",
+        false,
+        message,
+        errorName,
+        stack
+      );
+    }
+
+    // Cancellation
+    if (msg.includes("cancelled by user")) {
+      return this.buildError(
+        PrunaErrorType.CANCELLED,
+        "error.cancelled",
+        false,
+        message,
+        errorName,
+        stack
+      );
+    }
+
+    return this.buildError(
+      PrunaErrorType.UNKNOWN,
+      "error.unknown",
+      false,
+      message,
+      errorName,
+      stack
+    );
+  }
+
+  private static buildError(
+    type: PrunaErrorType,
+    messageKey: string,
+    retryable: boolean,
+    originalError: string,
+    originalErrorName?: string,
+    stack?: string,
+    statusCode?: number
+  ): PrunaErrorInfo {
+    const error: PrunaErrorInfo = {
+      type,
+      messageKey,
+      retryable,
+      originalError,
+    };
+
+    if (originalErrorName) error.originalErrorName = originalErrorName;
+    if (stack) error.stack = stack;
+    if (statusCode !== undefined) error.statusCode = statusCode;
+
+    return error;
+  }
+
+  private static extractMessage(error: unknown): string {
+    if (error instanceof Error) return error.message;
+    if (typeof error === 'string') return error;
+    return String(error);
+  }
+
+  private static matchesAny(text: string, patterns: string[]): boolean {
+    return patterns.some(pattern => text.includes(pattern));
+  }
+}

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

@@ -0,0 +1,93 @@
+/**
+ * Validation Domain Service
+ * Centralized validation logic for Pruna operations
+ */
+
+import { ApiKey } from "../value-objects/api-key.value";
+import { ModelId } from "../value-objects/model-id.value";
+
+export interface ValidationResult {
+  isValid: boolean;
+  error?: string;
+}
+
+export class ValidationService {
+  static validatePrompt(prompt: unknown): ValidationResult {
+    if (!prompt || typeof prompt !== 'string') {
+      return { isValid: false, error: "Prompt is required and must be a string" };
+    }
+    if (prompt.trim().length === 0) {
+      return { isValid: false, error: "Prompt cannot be empty" };
+    }
+    if (prompt.length > 2000) {
+      return { isValid: false, error: "Prompt exceeds maximum length of 2000 characters" };
+    }
+    return { isValid: true };
+  }
+
+  static validateApiKey(apiKey: string | ApiKey): ValidationResult {
+    try {
+      if (apiKey instanceof ApiKey) {
+        return { isValid: true };
+      }
+      ApiKey.create(apiKey);
+      return { isValid: true };
+    } catch (error) {
+      return {
+        isValid: false,
+        error: error instanceof Error ? error.message : "Invalid API key"
+      };
+    }
+  }
+
+  static validateModel(model: string): ValidationResult {
+    try {
+      ModelId.create(model);
+      return { isValid: true };
+    } catch (error) {
+      return {
+        isValid: false,
+        error: error instanceof Error ? error.message : "Invalid model"
+      };
+    }
+  }
+
+  static validateTimeout(timeoutMs: number, maxTimeoutMs: number): ValidationResult {
+    if (!Number.isInteger(timeoutMs)) {
+      return { isValid: false, error: "Timeout must be an integer" };
+    }
+    if (timeoutMs <= 0) {
+      return { isValid: false, error: "Timeout must be positive" };
+    }
+    if (timeoutMs > maxTimeoutMs) {
+      return { isValid: false, error: `Timeout cannot exceed ${maxTimeoutMs}ms` };
+    }
+    return { isValid: true };
+  }
+
+  static validateImageData(imageData: unknown): ValidationResult {
+    if (!imageData) {
+      return { isValid: false, error: "Image data is required" };
+    }
+
+    if (typeof imageData === 'string') {
+      if (imageData.trim().length === 0) {
+        return { isValid: false, error: "Image data cannot be empty" };
+      }
+      return { isValid: true };
+    }
+
+    if (Array.isArray(imageData)) {
+      if (imageData.length === 0) {
+        return { isValid: false, error: "Image array cannot be empty" };
+      }
+      const hasInvalidItem = imageData.some(item => typeof item !== 'string' || item.trim().length === 0);
+      if (hasInvalidItem) {
+        return { isValid: false, error: "Image array contains invalid items" };
+      }
+      return { isValid: true };
+    }
+
+    return { isValid: false, error: "Image data must be a string or array of strings" };
+  }
+}

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

@@ -0,0 +1,30 @@
+/**
+ * ApiKey Value Object
+ * Encapsulates API key validation and storage
+ */
+
+export class ApiKey {
+  private static readonly MIN_LENGTH = 10;
+
+  private readonly value: string;
+
+  private constructor(value: string) {
+    this.value = value;
+  }
+
+  static create(value: string): ApiKey {
+    if (!value || value.trim().length < ApiKey.MIN_LENGTH) {
+      throw new Error(`API key must be at least ${ApiKey.MIN_LENGTH} characters`);
+    }
+    return new ApiKey(value.trim());
+  }
+
+  toString(): string {
+    return this.value;
+  }
+
+  mask(): string {
+    if (this.value.length <= 8) return '********';
+    return `${this.value.substring(0, 4)}...${this.value.substring(this.value.length - 4)}`;
+  }
+}

package/src/domain/value-objects/model-id.value.ts

@@ -0,0 +1,41 @@
+/**
+ * ModelId Value Object
+ * Represents a valid Pruna model identifier
+ */
+
+import { VALID_PRUNA_MODELS } from "../../infrastructure/services/pruna-provider.constants";
+
+export type PrunaModelId = 'p-image' | 'p-image-edit' | 'p-video';
+
+export class ModelId {
+  private readonly value: PrunaModelId;
+
+  private constructor(value: PrunaModelId) {
+    this.value = value;
+  }
+
+  static create(value: string): ModelId {
+    if (!VALID_PRUNA_MODELS.includes(value as PrunaModelId)) {
+      throw new Error(
+        `Invalid model: "${value}". Valid models: ${VALID_PRUNA_MODELS.join(', ')}`
+      );
+    }
+    return new ModelId(value as PrunaModelId);
+  }
+
+  toString(): string {
+    return this.value;
+  }
+
+  isImage(): boolean {
+    return this.value === 'p-image';
+  }
+
+  isImageEdit(): boolean {
+    return this.value === 'p-image-edit';
+  }
+
+  isVideo(): boolean {
+    return this.value === 'p-video';
+  }
+}

package/src/domain/value-objects/session-id.value.ts

@@ -0,0 +1,22 @@
+/**
+ * SessionId Value Object
+ * Represents a unique session identifier for logging
+ */
+
+export class SessionId {
+  private static counter = 0;
+
+  private readonly value: string;
+
+  constructor() {
+    this.value = `session_${++SessionId.counter}_${Date.now()}`;
+  }
+
+  toString(): string {
+    return this.value;
+  }
+
+  equals(other: SessionId): boolean {
+    return this.value === other.value;
+  }
+}

package/src/index.new.ts

@@ -0,0 +1,65 @@
+/**
+ * Pruna AI Provider - Refactored with DDD Architecture
+ *
+ * @module react-native-ai-pruna-provider
+ *
+ * Architecture:
+ * - Domain: Business logic, value objects, domain services
+ * - Application: Use cases, orchestration, DTOs
+ * - Infrastructure: API clients, storage, logging
+ * - Presentation: React hooks, UI integration
+ *
+ * Key Features:
+ * - Clean separation of concerns
+ * - Maximum 150 lines per file
+ * - No code duplication
+ * - Type-safe with TypeScript
+ * - Comprehensive error handling
+ */
+
+// Core Service
+export { prunaService, PrunaService } from './application/services/pruna-service';
+export type {
+  PrunaConfig,
+  PrunaModel,
+} from './application/services/pruna-service';
+
+// React Hooks
+export { usePrunaGeneration } from './presentation/hooks/use-pruna-generation.new';
+export type { PrunaGenerationState } from './presentation/hooks/use-pruna-generation.new';
+
+// DTOs
+export type {
+  PrunaImageGenerationRequest,
+  PrunaVideoGenerationRequest,
+  PrunaImageEditRequest,
+  PrunaGenerationResponse,
+  PrunaGenerationOptions,
+  PrunaGenerationError,
+} from './application/dto/pruna.dto';
+
+// Domain Layer
+export { SessionId } from './domain/value-objects/session-id.value';
+export { ApiKey } from './domain/value-objects/api-key.value';
+export { ModelId, PrunaModelId } from './domain/value-objects/model-id.value';
+export { ValidationService, ValidationResult } from './domain/services/validation.domain-service';
+export { ErrorMapperService } from './domain/services/error-mapper.domain-service';
+
+// Infrastructure Layer
+export { logger, createLogger, LogLevel } from './infrastructure/logging/pruna-logger';
+export { httpClient, HttpClient } from './infrastructure/api/http-client';
+export { fileStorageService, FileStorageService } from './infrastructure/storage/file-storage';
+
+// Use Cases (for advanced usage)
+export { generateImageUseCase, GenerateImageUseCase } from './application/use-cases/generate-image.use-case';
+export { generateVideoUseCase, GenerateVideoUseCase } from './application/use-cases/generate-video.use-case';
+export { generateImageEditUseCase, GenerateImageEditUseCase } from './application/use-cases/generate-image-edit.use-case';
+
+// Legacy Exports (for backward compatibility)
+export { prunaProvider as PrunaProvider } from './infrastructure/services/pruna-provider';
+export type {
+  IAIProvider,
+  AIProviderConfig,
+  SubscribeOptions,
+  RunOptions,
+} from './domain/types';

package/src/infrastructure/api/http-client.ts

@@ -0,0 +1,111 @@
+/**
+ * HTTP Client Infrastructure
+ * Centralized HTTP request handling with error handling and retry logic
+ */
+
+import { ErrorMapperService } from "../../domain/services/error-mapper.domain-service";
+import { logger } from "../logging/pruna-logger";
+
+export interface HttpRequestConfig {
+  url: string;
+  method: 'GET' | 'POST' | 'PUT' | 'DELETE';
+  headers?: Record<string, string>;
+  body?: string | FormData;
+  signal?: AbortSignal;
+  timeout?: number;
+}
+
+export interface HttpResponse<T = unknown> {
+  data: T;
+  status: number;
+  statusText: string;
+}
+
+export class HttpClient {
+  async request<T>(config: HttpRequestConfig, sessionId: string, tag: string): Promise<HttpResponse<T>> {
+    const log = logger;
+    const controller = new AbortController();
+    const timeoutId = config.timeout ?
+      setTimeout(() => controller.abort(), config.timeout) : undefined;
+
+    try {
+      log.info(sessionId, tag, `HTTP ${config.method} ${config.url}`, {
+        hasBody: !!config.body,
+        hasSignal: !!config.signal,
+      });
+
+      const response = await fetch(config.url, {
+        method: config.method,
+        headers: config.headers,
+        body: config.body,
+        signal: config.signal || controller.signal,
+      });
+
+      if (timeoutId) clearTimeout(timeoutId);
+
+      if (!response.ok) {
+        await this.handleErrorResponse(response, sessionId, tag);
+      }
+
+      const data = await response.json() as T;
+      log.info(sessionId, tag, `HTTP ${response.status} ${response.statusText}`, {
+        keys: Object.keys(data as Record<string, unknown>),
+      });
+
+      return { data, status: response.status, statusText: response.statusText };
+
+    } catch (error) {
+      if (timeoutId) clearTimeout(timeoutId);
+      throw this.handleRequestError(error, sessionId, tag);
+    }
+  }
+
+  private async handleErrorResponse(response: Response, sessionId: string, tag: string): Promise<never> {
+    let rawBody = '';
+    try {
+      rawBody = await response.text();
+    } catch {
+      // Ignore body read errors
+    }
+
+    const errorMessage = this.extractErrorMessage(rawBody) || `HTTP ${response.status}`;
+    const error = new Error(errorMessage);
+    (error as Error & { statusCode?: number }).statusCode = response.status;
+
+    logger.error(sessionId, tag, `HTTP Error ${response.status}`, {
+      statusText: response.statusText,
+      errorMessage,
+      bodyLength: rawBody.length,
+    });
+
+    throw error;
+  }
+
+  private handleRequestError(error: unknown, sessionId: string, tag: string): Error {
+    if (error instanceof Error && error.name === 'AbortError') {
+      const abortError = new Error("Request cancelled by user");
+      (abortError as Error & { statusCode?: number }).statusCode = 499;
+      return abortError;
+    }
+
+    const mappedError = ErrorMapperService.mapError(error);
+    logger.error(sessionId, tag, `Request failed: ${mappedError.messageKey}`, {
+      originalError: mappedError.originalError,
+    });
+
+    return error instanceof Error ? error : new Error(String(error));
+  }
+
+  private extractErrorMessage(body: string): string | null {
+    if (!body) return null;
+
+    try {
+      const parsed = JSON.parse(body) as Record<string, unknown>;
+      return String(parsed.message || parsed.detail || parsed.error || body);
+    } catch {
+      return body || null;
+    }
+  }
+}
+
+export const httpClient = new HttpClient();

package/src/infrastructure/logging/pruna-logger.ts

@@ -0,0 +1,100 @@
+/**
+ * Pruna Logger
+ * Centralized logging with automatic session management
+ * Eliminates repetitive logging code throughout the codebase
+ */
+
+import { SessionId } from "../../domain/value-objects/session-id.value";
+
+export enum LogLevel {
+  INFO = 'info',
+  WARN = 'warn',
+  ERROR = 'error',
+}
+
+export interface LogContext {
+  readonly sessionId: string;
+  readonly tag: string;
+}
+
+export class PrunaLogger {
+  private static instance: PrunaLogger;
+  private sessions = new Map<string, number>();
+
+  private constructor() {}
+
+  static getInstance(): PrunaLogger {
+    if (!PrunaLogger.instance) {
+      PrunaLogger.instance = new PrunaLogger();
+    }
+    return PrunaLogger.instance;
+  }
+
+  createSession(): string {
+    const sessionId = new SessionId();
+    const id = sessionId.toString();
+    this.sessions.set(id, Date.now());
+    return id;
+  }
+
+  endSession(sessionId: string): void {
+    this.sessions.delete(sessionId);
+  }
+
+  private log(
+    sessionId: string,
+    level: LogLevel,
+    tag: string,
+    message: string,
+    data?: Record<string, unknown>
+  ): void {
+    const elapsed = this.calculateElapsed(sessionId);
+    const entry = {
+      timestamp: Date.now(),
+      elapsed,
+      level,
+      tag,
+      message,
+      ...(data && { data }),
+    };
+
+    // Console output in DEV mode
+    if (typeof __DEV__ !== 'undefined' && __DEV__) {
+      const consoleFn = level === LogLevel.ERROR ? console.error :
+                       level === LogLevel.WARN ? console.warn : console.log;
+      consoleFn(`[${tag}] ${message}`, data ?? '');
+    }
+  }
+
+  info(sessionId: string, tag: string, message: string, data?: Record<string, unknown>): void {
+    this.log(sessionId, LogLevel.INFO, tag, message, data);
+  }
+
+  warn(sessionId: string, tag: string, message: string, data?: Record<string, unknown>): void {
+    this.log(sessionId, LogLevel.WARN, tag, message, data);
+  }
+
+  error(sessionId: string, tag: string, message: string, data?: Record<string, unknown>): void {
+    this.log(sessionId, LogLevel.ERROR, tag, message, data);
+  }
+
+  private calculateElapsed(sessionId: string): number {
+    const startTime = this.sessions.get(sessionId);
+    return startTime ? Date.now() - startTime : 0;
+  }
+}
+
+// Singleton instance
+export const logger = PrunaLogger.getInstance();
+
+// Convenience factory function
+export function createLogger(tag: string) {
+  return {
+    info: (sessionId: string, message: string, data?: Record<string, unknown>) =>
+      logger.info(sessionId, tag, message, data),
+    warn: (sessionId: string, message: string, data?: Record<string, unknown>) =>
+      logger.warn(sessionId, tag, message, data),
+    error: (sessionId: string, message: string, data?: Record<string, unknown>) =>
+      logger.error(sessionId, tag, message, data),
+  };
+}