@umituz/react-native-ai-pruna-provider 1.0.64 → 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/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,
+  };
+}