Skip to content

A modern, self-hosted backup solution for secure, encrypted backups across local and cloud storage.

9.0 KB
Raw Blame
import { useMutation, useQuery, useQueryClient } from '@tanstack/react-query';
import { toast } from 'react-toastify';
import { API_URL } from '../utils/constants';

const notifiedBackupProgress = new Set<string>();

// Generate Download
export async function generateBackupDownload({ backupId, replicationId }: { backupId: string; planId: string; replicationId?: string }) {
   const url = `${API_URL}/backups/${backupId}/action/download?${replicationId ? `replicationId=${replicationId}` : ''}`;
   const res = await fetch(url, {
      method: 'POST',
      credentials: 'include',
   });
   const data = await res.json();
   if (!data.success) {
      throw new Error(data.error);
   }
   return data;
}

export function useDownloadBackup() {
   const queryClient = useQueryClient();

   return useMutation({
      mutationFn: generateBackupDownload,
      onSuccess: (res, payload) => {
         console.log('res :', payload, res);
         queryClient.invalidateQueries({ queryKey: ['plan', payload.planId] });
      },
   });
}

// Get Download
export async function getBackupDownload(id: string) {
   const url = `${API_URL}/backups/${id}/action/download`;
   // HEAD pre-check so errors show a toast instead of a failed browser download
   const res = await fetch(url, { method: 'HEAD', credentials: 'include' });
   if (!res.ok) {
      throw new Error(res.status === 404 ? 'Download file not found. Please generate the download again.' : 'Download Failed!');
   }

   // Native browser download: shows size/progress and does not hold the file in memory
   const link = document.createElement('a');
   link.href = url;
   link.download = `backup-${id}.tar`;
   document.body.appendChild(link);
   link.click();
   link.remove();
}

export function useGetBackupDownload() {
   const queryClient = useQueryClient();
   return useMutation({
      mutationFn: getBackupDownload,
      onSuccess: (res) => {
         console.log('# Backup Downloaded! :', res);
      },
      onError: (error) => {
         console.log('# Download Failed! :', error);
         toast.error(error.message || 'Download Failed!');
         queryClient.invalidateQueries({ queryKey: ['plan'] });
      },
   });
}

// Cancel Download
export async function cancelBackupDownload({ backupId }: { backupId: string; planId: string }) {
   const res = await fetch(`${API_URL}/backups/${backupId}/action/download`, {
      method: 'DELETE',
      credentials: 'include',
      // headers: header,
   });
   // Check if response is ok
   const data = await res.json();
   if (!data.success) {
      throw new Error(data.error);
   }
   return data;
}
export function useCancelBackupDownload() {
   const queryClient = useQueryClient();
   return useMutation({
      mutationFn: cancelBackupDownload,
      onSuccess: (res, payload) => {
         console.log('res :', payload, res);
         queryClient.invalidateQueries({ queryKey: ['plan', payload.planId] });
      },
   });
}

// Remove Backup
export async function deleteBackup(id: string) {
   const header = new Headers({ 'Content-Type': 'application/json', Accept: 'application/json' });
   const res = await fetch(`${API_URL}/backups/${id}`, {
      method: 'DELETE',
      credentials: 'include',
      headers: header,
   });
   const data = await res.json();
   if (!data.success) {
      throw new Error(data.error);
   }
   return data;
}

export function useDeleteBackup() {
   return useMutation({
      mutationFn: deleteBackup,
      onSuccess: (res) => {
         console.log('# Backup Removed! :', res);
      },
   });
}

// Get Backup Progress
export async function getBackupProgress({ id, sourceId, sourceType, planId }: { id: string; sourceId: string; sourceType: string; planId: string }) {
   const url = new URL(`${API_URL}/backups/${id}/progress?sourceId=${sourceId}&sourceType=${sourceType}&planId=${planId}`);

   const res = await fetch(url.toString(), {
      method: 'GET',
      credentials: 'include',
   });
   const data = await res.json();
   return data;
}

