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

package/dist/components/BackupDashboard/index.js

@@ -0,0 +1,196 @@
+import { jsx as _jsx, jsxs as _jsxs, Fragment as _Fragment } from "react/jsx-runtime";
+import configPromise from '@payload-config';
+import { getPayload } from 'payload';
+import { listBackups, resolveBackupListToken } from '../../core/backup';
+import { getBackupSortTimeMs, getCurrentDbName, getCurrentHostname, isUserAllowedByEnvRoles, transformBlobName } from '../../utils/index';
+import { backupDashboardInlineCss } from './backupDashboardInlineCss';
+import { BackupListCollapsible, BackupSettingsModal, ManualBackupDialog } from './index.client';
+function defaultIsHidden(user, access) {
+    if (user === null) {
+        return true;
+    }
+    if (user === undefined) {
+        if (access) {
+            return true;
+        }
+        return false;
+    }
+    if (access) {
+        return !access(user);
+    }
+    // Role allow-list via `PAYLOAD_BACKUP_ALLOWED_ROLES`. When unset, falls back to the
+    // historical default (admin role, or "visible" when the project has no roles field).
+    return !isUserAllowedByEnvRoles(user);
+}
+export const BackupDashboard = async ({ i18n, user })=>{
+    if (defaultIsHidden(user)) {
+        return null;
+    }
+    const hasMongoConnection = Boolean(process.env.MONGODB_URI?.trim()) || Boolean(process.env.DATABASE_URL?.trim());
+    if (!hasMongoConnection) {
+        return /*#__PURE__*/ _jsxs(_Fragment, {
+            children: [
+                /*#__PURE__*/ _jsx("style", {
+                    dangerouslySetInnerHTML: {
+                        __html: backupDashboardInlineCss
+                    }
+                }),
+                /*#__PURE__*/ _jsxs("div", {
+                    className: "backup-dashboard",
+                    children: [
+                        /*#__PURE__*/ _jsxs("h2", {
+                            children: [
+                                "Backups ",
+                                /*#__PURE__*/ _jsx("span", {
+                                    className: "experimental",
+                                    children: "(experimental)"
+                                })
+                            ]
+                        }),
+                        /*#__PURE__*/ _jsxs("p", {
+                            className: "backup-dashboard__setup-hint",
+                            role: "status",
+                            children: [
+                                "Set ",
+                                /*#__PURE__*/ _jsx("code", {
+                                    className: "backup-dashboard__setup-hint-code",
+                                    children: "MONGODB_URI"
+                                }),
+                                " or",
+                                ' ',
+                                /*#__PURE__*/ _jsx("code", {
+                                    className: "backup-dashboard__setup-hint-code",
+                                    children: "DATABASE_URL"
+                                }),
+                                " so Payload can connect to MongoDB. The in-memory dev database sets both automatically when neither is provided."
+                            ]
+                        })
+                    ]
+                })
+            ]
+        });
+    }
+    const payload = await getPayload({
+        config: configPromise
+    });
+    const backupBlobToken = await resolveBackupListToken(payload);
+    const hasBlobToken = backupBlobToken.trim().length > 0;
+    const blobs = hasBlobToken ? await listBackups(payload, {
+        blobToken: backupBlobToken
+    }) : [];
+    const sortedBlobs = [
+        ...blobs
+    ].sort((a, b)=>{
+        const ta = getBackupSortTimeMs(transformBlobName(a.pathname), new Date(a.uploadedAt));
+        const tb = getBackupSortTimeMs(transformBlobName(b.pathname), new Date(b.uploadedAt));
+        return tb - ta;
+    });
+    const currentHostname = getCurrentHostname();
+    const currentDbName = getCurrentDbName();
+    const countOtherDb = sortedBlobs.filter((blob)=>{
+        const { dbName } = transformBlobName(blob.pathname);
+        return currentDbName !== dbName;
+    }).length;
+    const countOtherHostname = sortedBlobs.filter((blob)=>{
+        const { hostname } = transformBlobName(blob.pathname);
+        return currentHostname !== hostname;
+    }).length;
+    const lastBackup = sortedBlobs[0];
+    return /*#__PURE__*/ _jsxs(_Fragment, {
+        children: [
+            /*#__PURE__*/ _jsx("style", {
+                dangerouslySetInnerHTML: {
+                    __html: backupDashboardInlineCss
+                },
+                "data-payload-backup-mongodb": "1"
+            }),
+            /*#__PURE__*/ _jsxs("div", {
+                className: "backup-dashboard",
+                children: [
+                    /*#__PURE__*/ _jsxs("h2", {
+                        children: [
+                            "Backups ",
+                            /*#__PURE__*/ _jsx("span", {
+                                className: "experimental",
+                                children: "(experimental)"
+                            })
+                        ]
+                    }),
+                    !hasBlobToken && /*#__PURE__*/ _jsxs("p", {
+                        className: "backup-dashboard__setup-hint",
+                        role: "status",
+                        children: [
+                            "Add a Vercel Blob read/write token: set environment variable",
+                            ' ',
+                            /*#__PURE__*/ _jsx("code", {
+                                className: "backup-dashboard__setup-hint-code",
+                                children: "BLOB_READ_WRITE_TOKEN"
+                            }),
+                            ", or open ",
+                            /*#__PURE__*/ _jsx("strong", {
+                                children: "Backup settings"
+                            }),
+                            " and paste a token. Until then, the list stays empty and cron or manual backups cannot run."
+                        ]
+                    }),
+                    /*#__PURE__*/ _jsxs("div", {
+                        className: "backup-dashboard__toolbar",
+                        children: [
+                            /*#__PURE__*/ _jsxs("div", {
+                                className: "backup-dashboard__toolbar-meta",
+                                children: [
+                                    /*#__PURE__*/ _jsxs("span", {
+                                        className: "backup-dashboard__toolbar-pill",
+                                        children: [
+                                            /*#__PURE__*/ _jsx("span", {
+                                                className: "backup-dashboard__toolbar-key",
+                                                children: "Total"
+                                            }),
+                                            sortedBlobs.length,
+                                            " backup",
+                                            sortedBlobs.length === 1 ? '' : 's'
+                                        ]
+                                    }),
+                                    /*#__PURE__*/ _jsxs("span", {
+                                        className: "backup-dashboard__toolbar-pill",
+                                        children: [
+                                            /*#__PURE__*/ _jsx("span", {
+                                                className: "backup-dashboard__toolbar-key",
+                                                children: "Last backup"
+                                            }),
+                                            lastBackup ? new Date(getBackupSortTimeMs(transformBlobName(lastBackup.pathname), new Date(lastBackup.uploadedAt))).toLocaleString(i18n?.language || 'en') : 'No backups yet'
+                                        ]
+                                    })
+                                ]
+                            }),
+                            /*#__PURE__*/ _jsxs("div", {
+                                className: "make-backup-actions",
+                                children: [
+                                    /*#__PURE__*/ _jsx(BackupSettingsModal, {}),
+                                    /*#__PURE__*/ _jsx(ManualBackupDialog, {})
+                                ]
+                            })
+                        ]
+                    }),
+                    /*#__PURE__*/ _jsx(BackupListCollapsible, {
+                        blobs: sortedBlobs.map((b)=>({
+                                downloadUrl: b.downloadUrl,
+                                pathname: b.pathname,
+                                size: b.size,
+                                uploadedAt: new Date(b.uploadedAt).toISOString(),
+                                url: b.url
+                            })),
+                        countOtherDb: countOtherDb,
+                        countOtherHostname: countOtherHostname,
+                        currentDbName: currentDbName,
+                        currentHostname: currentHostname,
+                        i18nLanguage: i18n?.language || 'en'
+                    })
+                ]
+            })
+        ]
+    });
+};
+export default BackupDashboard;
+
+//# sourceMappingURL=index.js.map

