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

package/src/infrastructure/storage/file-storage.ts

@@ -0,0 +1,97 @@
+/**
+ * File Storage Infrastructure
+ * Handles file uploads to Pruna's storage service
+ */
+
+import { httpClient } from "../api/http-client";
+import { logger } from "../logging/pruna-logger";
+import { PRUNA_FILES_URL, UPLOAD_CONFIG } from "../../services/pruna-provider.constants";
+
+export class FileStorageService {
+  async uploadFile(
+    base64Data: string,
+    apiKey: string,
+    sessionId: string
+  ): Promise<string> {
+    const log = logger;
+
+    // Validation
+    if (!base64Data?.trim()) {
+      log.error(sessionId, 'file-storage', 'Empty file data');
+      throw new Error("File data is empty. Provide a base64 string or URL.");
+    }
+
+    // Already a URL
+    if (base64Data.startsWith('http')) {
+      log.info(sessionId, 'file-storage', 'File already a URL', {
+        url: base64Data.substring(0, 80) + '...',
+      });
+      return base64Data;
+    }
+
+    // Process base64
+    const rawBase64 = this.extractBase64(base64Data);
+    const dataUri = this.createDataUri(rawBase64);
+    const formData = this.createFormData(dataUri);
+
+    log.info(sessionId, 'file-storage', 'Uploading file', {
+      size: Math.round(rawBase64.length / 1024) + 'KB',
+    });
+
+    try {
+      const response = await httpClient.request<{ urls?: { get?: string }; id?: string }>(
+        {
+          url: PRUNA_FILES_URL,
+          method: 'POST',
+          headers: { apikey: apiKey },
+          body: formData,
+          timeout: UPLOAD_CONFIG.timeoutMs,
+        },
+        sessionId,
+        'file-storage'
+      );
+
+      const fileUrl = response.data.urls?.get ||
+                     (response.data.id ? `${PRUNA_FILES_URL}/${response.data.id}` : PRUNA_FILES_URL);
+
+      log.info(sessionId, 'file-storage', 'Upload complete', {
+        url: fileUrl.substring(0, 80) + '...',
+      });
+
+      return fileUrl;
+
+    } catch (error) {
+      log.error(sessionId, 'file-storage', 'Upload failed', {
+        error: error instanceof Error ? error.message : String(error),
+      });
+      throw error;
+    }
+  }
+
+  private extractBase64(data: string): string {
+    const base64Index = data.indexOf('base64,');
+    return base64Index !== -1 ? data.substring(base64Index + 7) : data;
+  }
+
+  private createDataUri(base64: string): string {
+    return `data:image/jpeg;base64,${base64}`;
+  }
+
+  private createFormData(dataUri: string): FormData {
+    const formData = new FormData();
+    const timestamp = Date.now();
+    const randomId = Math.random().toString(36).substring(2, 8);
+    const fileName = `vivoim_${timestamp}_${randomId}.jpg`;
+
+    (formData as unknown as { append: (name: string, value: { uri: string; type: string; name: string }) => void })
+      .append('content', {
+        uri: dataUri,
+        type: 'image/jpeg',
+        name: fileName,
+      });
+
+    return formData;
+  }
+}
+
+export const fileStorageService = new FileStorageService();

package/src/infrastructure/utils/calculation.utils.ts

@@ -1,6 +1,6 @@
 /**
  * Calculation Utilities
- * Centralized calculation functions for consistent and reusable operations
+ * Internal calculation functions for Pruna provider
  */
 
 import { DEFAULT_PRUNA_CONFIG } from "../services/pruna-provider.constants";
