@trieb.work/payload-plugin-backup-mongodb 0.1.1

package/dist/components/BackupDashboard/BackupSettingsModal.client.js

@@ -0,0 +1,939 @@
+'use client';
+import { jsx as _jsx, jsxs as _jsxs, Fragment as _Fragment } from "react/jsx-runtime";
+import { Button } from '@payloadcms/ui';
+import { useRouter } from 'next/navigation';
+import { useCallback, useEffect, useId, useMemo, useRef, useState } from 'react';
+import { backupPluginPublicApiPaths } from '../../publicApiPaths';
+import { selectedFromSkipMongoNames, skipMongoNamesFromPreview } from '../../utils/backupSelection';
+import { closeNativeDialogOnBackdropPointer } from '../../utils/dialogBackdrop';
+import { CollectionBackupPreviewBody } from './CollectionBackupPreviewBody.client';
+function parseBlobTransferTaskMessage(msg) {
+    try {
+        const o = JSON.parse(msg);
+        if (typeof o.total !== 'number' || typeof o.transferred !== 'number') {
+            return null;
+        }
+        return {
+            failed: typeof o.failed === 'number' ? o.failed : 0,
+            pathname: typeof o.pathname === 'string' ? o.pathname : undefined,
+            total: o.total,
+            transferred: o.transferred
+        };
+    } catch  {
+        return null;
+    }
+}
+const TIP_SETTINGS_SUBTITLE = 'These settings apply to scheduled (cron) backups only. Manual backups use the choices in the manual backup dialog each time you create one.';
+const TIP_TRANSFER_COPY = 'When enabled, objects under backups/ are copied from the previous backup token (or from BLOB_READ_WRITE_TOKEN on first setup) into the new store. When disabled, only the new token is saved — existing backups stay in the old storage and remain reachable with the previous token.';
+const TIP_TRANSFER_DELETE = 'Destructive: when enabled, each blob is removed from the old store only after a successful copy to the new store. Leave disabled to keep a full copy in the previous storage as a safety net.';
+function settingsHelpIconClassName(multiline) {
+    return [
+        'backup-help-icon',
+        'backup-help-icon--settings-tooltip',
+        multiline ? 'backup-help-icon--multiline' : ''
+    ].filter(Boolean).join(' ');
+}
+/** Info icon + CSS tooltip; fixed positioning so scroll/clipping in the dialog body does not hide it. */ const SettingsHelpTip = ({ multiline, tip })=>{
+    const elRef = useRef(null);
+    const syncTooltipAnchor = useCallback(()=>{
+        const el = elRef.current;
+        if (!el) {
+            return;
+        }
+        const r = el.getBoundingClientRect();
+        el.style.setProperty('--backup-tip-x', `${r.left + r.width / 2}px`);
+        el.style.setProperty('--backup-tip-y', `${r.top}px`);
+    }, []);
+    return /*#__PURE__*/ _jsx("button", {
+        "aria-label": tip,
+        className: settingsHelpIconClassName(multiline),
+        "data-tip": tip,
+        onFocus: syncTooltipAnchor,
+        onMouseEnter: syncTooltipAnchor,
+        ref: elRef,
+        title: tip,
+        type: "button",
+        children: "i"
+    });
+};
+export const BackupSettingsModal = ()=>{
+    const router = useRouter();
+    const transferOptId = useId();
+    const deleteSourceOptId = useId();
+    const dialogRef = useRef(null);
+    const isPreparingOpenRef = useRef(false);
+    const [preview, setPreview] = useState(null);
+    const [phase, setPhase] = useState('idle');
+    const [errorMessage, setErrorMessage] = useState(null);
+    const [selected, setSelected] = useState({});
+    const [backupAllCollections, setBackupAllCollections] = useState(false);
+    const [includeMediaBlobs, setIncludeMediaBlobs] = useState(true);
+    const [backupsToKeep, setBackupsToKeep] = useState(10);
+    const [backupBlobReadWriteToken, setBackupBlobReadWriteToken] = useState('');
+    /**
+   * When saving a new raw token, copy backup blobs from the old store. Default on so rotating a
+   * token automatically migrates existing archives; delete-from-source stays opt-in.
+   */ const [transferBackupBlobs, setTransferBackupBlobs] = useState(true);
+    /**
+   * When copying blobs into the new store, also delete them from the old store.
+   * Default: off — the user must explicitly opt in to destructive behavior.
+   */ const [deleteBackupBlobsFromSource, setDeleteBackupBlobsFromSource] = useState(false);
+    const [, setHasExistingBackupBlobToken] = useState(false);
+    const [storedBackupBlobAccess, setStoredBackupBlobAccess] = useState(null);
+    const [effectiveBackupBlobAccess, setEffectiveBackupBlobAccess] = useState(null);
+    const [tokenCheck, setTokenCheck] = useState({
+        status: 'idle'
+    });
+    const [pluginOverridesRetention, setPluginOverridesRetention] = useState(false);
+    const [cronInfo, setCronInfo] = useState(undefined);
+    const [transferSummary, setTransferSummary] = useState(null);
+    const [activeTransfer, setActiveTransfer] = useState(null);
+    const [transferLive, setTransferLive] = useState(null);
+    const [savePhase, setSavePhase] = useState('idle');
+    const [saveError, setSaveError] = useState(null);
+    const [isPreparingOpen, setIsPreparingOpen] = useState(false);
+    const resetState = useCallback(()=>{
+        setPreview(null);
+        setPhase('idle');
+        setErrorMessage(null);
+        setSelected({});
+        setBackupAllCollections(false);
+        setIncludeMediaBlobs(false);
+        setBackupsToKeep(10);
+        setBackupBlobReadWriteToken('');
+        setTransferBackupBlobs(true);
+        setDeleteBackupBlobsFromSource(false);
+        setHasExistingBackupBlobToken(false);
+        setStoredBackupBlobAccess(null);
+        setEffectiveBackupBlobAccess(null);
+        setTokenCheck({
+            status: 'idle'
+        });
+        setPluginOverridesRetention(false);
+        setCronInfo(undefined);
+        setTransferSummary(null);
+        setActiveTransfer(null);
+        setTransferLive(null);
+        setSavePhase('idle');
+        setSaveError(null);
+        isPreparingOpenRef.current = false;
+        setIsPreparingOpen(false);
+    }, []);
+    useEffect(()=>{
+        const el = dialogRef.current;
+        if (!el) {
+            return;
+        }
+        const onClose = ()=>resetState();
+        el.addEventListener('close', onClose);
+        return ()=>el.removeEventListener('close', onClose);
+    }, [
+        resetState
+    ]);
+    const fetchSettingsAndPreview = useCallback(async ()=>{
+        const locale = typeof document !== 'undefined' ? (document.documentElement.lang || 'en').slice(0, 2) : 'en';
+        const [settingsRes, previewRes] = await Promise.all([
+            fetch(backupPluginPublicApiPaths.adminSettings, {
+                method: 'GET'
+            }),
+            fetch(backupPluginPublicApiPaths.adminBackupPreview, {
+                body: JSON.stringify({
+                    locale
+                }),
+                headers: {
+                    'Content-Type': 'application/json'
+                },
+                method: 'POST'
+            })
+        ]);
+        const settingsJson = await settingsRes.json();
+        if (!settingsRes.ok) {
+            throw new Error(settingsJson.error || 'Could not load settings');
+        }
+        const previewJson = await previewRes.json();
+        if (!previewRes.ok) {
+            throw new Error(previewJson.error || 'Could not load collections');
+        }
+        return {
+            previewJson,
+            settingsJson
+        };
+    }, []);
+    const applyLoadedSettingsPreview = useCallback((settingsJson, previewJson)=>{
+        setActiveTransfer(null);
+        setTransferLive(null);
+        setPreview(previewJson);
+        setBackupsToKeep(typeof settingsJson.backupsToKeep === 'number' ? settingsJson.backupsToKeep : 10);
+        setBackupBlobReadWriteToken(settingsJson.backupBlobTokenMasked || '');
+        setHasExistingBackupBlobToken(settingsJson.hasBackupBlobReadWriteToken === true);
+        setStoredBackupBlobAccess(settingsJson.backupBlobAccess ?? null);
+        setEffectiveBackupBlobAccess(settingsJson.backupBlobAccessEffective ?? null);
+        setTokenCheck({
+            status: 'idle'
+        });
+        setPluginOverridesRetention(settingsJson.pluginBackupsToKeepOverride === true);
+        setCronInfo(settingsJson.cron ?? null);
+        setIncludeMediaBlobs(settingsJson.includeMediaForCron === true);
+        const skip = Array.isArray(settingsJson.skipMongoCollections) ? settingsJson.skipMongoCollections : [];
+        setSelected(selectedFromSkipMongoNames(previewJson, skip));
+        setBackupAllCollections(skip.length === 0);
+        setTransferBackupBlobs(true);
+        setDeleteBackupBlobsFromSource(false);
+        setPhase('ready');
+    }, []);
+    const loadPreview = useCallback(async ()=>{
+        setPhase('loading');
+        setErrorMessage(null);
+        setPreview(null);
+        setCronInfo(undefined);
+        try {
+            const { previewJson, settingsJson } = await fetchSettingsAndPreview();
+            applyLoadedSettingsPreview(settingsJson, previewJson);
+        } catch (e) {
+            setPhase('error');
+            setErrorMessage(e instanceof Error ? e.message : 'Could not load backup settings');
+        }
+    }, [
+        applyLoadedSettingsPreview,
+        fetchSettingsAndPreview
+    ]);
+    const openDialog = useCallback(()=>{
+        if (isPreparingOpenRef.current) {
+            return;
+        }
+        isPreparingOpenRef.current = true;
+        setSavePhase('idle');
+        setSaveError(null);
+        setIsPreparingOpen(true);
+        void (async ()=>{
+            try {
+                const { previewJson, settingsJson } = await fetchSettingsAndPreview();
+                applyLoadedSettingsPreview(settingsJson, previewJson);
+                dialogRef.current?.showModal();
+            } catch (e) {
+                setPhase('error');
+                setErrorMessage(e instanceof Error ? e.message : 'Could not load backup settings');
+                setPreview(null);
+                setCronInfo(undefined);
+                dialogRef.current?.showModal();
+            } finally{
+                isPreparingOpenRef.current = false;
+                setIsPreparingOpen(false);
+            }
+        })();
+    }, [
+        applyLoadedSettingsPreview,
+        fetchSettingsAndPreview
+    ]);
+    const skipCollections = useMemo(()=>{
+        if (!preview) {
+            return [];
+        }
+        if (backupAllCollections) {
+            return [];
+        }
+        return skipMongoNamesFromPreview(preview, selected);
+    }, [
+        backupAllCollections,
+        preview,
+        selected
+    ]);
+    const mediaGroupIncluded = preview ? backupAllCollections || selected['media'] !== false : false;
+    const hasMediaBlobOption = Boolean(preview && preview.mediaBlobCandidates > 0 && mediaGroupIncluded);
+    const willSaveNewRawToken = useMemo(()=>backupBlobReadWriteToken.trim().length > 0 && !/\*{2,}/.test(backupBlobReadWriteToken), [
+        backupBlobReadWriteToken
+    ]);
+    const onChangeBackupBlobToken = useCallback((value)=>{
+        setBackupBlobReadWriteToken(value);
+        setTokenCheck({
+            status: 'idle'
+        });
+    }, []);
+    // Auto-validate a freshly pasted/typed token after a short debounce. The masked token coming
+    // from the server (contains "**") never triggers this because `willSaveNewRawToken` stays false.
+    useEffect(()=>{
+        if (!willSaveNewRawToken) {
+            setTokenCheck((prev)=>prev.status === 'idle' ? prev : {
+                    status: 'idle'
+                });
+            return;
+        }
+        const candidate = backupBlobReadWriteToken.trim();
+        if (!candidate) {
+            return;
+        }
+        let cancelled = false;
+        const timer = window.setTimeout(async ()=>{
+            if (cancelled) {
+                return;
+            }
+            setTokenCheck({
+                status: 'checking'
+            });
+            try {
+                const response = await fetch(backupPluginPublicApiPaths.adminValidateBlobToken, {
+                    body: JSON.stringify({
+                        token: candidate
+                    }),
+                    headers: {
+                        'Content-Type': 'application/json'
+                    },
+                    method: 'POST'
+                });
+                if (cancelled) {
+                    return;
+                }
+                const data = await response.json();
+                if (cancelled) {
+                    return;
+                }
+                if (response.ok && data.ok && (data.access === 'public' || data.access === 'private')) {
+                    setTokenCheck({
+                        access: data.access,
+                        status: 'valid'
+                    });
+                } else {
+                    setTokenCheck({
+                        message: data.error || 'Token rejected',
+                        status: 'invalid'
+                    });
+                }
+            } catch (error) {
+                if (cancelled) {
+                    return;
+                }
+                setTokenCheck({
+                    message: error instanceof Error ? error.message : 'Token validation failed',
+                    status: 'invalid'
+                });
+            }
+        }, 150);
+        return ()=>{
+            cancelled = true;
+            window.clearTimeout(timer);
+        };
+    }, [
+        backupBlobReadWriteToken,
+        willSaveNewRawToken
+    ]);
+    const blockSaveForTokenCheck = willSaveNewRawToken && (tokenCheck.status === 'checking' || tokenCheck.status === 'invalid');
+    const tokenStatusPill = (()=>{
+        if (willSaveNewRawToken) {
+            if (tokenCheck.status === 'checking') {
+                return /*#__PURE__*/ _jsx("span", {
+                    className: "backup-item__pill backup-item__pill--neutral",
+                    children: "Checking…"
+                });
+            }
+            if (tokenCheck.status === 'valid' && tokenCheck.access) {
+                return /*#__PURE__*/ _jsx("span", {
+                    className: `backup-item__pill backup-item__pill--${tokenCheck.access === 'private' ? 'cron' : 'manual'}`,
+                    children: tokenCheck.access === 'private' ? 'Private' : 'Public'
+                });
+            }
+            if (tokenCheck.status === 'invalid') {
+                return /*#__PURE__*/ _jsx("span", {
+                    className: "backup-item__pill backup-item__pill--danger",
+                    children: "Invalid"
+                });
+            }
+            return null;
+        }
+        if (effectiveBackupBlobAccess) {
+            return /*#__PURE__*/ _jsx("span", {
+                className: `backup-item__pill backup-item__pill--${effectiveBackupBlobAccess === 'private' ? 'cron' : 'manual'}`,
+                title: storedBackupBlobAccess ? 'Detected and persisted after last validation' : 'Heuristic fallback — will be re-validated when saving a new token',
+                children: effectiveBackupBlobAccess === 'private' ? 'Private' : 'Public'
+            });
+        }
+        return null;
+    })();
+    const includeMediaForCron = useMemo(()=>{
+        if (!hasMediaBlobOption) {
+            return false;
+        }
+        return includeMediaBlobs;
+    }, [
+        hasMediaBlobOption,
+        includeMediaBlobs
+    ]);
+    const onToggleGroup = useCallback((groupId)=>{
+        setSelected((prev)=>{
+            const isOn = prev[groupId] !== false;
+            return {
+                ...prev,
+                [groupId]: !isOn
+            };
+        });
+    }, []);
+    const onToggleBackupAllCollections = useCallback(()=>{
+        setBackupAllCollections((prev)=>{
+            const next = !prev;
+            if (next && preview) {
+                setSelected(Object.fromEntries(preview.groups.map((g)=>[
+                        g.groupId,
+                        true
+                    ])));
+            }
+            return next;
+        });
+    }, [
+        preview
+    ]);
+    const save = useCallback(async ()=>{
+        if (!preview) {
+            return;
+        }
+        setSavePhase('saving');
+        setSaveError(null);
+        setTransferSummary(null);
+        setActiveTransfer(null);
+        setTransferLive(null);
+        try {
+            const response = await fetch(backupPluginPublicApiPaths.adminSettings, {
+                body: JSON.stringify({
+                    backupBlobReadWriteToken,
+                    backupsToKeep,
+                    deleteBackupBlobsFromSource: transferBackupBlobs && deleteBackupBlobsFromSource,
+                    includeMediaForCron,
+                    skipMongoCollections: skipCollections,
+                    transferBackupBlobs
+                }),
+                headers: {
+                    'Content-Type': 'application/json'
+                },
+                method: 'PATCH'
+            });
+            const data = await response.json();
+            if (!response.ok) {
+                throw new Error(data.error || 'Save failed');
+            }
+            setHasExistingBackupBlobToken(data.hasBackupBlobReadWriteToken === true);
+            setBackupBlobReadWriteToken(data.backupBlobTokenMasked || '');
+            setStoredBackupBlobAccess(data.backupBlobAccess ?? null);
+            setEffectiveBackupBlobAccess(data.backupBlobAccessEffective ?? null);
+            setTokenCheck({
+                status: 'idle'
+            });
+            const tr = data.transfer;
+            if (tr?.performed && tr.deferred && tr.taskId && tr.pollSecret) {
+                setActiveTransfer({
+                    pollSecret: tr.pollSecret,
+                    taskId: tr.taskId,
+                    total: tr.total
+                });
+                setTransferLive({
+                    failed: 0,
+                    total: tr.total,
+                    transferred: 0
+                });
+                setSavePhase('transferring');
+                return;
+            }
+            setTransferSummary(tr ?? null);
+            setSavePhase('saved');
+            router.refresh();
+            if (!tr?.performed) {
+                window.setTimeout(()=>{
+                    setSavePhase('idle');
+                    dialogRef.current?.close();
+                }, 800);
+            } else {
+                window.setTimeout(()=>{
+                    setSavePhase('idle');
+                    dialogRef.current?.close();
+                }, 1200);
+            }
+        } catch (e) {
+            setSavePhase('error');
+            setSaveError(e instanceof Error ? e.message : 'Save failed');
+        }
+    }, [
+        preview,
+        backupsToKeep,
+        backupBlobReadWriteToken,
+        skipCollections,
+        includeMediaForCron,
+        transferBackupBlobs,
+        deleteBackupBlobsFromSource,
+        router
+    ]);
+    useEffect(()=>{
+        if (!activeTransfer) {
+            return;
+        }
+        let cancelled = false;
+        let intervalId = null;
+        let successCloseTimer = null;
+        const stopPolling = ()=>{
+            if (intervalId != null) {
+                window.clearInterval(intervalId);
+                intervalId = null;
+            }
+        };
+        const pollOnce = async ()=>{
+            const res = await fetch(backupPluginPublicApiPaths.adminTask(activeTransfer.taskId), {
+                cache: 'no-store',
+                headers: {
+                    Authorization: `Bearer ${activeTransfer.pollSecret}`
+                }
+            });
+            if (!res.ok || cancelled) {
+                return;
+            }
+            const task = await res.json();
+            const parsed = parseBlobTransferTaskMessage(task.message);
+            if (parsed) {
+                setTransferLive({
+                    failed: parsed.failed,
+                    pathname: parsed.pathname,
+                    total: parsed.total,
+                    transferred: parsed.transferred
+                });
+            }
+            if (task.status === 'completed') {
+                stopPolling();
+                const final = parseBlobTransferTaskMessage(task.message);
+                setTransferSummary({
+                    deferred: false,
+                    failed: final?.failed ?? 0,
+                    performed: true,
+                    skipped: 0,
+                    total: final?.total ?? activeTransfer.total,
+                    transferred: final?.transferred ?? 0
+                });
+                setActiveTransfer(null);
+                setTransferLive(null);
+                setSavePhase('saved');
+                try {
+                    const settingsRes = await fetch(backupPluginPublicApiPaths.adminSettings, {
+                        method: 'GET'
+                    });
+                    const refreshed = await settingsRes.json();
+                    if (settingsRes.ok) {
+                        setBackupBlobReadWriteToken(refreshed.backupBlobTokenMasked || '');
+                        setHasExistingBackupBlobToken(refreshed.hasBackupBlobReadWriteToken === true);
+                    }
+                } catch  {
+                /* ignore */ }
+                router.refresh();
+                successCloseTimer = window.setTimeout(()=>{
+                    successCloseTimer = null;
+                    setSavePhase('idle');
+                    setTransferSummary(null);
+                    dialogRef.current?.close();
+                }, 1400);
+                return;
+            }
+            if (task.status === 'failed') {
+                stopPolling();
+                setSavePhase('error');
+                setSaveError(task.error || task.message || 'Transfer failed');
+                setActiveTransfer(null);
+                setTransferLive(null);
+            }
+        };
+        intervalId = window.setInterval(()=>void pollOnce(), 900);
+        void pollOnce();
+        return ()=>{
+            cancelled = true;
+            stopPolling();
+            if (successCloseTimer != null) {
+                window.clearTimeout(successCloseTimer);
+            }
+        };
+    }, [
+        activeTransfer,
+        router
+    ]);
+    const retentionDisabled = pluginOverridesRetention;
+    return /*#__PURE__*/ _jsxs(_Fragment, {
+        children: [
+            /*#__PURE__*/ _jsx(Button, {
+                buttonStyle: "secondary",
+                disabled: isPreparingOpen,
+                onClick: openDialog,
+                size: "small",
+                children: isPreparingOpen ? 'Loading…' : 'Backup settings'
+            }),
+            /*#__PURE__*/ _jsxs("dialog", {
+                className: "backup-confirm-dialog backup-confirm-dialog--settings",
+                onMouseDown: (e)=>closeNativeDialogOnBackdropPointer(e, dialogRef),
+                ref: dialogRef,
+                children: [
+                    /*#__PURE__*/ _jsx("p", {
+                        className: "backup-confirm-dialog__title",
+                        children: "Scheduled backup settings"
+                    }),
+                    /*#__PURE__*/ _jsx("p", {
+                        className: "backup-confirm-dialog__subtitle backup-confirm-dialog__subtitle--with-help",
+                        children: /*#__PURE__*/ _jsx("span", {
+                            className: "backup-confirm-dialog__subtitle-text",
+                            children: TIP_SETTINGS_SUBTITLE
+                        })
+                    }),
+                    /*#__PURE__*/ _jsxs("div", {
+                        className: "backup-confirm-dialog__body restore-preview",
+                        children: [
+                            phase !== 'idle' ? /*#__PURE__*/ _jsxs(_Fragment, {
+                                children: [
+                                    /*#__PURE__*/ _jsx("p", {
+                                        className: "restore-preview__sticky-heading",
+                                        children: "Schedule"
+                                    }),
+                                    phase === 'loading' ? /*#__PURE__*/ _jsxs("div", {
+                                        "aria-live": "polite",
+                                        className: "restore-preview__loading-block restore-preview__loading-block--section",
+                                        children: [
+                                            /*#__PURE__*/ _jsx("p", {
+                                                className: "restore-preview__status",
+                                                children: "Loading cron configuration…"
+                                            }),
+                                            /*#__PURE__*/ _jsx("div", {
+                                                className: "restore-preview__loading-line"
+                                            }),
+                                            /*#__PURE__*/ _jsx("div", {
+                                                className: "restore-preview__loading-line restore-preview__loading-line--short"
+                                            })
+                                        ]
+                                    }) : phase === 'error' ? /*#__PURE__*/ _jsx("p", {
+                                        className: "restore-preview__intro",
+                                        children: "Schedule details could not be loaded."
+                                    }) : cronInfo ? /*#__PURE__*/ _jsxs(_Fragment, {
+                                        children: [
+                                            /*#__PURE__*/ _jsxs("p", {
+                                                className: "restore-preview__intro",
+                                                children: [
+                                                    "Active job: ",
+                                                    /*#__PURE__*/ _jsx("code", {
+                                                        children: cronInfo.configFileRelative
+                                                    }),
+                                                    " — edit and redeploy to change the schedule."
+                                                ]
+                                            }),
+                                            /*#__PURE__*/ _jsxs("div", {
+                                                "aria-label": "Configured schedule",
+                                                className: "restore-preview__settings-block",
+                                                children: [
+                                                    /*#__PURE__*/ _jsxs("p", {
+                                                        className: "restore-preview__settings-row",
+                                                        children: [
+                                                            /*#__PURE__*/ _jsx("span", {
+                                                                className: "restore-preview__settings-k",
+                                                                children: "HTTP path"
+                                                            }),
+                                                            ' ',
+                                                            /*#__PURE__*/ _jsx("code", {
+                                                                children: cronInfo.path
+                                                            })
+                                                        ]
+                                                    }),
+                                                    /*#__PURE__*/ _jsxs("p", {
+                                                        className: "restore-preview__settings-row",
+                                                        children: [
+                                                            /*#__PURE__*/ _jsx("span", {
+                                                                className: "restore-preview__settings-k",
+                                                                children: "Cron expression"
+                                                            }),
+                                                            ' ',
+                                                            /*#__PURE__*/ _jsx("code", {
+                                                                children: cronInfo.schedule
+                                                            })
+                                                        ]
+                                                    }),
+                                                    cronInfo.humanDescription ? /*#__PURE__*/ _jsx("p", {
+                                                        className: "restore-preview__settings-human",
+                                                        children: cronInfo.humanDescription
+                                                    }) : /*#__PURE__*/ _jsx("p", {
+                                                        className: "restore-preview__settings-human restore-preview__settings-human--muted",
+                                                        children: "Could not turn the cron expression into a short description."
+                                                    })
+                                                ]
+                                            })
+                                        ]
+                                    }) : /*#__PURE__*/ _jsxs(_Fragment, {
+                                        children: [
+                                            /*#__PURE__*/ _jsxs("p", {
+                                                className: "restore-preview__intro",
+                                                children: [
+                                                    "No vercel ",
+                                                    /*#__PURE__*/ _jsx("code", {
+                                                        children: "crons"
+                                                    }),
+                                                    " entry for the backup path yet. You can either setup an external service to call /api/backup-mongodb/cron/run with your cron secret or use Vercel. To use vercel create a file ",
+                                                    /*#__PURE__*/ _jsx("code", {
+                                                        children: "vercel.json"
+                                                    }),
+                                                    " in your project root with the following content:"
+                                                ]
+                                            }),
+                                            /*#__PURE__*/ _jsx("p", {
+                                                className: "restore-preview__settings-hint",
+                                                children: "Example"
+                                            }),
+                                            /*#__PURE__*/ _jsx("pre", {
+                                                className: "restore-preview__settings-snippet",
+                                                children: `{
+  "crons": [
+    {
+      "path": "/api/backup-mongodb/cron/run",
+      "schedule": "0 3 * * *"
+    }
+  ]
+}`
+                                            }),
+                                            /*#__PURE__*/ _jsxs("p", {
+                                                children: [
+                                                    "Then add a ",
+                                                    /*#__PURE__*/ _jsx("code", {
+                                                        children: "CRON_SECRET"
+                                                    }),
+                                                    " environment variable to your Vercel project and redeploy on Vercel so the cron job is registered."
+                                                ]
+                                            })
+                                        ]
+                                    })
+                                ]
+                            }) : null,
+                            /*#__PURE__*/ _jsx("p", {
+                                className: "restore-preview__sticky-heading",
+                                children: "Retention"
+                            }),
+                            /*#__PURE__*/ _jsx("p", {
+                                className: "restore-preview__intro",
+                                children: retentionDisabled ? /*#__PURE__*/ _jsxs(_Fragment, {
+                                    children: [
+                                        "Locked by ",
+                                        /*#__PURE__*/ _jsxs("code", {
+                                            children: [
+                                                "backupMongodbPlugin(",
+                                                '{ backupsToKeep }',
+                                                ")"
+                                            ]
+                                        }),
+                                        " in Payload config."
+                                    ]
+                                }) : /*#__PURE__*/ _jsx(_Fragment, {
+                                    children: "Oldest cron archives are deleted once the count exceeds this limit."
+                                })
+                            }),
+                            /*#__PURE__*/ _jsxs("div", {
+                                className: "restore-preview__settings-fields",
+                                children: [
+                                    /*#__PURE__*/ _jsx("label", {
+                                        className: "restore-preview__settings-label",
+                                        htmlFor: "backups-to-keep",
+                                        children: "Cron backups to keep"
+                                    }),
+                                    /*#__PURE__*/ _jsx("input", {
+                                        "aria-label": "Cron backups to keep",
+                                        className: "restore-preview__settings-input",
+                                        disabled: retentionDisabled,
+                                        id: "backups-to-keep",
+                                        max: 365,
+                                        min: 1,
+                                        onChange: (e)=>setBackupsToKeep(Number(e.target.value) || 1),
+                                        type: "number",
+                                        value: backupsToKeep
+                                    })
+                                ]
+                            }),
+                            /*#__PURE__*/ _jsxs("p", {
+                                className: "restore-preview__sticky-heading",
+                                children: [
+                                    "Dedicated backup storage",
+                                    ' ',
+                                    /*#__PURE__*/ _jsx("span", {
+                                        className: "restore-preview__sticky-heading-hint",
+                                        children: "(optional)"
+                                    })
+                                ]
+                            }),
+                            /*#__PURE__*/ _jsxs("p", {
+                                className: "restore-preview__intro",
+                                children: [
+                                    "Separate Vercel Blob token for ",
+                                    /*#__PURE__*/ _jsx("code", {
+                                        children: "backups/"
+                                    }),
+                                    ". Without one, archives share the default media store."
+                                ]
+                            }),
+                            /*#__PURE__*/ _jsxs("div", {
+                                className: "restore-preview__settings-fields",
+                                children: [
+                                    /*#__PURE__*/ _jsx("label", {
+                                        className: "restore-preview__settings-label",
+                                        htmlFor: "backup-blob-token",
+                                        children: "Backup Blob read/write token"
+                                    }),
+                                    /*#__PURE__*/ _jsxs("div", {
+                                        className: "restore-preview__blob-token-row",
+                                        children: [
+                                            /*#__PURE__*/ _jsx("input", {
+                                                "aria-label": "Backup Blob read/write token",
+                                                autoComplete: "off",
+                                                className: "restore-preview__settings-input restore-preview__settings-input--wide",
+                                                id: "backup-blob-token",
+                                                onChange: (e)=>onChangeBackupBlobToken(e.target.value),
+                                                placeholder: "vercel_blob_rw_...",
+                                                spellCheck: false,
+                                                type: "text",
+                                                value: backupBlobReadWriteToken
+                                            }),
+                                            /*#__PURE__*/ _jsx("span", {
+                                                className: "restore-preview__blob-token-pill-slot",
+                                                children: tokenStatusPill
+                                            })
+                                        ]
+                                    }),
+                                    tokenCheck.status === 'invalid' && tokenCheck.message ? /*#__PURE__*/ _jsx("p", {
+                                        "aria-live": "polite",
+                                        className: "restore-preview__blob-token-error",
+                                        children: tokenCheck.message
+                                    }) : null,
+                                    savePhase === 'transferring' && transferLive && transferLive.total > 0 ? /*#__PURE__*/ _jsxs("div", {
+                                        "aria-live": "polite",
+                                        className: "restore-preview__transfer-panel",
+                                        children: [
+                                            /*#__PURE__*/ _jsx("div", {
+                                                className: "restore-preview__transfer-bar-track",
+                                                children: /*#__PURE__*/ _jsx("div", {
+                                                    className: "restore-preview__transfer-bar-fill",
+                                                    style: {
+                                                        width: `${Math.min(100, (transferLive.transferred + transferLive.failed) / transferLive.total * 100)}%`
+                                                    }
+                                                })
+                                            }),
+                                            /*#__PURE__*/ _jsxs("p", {
+                                                className: "restore-preview__transfer-meta",
+                                                children: [
+                                                    "Copying backup files: ",
+                                                    transferLive.transferred + transferLive.failed,
+                                                    " /",
+                                                    ' ',
+                                                    transferLive.total,
+                                                    transferLive.failed > 0 ? ` (${transferLive.failed} failed)` : '',
+                                                    transferLive.pathname ? /*#__PURE__*/ _jsxs(_Fragment, {
+                                                        children: [
+                                                            /*#__PURE__*/ _jsx("br", {}),
+                                                            /*#__PURE__*/ _jsx("span", {
+                                                                className: "restore-preview__transfer-path",
+                                                                title: transferLive.pathname,
+                                                                children: transferLive.pathname.length > 56 ? `${transferLive.pathname.slice(0, 28)}…${transferLive.pathname.slice(-24)}` : transferLive.pathname
+                                                            })
+                                                        ]
+                                                    }) : null
+                                                ]
+                                            })
+                                        ]
+                                    }) : null,
+                                    willSaveNewRawToken ? /*#__PURE__*/ _jsxs(_Fragment, {
+                                        children: [
+                                            /*#__PURE__*/ _jsxs("div", {
+                                                className: "field-type checkbox backup-dashboard__collapsible-checkbox restore-preview__blob-transfer-row restore-preview__blob-transfer-row--with-help-tip",
+                                                children: [
+                                                    /*#__PURE__*/ _jsx("input", {
+                                                        "aria-label": "Copy existing backup files into this storage when saving",
+                                                        checked: transferBackupBlobs,
+                                                        className: "checkbox-input__input",
+                                                        id: transferOptId,
+                                                        onChange: (e)=>setTransferBackupBlobs(e.target.checked),
+                                                        type: "checkbox"
+                                                    }),
+                                                    /*#__PURE__*/ _jsx("label", {
+                                                        className: "field-label",
+                                                        htmlFor: transferOptId,
+                                                        children: "Copy existing backup files into this storage when saving"
+                                                    }),
+                                                    /*#__PURE__*/ _jsx(SettingsHelpTip, {
+                                                        multiline: true,
+                                                        tip: TIP_TRANSFER_COPY
+                                                    })
+                                                ]
+                                            }),
+                                            transferBackupBlobs ? /*#__PURE__*/ _jsxs("div", {
+                                                className: "field-type checkbox backup-dashboard__collapsible-checkbox restore-preview__blob-transfer-row restore-preview__blob-transfer-row--with-help-tip",
+                                                children: [
+                                                    /*#__PURE__*/ _jsx("input", {
+                                                        "aria-label": "Delete from previous storage after successful copy",
+                                                        checked: deleteBackupBlobsFromSource,
+                                                        className: "checkbox-input__input",
+                                                        id: deleteSourceOptId,
+                                                        onChange: (e)=>setDeleteBackupBlobsFromSource(e.target.checked),
+                                                        type: "checkbox"
+                                                    }),
+                                                    /*#__PURE__*/ _jsx("label", {
+                                                        className: "field-label",
+                                                        htmlFor: deleteSourceOptId,
+                                                        children: "Delete from previous storage after successful copy"
+                                                    }),
+                                                    /*#__PURE__*/ _jsx(SettingsHelpTip, {
+                                                        multiline: true,
+                                                        tip: TIP_TRANSFER_DELETE
+                                                    })
+                                                ]
+                                            }) : null
+                                        ]
+                                    }) : null
+                                ]
+                            }),
+                            /*#__PURE__*/ _jsx(CollectionBackupPreviewBody, {
+                                embedded: true,
+                                errorMessage: errorMessage,
+                                includeAllCollections: backupAllCollections,
+                                includeAllLabel: "Backup all collections",
+                                includeMediaBlobs: includeMediaBlobs,
+                                onRetry: loadPreview,
+                                onToggleGroup: onToggleGroup,
+                                onToggleIncludeAllCollections: onToggleBackupAllCollections,
+                                onToggleIncludeMedia: ()=>setIncludeMediaBlobs((v)=>!v),
+                                phase: phase,
+                                preview: preview,
+                                selected: selected
+                            }),
+                            saveError ? /*#__PURE__*/ _jsx("p", {
+                                className: "restore-preview__error restore-preview__error--inline",
+                                children: saveError
+                            }) : null,
+                            savePhase === 'saving' ? /*#__PURE__*/ _jsx("p", {
+                                className: "restore-preview__status restore-preview__status--footer",
+                                children: "Saving settings…"
+                            }) : null,
+                            transferSummary?.performed ? /*#__PURE__*/ _jsxs("p", {
+                                className: "restore-preview__status restore-preview__status--footer",
+                                children: [
+                                    "Migrated backups: ",
+                                    transferSummary.transferred,
+                                    "/",
+                                    transferSummary.total,
+                                    transferSummary.failed > 0 ? `, failed: ${transferSummary.failed}` : ''
+                                ]
+                            }) : null
+                        ]
+                    }),
+                    /*#__PURE__*/ _jsxs("div", {
+                        className: "backup-confirm-dialog__actions",
+                        children: [
+                            /*#__PURE__*/ _jsx(Button, {
+                                buttonStyle: "primary",
+                                disabled: phase !== 'ready' || savePhase === 'saving' || savePhase === 'transferring' || blockSaveForTokenCheck,
+                                onClick: ()=>void save(),
+                                size: "small",
+                                children: savePhase === 'transferring' ? 'Transferring…' : savePhase === 'saving' ? 'Saving…' : savePhase === 'saved' ? 'Saved' : 'Save settings'
+                            }),
+                            /*#__PURE__*/ _jsx(Button, {
+                                buttonStyle: "secondary",
+                                onClick: ()=>dialogRef.current?.close(),
+                                size: "small",
+                                children: "Cancel"
+                            })
+                        ]
+                    })
+                ]
+            })
+        ]
+    });
+};
+
+//# sourceMappingURL=BackupSettingsModal.client.js.map