A modern, self-hosted backup solution for secure, encrypted backups across local and cloud storage.
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] });
},
});
}