@@ -21,7 +21,7 @@ export function bytesToKB(bytes: number): number {
 /**
  * Converts bytes to megabytes (MB)
  */
-export function bytesToMB(bytes: number): number {
+function bytesToMB(bytes: number): number {
   return Math.round(bytes / 1024 / 1024);
 }
 
@@ -32,17 +32,6 @@ export function calculateElapsedMs(startTime: number): number {
   return Date.now() - startTime;
 }
 
-/**
- * Formats elapsed time in human-readable format
- */
-export function formatElapsedMs(ms: number): string {
-  if (ms < 1000) return `${ms}ms`;
-  if (ms < 60000) return `${(ms / 1000).toFixed(1)}s`;
-  const minutes = Math.floor(ms / 60000);
-  const seconds = Math.floor((ms % 60000) / 1000);
-  return `${minutes}m ${seconds}s`;
-}
-
 /**
  * Creates a preview of a string by truncating and adding ellipsis
  */
@@ -51,15 +40,6 @@ export function createStringPreview(str: string, maxLength: number = DEFAULT_MAX
   return `${str.substring(0, maxLength)}...`;
 }
 
-/**
- * Creates a size preview (e.g., "2.5 MB", "1024 KB")
- */
-export function formatSize(bytes: number): string {
-  if (bytes < 1024) return `${bytes} B`;
-  if (bytes < 1024 * 1024) return `${bytesToKB(bytes)} KB`;
-  return `${bytesToMB(bytes)} MB`;
-}
-
 /**
  * Calculates percentage with specified precision
  */
@@ -68,25 +48,6 @@ export function calculatePercentage(value: number, total: number, precision: num
   return Number(((value / total) * 100).toFixed(precision));
 }
 
-/**
- * Clamps a number between min and max values
- */
-export function clamp(value: number, min: number, max: number): number {
-  return Math.min(Math.max(value, min), max);
-}
-
-/**
- * Calculates retry delay with exponential backoff
- */
-export function calculateRetryDelay(
-  attempt: number,
-  baseDelayMs: number,
-  maxDelayMs: number
-): number {
-  const delay = Math.min(baseDelayMs * Math.pow(2, attempt), maxDelayMs);
-  return Math.round(delay);
-}
-
 /**
  * Validates if a timeout value is within acceptable range
  */
@@ -97,17 +58,3 @@ export function isValidTimeout(timeoutMs: number): boolean {
     timeoutMs <= MAX_TIMEOUT_MS
   );
 }
-
-/**
- * Calculates hash of a string for request deduplication
- * Uses base64 encoding for collision resistance
- */
-export function calculateRequestHash(input: string): string {
-  // Replace non-alphanumeric chars with underscores for safe string representation
-  const safeInput = input.replace(/[^a-zA-Z0-9]/g, '_');
-
-  // Use first 64 chars + last 64 chars to keep key length manageable
-  if (safeInput.length <= 128) return safeInput;
-
-  return `${safeInput.substring(0, 64)}...${safeInput.slice(-64)}`;
-}

package/src/presentation/hooks/use-pruna-generation.new.ts

@@ -0,0 +1,182 @@
+/**
+ * Pruna Generation Hook (Refactored)
+ * Clean React hook using new DDD architecture
+ */
+
+import { useState, useCallback, useRef } from 'react';
+import { prunaService } from '../../application/services/pruna-service';
+import type {
+  PrunaImageGenerationRequest,
+  PrunaVideoGenerationRequest,
+  PrunaImageEditRequest,
+  PrunaGenerationResponse,
+  PrunaGenerationError,
+} from '../../application/dto/pruna.dto';
+
+export interface PrunaGenerationState {
+  isGenerating: boolean;
+  progress: number;
+  status: string;
+  error: PrunaGenerationError | null;
+  result: PrunaGenerationResponse | null;
+}
+
+export function usePrunaGeneration() {
+  const [state, setState] = useState<PrunaGenerationState>({
+    isGenerating: false,
+    progress: 0,
+    status: 'idle',
+    error: null,
+    result: null,
+  });
+
+  const abortControllerRef = useRef<AbortController | null>(null);
+
+  const generateImage = useCallback(async (request: PrunaImageGenerationRequest) => {
+    const controller = new AbortController();
+    abortControllerRef.current = controller;
+
+    setState({
+      isGenerating: true,
+      progress: 0,
+      status: 'starting',
+      error: null,
+      result: null,
+    });
+
+    try {
+      const response = await prunaService.generateImage(request, controller.signal);
+      setState({
+        isGenerating: false,
+        progress: 100,
+        status: 'completed',
+        error: null,
+        result: response,
+      });
+      return response;
+    } catch (error) {
+      const errorObj: PrunaGenerationError = {
+        type: 'unknown',
+        message: error instanceof Error ? error.message : String(error),
+        retryable: false,
+        originalError: error instanceof Error ? error.stack : undefined,
+      };
+      setState({
+        isGenerating: false,
+        progress: 0,
+        status: 'error',
+        error: errorObj,
+        result: null,
+      });
+      throw error;
+    }
+  }, []);
+
+  const generateVideo = useCallback(async (request: PrunaVideoGenerationRequest) => {
+    const controller = new AbortController();
+    abortControllerRef.current = controller;
+
+    setState({
+      isGenerating: true,
+      progress: 0,
+      status: 'starting',
+      error: null,
+      result: null,
+    });
+
+    try {
+      const response = await prunaService.generateVideo(request, controller.signal);
+      setState({
+        isGenerating: false,
+        progress: 100,
+        status: 'completed',
+        error: null,
+        result: response,
+      });
+      return response;
+    } catch (error) {
+      const errorObj: PrunaGenerationError = {
+        type: 'unknown',
+        message: error instanceof Error ? error.message : String(error),
+        retryable: false,
+        originalError: error instanceof Error ? error.stack : undefined,
+      };
+      setState({
+        isGenerating: false,
+        progress: 0,
+        status: 'error',
+        error: errorObj,
+        result: null,
+      });
+      throw error;
+    }
+  }, []);
+
+  const generateImageEdit = useCallback(async (request: PrunaImageEditRequest) => {
+    const controller = new AbortController();
+    abortControllerRef.current = controller;
+
+    setState({
+      isGenerating: true,
+      progress: 0,
+      status: 'starting',
+      error: null,
+      result: null,
+    });
+
+    try {
+      const response = await prunaService.generateImageEdit(request, controller.signal);
+      setState({
+        isGenerating: false,
+        progress: 100,
+        status: 'completed',
+        error: null,
+        result: response,
+      });
+      return response;
+    } catch (error) {
+      const errorObj: PrunaGenerationError = {
+        type: 'unknown',
+        message: error instanceof Error ? error.message : String(error),
+        retryable: false,
+        originalError: error instanceof Error ? error.stack : undefined,
+      };
+      setState({
+        isGenerating: false,
+        progress: 0,
+        status: 'error',
+        error: errorObj,
+        result: null,
+      });
+      throw error;
+    }
+  }, []);
+
+  const cancel = useCallback(() => {
+    abortControllerRef.current?.abort();
+    setState(prev => ({
+      ...prev,
+      isGenerating: false,
+      status: 'cancelled',
+    }));
+  }, []);
+
+  const reset = useCallback(() => {
+    setState({
+      isGenerating: false,
+      progress: 0,
+      status: 'idle',
+      error: null,
+      result: null,
+    });
+  }, []);
+
+  return {
+    state,
+    generateImage,
+    generateVideo,
+    generateImageEdit,
+    cancel,
+    reset,
+  };
+}