package/dist/components/BackupDashboard/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/components/BackupDashboard/index.tsx"],"sourcesContent":["import type { I18n } from '@payloadcms/translations'\n\nimport configPromise from '@payload-config'\nimport { getPayload } from 'payload'\n\nimport type { BackupPluginOptions } from '../../types'\n\nimport { listBackups, resolveBackupListToken } from '../../core/backup'\nimport {\n  getBackupSortTimeMs,\n  getCurrentDbName,\n  getCurrentHostname,\n  isUserAllowedByEnvRoles,\n  transformBlobName,\n} from '../../utils/index'\nimport { backupDashboardInlineCss } from './backupDashboardInlineCss'\nimport { BackupListCollapsible, BackupSettingsModal, ManualBackupDialog } from './index.client'\n\ninterface BackupDashboardProps {\n  i18n: I18n\n  /** Optional on admin server props; omitted does not mean logged out (see `defaultIsHidden`). */\n  user?: null | Record<string, unknown>\n}\n\nfunction defaultIsHidden(\n  user: null | Record<string, unknown> | undefined,\n  access?: BackupPluginOptions['access'],\n): boolean {\n  if (user === null) {\n    return true\n  }\n  if (user === undefined) {\n    if (access) {\n      return true\n    }\n    return false\n  }\n  if (access) {\n    return !access(user)\n  }\n  // Role allow-list via `PAYLOAD_BACKUP_ALLOWED_ROLES`. When unset, falls back to the\n  // historical default (admin role, or \"visible\" when the project has no roles field).\n  return !isUserAllowedByEnvRoles(user)\n}\n\nexport const BackupDashboard: React.FC<BackupDashboardProps> = async ({ i18n, user }) => {\n  if (defaultIsHidden(user)) {\n    return null\n  }\n\n  const hasMongoConnection =\n    Boolean(process.env.MONGODB_URI?.trim()) || Boolean(process.env.DATABASE_URL?.trim())\n  if (!hasMongoConnection) {\n    return (\n      <>\n        <style dangerouslySetInnerHTML={{ __html: backupDashboardInlineCss }} />\n        <div className=\"backup-dashboard\">\n          <h2>\n            Backups <span className=\"experimental\">(experimental)</span>\n          </h2>\n          <p className=\"backup-dashboard__setup-hint\" role=\"status\">\n            Set <code className=\"backup-dashboard__setup-hint-code\">MONGODB_URI</code> or{' '}\n            <code className=\"backup-dashboard__setup-hint-code\">DATABASE_URL</code> so Payload can\n            connect to MongoDB. The in-memory dev database sets both automatically when neither is\n            provided.\n          </p>\n        </div>\n      </>\n    )\n  }\n\n  const payload = await getPayload({ config: configPromise })\n  const backupBlobToken = await resolveBackupListToken(payload)\n  const hasBlobToken = backupBlobToken.trim().length > 0\n\n  const blobs = hasBlobToken ? await listBackups(payload, { blobToken: backupBlobToken }) : []\n  const sortedBlobs = [...blobs].sort((a, b) => {\n    const ta = getBackupSortTimeMs(transformBlobName(a.pathname), new Date(a.uploadedAt))\n    const tb = getBackupSortTimeMs(transformBlobName(b.pathname), new Date(b.uploadedAt))\n    return tb - ta\n  })\n  const currentHostname = getCurrentHostname()\n  const currentDbName = getCurrentDbName()\n\n  const countOtherDb = sortedBlobs.filter((blob) => {\n    const { dbName } = transformBlobName(blob.pathname)\n    return currentDbName !== dbName\n  }).length\n\n  const countOtherHostname = sortedBlobs.filter((blob) => {\n    const { hostname } = transformBlobName(blob.pathname)\n    return currentHostname !== hostname\n  }).length\n  const lastBackup = sortedBlobs[0]\n\n  return (\n    <>\n      <style\n        dangerouslySetInnerHTML={{ __html: backupDashboardInlineCss }}\n        data-payload-backup-mongodb=\"1\"\n      />\n      <div className=\"backup-dashboard\">\n        <h2>\n          Backups <span className=\"experimental\">(experimental)</span>\n        </h2>\n\n        {!hasBlobToken && (\n          <p className=\"backup-dashboard__setup-hint\" role=\"status\">\n            Add a Vercel Blob read/write token: set environment variable{' '}\n            <code className=\"backup-dashboard__setup-hint-code\">BLOB_READ_WRITE_TOKEN</code>, or\n            open <strong>Backup settings</strong> and paste a token. Until then, the list stays\n            empty and cron or manual backups cannot run.\n          </p>\n        )}\n\n        <div className=\"backup-dashboard__toolbar\">\n          <div className=\"backup-dashboard__toolbar-meta\">\n            <span className=\"backup-dashboard__toolbar-pill\">\n              <span className=\"backup-dashboard__toolbar-key\">Total</span>\n              {sortedBlobs.length} backup{sortedBlobs.length === 1 ? '' : 's'}\n            </span>\n            <span className=\"backup-dashboard__toolbar-pill\">\n              <span className=\"backup-dashboard__toolbar-key\">Last backup</span>\n              {lastBackup\n                ? new Date(\n                    getBackupSortTimeMs(\n                      transformBlobName(lastBackup.pathname),\n                      new Date(lastBackup.uploadedAt),\n                    ),\n                  ).toLocaleString(i18n?.language || 'en')\n                : 'No backups yet'}\n            </span>\n          </div>\n          <div className=\"make-backup-actions\">\n            <BackupSettingsModal />\n            <ManualBackupDialog />\n          </div>\n        </div>\n\n        <BackupListCollapsible\n          blobs={sortedBlobs.map((b) => ({\n            downloadUrl: b.downloadUrl,\n            pathname: b.pathname,\n            size: b.size,\n            uploadedAt: new Date(b.uploadedAt).toISOString(),\n            url: b.url,\n          }))}\n          countOtherDb={countOtherDb}\n          countOtherHostname={countOtherHostname}\n          currentDbName={currentDbName}\n          currentHostname={currentHostname}\n          i18nLanguage={i18n?.language || 'en'}\n        />\n      </div>\n    </>\n  )\n}\n\nexport default BackupDashboard\n"],"names":["configPromise","getPayload","listBackups","resolveBackupListToken","getBackupSortTimeMs","getCurrentDbName","getCurrentHostname","isUserAllowedByEnvRoles","transformBlobName","backupDashboardInlineCss","BackupListCollapsible","BackupSettingsModal","ManualBackupDialog","defaultIsHidden","user","access","undefined","BackupDashboard","i18n","hasMongoConnection","Boolean","process","env","MONGODB_URI","trim","DATABASE_URL","style","dangerouslySetInnerHTML","__html","div","className","h2","span","p","role","code","payload","config","backupBlobToken","hasBlobToken","length","blobs","blobToken","sortedBlobs","sort","a","b","ta","pathname","Date","uploadedAt","tb","currentHostname","currentDbName","countOtherDb","filter","blob","dbName","countOtherHostname","hostname","lastBackup","data-payload-backup-mongodb","strong","toLocaleString","language","map","downloadUrl","size","toISOString","url","i18nLanguage"],"mappings":"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"}

package/dist/core/archive.d.ts

@@ -0,0 +1,8 @@
+export declare function createTarGzip(files: {
+    content: Buffer;
+    name: string;
+}[]): Promise<Buffer>;
+export declare function resolveTarGzip(fileBuffer: Buffer): Promise<{
+    content: Buffer;
+    name: string;
+}[]>;

package/dist/core/archive.js

@@ -0,0 +1,47 @@
+import { Readable } from 'node:stream';
+import zlib from 'node:zlib';
+import tar from 'tar-stream';
+export function createTarGzip(files) {
+    return new Promise((resolve, reject)=>{
+        const pack = tar.pack();
+        const gzip = zlib.createGzip();
+        const chunks = [];
+        files.forEach(({ name, content })=>{
+            pack.entry({
+                name
+            }, content);
+        });
+        pack.finalize();
+        const compressedStream = pack.pipe(gzip);
+        compressedStream.on('data', (chunk)=>chunks.push(chunk));
+        compressedStream.on('end', ()=>resolve(Buffer.concat(chunks)));
+        compressedStream.on('error', reject);
+    });
+}
+export function resolveTarGzip(fileBuffer) {
+    return new Promise((resolve, reject)=>{
+        const gunzip = zlib.createGunzip();
+        const extract = tar.extract();
+        const files = [];
+        extract.on('entry', (header, stream, next)=>{
+            const chunks = [];
+            stream.on('data', (chunk)=>chunks.push(chunk));
+            stream.on('end', ()=>{
+                files.push({
+                    name: header.name,
+                    content: Buffer.concat(chunks)
+                });
+                next();
+            });
+            stream.resume();
+        });
+        extract.on('finish', ()=>{
+            resolve(files);
+        });
+        extract.on('error', reject);
+        const stream = Readable.from(fileBuffer);
+        stream.pipe(gunzip).pipe(extract);
+    });
+}
+
+//# sourceMappingURL=archive.js.map

package/dist/core/archive.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/core/archive.ts"],"sourcesContent":["import { Readable } from 'node:stream'\nimport zlib from 'node:zlib'\nimport tar from 'tar-stream'\n\nexport function createTarGzip(files: { content: Buffer; name: string }[]): Promise<Buffer> {\n  return new Promise<Buffer>((resolve, reject) => {\n    const pack = tar.pack()\n    const gzip = zlib.createGzip()\n    const chunks: Buffer[] = []\n\n    files.forEach(({ name, content }) => {\n      pack.entry({ name }, content)\n    })\n\n    pack.finalize()\n\n    const compressedStream = pack.pipe(gzip)\n\n    compressedStream.on('data', (chunk: Buffer) => chunks.push(chunk))\n    compressedStream.on('end', () => resolve(Buffer.concat(chunks)))\n    compressedStream.on('error', reject)\n  })\n}\n\nexport function resolveTarGzip(\n  fileBuffer: Buffer,\n): Promise<{ content: Buffer; name: string }[]> {\n  return new Promise<{ content: Buffer; name: string }[]>((resolve, reject) => {\n    const gunzip = zlib.createGunzip()\n    const extract = tar.extract()\n\n    const files: { content: Buffer; name: string }[] = []\n\n    extract.on('entry', (header, stream, next) => {\n      const chunks: Buffer[] = []\n      stream.on('data', (chunk) => chunks.push(chunk))\n      stream.on('end', () => {\n        files.push({\n          name: header.name,\n          content: Buffer.concat(chunks),\n        })\n        next()\n      })\n      stream.resume()\n    })\n    extract.on('finish', () => {\n      resolve(files)\n    })\n    extract.on('error', reject)\n\n    const stream = Readable.from(fileBuffer)\n    stream.pipe(gunzip).pipe(extract)\n  })\n}\n"],"names":["Readable","zlib","tar","createTarGzip","files","Promise","resolve","reject","pack","gzip","createGzip","chunks","forEach","name","content","entry","finalize","compressedStream","pipe","on","chunk","push","Buffer","concat","resolveTarGzip","fileBuffer","gunzip","createGunzip","extract","header","stream","next","resume","from"],"mappings":"AAAA,SAASA,QAAQ,QAAQ,cAAa;AACtC,OAAOC,UAAU,YAAW;AAC5B,OAAOC,SAAS,aAAY;AAE5B,OAAO,SAASC,cAAcC,KAA0C;IACtE,OAAO,IAAIC,QAAgB,CAACC,SAASC;QACnC,MAAMC,OAAON,IAAIM,IAAI;QACrB,MAAMC,OAAOR,KAAKS,UAAU;QAC5B,MAAMC,SAAmB,EAAE;QAE3BP,MAAMQ,OAAO,CAAC,CAAC,EAAEC,IAAI,EAAEC,OAAO,EAAE;YAC9BN,KAAKO,KAAK,CAAC;gBAAEF;YAAK,GAAGC;QACvB;QAEAN,KAAKQ,QAAQ;QAEb,MAAMC,mBAAmBT,KAAKU,IAAI,CAACT;QAEnCQ,iBAAiBE,EAAE,CAAC,QAAQ,CAACC,QAAkBT,OAAOU,IAAI,CAACD;QAC3DH,iBAAiBE,EAAE,CAAC,OAAO,IAAMb,QAAQgB,OAAOC,MAAM,CAACZ;QACvDM,iBAAiBE,EAAE,CAAC,SAASZ;IAC/B;AACF;AAEA,OAAO,SAASiB,eACdC,UAAkB;IAElB,OAAO,IAAIpB,QAA6C,CAACC,SAASC;QAChE,MAAMmB,SAASzB,KAAK0B,YAAY;QAChC,MAAMC,UAAU1B,IAAI0B,OAAO;QAE3B,MAAMxB,QAA6C,EAAE;QAErDwB,QAAQT,EAAE,CAAC,SAAS,CAACU,QAAQC,QAAQC;YACnC,MAAMpB,SAAmB,EAAE;YAC3BmB,OAAOX,EAAE,CAAC,QAAQ,CAACC,QAAUT,OAAOU,IAAI,CAACD;YACzCU,OAAOX,EAAE,CAAC,OAAO;gBACff,MAAMiB,IAAI,CAAC;oBACTR,MAAMgB,OAAOhB,IAAI;oBACjBC,SAASQ,OAAOC,MAAM,CAACZ;gBACzB;gBACAoB;YACF;YACAD,OAAOE,MAAM;QACf;QACAJ,QAAQT,EAAE,CAAC,UAAU;YACnBb,QAAQF;QACV;QACAwB,QAAQT,EAAE,CAAC,SAASZ;QAEpB,MAAMuB,SAAS9B,SAASiC,IAAI,CAACR;QAC7BK,OAAOZ,IAAI,CAACQ,QAAQR,IAAI,CAACU;IAC3B;AACF"}

package/dist/core/backup.d.ts

@@ -0,0 +1,41 @@
+import type { Payload } from 'payload';
+import { type BackupBlobAccessLevel } from './backupBlobIO';
+export declare const COLLECTION_FILE_NAME = "collections.json";
+/**
+ * Resolves the Vercel Blob read/write token the same way as backup endpoints and
+ * {@link createBackup} / {@link restoreBackup}: settings document override, else `BLOB_READ_WRITE_TOKEN`.
+ * Pass `explicitToken` to skip reading settings (same as `options.blobToken` in those calls).
+ */
+export declare function resolveBackupListToken(payload: Payload, explicitToken?: string): Promise<string>;
+export declare function listBackups(payload: Payload, options?: {
+    /**
+     * When set, used as the Vercel Blob token (e.g. tests or a pre-resolved value).
+     * When omitted, uses {@link resolveBackupListToken} (settings + env), same as other backup APIs.
+     */
+    blobToken?: string;
+}): Promise<import("@vercel/blob").ListBlobResultBlob[]>;
+/**
+ * @param mediaListToken Token for listing/fetching **Payload media** blobs (usually
+ * `BLOB_READ_WRITE_TOKEN`). When omitted, uses env then falls back to `backupBlobToken`.
+ */
+export declare function createMediaBackupFile(collectionBackupFile: string, mediaCollection: {
+    filename: string;
+}[], backupBlobToken?: string, mediaListToken?: string, payload?: Payload): Promise<Buffer>;
+export declare function createBackup(payload: Payload, options?: {
+    backupsToKeep?: number;
+    /** Public (default) or private Vercel Blob access for the uploaded backup archive. */
+    blobAccess?: BackupBlobAccessLevel;
+    /** Optional explicit Vercel Blob token (falls back to env inside @vercel/blob). */
+    blobToken?: string;
+    cron?: boolean;
+    includeMedia?: boolean;
+    /**
+     * Optional human-readable label for manual backups (appears in the backup list and is
+     * searchable via the label filter). Ignored for cron backups. Whitespace is collapsed,
+     * length is capped and the stored value is URL-encoded in the blob pathname.
+     */
+    label?: string;
+    /** Mongo collection names to omit from the dump (e.g. manual backup UI). */
+    skipCollections?: string[];
+    taskId?: string;
+}): Promise<void>;

package/dist/core/backup.js

@@ -0,0 +1,188 @@
+import { del, list } from '@vercel/blob';
+import { EJSON } from 'bson';
+import { createBlobName, getCurrentDbName, getCurrentHostname, sanitizeBackupLabel } from '../utils/index';
+import { createTarGzip } from './archive';
+import { putBackupBlobContent, readBackupBlobContentFlexible } from './backupBlobIO';
+import { getResolvedCronBackupSettings, resolveBackupBlobToken } from './backupSettings';
+import { getDb } from './db';
+import { updateBackupTask } from './taskProgress';
+export const COLLECTION_FILE_NAME = 'collections.json';
+/**
+ * Resolves the Vercel Blob read/write token the same way as backup endpoints and
+ * {@link createBackup} / {@link restoreBackup}: settings document override, else `BLOB_READ_WRITE_TOKEN`.
+ * Pass `explicitToken` to skip reading settings (same as `options.blobToken` in those calls).
+ */ export async function resolveBackupListToken(payload, explicitToken) {
+    const t = explicitToken?.trim();
+    if (t) {
+        return t;
+    }
+    return resolveBackupBlobToken(await getResolvedCronBackupSettings(payload)).trim();
+}
+export async function listBackups(payload, options = {}) {
+    const token = await resolveBackupListToken(payload, options.blobToken);
+    if (!token) {
+        return [];
+    }
+    const { blobs } = await list({
+        limit: 1000,
+        prefix: 'backups/',
+        token
+    });
+    return blobs;
+}
+function resolveBlobToken(blobToken) {
+    if (blobToken && blobToken.trim().length > 0) {
+        return blobToken;
+    }
+    return undefined;
+}
+/**
+ * @param mediaListToken Token for listing/fetching **Payload media** blobs (usually
+ * `BLOB_READ_WRITE_TOKEN`). When omitted, uses env then falls back to `backupBlobToken`.
+ */ export async function createMediaBackupFile(collectionBackupFile, mediaCollection, backupBlobToken, mediaListToken, payload) {
+    const envMedia = (process.env.BLOB_READ_WRITE_TOKEN || '').trim();
+    const tokenForMedia = resolveBlobToken(mediaListToken) ?? (envMedia.length > 0 ? envMedia : undefined) ?? resolveBlobToken(backupBlobToken);
+    const mediaFiles = await Promise.all(mediaCollection.map(async (media)=>{
+        const matchingFiles = await list({
+            limit: 2,
+            prefix: media.filename,
+            token: tokenForMedia
+        });
+        const blob = matchingFiles.blobs.find((blob)=>blob.pathname === media.filename);
+        if (!blob) {
+            payload?.logger.warn({
+                filename: media.filename
+            }, '[backup] File was in collection but not in blob storage');
+            return undefined;
+        }
+        const content = await readBackupBlobContentFlexible(blob.pathname, blob.downloadUrl, tokenForMedia ?? '');
+        return {
+            name: media.filename,
+            content
+        };
+    }));
+    return await createTarGzip([
+        {
+            name: COLLECTION_FILE_NAME,
+            content: Buffer.from(collectionBackupFile)
+        },
+        ...mediaFiles.filter(Boolean)
+    ]);
+}
+export async function createBackup(payload, options = {}) {
+    const { backupsToKeep, blobToken, cron = false, includeMedia = false, skipCollections, taskId } = options;
+    const label = cron ? '' : sanitizeBackupLabel(options.label);
+    const blobAccess = options.blobAccess ?? 'public';
+    const envMedia = (process.env.BLOB_READ_WRITE_TOKEN || '').trim();
+    const token = resolveBlobToken(blobToken);
+    const skip = new Set(skipCollections ?? []);
+    const resolvedBackupsToKeep = backupsToKeep ?? (Number(process.env.BACKUPS_TO_KEEP) || 10);
+    const currentHostname = getCurrentHostname();
+    const currentDbName = getCurrentDbName();
+    const type = cron ? 'cron' : 'manual';
+    const t0 = Date.now();
+    payload.logger.info({
+        type,
+        blacklist: skipCollections?.length ?? 0,
+        db: currentDbName,
+        host: currentHostname,
+        includeMedia
+    }, '[backup] Starting backup');
+    if (taskId) {
+        await updateBackupTask(payload, taskId, {
+            message: 'Starting backup',
+            status: 'running'
+        });
+    }
+    if (cron) {
+        const { blobs } = await list({
+            limit: 1000,
+            prefix: 'backups/cron-',
+            token
+        });
+        const sorted = blobs.sort((a, b)=>new Date(b.uploadedAt).getTime() - new Date(a.uploadedAt).getTime());
+        const oldest = sorted.slice(resolvedBackupsToKeep - 1);
+        if (oldest.length > 0) {
+            payload.logger.info({
+                count: oldest.length
+            }, '[backup] Pruning old cron backups');
+            if (taskId) {
+                await updateBackupTask(payload, taskId, {
+                    message: `Pruning ${oldest.length} old cron backup${oldest.length === 1 ? '' : 's'}`
+                });
+            }
+        }
+        for (const blob of oldest){
+            await del(blob.url, {
+                token
+            });
+            payload.logger.info({
+                pathname: blob.pathname
+            }, '[backup] Deleted old backup');
+        }
+    }
+    const db = getDb(payload);
+    const collections = await db.listCollections().toArray();
+    payload.logger.info({
+        collections: collections.length
+    }, '[backup] Dumping collections');
+    if (taskId) {
+        await updateBackupTask(payload, taskId, {
+            message: `Dumping ${collections.length} collection${collections.length === 1 ? '' : 's'}`
+        });
+    }
+    const allData = {};
+    for (const collection of collections){
+        if (skip.has(collection.name)) {
+            payload.logger.debug({
+                collection: collection.name
+            }, '[backup] Skipping blacklisted collection');
+            continue;
+        }
+        allData[collection.name] = await db.collection(collection.name).find({}).toArray();
+        payload.logger.debug({
+            collection: collection.name,
+            docs: allData[collection.name].length
+        }, '[backup] Collection dumped');
+        if (taskId) {
+            await updateBackupTask(payload, taskId, {
+                message: `Dumped collection ${collection.name} (${allData[collection.name].length} docs)`
+            });
+        }
+    }
+    const collectionBackupFile = EJSON.stringify(allData);
+    const includedCollectionCount = Object.keys(allData).length;
+    const backupTimestampMs = Date.now();
+    if (includeMedia) {
+        payload.logger.info('[backup] Bundling media files into archive');
+        if (taskId) {
+            await updateBackupTask(payload, taskId, {
+                message: 'Bundling media files into archive'
+            });
+        }
+    }
+    const backupFile = includeMedia ? await createMediaBackupFile(collectionBackupFile, allData?.['media'] || [], token, envMedia.length > 0 ? envMedia : undefined, payload) : collectionBackupFile;
+    const name = `backups/${createBlobName(type, currentDbName, currentHostname, includedCollectionCount, backupTimestampMs, includeMedia ? 'tar.gz' : 'json', label || undefined)}`;
+    payload.logger.info({
+        name
+    }, '[backup] Uploading backup to blob storage');
+    if (taskId) {
+        await updateBackupTask(payload, taskId, {
+            message: 'Uploading backup to blob storage'
+        });
+    }
+    const effectiveAccess = await putBackupBlobContent(name, backupFile, token, blobAccess);
+    if (effectiveAccess !== blobAccess) {
+        payload.logger.warn({
+            name,
+            effectiveAccess,
+            preferredAccess: blobAccess
+        }, '[backup] Blob store rejected preferred access level; uploaded with fallback');
+    }
+    payload.logger.info({
+        name,
+        durationMs: Date.now() - t0
+    }, '[backup] Backup complete');
+}
+
+//# sourceMappingURL=backup.js.map

package/dist/core/backup.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/core/backup.ts"],"sourcesContent":["import type { Payload } from 'payload'\n\nimport { del, list } from '@vercel/blob'\nimport { EJSON } from 'bson'\n\nimport {\n  createBlobName,\n  getCurrentDbName,\n  getCurrentHostname,\n  sanitizeBackupLabel,\n} from '../utils/index'\nimport { createTarGzip } from './archive'\nimport {\n  type BackupBlobAccessLevel,\n  putBackupBlobContent,\n  readBackupBlobContentFlexible,\n} from './backupBlobIO'\nimport { getResolvedCronBackupSettings, resolveBackupBlobToken } from './backupSettings'\nimport { getDb } from './db'\nimport { updateBackupTask } from './taskProgress'\n\nexport const COLLECTION_FILE_NAME = 'collections.json'\n\n/**\n * Resolves the Vercel Blob read/write token the same way as backup endpoints and\n * {@link createBackup} / {@link restoreBackup}: settings document override, else `BLOB_READ_WRITE_TOKEN`.\n * Pass `explicitToken` to skip reading settings (same as `options.blobToken` in those calls).\n */\nexport async function resolveBackupListToken(\n  payload: Payload,\n  explicitToken?: string,\n): Promise<string> {\n  const t = explicitToken?.trim()\n  if (t) {\n    return t\n  }\n  return resolveBackupBlobToken(await getResolvedCronBackupSettings(payload)).trim()\n}\n\nexport async function listBackups(\n  payload: Payload,\n  options: {\n    /**\n     * When set, used as the Vercel Blob token (e.g. tests or a pre-resolved value).\n     * When omitted, uses {@link resolveBackupListToken} (settings + env), same as other backup APIs.\n     */\n    blobToken?: string\n  } = {},\n) {\n  const token = await resolveBackupListToken(payload, options.blobToken)\n  if (!token) {\n    return []\n  }\n  const { blobs } = await list({\n    limit: 1000,\n    prefix: 'backups/',\n    token,\n  })\n  return blobs\n}\n\nfunction resolveBlobToken(blobToken?: string): string | undefined {\n  if (blobToken && blobToken.trim().length > 0) {\n    return blobToken\n  }\n  return undefined\n}\n\n/**\n * @param mediaListToken Token for listing/fetching **Payload media** blobs (usually\n * `BLOB_READ_WRITE_TOKEN`). When omitted, uses env then falls back to `backupBlobToken`.\n */\nexport async function createMediaBackupFile(\n  collectionBackupFile: string,\n  mediaCollection: { filename: string }[],\n  backupBlobToken?: string,\n  mediaListToken?: string,\n  payload?: Payload,\n): Promise<Buffer> {\n  const envMedia = (process.env.BLOB_READ_WRITE_TOKEN || '').trim()\n  const tokenForMedia =\n    resolveBlobToken(mediaListToken) ??\n    (envMedia.length > 0 ? envMedia : undefined) ??\n    resolveBlobToken(backupBlobToken)\n  const mediaFiles = await Promise.all(\n    mediaCollection.map(async (media) => {\n      const matchingFiles = await list({ limit: 2, prefix: media.filename, token: tokenForMedia })\n      const blob = matchingFiles.blobs.find((blob) => blob.pathname === media.filename)\n      if (!blob) {\n        payload?.logger.warn(\n          { filename: media.filename },\n          '[backup] File was in collection but not in blob storage',\n        )\n        return undefined\n      }\n      const content = await readBackupBlobContentFlexible(\n        blob.pathname,\n        blob.downloadUrl,\n        tokenForMedia ?? '',\n      )\n      return { name: media.filename, content }\n    }),\n  )\n  return await createTarGzip([\n    { name: COLLECTION_FILE_NAME, content: Buffer.from(collectionBackupFile) },\n    ...(mediaFiles.filter(Boolean) as { content: Buffer; name: string }[]),\n  ])\n}\n\nexport async function createBackup(\n  payload: Payload,\n  options: {\n    backupsToKeep?: number\n    /** Public (default) or private Vercel Blob access for the uploaded backup archive. */\n    blobAccess?: BackupBlobAccessLevel\n    /** Optional explicit Vercel Blob token (falls back to env inside @vercel/blob). */\n    blobToken?: string\n    cron?: boolean\n    includeMedia?: boolean\n    /**\n     * Optional human-readable label for manual backups (appears in the backup list and is\n     * searchable via the label filter). Ignored for cron backups. Whitespace is collapsed,\n     * length is capped and the stored value is URL-encoded in the blob pathname.\n     */\n    label?: string\n    /** Mongo collection names to omit from the dump (e.g. manual backup UI). */\n    skipCollections?: string[]\n    taskId?: string\n  } = {},\n): Promise<void> {\n  const {\n    backupsToKeep,\n    blobToken,\n    cron = false,\n    includeMedia = false,\n    skipCollections,\n    taskId,\n  } = options\n  const label = cron ? '' : sanitizeBackupLabel(options.label)\n  const blobAccess: BackupBlobAccessLevel = options.blobAccess ?? 'public'\n  const envMedia = (process.env.BLOB_READ_WRITE_TOKEN || '').trim()\n  const token = resolveBlobToken(blobToken)\n  const skip = new Set(skipCollections ?? [])\n  const resolvedBackupsToKeep = backupsToKeep ?? (Number(process.env.BACKUPS_TO_KEEP) || 10)\n\n  const currentHostname = getCurrentHostname()\n  const currentDbName = getCurrentDbName()\n  const type = cron ? 'cron' : 'manual'\n  const t0 = Date.now()\n\n  payload.logger.info(\n    {\n      type,\n      blacklist: skipCollections?.length ?? 0,\n      db: currentDbName,\n      host: currentHostname,\n      includeMedia,\n    },\n    '[backup] Starting backup',\n  )\n  if (taskId) {\n    await updateBackupTask(payload, taskId, {\n      message: 'Starting backup',\n      status: 'running',\n    })\n  }\n\n  if (cron) {\n    const { blobs } = await list({\n      limit: 1000,\n      prefix: 'backups/cron-',\n      token,\n    })\n    const sorted = blobs.sort(\n      (a, b) => new Date(b.uploadedAt).getTime() - new Date(a.uploadedAt).getTime(),\n    )\n    const oldest = sorted.slice(resolvedBackupsToKeep - 1)\n    if (oldest.length > 0) {\n      payload.logger.info({ count: oldest.length }, '[backup] Pruning old cron backups')\n      if (taskId) {\n        await updateBackupTask(payload, taskId, {\n          message: `Pruning ${oldest.length} old cron backup${oldest.length === 1 ? '' : 's'}`,\n        })\n      }\n    }\n    for (const blob of oldest) {\n      await del(blob.url, { token })\n      payload.logger.info({ pathname: blob.pathname }, '[backup] Deleted old backup')\n    }\n  }\n\n  const db = getDb(payload)\n  const collections = await db.listCollections().toArray()\n  payload.logger.info({ collections: collections.length }, '[backup] Dumping collections')\n  if (taskId) {\n    await updateBackupTask(payload, taskId, {\n      message: `Dumping ${collections.length} collection${collections.length === 1 ? '' : 's'}`,\n    })\n  }\n\n  const allData: Record<string, Record<string, unknown>[]> = {}\n  for (const collection of collections) {\n    if (skip.has(collection.name)) {\n      payload.logger.debug(\n        { collection: collection.name },\n        '[backup] Skipping blacklisted collection',\n      )\n      continue\n    }\n    allData[collection.name] = (await db\n      .collection(collection.name)\n      .find({})\n      .toArray()) as Record<string, unknown>[]\n    payload.logger.debug(\n      { collection: collection.name, docs: allData[collection.name].length },\n      '[backup] Collection dumped',\n    )\n    if (taskId) {\n      await updateBackupTask(payload, taskId, {\n        message: `Dumped collection ${collection.name} (${allData[collection.name].length} docs)`,\n      })\n    }\n  }\n\n  const collectionBackupFile = EJSON.stringify(allData)\n  const includedCollectionCount = Object.keys(allData).length\n  const backupTimestampMs = Date.now()\n\n  if (includeMedia) {\n    payload.logger.info('[backup] Bundling media files into archive')\n    if (taskId) {\n      await updateBackupTask(payload, taskId, {\n        message: 'Bundling media files into archive',\n      })\n    }\n  }\n\n  const backupFile = includeMedia\n    ? await createMediaBackupFile(\n        collectionBackupFile,\n        (allData?.['media'] as { filename: string }[] | undefined) || [],\n        token,\n        envMedia.length > 0 ? envMedia : undefined,\n        payload,\n      )\n    : collectionBackupFile\n  const name = `backups/${createBlobName(\n    type,\n    currentDbName,\n    currentHostname,\n    includedCollectionCount,\n    backupTimestampMs,\n    includeMedia ? 'tar.gz' : 'json',\n    label || undefined,\n  )}`\n\n  payload.logger.info({ name }, '[backup] Uploading backup to blob storage')\n  if (taskId) {\n    await updateBackupTask(payload, taskId, {\n      message: 'Uploading backup to blob storage',\n    })\n  }\n  const effectiveAccess = await putBackupBlobContent(name, backupFile, token, blobAccess)\n  if (effectiveAccess !== blobAccess) {\n    payload.logger.warn(\n      { name, effectiveAccess, preferredAccess: blobAccess },\n      '[backup] Blob store rejected preferred access level; uploaded with fallback',\n    )\n  }\n\n  payload.logger.info({ name, durationMs: Date.now() - t0 }, '[backup] Backup complete')\n}\n"],"names":["del","list","EJSON","createBlobName","getCurrentDbName","getCurrentHostname","sanitizeBackupLabel","createTarGzip","putBackupBlobContent","readBackupBlobContentFlexible","getResolvedCronBackupSettings","resolveBackupBlobToken","getDb","updateBackupTask","COLLECTION_FILE_NAME","resolveBackupListToken","payload","explicitToken","t","trim","listBackups","options","token","blobToken","blobs","limit","prefix","resolveBlobToken","length","undefined","createMediaBackupFile","collectionBackupFile","mediaCollection","backupBlobToken","mediaListToken","envMedia","process","env","BLOB_READ_WRITE_TOKEN","tokenForMedia","mediaFiles","Promise","all","map","media","matchingFiles","filename","blob","find","pathname","logger","warn","content","downloadUrl","name","Buffer","from","filter","Boolean","createBackup","backupsToKeep","cron","includeMedia","skipCollections","taskId","label","blobAccess","skip","Set","resolvedBackupsToKeep","Number","BACKUPS_TO_KEEP","currentHostname","currentDbName","type","t0","Date","now","info","blacklist","db","host","message","status","sorted","sort","a","b","uploadedAt","getTime","oldest","slice","count","url","collections","listCollections","toArray","allData","collection","has","debug","docs","stringify","includedCollectionCount","Object","keys","backupTimestampMs","backupFile","effectiveAccess","preferredAccess","durationMs"],"mappings":"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"}

package/dist/core/backupBlobIO.d.ts

@@ -0,0 +1,54 @@
+/** Vercel Blob access for backup archives under `backups/`. */
+export type BackupBlobAccessLevel = 'private' | 'public';
+/**
+ * Returns the blob pathname (no leading slash) for a trusted Vercel Blob HTTPS URL, or null.
+ * The URL's path component is percent-decoded once so the result matches the literal pathname
+ * stored by Vercel Blob (e.g. blobs whose own pathname contains `%2F` are served from a URL that
+ * double-encodes it to `%252F`).
+ */
+export declare function vercelBlobPathnameFromUrl(urlStr: string): null | string;
+export declare function isTrustedBackupBlobReference(urlStr: string, expectedPathname: string): boolean;
+export type BackupBlobDownloadStream = {
+    contentType: string;
+    stream: ReadableStream<Uint8Array>;
+};
+/**
+ * Opens a readable stream for a backup object (public or private). Prefers the `downloadUrl` /
+ * `blobUrl` returned by `list()` because Vercel Blob already encodes the pathname correctly there
+ * (some legacy backups store literal `%2F` sequences inside the pathname, which the SDK's
+ * pathname-to-URL construction would misinterpret).
+ */
+export declare function streamBackupBlobForDownload(options: {
+    blobUrl?: null | string;
+    downloadUrl?: null | string;
+    pathname: string;
+    preferredAccess: BackupBlobAccessLevel;
+    token: string;
+}): Promise<BackupBlobDownloadStream | null>;
+export declare function bufferFromWebReadableStream(stream: ReadableStream<Uint8Array>): Promise<Buffer>;
+/**
+ * Read a backup blob using the trusted `downloadUrl` returned by `list()`. The Bearer token is
+ * always attached for Vercel Blob hosts; this works for public blobs (token ignored) and is
+ * required for private blobs.
+ */
+export declare function readBackupBlobContent(options: {
+    /** Kept for API compatibility — the fetch path is the same for public and private stores. */
+    access: BackupBlobAccessLevel;
+    downloadUrl: string;
+    pathname: string;
+    token: string;
+}): Promise<Buffer>;
+/**
+ * Flexible read used during restore/preview/transfer where the source store visibility may differ
+ * from the new one. Always tries authenticated access first (correct for private stores and
+ * harmless for public ones). Falls back to anonymous fetch only when the URL is not a Vercel
+ * Blob URL, so tokens never leak to arbitrary hosts.
+ */
+export declare function readBackupBlobContentFlexible(pathname: string, downloadUrl: string, token: string, _sourceAccessHint?: BackupBlobAccessLevel): Promise<Buffer>;
+/**
+ * Uploads a backup blob with the preferred access level and transparently retries the other level
+ * if the Vercel Blob store rejects the preferred one (e.g. legacy public-only stores reject
+ * `access: 'private'`). Returns the effective access level that succeeded so callers can log/track
+ * it; throws the original error if both attempts fail.
+ */
+export declare function putBackupBlobContent(pathname: string, body: Buffer | string | Uint8Array, token: string | undefined, access: BackupBlobAccessLevel): Promise<BackupBlobAccessLevel>;