export function useGetBackupProgress(payload: { id: string; sourceId: string; sourceType: string; planId: string }) {
   const queryClient = useQueryClient();
   return useQuery({
      queryKey: ['progress-backup', payload.id],
      queryFn: () => getBackupProgress(payload),
      refetchOnMount: true,
      retry: false,
      refetchInterval(query) {
         // Only refetch if the browser tab is active
         // if (document.hidden) return false;

         // console.log('query :', query.state?.data);
         const progressData = query.state?.data;

         // Check if backup is finished by looking for a "finished" phase event
         const isFinished = progressData?.events?.some((event: any) => event.phase === 'finished' && event.completed === true);

         if (isFinished) {
            const planId = progressData?.planId || payload.planId;
            if (!notifiedBackupProgress.has(payload.id)) {
               notifiedBackupProgress.add(payload.id);
               if (planId) {
                  console.log('Invalidate Plan and Reload It :', planId);
                  queryClient.invalidateQueries({ queryKey: ['plan', planId] });
               }
               toast.success('Process Complete!');
            }
            return false;
         }

         return 1000;
      },
   });
}

export function useGetBackupProgressOnce(payload: { id: string; sourceId: string; sourceType: string; planId: string }) {
   return useQuery({
      queryKey: ['progress-backup', payload.id],
      queryFn: () => getBackupProgress(payload),
      refetchOnMount: true,
      retry: false,
   });
}

// Cancel Backup
export async function cancelBackup({ planId, backupId }: { planId: string; backupId: string }) {
   const res = await fetch(`${API_URL}/backups/${backupId}/action/cancel?planId=${planId}`, {
      method: 'POST',
      credentials: 'include',
      // headers: header,
   });
   // Check if response is ok
   const data = await res.json();
   if (!data.success) {
      throw new Error(data.error);
   }
   return data;
}
export function useCancelBackup() {
   return useMutation({
      mutationFn: cancelBackup,
      onSuccess: (res, payload) => {
         console.log('res :', payload, res);
      },
   });
}

// Update Backup Title and Description
export async function updateBackup({ backupId, updatePayload }: { backupId: string; updatePayload: { title?: string; description?: string } }) {
   console.log('updatePayload :', updatePayload);
   const header = new Headers({ 'Content-Type': 'application/json', Accept: 'application/json' });
   const res = await fetch(`${API_URL}/backups/${backupId}`, {
      method: 'POST',
      credentials: 'include',
      body: JSON.stringify(updatePayload),
      headers: header,
   });
   // Check if response is ok
   const data = await res.json();
   if (!data.success) {
      throw new Error(data.error);
   }
   return data;
}
export function useUpdateBackup() {
   return useMutation({
      mutationFn: updateBackup,
      onSuccess: (res, payload) => {
         console.log('res :', payload, res);
      },
   });
}

// Get Snapshot Files
export async function getSnapshotFiles({ backupId, replicationId }: { backupId: string; replicationId?: string }) {
   const url = replicationId ? `${API_URL}/backups/${backupId}/files?replicationId=${replicationId}` : `${API_URL}/backups/${backupId}/files`;
   const res = await fetch(url, {
      method: 'GET',
      credentials: 'include',
   });
   const data = await res.json();
   if (!data.success) {
      throw new Error(data.error);
   }
   return data;
}
export function useGetSnapshotFiles(payload: { backupId: string }) {
   return useQuery({
      queryKey: ['snapshot-files', payload.backupId],
      queryFn: () => getSnapshotFiles(payload),
      refetchOnMount: true,
      staleTime: 1000 * 60 * 60, // Cache the data for 60 minutes
      retry: false,
   });
}

// Get Snapshot Files (Mutation)
// To be used for manual refresh or when triggered from an action,
// since it bypasses the cache and directly calls the API
export function useBrowseSnapshot() {
   return useMutation({
      mutationFn: getSnapshotFiles,
      onSuccess: (res, payload) => {
         console.log('res :', payload, res);
      },
   });
}

// Retry Failed Replications
export async function retryFailedReplications({ backupId, replicationId }: { backupId: string; planId: string; replicationId: string }) {
   const header = new Headers({ 'Content-Type': 'application/json', Accept: 'application/json' });
   const res = await fetch(`${API_URL}/backups/${backupId}/action/replication-retry?replicationId=${replicationId}`, {
      method: 'POST',
      credentials: 'include',
      headers: header,
   });
   const data = await res.json();
   if (!data.success) {
      throw new Error(data.error);
   }
   return data;
}

export function useRetryFailedReplications() {
   const queryClient = useQueryClient();
   return useMutation({
      mutationFn: retryFailedReplications,
      onSuccess: (res, payload) => {
         console.log('res :', payload, res);
         queryClient.invalidateQueries({ queryKey: ['plan', payload.planId] });
      },
   });
}