feat: add Firebase integration for file storage and management

Author: aramb-dev

netlify/functions/cleanup.js

@@ -0,0 +1,46 @@
+import dotenv from 'dotenv';
+import { initializeApp } from 'firebase/app';
+import { getStorage, ref, deleteObject } from 'firebase/storage';
+import { getFirebaseConfig } from './firebase-config.js';
+dotenv.config();
+
+export async function handler(event, context) {
+  if (event.httpMethod !== 'POST') {
+    return {
+      statusCode: 405,
+      body: JSON.stringify({ error: 'Method not allowed' })
+    };
+  }
+
+  try {
+    const { filePath } = JSON.parse(event.body);
+
+    if (!filePath) {
+      return {
+        statusCode: 400,
+        body: JSON.stringify({ error: 'Missing file path' })
+      };
+    }
+
+    // Initialize Firebase
+    const app = initializeApp(getFirebaseConfig());
+    const storage = getStorage(app);
+
+    // Create a reference to the file
+    const fileRef = ref(storage, filePath);
+
+    // Delete the file
+    await deleteObject(fileRef);
+
+    return {
+      statusCode: 200,
+      body: JSON.stringify({ message: 'File deleted successfully' })
+    };
+  } catch (error) {
+    console.error('Error deleting file:', error);
+    return {
+      statusCode: 500,
+      body: JSON.stringify({ error: error.message || 'Unknown error' })
+    };
+  }
+}

netlify/functions/firebase-config.js

@@ -0,0 +1,10 @@
+export function getFirebaseConfig() {
+  return {
+    apiKey: process.env.VITE_FIREBASE_API_KEY,
+    authDomain: process.env.VITE_FIREBASE_AUTH_DOMAIN,
+    projectId: process.env.VITE_FIREBASE_PROJECT_ID,
+    storageBucket: process.env.VITE_FIREBASE_STORAGE_BUCKET,
+    messagingSenderId: process.env.VITE_FIREBASE_MESSAGING_SENDER_ID,
+    appId: process.env.VITE_FIREBASE_APP_ID
+  };
+}

netlify/functions/transcribe.js

@@ -1,7 +1,65 @@
-
 import dotenv from 'dotenv';
+import { initializeApp } from 'firebase/app';
+import { getStorage, ref, uploadBytes, getDownloadURL } from 'firebase/storage';
+import { getFirebaseConfig } from './firebase-config.js';
 dotenv.config();
 
+// Initialize Firebase when needed
+let firebaseApp;
+let storage;
+
+function initializeFirebase() {
+  if (!firebaseApp) {
+    firebaseApp = initializeApp(getFirebaseConfig());
+    storage = getStorage(firebaseApp);
+  }
+  return { firebaseApp, storage };
+}
+
+// Generate a unique filename with timestamp and random string
+const generateUniqueFilename = (originalName) => {
+  const timestamp = Date.now();
+  const randomString = Math.random().toString(36).substring(2, 8);
+  const fileExtension = originalName?.split('.').pop() || 'audio';
+  return `audio_${timestamp}_${randomString}.${fileExtension}`;
+};
+
+// Function to upload base64 data to Firebase Storage
+async function uploadBase64ToFirebase(base64Data, mimeType = 'audio/mpeg') {
+  const { storage } = initializeFirebase();
+
+  // Strip the data URL prefix if present
+  const base64WithoutPrefix = base64Data.replace(/^data:.*;base64,/, '');
+
+  // Convert base64 to a Blob
+  const byteCharacters = atob(base64WithoutPrefix);
+  const byteArrays = [];
+
+  for (let offset = 0; offset < byteCharacters.length; offset += 512) {
+    const slice = byteCharacters.slice(offset, offset + 512);
+    const byteNumbers = new Array(slice.length);
+    for (let i = 0; i < slice.length; i++) {
+      byteNumbers[i] = slice.charCodeAt(i);
+    }
+    const byteArray = new Uint8Array(byteNumbers);
+    byteArrays.push(byteArray);
+  }
+
+  const blob = new Blob(byteArrays, { type: mimeType });
+
+  // Create a reference with a unique filename
+  const filename = generateUniqueFilename('upload');
+  const fileRef = ref(storage, `temp_audio/${filename}`);
+
+  // Upload the blob
+  const snapshot = await uploadBytes(fileRef, blob);
+  console.log('Uploaded a blob to Firebase Storage');
+
+  // Get download URL
+  const downloadURL = await getDownloadURL(snapshot.ref);
+  return { url: downloadURL, ref: `temp_audio/${filename}` };
+}
+
 export async function handler(event, context) {
   if (event.httpMethod !== 'POST') {
     return {
@@ -11,17 +69,41 @@ export async function handler(event, context) {
   }
 
   try {
-    const { audioData, options } = JSON.parse(event.body);
+    const { audioData, audioUrl, options } = JSON.parse(event.body);
 
-    // Format input parameters like in your server
+    // Format input parameters
     const inputParams = {
       task: options.task || 'transcribe',
-      audio: audioData,
       batch_size: options.batch_size || 64,
       return_timestamps: options.return_timestamps || true,
       diarize: options.diarize || false,
     };
 
+    // Set audio source - check file size by base64 length
+    let finalAudioUrl = audioUrl;
+
+    // If no URL is provided but we have base64 data, check if it's large
+    if (!audioUrl && audioData) {
+      // Estimate size of base64 (rough estimate: base64 size * 0.75 = binary size)
+      const estimatedSizeInMB = (audioData.length * 0.75) / (1024 * 1024);
+
+      if (estimatedSizeInMB > 1) {
+        // Large file detected, upload to Firebase
+        console.log(`Large audio file detected (${estimatedSizeInMB.toFixed(2)}MB), uploading to Firebase`);
+        const uploadResult = await uploadBase64ToFirebase(audioData);
+        finalAudioUrl = uploadResult.url;
+        console.log('Uploaded to Firebase, URL:', finalAudioUrl);
+      } else {
+        // Small file, use base64 directly
+        inputParams.audio = audioData;
+      }
+    }
+
+    // If we have a URL (either provided or from Firebase upload), use it
+    if (finalAudioUrl) {
+      inputParams.audio = finalAudioUrl;
+    }
+
     // Only include language if it's not "None" (auto-detect)
     if (options.language !== "None") {
       inputParams.language = options.language;
@@ -55,11 +137,17 @@ export async function handler(event, context) {
       };
     }
 
+    // If we used Firebase, include the reference in the response for later cleanup
+    if (finalAudioUrl && finalAudioUrl !== audioUrl) {
+      data.firebaseRef = `Used Firebase Storage for large file`;
+    }
+
     return {
       statusCode: 200,
       body: JSON.stringify(data)
     };
   } catch (error) {
+    console.error('Error in transcribe function:', error);
     return {
       statusCode: 500,
       body: JSON.stringify({ error: error.message || 'Unknown error' })