mirror of
https://github.com/nicotsx/zerobyte.git
synced 2026-04-18 05:47:31 -04:00
d2f65716fe
* feat(mirrors): add selective snapshot sync to mirror repositories Allow users to sync missing snapshots from the source repository to a mirror. A new sync button per mirror opens a dialog showing which snapshots are missing, with checkboxes to select which ones to copy. - Add GET /:shortId/mirrors/:mirrorShortId/status endpoint to compare snapshots between source and mirror repositories - Add POST /:shortId/mirrors/:mirrorShortId/sync endpoint accepting selected snapshotIds in the request body - Extend restic copy command to accept multiple snapshotIds - Add sync preview dialog with snapshot selection to the frontend * refactor: stylistic changes --------- Co-authored-by: Nicolas Meienberger <github@thisprops.com>
1398 lines
57 KiB
TypeScript
1398 lines
57 KiB
TypeScript
// @ts-nocheck
|
|
// This file is auto-generated by @hey-api/openapi-ts
|
|
|
|
import { type DefaultError, type InfiniteData, infiniteQueryOptions, queryOptions, type UseMutationOptions } from '@tanstack/react-query';
|
|
|
|
import { client } from '../client.gen';
|
|
import { browseFilesystem, cancelDoctor, createBackupSchedule, createNotificationDestination, createRepository, createVolume, deleteBackupSchedule, deleteNotificationDestination, deleteRepository, deleteSnapshot, deleteSnapshots, deleteSsoInvitation, deleteSsoProvider, deleteUserAccount, deleteVolume, downloadResticPassword, dumpSnapshot, getAdminUsers, getBackupProgress, getBackupSchedule, getBackupScheduleForVolume, getDevPanel, getMirrorCompatibility, getMirrorSyncStatus, getNotificationDestination, getOrgMembers, getPublicSsoProviders, getRegistrationStatus, getRepository, getRepositoryStats, getScheduleMirrors, getScheduleNotifications, getSnapshotDetails, getSsoSettings, getStatus, getSystemInfo, getUpdates, getUserDeletionImpact, getVolume, healthCheckVolume, listBackupSchedules, listFiles, listNotificationDestinations, listRcloneRemotes, listRepositories, listSnapshotFiles, listSnapshots, listVolumes, mountVolume, type Options, refreshRepositoryStats, refreshSnapshots, removeOrgMember, reorderBackupSchedules, restoreSnapshot, runBackupNow, runForget, setRegistrationStatus, startDoctor, stopBackup, syncMirror, tagSnapshots, testConnection, testNotificationDestination, unlockRepository, unmountVolume, updateBackupSchedule, updateMemberRole, updateNotificationDestination, updateRepository, updateScheduleMirrors, updateScheduleNotifications, updateSsoProviderAutoLinking, updateVolume } from '../sdk.gen';
|
|
import type { BrowseFilesystemData, BrowseFilesystemResponse, CancelDoctorData, CancelDoctorResponse, CreateBackupScheduleData, CreateBackupScheduleResponse, CreateNotificationDestinationData, CreateNotificationDestinationResponse, CreateRepositoryData, CreateRepositoryResponse, CreateVolumeData, CreateVolumeResponse, DeleteBackupScheduleData, DeleteBackupScheduleResponse, DeleteNotificationDestinationData, DeleteNotificationDestinationResponse, DeleteRepositoryData, DeleteRepositoryResponse, DeleteSnapshotData, DeleteSnapshotResponse, DeleteSnapshotsData, DeleteSnapshotsResponse, DeleteSsoInvitationData, DeleteSsoProviderData, DeleteUserAccountData, DeleteVolumeData, DeleteVolumeResponse, DownloadResticPasswordData, DownloadResticPasswordResponse, DumpSnapshotData, DumpSnapshotResponse, GetAdminUsersData, GetAdminUsersResponse, GetBackupProgressData, GetBackupProgressResponse, GetBackupScheduleData, GetBackupScheduleForVolumeData, GetBackupScheduleForVolumeResponse, GetBackupScheduleResponse, GetDevPanelData, GetDevPanelResponse, GetMirrorCompatibilityData, GetMirrorCompatibilityResponse, GetMirrorSyncStatusData, GetMirrorSyncStatusResponse, GetNotificationDestinationData, GetNotificationDestinationResponse, GetOrgMembersData, GetOrgMembersResponse, GetPublicSsoProvidersData, GetPublicSsoProvidersResponse, GetRegistrationStatusData, GetRegistrationStatusResponse, GetRepositoryData, GetRepositoryResponse, GetRepositoryStatsData, GetRepositoryStatsResponse, GetScheduleMirrorsData, GetScheduleMirrorsResponse, GetScheduleNotificationsData, GetScheduleNotificationsResponse, GetSnapshotDetailsData, GetSnapshotDetailsResponse, GetSsoSettingsData, GetSsoSettingsResponse, GetStatusData, GetStatusResponse, GetSystemInfoData, GetSystemInfoResponse, GetUpdatesData, GetUpdatesResponse, GetUserDeletionImpactData, GetUserDeletionImpactResponse, GetVolumeData, GetVolumeResponse, HealthCheckVolumeData, HealthCheckVolumeResponse, ListBackupSchedulesData, ListBackupSchedulesResponse, ListFilesData, ListFilesResponse, ListNotificationDestinationsData, ListNotificationDestinationsResponse, ListRcloneRemotesData, ListRcloneRemotesResponse, ListRepositoriesData, ListRepositoriesResponse, ListSnapshotFilesData, ListSnapshotFilesResponse, ListSnapshotsData, ListSnapshotsResponse, ListVolumesData, ListVolumesResponse, MountVolumeData, MountVolumeResponse, RefreshRepositoryStatsData, RefreshRepositoryStatsResponse, RefreshSnapshotsData, RefreshSnapshotsResponse, RemoveOrgMemberData, ReorderBackupSchedulesData, ReorderBackupSchedulesResponse, RestoreSnapshotData, RestoreSnapshotResponse, RunBackupNowData, RunBackupNowResponse, RunForgetData, RunForgetResponse, SetRegistrationStatusData, SetRegistrationStatusResponse, StartDoctorData, StartDoctorResponse, StopBackupData, StopBackupResponse, SyncMirrorData, SyncMirrorResponse, TagSnapshotsData, TagSnapshotsResponse, TestConnectionData, TestConnectionResponse, TestNotificationDestinationData, TestNotificationDestinationResponse, UnlockRepositoryData, UnlockRepositoryResponse, UnmountVolumeData, UnmountVolumeResponse, UpdateBackupScheduleData, UpdateBackupScheduleResponse, UpdateMemberRoleData, UpdateNotificationDestinationData, UpdateNotificationDestinationResponse, UpdateRepositoryData, UpdateRepositoryResponse, UpdateScheduleMirrorsData, UpdateScheduleMirrorsResponse, UpdateScheduleNotificationsData, UpdateScheduleNotificationsResponse, UpdateSsoProviderAutoLinkingData, UpdateVolumeData, UpdateVolumeResponse } from '../types.gen';
|
|
|
|
export type QueryKey<TOptions extends Options> = [
|
|
Pick<TOptions, 'baseUrl' | 'body' | 'headers' | 'path' | 'query'> & {
|
|
_id: string;
|
|
_infinite?: boolean;
|
|
tags?: ReadonlyArray<string>;
|
|
}
|
|
];
|
|
|
|
const createQueryKey = <TOptions extends Options>(id: string, options?: TOptions, infinite?: boolean, tags?: ReadonlyArray<string>): [
|
|
QueryKey<TOptions>[0]
|
|
] => {
|
|
const params: QueryKey<TOptions>[0] = { _id: id, baseUrl: options?.baseUrl || (options?.client ?? client).getConfig().baseUrl } as QueryKey<TOptions>[0];
|
|
if (infinite) {
|
|
params._infinite = infinite;
|
|
}
|
|
if (tags) {
|
|
params.tags = tags;
|
|
}
|
|
if (options?.body) {
|
|
params.body = options.body;
|
|
}
|
|
if (options?.headers) {
|
|
params.headers = options.headers;
|
|
}
|
|
if (options?.path) {
|
|
params.path = options.path;
|
|
}
|
|
if (options?.query) {
|
|
params.query = options.query;
|
|
}
|
|
return [params];
|
|
};
|
|
|
|
export const getStatusQueryKey = (options?: Options<GetStatusData>) => createQueryKey('getStatus', options);
|
|
|
|
/**
|
|
* Get authentication system status
|
|
*/
|
|
export const getStatusOptions = (options?: Options<GetStatusData>) => queryOptions<GetStatusResponse, DefaultError, GetStatusResponse, ReturnType<typeof getStatusQueryKey>>({
|
|
queryFn: async ({ queryKey, signal }) => {
|
|
const { data } = await getStatus({
|
|
...options,
|
|
...queryKey[0],
|
|
signal,
|
|
throwOnError: true
|
|
});
|
|
return data;
|
|
},
|
|
queryKey: getStatusQueryKey(options)
|
|
});
|
|
|
|
export const getAdminUsersQueryKey = (options?: Options<GetAdminUsersData>) => createQueryKey('getAdminUsers', options);
|
|
|
|
/**
|
|
* List admin users for settings management
|
|
*/
|
|
export const getAdminUsersOptions = (options?: Options<GetAdminUsersData>) => queryOptions<GetAdminUsersResponse, DefaultError, GetAdminUsersResponse, ReturnType<typeof getAdminUsersQueryKey>>({
|
|
queryFn: async ({ queryKey, signal }) => {
|
|
const { data } = await getAdminUsers({
|
|
...options,
|
|
...queryKey[0],
|
|
signal,
|
|
throwOnError: true
|
|
});
|
|
return data;
|
|
},
|
|
queryKey: getAdminUsersQueryKey(options)
|
|
});
|
|
|
|
/**
|
|
* Delete an account linked to a user
|
|
*/
|
|
export const deleteUserAccountMutation = (options?: Partial<Options<DeleteUserAccountData>>): UseMutationOptions<unknown, DefaultError, Options<DeleteUserAccountData>> => {
|
|
const mutationOptions: UseMutationOptions<unknown, DefaultError, Options<DeleteUserAccountData>> = {
|
|
mutationFn: async (fnOptions) => {
|
|
const { data } = await deleteUserAccount({
|
|
...options,
|
|
...fnOptions,
|
|
throwOnError: true
|
|
});
|
|
return data;
|
|
}
|
|
};
|
|
return mutationOptions;
|
|
};
|
|
|
|
export const getUserDeletionImpactQueryKey = (options: Options<GetUserDeletionImpactData>) => createQueryKey('getUserDeletionImpact', options);
|
|
|
|
/**
|
|
* Get impact of deleting a user
|
|
*/
|
|
export const getUserDeletionImpactOptions = (options: Options<GetUserDeletionImpactData>) => queryOptions<GetUserDeletionImpactResponse, DefaultError, GetUserDeletionImpactResponse, ReturnType<typeof getUserDeletionImpactQueryKey>>({
|
|
queryFn: async ({ queryKey, signal }) => {
|
|
const { data } = await getUserDeletionImpact({
|
|
...options,
|
|
...queryKey[0],
|
|
signal,
|
|
throwOnError: true
|
|
});
|
|
return data;
|
|
},
|
|
queryKey: getUserDeletionImpactQueryKey(options)
|
|
});
|
|
|
|
export const getOrgMembersQueryKey = (options?: Options<GetOrgMembersData>) => createQueryKey('getOrgMembers', options);
|
|
|
|
/**
|
|
* Get members of the active organization
|
|
*/
|
|
export const getOrgMembersOptions = (options?: Options<GetOrgMembersData>) => queryOptions<GetOrgMembersResponse, DefaultError, GetOrgMembersResponse, ReturnType<typeof getOrgMembersQueryKey>>({
|
|
queryFn: async ({ queryKey, signal }) => {
|
|
const { data } = await getOrgMembers({
|
|
...options,
|
|
...queryKey[0],
|
|
signal,
|
|
throwOnError: true
|
|
});
|
|
return data;
|
|
},
|
|
queryKey: getOrgMembersQueryKey(options)
|
|
});
|
|
|
|
/**
|
|
* Update a member's role in the active organization
|
|
*/
|
|
export const updateMemberRoleMutation = (options?: Partial<Options<UpdateMemberRoleData>>): UseMutationOptions<unknown, DefaultError, Options<UpdateMemberRoleData>> => {
|
|
const mutationOptions: UseMutationOptions<unknown, DefaultError, Options<UpdateMemberRoleData>> = {
|
|
mutationFn: async (fnOptions) => {
|
|
const { data } = await updateMemberRole({
|
|
...options,
|
|
...fnOptions,
|
|
throwOnError: true
|
|
});
|
|
return data;
|
|
}
|
|
};
|
|
return mutationOptions;
|
|
};
|
|
|
|
/**
|
|
* Remove a member from the active organization
|
|
*/
|
|
export const removeOrgMemberMutation = (options?: Partial<Options<RemoveOrgMemberData>>): UseMutationOptions<unknown, DefaultError, Options<RemoveOrgMemberData>> => {
|
|
const mutationOptions: UseMutationOptions<unknown, DefaultError, Options<RemoveOrgMemberData>> = {
|
|
mutationFn: async (fnOptions) => {
|
|
const { data } = await removeOrgMember({
|
|
...options,
|
|
...fnOptions,
|
|
throwOnError: true
|
|
});
|
|
return data;
|
|
}
|
|
};
|
|
return mutationOptions;
|
|
};
|
|
|
|
export const getPublicSsoProvidersQueryKey = (options?: Options<GetPublicSsoProvidersData>) => createQueryKey('getPublicSsoProviders', options);
|
|
|
|
/**
|
|
* Get public SSO providers for the instance
|
|
*/
|
|
export const getPublicSsoProvidersOptions = (options?: Options<GetPublicSsoProvidersData>) => queryOptions<GetPublicSsoProvidersResponse, DefaultError, GetPublicSsoProvidersResponse, ReturnType<typeof getPublicSsoProvidersQueryKey>>({
|
|
queryFn: async ({ queryKey, signal }) => {
|
|
const { data } = await getPublicSsoProviders({
|
|
...options,
|
|
...queryKey[0],
|
|
signal,
|
|
throwOnError: true
|
|
});
|
|
return data;
|
|
},
|
|
queryKey: getPublicSsoProvidersQueryKey(options)
|
|
});
|
|
|
|
export const getSsoSettingsQueryKey = (options?: Options<GetSsoSettingsData>) => createQueryKey('getSsoSettings', options);
|
|
|
|
/**
|
|
* Get SSO providers and invitations for the active organization
|
|
*/
|
|
export const getSsoSettingsOptions = (options?: Options<GetSsoSettingsData>) => queryOptions<GetSsoSettingsResponse, DefaultError, GetSsoSettingsResponse, ReturnType<typeof getSsoSettingsQueryKey>>({
|
|
queryFn: async ({ queryKey, signal }) => {
|
|
const { data } = await getSsoSettings({
|
|
...options,
|
|
...queryKey[0],
|
|
signal,
|
|
throwOnError: true
|
|
});
|
|
return data;
|
|
},
|
|
queryKey: getSsoSettingsQueryKey(options)
|
|
});
|
|
|
|
/**
|
|
* Delete an SSO provider
|
|
*/
|
|
export const deleteSsoProviderMutation = (options?: Partial<Options<DeleteSsoProviderData>>): UseMutationOptions<unknown, DefaultError, Options<DeleteSsoProviderData>> => {
|
|
const mutationOptions: UseMutationOptions<unknown, DefaultError, Options<DeleteSsoProviderData>> = {
|
|
mutationFn: async (fnOptions) => {
|
|
const { data } = await deleteSsoProvider({
|
|
...options,
|
|
...fnOptions,
|
|
throwOnError: true
|
|
});
|
|
return data;
|
|
}
|
|
};
|
|
return mutationOptions;
|
|
};
|
|
|
|
/**
|
|
* Update whether SSO sign-in can auto-link existing accounts by email
|
|
*/
|
|
export const updateSsoProviderAutoLinkingMutation = (options?: Partial<Options<UpdateSsoProviderAutoLinkingData>>): UseMutationOptions<unknown, DefaultError, Options<UpdateSsoProviderAutoLinkingData>> => {
|
|
const mutationOptions: UseMutationOptions<unknown, DefaultError, Options<UpdateSsoProviderAutoLinkingData>> = {
|
|
mutationFn: async (fnOptions) => {
|
|
const { data } = await updateSsoProviderAutoLinking({
|
|
...options,
|
|
...fnOptions,
|
|
throwOnError: true
|
|
});
|
|
return data;
|
|
}
|
|
};
|
|
return mutationOptions;
|
|
};
|
|
|
|
/**
|
|
* Delete an SSO invitation
|
|
*/
|
|
export const deleteSsoInvitationMutation = (options?: Partial<Options<DeleteSsoInvitationData>>): UseMutationOptions<unknown, DefaultError, Options<DeleteSsoInvitationData>> => {
|
|
const mutationOptions: UseMutationOptions<unknown, DefaultError, Options<DeleteSsoInvitationData>> = {
|
|
mutationFn: async (fnOptions) => {
|
|
const { data } = await deleteSsoInvitation({
|
|
...options,
|
|
...fnOptions,
|
|
throwOnError: true
|
|
});
|
|
return data;
|
|
}
|
|
};
|
|
return mutationOptions;
|
|
};
|
|
|
|
export const listVolumesQueryKey = (options?: Options<ListVolumesData>) => createQueryKey('listVolumes', options);
|
|
|
|
/**
|
|
* List all volumes
|
|
*/
|
|
export const listVolumesOptions = (options?: Options<ListVolumesData>) => queryOptions<ListVolumesResponse, DefaultError, ListVolumesResponse, ReturnType<typeof listVolumesQueryKey>>({
|
|
queryFn: async ({ queryKey, signal }) => {
|
|
const { data } = await listVolumes({
|
|
...options,
|
|
...queryKey[0],
|
|
signal,
|
|
throwOnError: true
|
|
});
|
|
return data;
|
|
},
|
|
queryKey: listVolumesQueryKey(options)
|
|
});
|
|
|
|
/**
|
|
* Create a new volume
|
|
*/
|
|
export const createVolumeMutation = (options?: Partial<Options<CreateVolumeData>>): UseMutationOptions<CreateVolumeResponse, DefaultError, Options<CreateVolumeData>> => {
|
|
const mutationOptions: UseMutationOptions<CreateVolumeResponse, DefaultError, Options<CreateVolumeData>> = {
|
|
mutationFn: async (fnOptions) => {
|
|
const { data } = await createVolume({
|
|
...options,
|
|
...fnOptions,
|
|
throwOnError: true
|
|
});
|
|
return data;
|
|
}
|
|
};
|
|
return mutationOptions;
|
|
};
|
|
|
|
/**
|
|
* Test connection to backend
|
|
*/
|
|
export const testConnectionMutation = (options?: Partial<Options<TestConnectionData>>): UseMutationOptions<TestConnectionResponse, DefaultError, Options<TestConnectionData>> => {
|
|
const mutationOptions: UseMutationOptions<TestConnectionResponse, DefaultError, Options<TestConnectionData>> = {
|
|
mutationFn: async (fnOptions) => {
|
|
const { data } = await testConnection({
|
|
...options,
|
|
...fnOptions,
|
|
throwOnError: true
|
|
});
|
|
return data;
|
|
}
|
|
};
|
|
return mutationOptions;
|
|
};
|
|
|
|
/**
|
|
* Delete a volume
|
|
*/
|
|
export const deleteVolumeMutation = (options?: Partial<Options<DeleteVolumeData>>): UseMutationOptions<DeleteVolumeResponse, DefaultError, Options<DeleteVolumeData>> => {
|
|
const mutationOptions: UseMutationOptions<DeleteVolumeResponse, DefaultError, Options<DeleteVolumeData>> = {
|
|
mutationFn: async (fnOptions) => {
|
|
const { data } = await deleteVolume({
|
|
...options,
|
|
...fnOptions,
|
|
throwOnError: true
|
|
});
|
|
return data;
|
|
}
|
|
};
|
|
return mutationOptions;
|
|
};
|
|
|
|
export const getVolumeQueryKey = (options: Options<GetVolumeData>) => createQueryKey('getVolume', options);
|
|
|
|
/**
|
|
* Get a volume by name
|
|
*/
|
|
export const getVolumeOptions = (options: Options<GetVolumeData>) => queryOptions<GetVolumeResponse, DefaultError, GetVolumeResponse, ReturnType<typeof getVolumeQueryKey>>({
|
|
queryFn: async ({ queryKey, signal }) => {
|
|
const { data } = await getVolume({
|
|
...options,
|
|
...queryKey[0],
|
|
signal,
|
|
throwOnError: true
|
|
});
|
|
return data;
|
|
},
|
|
queryKey: getVolumeQueryKey(options)
|
|
});
|
|
|
|
/**
|
|
* Update a volume's configuration
|
|
*/
|
|
export const updateVolumeMutation = (options?: Partial<Options<UpdateVolumeData>>): UseMutationOptions<UpdateVolumeResponse, DefaultError, Options<UpdateVolumeData>> => {
|
|
const mutationOptions: UseMutationOptions<UpdateVolumeResponse, DefaultError, Options<UpdateVolumeData>> = {
|
|
mutationFn: async (fnOptions) => {
|
|
const { data } = await updateVolume({
|
|
...options,
|
|
...fnOptions,
|
|
throwOnError: true
|
|
});
|
|
return data;
|
|
}
|
|
};
|
|
return mutationOptions;
|
|
};
|
|
|
|
/**
|
|
* Mount a volume
|
|
*/
|
|
export const mountVolumeMutation = (options?: Partial<Options<MountVolumeData>>): UseMutationOptions<MountVolumeResponse, DefaultError, Options<MountVolumeData>> => {
|
|
const mutationOptions: UseMutationOptions<MountVolumeResponse, DefaultError, Options<MountVolumeData>> = {
|
|
mutationFn: async (fnOptions) => {
|
|
const { data } = await mountVolume({
|
|
...options,
|
|
...fnOptions,
|
|
throwOnError: true
|
|
});
|
|
return data;
|
|
}
|
|
};
|
|
return mutationOptions;
|
|
};
|
|
|
|
/**
|
|
* Unmount a volume
|
|
*/
|
|
export const unmountVolumeMutation = (options?: Partial<Options<UnmountVolumeData>>): UseMutationOptions<UnmountVolumeResponse, DefaultError, Options<UnmountVolumeData>> => {
|
|
const mutationOptions: UseMutationOptions<UnmountVolumeResponse, DefaultError, Options<UnmountVolumeData>> = {
|
|
mutationFn: async (fnOptions) => {
|
|
const { data } = await unmountVolume({
|
|
...options,
|
|
...fnOptions,
|
|
throwOnError: true
|
|
});
|
|
return data;
|
|
}
|
|
};
|
|
return mutationOptions;
|
|
};
|
|
|
|
/**
|
|
* Perform a health check on a volume
|
|
*/
|
|
export const healthCheckVolumeMutation = (options?: Partial<Options<HealthCheckVolumeData>>): UseMutationOptions<HealthCheckVolumeResponse, DefaultError, Options<HealthCheckVolumeData>> => {
|
|
const mutationOptions: UseMutationOptions<HealthCheckVolumeResponse, DefaultError, Options<HealthCheckVolumeData>> = {
|
|
mutationFn: async (fnOptions) => {
|
|
const { data } = await healthCheckVolume({
|
|
...options,
|
|
...fnOptions,
|
|
throwOnError: true
|
|
});
|
|
return data;
|
|
}
|
|
};
|
|
return mutationOptions;
|
|
};
|
|
|
|
export const listFilesQueryKey = (options: Options<ListFilesData>) => createQueryKey('listFiles', options);
|
|
|
|
/**
|
|
* List files in a volume directory
|
|
*/
|
|
export const listFilesOptions = (options: Options<ListFilesData>) => queryOptions<ListFilesResponse, DefaultError, ListFilesResponse, ReturnType<typeof listFilesQueryKey>>({
|
|
queryFn: async ({ queryKey, signal }) => {
|
|
const { data } = await listFiles({
|
|
...options,
|
|
...queryKey[0],
|
|
signal,
|
|
throwOnError: true
|
|
});
|
|
return data;
|
|
},
|
|
queryKey: listFilesQueryKey(options)
|
|
});
|
|
|
|
const createInfiniteParams = <K extends Pick<QueryKey<Options>[0], 'body' | 'headers' | 'path' | 'query'>>(queryKey: QueryKey<Options>, page: K) => {
|
|
const params = { ...queryKey[0] };
|
|
if (page.body) {
|
|
params.body = {
|
|
...queryKey[0].body as any,
|
|
...page.body as any
|
|
};
|
|
}
|
|
if (page.headers) {
|
|
params.headers = {
|
|
...queryKey[0].headers,
|
|
...page.headers
|
|
};
|
|
}
|
|
if (page.path) {
|
|
params.path = {
|
|
...queryKey[0].path as any,
|
|
...page.path as any
|
|
};
|
|
}
|
|
if (page.query) {
|
|
params.query = {
|
|
...queryKey[0].query as any,
|
|
...page.query as any
|
|
};
|
|
}
|
|
return params as unknown as typeof page;
|
|
};
|
|
|
|
export const listFilesInfiniteQueryKey = (options: Options<ListFilesData>): QueryKey<Options<ListFilesData>> => createQueryKey('listFiles', options, true);
|
|
|
|
/**
|
|
* List files in a volume directory
|
|
*/
|
|
export const listFilesInfiniteOptions = (options: Options<ListFilesData>) => infiniteQueryOptions<ListFilesResponse, DefaultError, InfiniteData<ListFilesResponse>, QueryKey<Options<ListFilesData>>, number | Pick<QueryKey<Options<ListFilesData>>[0], 'body' | 'headers' | 'path' | 'query'>>(
|
|
// @ts-ignore
|
|
{
|
|
queryFn: async ({ pageParam, queryKey, signal }) => {
|
|
// @ts-ignore
|
|
const page: Pick<QueryKey<Options<ListFilesData>>[0], 'body' | 'headers' | 'path' | 'query'> = typeof pageParam === 'object' ? pageParam : {
|
|
query: {
|
|
offset: pageParam
|
|
}
|
|
};
|
|
const params = createInfiniteParams(queryKey, page);
|
|
const { data } = await listFiles({
|
|
...options,
|
|
...params,
|
|
signal,
|
|
throwOnError: true
|
|
});
|
|
return data;
|
|
},
|
|
queryKey: listFilesInfiniteQueryKey(options)
|
|
});
|
|
|
|
export const browseFilesystemQueryKey = (options?: Options<BrowseFilesystemData>) => createQueryKey('browseFilesystem', options);
|
|
|
|
/**
|
|
* Browse directories on the host filesystem
|
|
*/
|
|
export const browseFilesystemOptions = (options?: Options<BrowseFilesystemData>) => queryOptions<BrowseFilesystemResponse, DefaultError, BrowseFilesystemResponse, ReturnType<typeof browseFilesystemQueryKey>>({
|
|
queryFn: async ({ queryKey, signal }) => {
|
|
const { data } = await browseFilesystem({
|
|
...options,
|
|
...queryKey[0],
|
|
signal,
|
|
throwOnError: true
|
|
});
|
|
return data;
|
|
},
|
|
queryKey: browseFilesystemQueryKey(options)
|
|
});
|
|
|
|
export const listRepositoriesQueryKey = (options?: Options<ListRepositoriesData>) => createQueryKey('listRepositories', options);
|
|
|
|
/**
|
|
* List all repositories
|
|
*/
|
|
export const listRepositoriesOptions = (options?: Options<ListRepositoriesData>) => queryOptions<ListRepositoriesResponse, DefaultError, ListRepositoriesResponse, ReturnType<typeof listRepositoriesQueryKey>>({
|
|
queryFn: async ({ queryKey, signal }) => {
|
|
const { data } = await listRepositories({
|
|
...options,
|
|
...queryKey[0],
|
|
signal,
|
|
throwOnError: true
|
|
});
|
|
return data;
|
|
},
|
|
queryKey: listRepositoriesQueryKey(options)
|
|
});
|
|
|
|
/**
|
|
* Create a new restic repository
|
|
*/
|
|
export const createRepositoryMutation = (options?: Partial<Options<CreateRepositoryData>>): UseMutationOptions<CreateRepositoryResponse, DefaultError, Options<CreateRepositoryData>> => {
|
|
const mutationOptions: UseMutationOptions<CreateRepositoryResponse, DefaultError, Options<CreateRepositoryData>> = {
|
|
mutationFn: async (fnOptions) => {
|
|
const { data } = await createRepository({
|
|
...options,
|
|
...fnOptions,
|
|
throwOnError: true
|
|
});
|
|
return data;
|
|
}
|
|
};
|
|
return mutationOptions;
|
|
};
|
|
|
|
export const listRcloneRemotesQueryKey = (options?: Options<ListRcloneRemotesData>) => createQueryKey('listRcloneRemotes', options);
|
|
|
|
/**
|
|
* List all configured rclone remotes on the host system
|
|
*/
|
|
export const listRcloneRemotesOptions = (options?: Options<ListRcloneRemotesData>) => queryOptions<ListRcloneRemotesResponse, DefaultError, ListRcloneRemotesResponse, ReturnType<typeof listRcloneRemotesQueryKey>>({
|
|
queryFn: async ({ queryKey, signal }) => {
|
|
const { data } = await listRcloneRemotes({
|
|
...options,
|
|
...queryKey[0],
|
|
signal,
|
|
throwOnError: true
|
|
});
|
|
return data;
|
|
},
|
|
queryKey: listRcloneRemotesQueryKey(options)
|
|
});
|
|
|
|
/**
|
|
* Delete a repository
|
|
*/
|
|
export const deleteRepositoryMutation = (options?: Partial<Options<DeleteRepositoryData>>): UseMutationOptions<DeleteRepositoryResponse, DefaultError, Options<DeleteRepositoryData>> => {
|
|
const mutationOptions: UseMutationOptions<DeleteRepositoryResponse, DefaultError, Options<DeleteRepositoryData>> = {
|
|
mutationFn: async (fnOptions) => {
|
|
const { data } = await deleteRepository({
|
|
...options,
|
|
...fnOptions,
|
|
throwOnError: true
|
|
});
|
|
return data;
|
|
}
|
|
};
|
|
return mutationOptions;
|
|
};
|
|
|
|
export const getRepositoryQueryKey = (options: Options<GetRepositoryData>) => createQueryKey('getRepository', options);
|
|
|
|
/**
|
|
* Get a single repository by ID
|
|
*/
|
|
export const getRepositoryOptions = (options: Options<GetRepositoryData>) => queryOptions<GetRepositoryResponse, DefaultError, GetRepositoryResponse, ReturnType<typeof getRepositoryQueryKey>>({
|
|
queryFn: async ({ queryKey, signal }) => {
|
|
const { data } = await getRepository({
|
|
...options,
|
|
...queryKey[0],
|
|
signal,
|
|
throwOnError: true
|
|
});
|
|
return data;
|
|
},
|
|
queryKey: getRepositoryQueryKey(options)
|
|
});
|
|
|
|
/**
|
|
* Update a repository's name or settings
|
|
*/
|
|
export const updateRepositoryMutation = (options?: Partial<Options<UpdateRepositoryData>>): UseMutationOptions<UpdateRepositoryResponse, DefaultError, Options<UpdateRepositoryData>> => {
|
|
const mutationOptions: UseMutationOptions<UpdateRepositoryResponse, DefaultError, Options<UpdateRepositoryData>> = {
|
|
mutationFn: async (fnOptions) => {
|
|
const { data } = await updateRepository({
|
|
...options,
|
|
...fnOptions,
|
|
throwOnError: true
|
|
});
|
|
return data;
|
|
}
|
|
};
|
|
return mutationOptions;
|
|
};
|
|
|
|
export const getRepositoryStatsQueryKey = (options: Options<GetRepositoryStatsData>) => createQueryKey('getRepositoryStats', options);
|
|
|
|
/**
|
|
* Get repository storage and compression statistics
|
|
*/
|
|
export const getRepositoryStatsOptions = (options: Options<GetRepositoryStatsData>) => queryOptions<GetRepositoryStatsResponse, DefaultError, GetRepositoryStatsResponse, ReturnType<typeof getRepositoryStatsQueryKey>>({
|
|
queryFn: async ({ queryKey, signal }) => {
|
|
const { data } = await getRepositoryStats({
|
|
...options,
|
|
...queryKey[0],
|
|
signal,
|
|
throwOnError: true
|
|
});
|
|
return data;
|
|
},
|
|
queryKey: getRepositoryStatsQueryKey(options)
|
|
});
|
|
|
|
/**
|
|
* Refresh repository storage and compression statistics
|
|
*/
|
|
export const refreshRepositoryStatsMutation = (options?: Partial<Options<RefreshRepositoryStatsData>>): UseMutationOptions<RefreshRepositoryStatsResponse, DefaultError, Options<RefreshRepositoryStatsData>> => {
|
|
const mutationOptions: UseMutationOptions<RefreshRepositoryStatsResponse, DefaultError, Options<RefreshRepositoryStatsData>> = {
|
|
mutationFn: async (fnOptions) => {
|
|
const { data } = await refreshRepositoryStats({
|
|
...options,
|
|
...fnOptions,
|
|
throwOnError: true
|
|
});
|
|
return data;
|
|
}
|
|
};
|
|
return mutationOptions;
|
|
};
|
|
|
|
/**
|
|
* Delete multiple snapshots from a repository
|
|
*/
|
|
export const deleteSnapshotsMutation = (options?: Partial<Options<DeleteSnapshotsData>>): UseMutationOptions<DeleteSnapshotsResponse, DefaultError, Options<DeleteSnapshotsData>> => {
|
|
const mutationOptions: UseMutationOptions<DeleteSnapshotsResponse, DefaultError, Options<DeleteSnapshotsData>> = {
|
|
mutationFn: async (fnOptions) => {
|
|
const { data } = await deleteSnapshots({
|
|
...options,
|
|
...fnOptions,
|
|
throwOnError: true
|
|
});
|
|
return data;
|
|
}
|
|
};
|
|
return mutationOptions;
|
|
};
|
|
|
|
export const listSnapshotsQueryKey = (options: Options<ListSnapshotsData>) => createQueryKey('listSnapshots', options);
|
|
|
|
/**
|
|
* List all snapshots in a repository
|
|
*/
|
|
export const listSnapshotsOptions = (options: Options<ListSnapshotsData>) => queryOptions<ListSnapshotsResponse, DefaultError, ListSnapshotsResponse, ReturnType<typeof listSnapshotsQueryKey>>({
|
|
queryFn: async ({ queryKey, signal }) => {
|
|
const { data } = await listSnapshots({
|
|
...options,
|
|
...queryKey[0],
|
|
signal,
|
|
throwOnError: true
|
|
});
|
|
return data;
|
|
},
|
|
queryKey: listSnapshotsQueryKey(options)
|
|
});
|
|
|
|
/**
|
|
* Clear snapshot cache and force refresh from repository
|
|
*/
|
|
export const refreshSnapshotsMutation = (options?: Partial<Options<RefreshSnapshotsData>>): UseMutationOptions<RefreshSnapshotsResponse, DefaultError, Options<RefreshSnapshotsData>> => {
|
|
const mutationOptions: UseMutationOptions<RefreshSnapshotsResponse, DefaultError, Options<RefreshSnapshotsData>> = {
|
|
mutationFn: async (fnOptions) => {
|
|
const { data } = await refreshSnapshots({
|
|
...options,
|
|
...fnOptions,
|
|
throwOnError: true
|
|
});
|
|
return data;
|
|
}
|
|
};
|
|
return mutationOptions;
|
|
};
|
|
|
|
/**
|
|
* Delete a specific snapshot from a repository
|
|
*/
|
|
export const deleteSnapshotMutation = (options?: Partial<Options<DeleteSnapshotData>>): UseMutationOptions<DeleteSnapshotResponse, DefaultError, Options<DeleteSnapshotData>> => {
|
|
const mutationOptions: UseMutationOptions<DeleteSnapshotResponse, DefaultError, Options<DeleteSnapshotData>> = {
|
|
mutationFn: async (fnOptions) => {
|
|
const { data } = await deleteSnapshot({
|
|
...options,
|
|
...fnOptions,
|
|
throwOnError: true
|
|
});
|
|
return data;
|
|
}
|
|
};
|
|
return mutationOptions;
|
|
};
|
|
|
|
export const getSnapshotDetailsQueryKey = (options: Options<GetSnapshotDetailsData>) => createQueryKey('getSnapshotDetails', options);
|
|
|
|
/**
|
|
* Get details of a specific snapshot
|
|
*/
|
|
export const getSnapshotDetailsOptions = (options: Options<GetSnapshotDetailsData>) => queryOptions<GetSnapshotDetailsResponse, DefaultError, GetSnapshotDetailsResponse, ReturnType<typeof getSnapshotDetailsQueryKey>>({
|
|
queryFn: async ({ queryKey, signal }) => {
|
|
const { data } = await getSnapshotDetails({
|
|
...options,
|
|
...queryKey[0],
|
|
signal,
|
|
throwOnError: true
|
|
});
|
|
return data;
|
|
},
|
|
queryKey: getSnapshotDetailsQueryKey(options)
|
|
});
|
|
|
|
export const listSnapshotFilesQueryKey = (options: Options<ListSnapshotFilesData>) => createQueryKey('listSnapshotFiles', options);
|
|
|
|
/**
|
|
* List files and directories in a snapshot
|
|
*/
|
|
export const listSnapshotFilesOptions = (options: Options<ListSnapshotFilesData>) => queryOptions<ListSnapshotFilesResponse, DefaultError, ListSnapshotFilesResponse, ReturnType<typeof listSnapshotFilesQueryKey>>({
|
|
queryFn: async ({ queryKey, signal }) => {
|
|
const { data } = await listSnapshotFiles({
|
|
...options,
|
|
...queryKey[0],
|
|
signal,
|
|
throwOnError: true
|
|
});
|
|
return data;
|
|
},
|
|
queryKey: listSnapshotFilesQueryKey(options)
|
|
});
|
|
|
|
export const listSnapshotFilesInfiniteQueryKey = (options: Options<ListSnapshotFilesData>): QueryKey<Options<ListSnapshotFilesData>> => createQueryKey('listSnapshotFiles', options, true);
|
|
|
|
/**
|
|
* List files and directories in a snapshot
|
|
*/
|
|
export const listSnapshotFilesInfiniteOptions = (options: Options<ListSnapshotFilesData>) => infiniteQueryOptions<ListSnapshotFilesResponse, DefaultError, InfiniteData<ListSnapshotFilesResponse>, QueryKey<Options<ListSnapshotFilesData>>, number | Pick<QueryKey<Options<ListSnapshotFilesData>>[0], 'body' | 'headers' | 'path' | 'query'>>(
|
|
// @ts-ignore
|
|
{
|
|
queryFn: async ({ pageParam, queryKey, signal }) => {
|
|
// @ts-ignore
|
|
const page: Pick<QueryKey<Options<ListSnapshotFilesData>>[0], 'body' | 'headers' | 'path' | 'query'> = typeof pageParam === 'object' ? pageParam : {
|
|
query: {
|
|
offset: pageParam
|
|
}
|
|
};
|
|
const params = createInfiniteParams(queryKey, page);
|
|
const { data } = await listSnapshotFiles({
|
|
...options,
|
|
...params,
|
|
signal,
|
|
throwOnError: true
|
|
});
|
|
return data;
|
|
},
|
|
queryKey: listSnapshotFilesInfiniteQueryKey(options)
|
|
});
|
|
|
|
export const dumpSnapshotQueryKey = (options: Options<DumpSnapshotData>) => createQueryKey('dumpSnapshot', options);
|
|
|
|
/**
|
|
* Download a snapshot path as a tar archive (folders) or raw file stream (single files)
|
|
*/
|
|
export const dumpSnapshotOptions = (options: Options<DumpSnapshotData>) => queryOptions<DumpSnapshotResponse, DefaultError, DumpSnapshotResponse, ReturnType<typeof dumpSnapshotQueryKey>>({
|
|
queryFn: async ({ queryKey, signal }) => {
|
|
const { data } = await dumpSnapshot({
|
|
...options,
|
|
...queryKey[0],
|
|
signal,
|
|
throwOnError: true
|
|
});
|
|
return data;
|
|
},
|
|
queryKey: dumpSnapshotQueryKey(options)
|
|
});
|
|
|
|
/**
|
|
* Restore a snapshot to a target path on the filesystem
|
|
*/
|
|
export const restoreSnapshotMutation = (options?: Partial<Options<RestoreSnapshotData>>): UseMutationOptions<RestoreSnapshotResponse, DefaultError, Options<RestoreSnapshotData>> => {
|
|
const mutationOptions: UseMutationOptions<RestoreSnapshotResponse, DefaultError, Options<RestoreSnapshotData>> = {
|
|
mutationFn: async (fnOptions) => {
|
|
const { data } = await restoreSnapshot({
|
|
...options,
|
|
...fnOptions,
|
|
throwOnError: true
|
|
});
|
|
return data;
|
|
}
|
|
};
|
|
return mutationOptions;
|
|
};
|
|
|
|
/**
|
|
* Cancel a running doctor operation on a repository
|
|
*/
|
|
export const cancelDoctorMutation = (options?: Partial<Options<CancelDoctorData>>): UseMutationOptions<CancelDoctorResponse, DefaultError, Options<CancelDoctorData>> => {
|
|
const mutationOptions: UseMutationOptions<CancelDoctorResponse, DefaultError, Options<CancelDoctorData>> = {
|
|
mutationFn: async (fnOptions) => {
|
|
const { data } = await cancelDoctor({
|
|
...options,
|
|
...fnOptions,
|
|
throwOnError: true
|
|
});
|
|
return data;
|
|
}
|
|
};
|
|
return mutationOptions;
|
|
};
|
|
|
|
/**
|
|
* Start an asynchronous doctor operation on a repository to fix common issues (unlock, check, repair index). The operation runs in the background and sends results via SSE events.
|
|
*/
|
|
export const startDoctorMutation = (options?: Partial<Options<StartDoctorData>>): UseMutationOptions<StartDoctorResponse, DefaultError, Options<StartDoctorData>> => {
|
|
const mutationOptions: UseMutationOptions<StartDoctorResponse, DefaultError, Options<StartDoctorData>> = {
|
|
mutationFn: async (fnOptions) => {
|
|
const { data } = await startDoctor({
|
|
...options,
|
|
...fnOptions,
|
|
throwOnError: true
|
|
});
|
|
return data;
|
|
}
|
|
};
|
|
return mutationOptions;
|
|
};
|
|
|
|
/**
|
|
* Unlock a repository by removing all stale locks
|
|
*/
|
|
export const unlockRepositoryMutation = (options?: Partial<Options<UnlockRepositoryData>>): UseMutationOptions<UnlockRepositoryResponse, DefaultError, Options<UnlockRepositoryData>> => {
|
|
const mutationOptions: UseMutationOptions<UnlockRepositoryResponse, DefaultError, Options<UnlockRepositoryData>> = {
|
|
mutationFn: async (fnOptions) => {
|
|
const { data } = await unlockRepository({
|
|
...options,
|
|
...fnOptions,
|
|
throwOnError: true
|
|
});
|
|
return data;
|
|
}
|
|
};
|
|
return mutationOptions;
|
|
};
|
|
|
|
/**
|
|
* Tag multiple snapshots in a repository
|
|
*/
|
|
export const tagSnapshotsMutation = (options?: Partial<Options<TagSnapshotsData>>): UseMutationOptions<TagSnapshotsResponse, DefaultError, Options<TagSnapshotsData>> => {
|
|
const mutationOptions: UseMutationOptions<TagSnapshotsResponse, DefaultError, Options<TagSnapshotsData>> = {
|
|
mutationFn: async (fnOptions) => {
|
|
const { data } = await tagSnapshots({
|
|
...options,
|
|
...fnOptions,
|
|
throwOnError: true
|
|
});
|
|
return data;
|
|
}
|
|
};
|
|
return mutationOptions;
|
|
};
|
|
|
|
export const listBackupSchedulesQueryKey = (options?: Options<ListBackupSchedulesData>) => createQueryKey('listBackupSchedules', options);
|
|
|
|
/**
|
|
* List all backup schedules
|
|
*/
|
|
export const listBackupSchedulesOptions = (options?: Options<ListBackupSchedulesData>) => queryOptions<ListBackupSchedulesResponse, DefaultError, ListBackupSchedulesResponse, ReturnType<typeof listBackupSchedulesQueryKey>>({
|
|
queryFn: async ({ queryKey, signal }) => {
|
|
const { data } = await listBackupSchedules({
|
|
...options,
|
|
...queryKey[0],
|
|
signal,
|
|
throwOnError: true
|
|
});
|
|
return data;
|
|
},
|
|
queryKey: listBackupSchedulesQueryKey(options)
|
|
});
|
|
|
|
/**
|
|
* Create a new backup schedule for a volume
|
|
*/
|
|
export const createBackupScheduleMutation = (options?: Partial<Options<CreateBackupScheduleData>>): UseMutationOptions<CreateBackupScheduleResponse, DefaultError, Options<CreateBackupScheduleData>> => {
|
|
const mutationOptions: UseMutationOptions<CreateBackupScheduleResponse, DefaultError, Options<CreateBackupScheduleData>> = {
|
|
mutationFn: async (fnOptions) => {
|
|
const { data } = await createBackupSchedule({
|
|
...options,
|
|
...fnOptions,
|
|
throwOnError: true
|
|
});
|
|
return data;
|
|
}
|
|
};
|
|
return mutationOptions;
|
|
};
|
|
|
|
/**
|
|
* Delete a backup schedule
|
|
*/
|
|
export const deleteBackupScheduleMutation = (options?: Partial<Options<DeleteBackupScheduleData>>): UseMutationOptions<DeleteBackupScheduleResponse, DefaultError, Options<DeleteBackupScheduleData>> => {
|
|
const mutationOptions: UseMutationOptions<DeleteBackupScheduleResponse, DefaultError, Options<DeleteBackupScheduleData>> = {
|
|
mutationFn: async (fnOptions) => {
|
|
const { data } = await deleteBackupSchedule({
|
|
...options,
|
|
...fnOptions,
|
|
throwOnError: true
|
|
});
|
|
return data;
|
|
}
|
|
};
|
|
return mutationOptions;
|
|
};
|
|
|
|
export const getBackupScheduleQueryKey = (options: Options<GetBackupScheduleData>) => createQueryKey('getBackupSchedule', options);
|
|
|
|
/**
|
|
* Get a backup schedule by ID
|
|
*/
|
|
export const getBackupScheduleOptions = (options: Options<GetBackupScheduleData>) => queryOptions<GetBackupScheduleResponse, DefaultError, GetBackupScheduleResponse, ReturnType<typeof getBackupScheduleQueryKey>>({
|
|
queryFn: async ({ queryKey, signal }) => {
|
|
const { data } = await getBackupSchedule({
|
|
...options,
|
|
...queryKey[0],
|
|
signal,
|
|
throwOnError: true
|
|
});
|
|
return data;
|
|
},
|
|
queryKey: getBackupScheduleQueryKey(options)
|
|
});
|
|
|
|
/**
|
|
* Update a backup schedule
|
|
*/
|
|
export const updateBackupScheduleMutation = (options?: Partial<Options<UpdateBackupScheduleData>>): UseMutationOptions<UpdateBackupScheduleResponse, DefaultError, Options<UpdateBackupScheduleData>> => {
|
|
const mutationOptions: UseMutationOptions<UpdateBackupScheduleResponse, DefaultError, Options<UpdateBackupScheduleData>> = {
|
|
mutationFn: async (fnOptions) => {
|
|
const { data } = await updateBackupSchedule({
|
|
...options,
|
|
...fnOptions,
|
|
throwOnError: true
|
|
});
|
|
return data;
|
|
}
|
|
};
|
|
return mutationOptions;
|
|
};
|
|
|
|
export const getBackupScheduleForVolumeQueryKey = (options: Options<GetBackupScheduleForVolumeData>) => createQueryKey('getBackupScheduleForVolume', options);
|
|
|
|
/**
|
|
* Get a backup schedule for a specific volume
|
|
*/
|
|
export const getBackupScheduleForVolumeOptions = (options: Options<GetBackupScheduleForVolumeData>) => queryOptions<GetBackupScheduleForVolumeResponse, DefaultError, GetBackupScheduleForVolumeResponse, ReturnType<typeof getBackupScheduleForVolumeQueryKey>>({
|
|
queryFn: async ({ queryKey, signal }) => {
|
|
const { data } = await getBackupScheduleForVolume({
|
|
...options,
|
|
...queryKey[0],
|
|
signal,
|
|
throwOnError: true
|
|
});
|
|
return data;
|
|
},
|
|
queryKey: getBackupScheduleForVolumeQueryKey(options)
|
|
});
|
|
|
|
/**
|
|
* Trigger a backup immediately for a schedule
|
|
*/
|
|
export const runBackupNowMutation = (options?: Partial<Options<RunBackupNowData>>): UseMutationOptions<RunBackupNowResponse, DefaultError, Options<RunBackupNowData>> => {
|
|
const mutationOptions: UseMutationOptions<RunBackupNowResponse, DefaultError, Options<RunBackupNowData>> = {
|
|
mutationFn: async (fnOptions) => {
|
|
const { data } = await runBackupNow({
|
|
...options,
|
|
...fnOptions,
|
|
throwOnError: true
|
|
});
|
|
return data;
|
|
}
|
|
};
|
|
return mutationOptions;
|
|
};
|
|
|
|
/**
|
|
* Stop a backup that is currently in progress
|
|
*/
|
|
export const stopBackupMutation = (options?: Partial<Options<StopBackupData>>): UseMutationOptions<StopBackupResponse, DefaultError, Options<StopBackupData>> => {
|
|
const mutationOptions: UseMutationOptions<StopBackupResponse, DefaultError, Options<StopBackupData>> = {
|
|
mutationFn: async (fnOptions) => {
|
|
const { data } = await stopBackup({
|
|
...options,
|
|
...fnOptions,
|
|
throwOnError: true
|
|
});
|
|
return data;
|
|
}
|
|
};
|
|
return mutationOptions;
|
|
};
|
|
|
|
/**
|
|
* Manually apply retention policy to clean up old snapshots
|
|
*/
|
|
export const runForgetMutation = (options?: Partial<Options<RunForgetData>>): UseMutationOptions<RunForgetResponse, DefaultError, Options<RunForgetData>> => {
|
|
const mutationOptions: UseMutationOptions<RunForgetResponse, DefaultError, Options<RunForgetData>> = {
|
|
mutationFn: async (fnOptions) => {
|
|
const { data } = await runForget({
|
|
...options,
|
|
...fnOptions,
|
|
throwOnError: true
|
|
});
|
|
return data;
|
|
}
|
|
};
|
|
return mutationOptions;
|
|
};
|
|
|
|
export const getScheduleNotificationsQueryKey = (options: Options<GetScheduleNotificationsData>) => createQueryKey('getScheduleNotifications', options);
|
|
|
|
/**
|
|
* Get notification assignments for a backup schedule
|
|
*/
|
|
export const getScheduleNotificationsOptions = (options: Options<GetScheduleNotificationsData>) => queryOptions<GetScheduleNotificationsResponse, DefaultError, GetScheduleNotificationsResponse, ReturnType<typeof getScheduleNotificationsQueryKey>>({
|
|
queryFn: async ({ queryKey, signal }) => {
|
|
const { data } = await getScheduleNotifications({
|
|
...options,
|
|
...queryKey[0],
|
|
signal,
|
|
throwOnError: true
|
|
});
|
|
return data;
|
|
},
|
|
queryKey: getScheduleNotificationsQueryKey(options)
|
|
});
|
|
|
|
/**
|
|
* Update notification assignments for a backup schedule
|
|
*/
|
|
export const updateScheduleNotificationsMutation = (options?: Partial<Options<UpdateScheduleNotificationsData>>): UseMutationOptions<UpdateScheduleNotificationsResponse, DefaultError, Options<UpdateScheduleNotificationsData>> => {
|
|
const mutationOptions: UseMutationOptions<UpdateScheduleNotificationsResponse, DefaultError, Options<UpdateScheduleNotificationsData>> = {
|
|
mutationFn: async (fnOptions) => {
|
|
const { data } = await updateScheduleNotifications({
|
|
...options,
|
|
...fnOptions,
|
|
throwOnError: true
|
|
});
|
|
return data;
|
|
}
|
|
};
|
|
return mutationOptions;
|
|
};
|
|
|
|
export const getScheduleMirrorsQueryKey = (options: Options<GetScheduleMirrorsData>) => createQueryKey('getScheduleMirrors', options);
|
|
|
|
/**
|
|
* Get mirror repository assignments for a backup schedule
|
|
*/
|
|
export const getScheduleMirrorsOptions = (options: Options<GetScheduleMirrorsData>) => queryOptions<GetScheduleMirrorsResponse, DefaultError, GetScheduleMirrorsResponse, ReturnType<typeof getScheduleMirrorsQueryKey>>({
|
|
queryFn: async ({ queryKey, signal }) => {
|
|
const { data } = await getScheduleMirrors({
|
|
...options,
|
|
...queryKey[0],
|
|
signal,
|
|
throwOnError: true
|
|
});
|
|
return data;
|
|
},
|
|
queryKey: getScheduleMirrorsQueryKey(options)
|
|
});
|
|
|
|
/**
|
|
* Update mirror repository assignments for a backup schedule
|
|
*/
|
|
export const updateScheduleMirrorsMutation = (options?: Partial<Options<UpdateScheduleMirrorsData>>): UseMutationOptions<UpdateScheduleMirrorsResponse, DefaultError, Options<UpdateScheduleMirrorsData>> => {
|
|
const mutationOptions: UseMutationOptions<UpdateScheduleMirrorsResponse, DefaultError, Options<UpdateScheduleMirrorsData>> = {
|
|
mutationFn: async (fnOptions) => {
|
|
const { data } = await updateScheduleMirrors({
|
|
...options,
|
|
...fnOptions,
|
|
throwOnError: true
|
|
});
|
|
return data;
|
|
}
|
|
};
|
|
return mutationOptions;
|
|
};
|
|
|
|
export const getMirrorSyncStatusQueryKey = (options: Options<GetMirrorSyncStatusData>) => createQueryKey('getMirrorSyncStatus', options);
|
|
|
|
/**
|
|
* Get sync status for a specific mirror, including missing snapshots
|
|
*/
|
|
export const getMirrorSyncStatusOptions = (options: Options<GetMirrorSyncStatusData>) => queryOptions<GetMirrorSyncStatusResponse, DefaultError, GetMirrorSyncStatusResponse, ReturnType<typeof getMirrorSyncStatusQueryKey>>({
|
|
queryFn: async ({ queryKey, signal }) => {
|
|
const { data } = await getMirrorSyncStatus({
|
|
...options,
|
|
...queryKey[0],
|
|
signal,
|
|
throwOnError: true
|
|
});
|
|
return data;
|
|
},
|
|
queryKey: getMirrorSyncStatusQueryKey(options)
|
|
});
|
|
|
|
/**
|
|
* Sync selected snapshots to a specific mirror repository
|
|
*/
|
|
export const syncMirrorMutation = (options?: Partial<Options<SyncMirrorData>>): UseMutationOptions<SyncMirrorResponse, DefaultError, Options<SyncMirrorData>> => {
|
|
const mutationOptions: UseMutationOptions<SyncMirrorResponse, DefaultError, Options<SyncMirrorData>> = {
|
|
mutationFn: async (fnOptions) => {
|
|
const { data } = await syncMirror({
|
|
...options,
|
|
...fnOptions,
|
|
throwOnError: true
|
|
});
|
|
return data;
|
|
}
|
|
};
|
|
return mutationOptions;
|
|
};
|
|
|
|
export const getMirrorCompatibilityQueryKey = (options: Options<GetMirrorCompatibilityData>) => createQueryKey('getMirrorCompatibility', options);
|
|
|
|
/**
|
|
* Get mirror compatibility info for all repositories relative to a backup schedule's primary repository
|
|
*/
|
|
export const getMirrorCompatibilityOptions = (options: Options<GetMirrorCompatibilityData>) => queryOptions<GetMirrorCompatibilityResponse, DefaultError, GetMirrorCompatibilityResponse, ReturnType<typeof getMirrorCompatibilityQueryKey>>({
|
|
queryFn: async ({ queryKey, signal }) => {
|
|
const { data } = await getMirrorCompatibility({
|
|
...options,
|
|
...queryKey[0],
|
|
signal,
|
|
throwOnError: true
|
|
});
|
|
return data;
|
|
},
|
|
queryKey: getMirrorCompatibilityQueryKey(options)
|
|
});
|
|
|
|
/**
|
|
* Reorder backup schedules by providing an array of schedule short IDs in the desired order
|
|
*/
|
|
export const reorderBackupSchedulesMutation = (options?: Partial<Options<ReorderBackupSchedulesData>>): UseMutationOptions<ReorderBackupSchedulesResponse, DefaultError, Options<ReorderBackupSchedulesData>> => {
|
|
const mutationOptions: UseMutationOptions<ReorderBackupSchedulesResponse, DefaultError, Options<ReorderBackupSchedulesData>> = {
|
|
mutationFn: async (fnOptions) => {
|
|
const { data } = await reorderBackupSchedules({
|
|
...options,
|
|
...fnOptions,
|
|
throwOnError: true
|
|
});
|
|
return data;
|
|
}
|
|
};
|
|
return mutationOptions;
|
|
};
|
|
|
|
export const getBackupProgressQueryKey = (options: Options<GetBackupProgressData>) => createQueryKey('getBackupProgress', options);
|
|
|
|
/**
|
|
* Get the last known progress for a currently running backup. Returns null if no progress has been reported yet.
|
|
*/
|
|
export const getBackupProgressOptions = (options: Options<GetBackupProgressData>) => queryOptions<GetBackupProgressResponse, DefaultError, GetBackupProgressResponse, ReturnType<typeof getBackupProgressQueryKey>>({
|
|
queryFn: async ({ queryKey, signal }) => {
|
|
const { data } = await getBackupProgress({
|
|
...options,
|
|
...queryKey[0],
|
|
signal,
|
|
throwOnError: true
|
|
});
|
|
return data;
|
|
},
|
|
queryKey: getBackupProgressQueryKey(options)
|
|
});
|
|
|
|
export const listNotificationDestinationsQueryKey = (options?: Options<ListNotificationDestinationsData>) => createQueryKey('listNotificationDestinations', options);
|
|
|
|
/**
|
|
* List all notification destinations
|
|
*/
|
|
export const listNotificationDestinationsOptions = (options?: Options<ListNotificationDestinationsData>) => queryOptions<ListNotificationDestinationsResponse, DefaultError, ListNotificationDestinationsResponse, ReturnType<typeof listNotificationDestinationsQueryKey>>({
|
|
queryFn: async ({ queryKey, signal }) => {
|
|
const { data } = await listNotificationDestinations({
|
|
...options,
|
|
...queryKey[0],
|
|
signal,
|
|
throwOnError: true
|
|
});
|
|
return data;
|
|
},
|
|
queryKey: listNotificationDestinationsQueryKey(options)
|
|
});
|
|
|
|
/**
|
|
* Create a new notification destination
|
|
*/
|
|
export const createNotificationDestinationMutation = (options?: Partial<Options<CreateNotificationDestinationData>>): UseMutationOptions<CreateNotificationDestinationResponse, DefaultError, Options<CreateNotificationDestinationData>> => {
|
|
const mutationOptions: UseMutationOptions<CreateNotificationDestinationResponse, DefaultError, Options<CreateNotificationDestinationData>> = {
|
|
mutationFn: async (fnOptions) => {
|
|
const { data } = await createNotificationDestination({
|
|
...options,
|
|
...fnOptions,
|
|
throwOnError: true
|
|
});
|
|
return data;
|
|
}
|
|
};
|
|
return mutationOptions;
|
|
};
|
|
|
|
/**
|
|
* Delete a notification destination
|
|
*/
|
|
export const deleteNotificationDestinationMutation = (options?: Partial<Options<DeleteNotificationDestinationData>>): UseMutationOptions<DeleteNotificationDestinationResponse, DefaultError, Options<DeleteNotificationDestinationData>> => {
|
|
const mutationOptions: UseMutationOptions<DeleteNotificationDestinationResponse, DefaultError, Options<DeleteNotificationDestinationData>> = {
|
|
mutationFn: async (fnOptions) => {
|
|
const { data } = await deleteNotificationDestination({
|
|
...options,
|
|
...fnOptions,
|
|
throwOnError: true
|
|
});
|
|
return data;
|
|
}
|
|
};
|
|
return mutationOptions;
|
|
};
|
|
|
|
export const getNotificationDestinationQueryKey = (options: Options<GetNotificationDestinationData>) => createQueryKey('getNotificationDestination', options);
|
|
|
|
/**
|
|
* Get a notification destination by ID
|
|
*/
|
|
export const getNotificationDestinationOptions = (options: Options<GetNotificationDestinationData>) => queryOptions<GetNotificationDestinationResponse, DefaultError, GetNotificationDestinationResponse, ReturnType<typeof getNotificationDestinationQueryKey>>({
|
|
queryFn: async ({ queryKey, signal }) => {
|
|
const { data } = await getNotificationDestination({
|
|
...options,
|
|
...queryKey[0],
|
|
signal,
|
|
throwOnError: true
|
|
});
|
|
return data;
|
|
},
|
|
queryKey: getNotificationDestinationQueryKey(options)
|
|
});
|
|
|
|
/**
|
|
* Update a notification destination
|
|
*/
|
|
export const updateNotificationDestinationMutation = (options?: Partial<Options<UpdateNotificationDestinationData>>): UseMutationOptions<UpdateNotificationDestinationResponse, DefaultError, Options<UpdateNotificationDestinationData>> => {
|
|
const mutationOptions: UseMutationOptions<UpdateNotificationDestinationResponse, DefaultError, Options<UpdateNotificationDestinationData>> = {
|
|
mutationFn: async (fnOptions) => {
|
|
const { data } = await updateNotificationDestination({
|
|
...options,
|
|
...fnOptions,
|
|
throwOnError: true
|
|
});
|
|
return data;
|
|
}
|
|
};
|
|
return mutationOptions;
|
|
};
|
|
|
|
/**
|
|
* Test a notification destination by sending a test message
|
|
*/
|
|
export const testNotificationDestinationMutation = (options?: Partial<Options<TestNotificationDestinationData>>): UseMutationOptions<TestNotificationDestinationResponse, DefaultError, Options<TestNotificationDestinationData>> => {
|
|
const mutationOptions: UseMutationOptions<TestNotificationDestinationResponse, DefaultError, Options<TestNotificationDestinationData>> = {
|
|
mutationFn: async (fnOptions) => {
|
|
const { data } = await testNotificationDestination({
|
|
...options,
|
|
...fnOptions,
|
|
throwOnError: true
|
|
});
|
|
return data;
|
|
}
|
|
};
|
|
return mutationOptions;
|
|
};
|
|
|
|
export const getSystemInfoQueryKey = (options?: Options<GetSystemInfoData>) => createQueryKey('getSystemInfo', options);
|
|
|
|
/**
|
|
* Get system information including available capabilities
|
|
*/
|
|
export const getSystemInfoOptions = (options?: Options<GetSystemInfoData>) => queryOptions<GetSystemInfoResponse, DefaultError, GetSystemInfoResponse, ReturnType<typeof getSystemInfoQueryKey>>({
|
|
queryFn: async ({ queryKey, signal }) => {
|
|
const { data } = await getSystemInfo({
|
|
...options,
|
|
...queryKey[0],
|
|
signal,
|
|
throwOnError: true
|
|
});
|
|
return data;
|
|
},
|
|
queryKey: getSystemInfoQueryKey(options)
|
|
});
|
|
|
|
export const getUpdatesQueryKey = (options?: Options<GetUpdatesData>) => createQueryKey('getUpdates', options);
|
|
|
|
/**
|
|
* Check for application updates from GitHub
|
|
*/
|
|
export const getUpdatesOptions = (options?: Options<GetUpdatesData>) => queryOptions<GetUpdatesResponse, DefaultError, GetUpdatesResponse, ReturnType<typeof getUpdatesQueryKey>>({
|
|
queryFn: async ({ queryKey, signal }) => {
|
|
const { data } = await getUpdates({
|
|
...options,
|
|
...queryKey[0],
|
|
signal,
|
|
throwOnError: true
|
|
});
|
|
return data;
|
|
},
|
|
queryKey: getUpdatesQueryKey(options)
|
|
});
|
|
|
|
export const getRegistrationStatusQueryKey = (options?: Options<GetRegistrationStatusData>) => createQueryKey('getRegistrationStatus', options);
|
|
|
|
/**
|
|
* Get the current registration status for new users
|
|
*/
|
|
export const getRegistrationStatusOptions = (options?: Options<GetRegistrationStatusData>) => queryOptions<GetRegistrationStatusResponse, DefaultError, GetRegistrationStatusResponse, ReturnType<typeof getRegistrationStatusQueryKey>>({
|
|
queryFn: async ({ queryKey, signal }) => {
|
|
const { data } = await getRegistrationStatus({
|
|
...options,
|
|
...queryKey[0],
|
|
signal,
|
|
throwOnError: true
|
|
});
|
|
return data;
|
|
},
|
|
queryKey: getRegistrationStatusQueryKey(options)
|
|
});
|
|
|
|
/**
|
|
* Update the registration status for new users. Requires global admin role.
|
|
*/
|
|
export const setRegistrationStatusMutation = (options?: Partial<Options<SetRegistrationStatusData>>): UseMutationOptions<SetRegistrationStatusResponse, DefaultError, Options<SetRegistrationStatusData>> => {
|
|
const mutationOptions: UseMutationOptions<SetRegistrationStatusResponse, DefaultError, Options<SetRegistrationStatusData>> = {
|
|
mutationFn: async (fnOptions) => {
|
|
const { data } = await setRegistrationStatus({
|
|
...options,
|
|
...fnOptions,
|
|
throwOnError: true
|
|
});
|
|
return data;
|
|
}
|
|
};
|
|
return mutationOptions;
|
|
};
|
|
|
|
/**
|
|
* Download the organization's Restic password for backup recovery. Requires organization owner or admin role and password re-authentication.
|
|
*/
|
|
export const downloadResticPasswordMutation = (options?: Partial<Options<DownloadResticPasswordData>>): UseMutationOptions<DownloadResticPasswordResponse, DefaultError, Options<DownloadResticPasswordData>> => {
|
|
const mutationOptions: UseMutationOptions<DownloadResticPasswordResponse, DefaultError, Options<DownloadResticPasswordData>> = {
|
|
mutationFn: async (fnOptions) => {
|
|
const { data } = await downloadResticPassword({
|
|
...options,
|
|
...fnOptions,
|
|
throwOnError: true
|
|
});
|
|
return data;
|
|
}
|
|
};
|
|
return mutationOptions;
|
|
};
|
|
|
|
export const getDevPanelQueryKey = (options?: Options<GetDevPanelData>) => createQueryKey('getDevPanel', options);
|
|
|
|
/**
|
|
* Get the dev panel status
|
|
*/
|
|
export const getDevPanelOptions = (options?: Options<GetDevPanelData>) => queryOptions<GetDevPanelResponse, DefaultError, GetDevPanelResponse, ReturnType<typeof getDevPanelQueryKey>>({
|
|
queryFn: async ({ queryKey, signal }) => {
|
|
const { data } = await getDevPanel({
|
|
...options,
|
|
...queryKey[0],
|
|
signal,
|
|
throwOnError: true
|
|
});
|
|
return data;
|
|
},
|
|
queryKey: getDevPanelQueryKey(options)
|
|
});
|