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

package/dist/endpoints/paths/admin-validate-blob-token.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/endpoints/paths/admin-validate-blob-token.ts"],"sourcesContent":["import type { Endpoint } from 'payload'\n\nimport type { BackupPluginOptions } from '../../types'\n\nimport { validateBackupBlobToken } from '../../core/blobTokenValidate'\nimport { readRequestJson, requireBackupAdmin } from '../shared'\n\n/**\n * Admin-only validation endpoint for a (candidate) Vercel Blob read/write token. Probes the store\n * by uploading and deleting a tiny marker file and reports back whether the token is usable and\n * which access level (public/private) the store accepts.\n */\nexport function createAdminValidateBlobTokenEndpoint(options: BackupPluginOptions): Endpoint {\n  return {\n    handler: async (req) => {\n      const auth = await requireBackupAdmin(req, options)\n      if (auth instanceof Response) {\n        return auth\n      }\n\n      const body = (await readRequestJson(req)) as { token?: unknown }\n      const token = typeof body?.token === 'string' ? body.token : ''\n\n      const result = await validateBackupBlobToken(token)\n      return Response.json(result, { status: result.ok ? 200 : 422 })\n    },\n    method: 'post',\n    path: '/backup-mongodb/admin/validate-blob-token',\n  }\n}\n"],"names":["validateBackupBlobToken","readRequestJson","requireBackupAdmin","createAdminValidateBlobTokenEndpoint","options","handler","req","auth","Response","body","token","result","json","status","ok","method","path"],"mappings":"AAIA,SAASA,uBAAuB,QAAQ,+BAA8B;AACtE,SAASC,eAAe,EAAEC,kBAAkB,QAAQ,YAAW;AAE/D;;;;CAIC,GACD,OAAO,SAASC,qCAAqCC,OAA4B;IAC/E,OAAO;QACLC,SAAS,OAAOC;YACd,MAAMC,OAAO,MAAML,mBAAmBI,KAAKF;YAC3C,IAAIG,gBAAgBC,UAAU;gBAC5B,OAAOD;YACT;YAEA,MAAME,OAAQ,MAAMR,gBAAgBK;YACpC,MAAMI,QAAQ,OAAOD,MAAMC,UAAU,WAAWD,KAAKC,KAAK,GAAG;YAE7D,MAAMC,SAAS,MAAMX,wBAAwBU;YAC7C,OAAOF,SAASI,IAAI,CAACD,QAAQ;gBAAEE,QAAQF,OAAOG,EAAE,GAAG,MAAM;YAAI;QAC/D;QACAC,QAAQ;QACRC,MAAM;IACR;AACF"}

package/dist/endpoints/paths/cron-list.d.ts

@@ -0,0 +1,2 @@
+import type { Endpoint } from 'payload';
+export declare function createCronListEndpoint(): Endpoint;

package/dist/endpoints/paths/cron-list.js

@@ -0,0 +1,33 @@
+import { listBackups, resolveBackupListToken } from '../../core/backup';
+import { requireCronBearer } from '../shared';
+export function createCronListEndpoint() {
+    return {
+        handler: async (req)=>{
+            const cronErr = requireCronBearer(req);
+            if (cronErr) {
+                return cronErr;
+            }
+            const { payload } = req;
+            const backupBlobToken = await resolveBackupListToken(payload);
+            if (!backupBlobToken) {
+                return new Response('Service unavailable', {
+                    status: 503
+                });
+            }
+            payload.logger.info('[backup-endpoint] Listing backups');
+            const blobs = await listBackups(payload, {
+                blobToken: backupBlobToken
+            });
+            payload.logger.info({
+                count: blobs.length
+            }, '[backup-endpoint] Backup list loaded');
+            return Response.json(blobs, {
+                status: 200
+            });
+        },
+        method: 'get',
+        path: '/backup-mongodb/cron/list'
+    };
+}
+
+//# sourceMappingURL=cron-list.js.map

package/dist/endpoints/paths/cron-list.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/endpoints/paths/cron-list.ts"],"sourcesContent":["import type { Endpoint } from 'payload'\n\nimport { listBackups, resolveBackupListToken } from '../../core/backup'\nimport { requireCronBearer } from '../shared'\n\nexport function createCronListEndpoint(): Endpoint {\n  return {\n    handler: async (req) => {\n      const cronErr = requireCronBearer(req)\n      if (cronErr) {\n        return cronErr\n      }\n\n      const { payload } = req\n      const backupBlobToken = await resolveBackupListToken(payload)\n      if (!backupBlobToken) {\n        return new Response('Service unavailable', { status: 503 })\n      }\n      payload.logger.info('[backup-endpoint] Listing backups')\n      const blobs = await listBackups(payload, { blobToken: backupBlobToken })\n      payload.logger.info({ count: blobs.length }, '[backup-endpoint] Backup list loaded')\n      return Response.json(blobs, { status: 200 })\n    },\n    method: 'get',\n    path: '/backup-mongodb/cron/list',\n  }\n}\n"],"names":["listBackups","resolveBackupListToken","requireCronBearer","createCronListEndpoint","handler","req","cronErr","payload","backupBlobToken","Response","status","logger","info","blobs","blobToken","count","length","json","method","path"],"mappings":"AAEA,SAASA,WAAW,EAAEC,sBAAsB,QAAQ,oBAAmB;AACvE,SAASC,iBAAiB,QAAQ,YAAW;AAE7C,OAAO,SAASC;IACd,OAAO;QACLC,SAAS,OAAOC;YACd,MAAMC,UAAUJ,kBAAkBG;YAClC,IAAIC,SAAS;gBACX,OAAOA;YACT;YAEA,MAAM,EAAEC,OAAO,EAAE,GAAGF;YACpB,MAAMG,kBAAkB,MAAMP,uBAAuBM;YACrD,IAAI,CAACC,iBAAiB;gBACpB,OAAO,IAAIC,SAAS,uBAAuB;oBAAEC,QAAQ;gBAAI;YAC3D;YACAH,QAAQI,MAAM,CAACC,IAAI,CAAC;YACpB,MAAMC,QAAQ,MAAMb,YAAYO,SAAS;gBAAEO,WAAWN;YAAgB;YACtED,QAAQI,MAAM,CAACC,IAAI,CAAC;gBAAEG,OAAOF,MAAMG,MAAM;YAAC,GAAG;YAC7C,OAAOP,SAASQ,IAAI,CAACJ,OAAO;gBAAEH,QAAQ;YAAI;QAC5C;QACAQ,QAAQ;QACRC,MAAM;IACR;AACF"}

package/dist/endpoints/paths/cron-restore.d.ts

@@ -0,0 +1,2 @@
+import type { Endpoint } from 'payload';
+export declare function createCronRestoreEndpoint(): Endpoint;

package/dist/endpoints/paths/cron-restore.js

@@ -0,0 +1,61 @@
+import { getResolvedCronBackupSettings, resolveBackupArchiveRead, resolveBackupBlobAccess, resolveBackupBlobToken } from '../../core/backupSettings';
+import { restoreBackup } from '../../core/restore';
+import { readRequestJson, requireCronBearer } from '../shared';
+export function createCronRestoreEndpoint() {
+    return {
+        handler: async (req)=>{
+            const cronErr = requireCronBearer(req);
+            if (cronErr) {
+                return cronErr;
+            }
+            const { payload } = req;
+            const settings = await getResolvedCronBackupSettings(payload);
+            const blobToken = resolveBackupBlobToken(settings);
+            const blobAccess = resolveBackupBlobAccess(settings);
+            if (!blobToken) {
+                return new Response('Service unavailable', {
+                    status: 503
+                });
+            }
+            const { pathname, url } = await readRequestJson(req);
+            if (!url || typeof url !== 'string') {
+                return new Response('Missing url', {
+                    status: 400
+                });
+            }
+            try {
+                new URL(url);
+            } catch  {
+                return new Response('Invalid url', {
+                    status: 400
+                });
+            }
+            const backupRead = resolveBackupArchiveRead(settings, pathname);
+            if (blobAccess === 'private' && !backupRead) {
+                return new Response('Missing pathname (required for dedicated backup blob store)', {
+                    status: 400
+                });
+            }
+            payload.logger.info({
+                url
+            }, '[backup-endpoint] Restore request accepted');
+            await restoreBackup(payload, url, [], false, undefined, {
+                backupRead: backupRead ?? undefined,
+                blobAccess,
+                blobToken
+            });
+            payload.logger.info({
+                url
+            }, '[backup-endpoint] Restore request finished');
+            return Response.json({
+                message: 'Backup restore finished'
+            }, {
+                status: 202
+            });
+        },
+        method: 'post',
+        path: '/backup-mongodb/cron/restore'
+    };
+}
+
+//# sourceMappingURL=cron-restore.js.map

package/dist/endpoints/paths/cron-restore.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/endpoints/paths/cron-restore.ts"],"sourcesContent":["import type { Endpoint } from 'payload'\n\nimport {\n  getResolvedCronBackupSettings,\n  resolveBackupArchiveRead,\n  resolveBackupBlobAccess,\n  resolveBackupBlobToken,\n} from '../../core/backupSettings'\nimport { restoreBackup } from '../../core/restore'\nimport { readRequestJson, requireCronBearer } from '../shared'\n\nexport function createCronRestoreEndpoint(): Endpoint {\n  return {\n    handler: async (req) => {\n      const cronErr = requireCronBearer(req)\n      if (cronErr) {\n        return cronErr\n      }\n      const { payload } = req\n      const settings = await getResolvedCronBackupSettings(payload)\n      const blobToken = resolveBackupBlobToken(settings)\n      const blobAccess = resolveBackupBlobAccess(settings)\n      if (!blobToken) {\n        return new Response('Service unavailable', { status: 503 })\n      }\n\n      const { pathname, url } = (await readRequestJson(req)) as { pathname?: string; url?: string }\n      if (!url || typeof url !== 'string') {\n        return new Response('Missing url', { status: 400 })\n      }\n      try {\n        new URL(url)\n      } catch {\n        return new Response('Invalid url', { status: 400 })\n      }\n\n      const backupRead = resolveBackupArchiveRead(settings, pathname)\n      if (blobAccess === 'private' && !backupRead) {\n        return new Response('Missing pathname (required for dedicated backup blob store)', {\n          status: 400,\n        })\n      }\n\n      payload.logger.info({ url }, '[backup-endpoint] Restore request accepted')\n      await restoreBackup(payload, url, [], false, undefined, {\n        backupRead: backupRead ?? undefined,\n        blobAccess,\n        blobToken,\n      })\n      payload.logger.info({ url }, '[backup-endpoint] Restore request finished')\n      return Response.json({ message: 'Backup restore finished' }, { status: 202 })\n    },\n    method: 'post',\n    path: '/backup-mongodb/cron/restore',\n  }\n}\n"],"names":["getResolvedCronBackupSettings","resolveBackupArchiveRead","resolveBackupBlobAccess","resolveBackupBlobToken","restoreBackup","readRequestJson","requireCronBearer","createCronRestoreEndpoint","handler","req","cronErr","payload","settings","blobToken","blobAccess","Response","status","pathname","url","URL","backupRead","logger","info","undefined","json","message","method","path"],"mappings":"AAEA,SACEA,6BAA6B,EAC7BC,wBAAwB,EACxBC,uBAAuB,EACvBC,sBAAsB,QACjB,4BAA2B;AAClC,SAASC,aAAa,QAAQ,qBAAoB;AAClD,SAASC,eAAe,EAAEC,iBAAiB,QAAQ,YAAW;AAE9D,OAAO,SAASC;IACd,OAAO;QACLC,SAAS,OAAOC;YACd,MAAMC,UAAUJ,kBAAkBG;YAClC,IAAIC,SAAS;gBACX,OAAOA;YACT;YACA,MAAM,EAAEC,OAAO,EAAE,GAAGF;YACpB,MAAMG,WAAW,MAAMZ,8BAA8BW;YACrD,MAAME,YAAYV,uBAAuBS;YACzC,MAAME,aAAaZ,wBAAwBU;YAC3C,IAAI,CAACC,WAAW;gBACd,OAAO,IAAIE,SAAS,uBAAuB;oBAAEC,QAAQ;gBAAI;YAC3D;YAEA,MAAM,EAAEC,QAAQ,EAAEC,GAAG,EAAE,GAAI,MAAMb,gBAAgBI;YACjD,IAAI,CAACS,OAAO,OAAOA,QAAQ,UAAU;gBACnC,OAAO,IAAIH,SAAS,eAAe;oBAAEC,QAAQ;gBAAI;YACnD;YACA,IAAI;gBACF,IAAIG,IAAID;YACV,EAAE,OAAM;gBACN,OAAO,IAAIH,SAAS,eAAe;oBAAEC,QAAQ;gBAAI;YACnD;YAEA,MAAMI,aAAanB,yBAAyBW,UAAUK;YACtD,IAAIH,eAAe,aAAa,CAACM,YAAY;gBAC3C,OAAO,IAAIL,SAAS,+DAA+D;oBACjFC,QAAQ;gBACV;YACF;YAEAL,QAAQU,MAAM,CAACC,IAAI,CAAC;gBAAEJ;YAAI,GAAG;YAC7B,MAAMd,cAAcO,SAASO,KAAK,EAAE,EAAE,OAAOK,WAAW;gBACtDH,YAAYA,cAAcG;gBAC1BT;gBACAD;YACF;YACAF,QAAQU,MAAM,CAACC,IAAI,CAAC;gBAAEJ;YAAI,GAAG;YAC7B,OAAOH,SAASS,IAAI,CAAC;gBAAEC,SAAS;YAA0B,GAAG;gBAAET,QAAQ;YAAI;QAC7E;QACAU,QAAQ;QACRC,MAAM;IACR;AACF"}

package/dist/endpoints/paths/cron-run.d.ts

@@ -0,0 +1,3 @@
+import type { Endpoint } from 'payload';
+import type { BackupPluginOptions } from '../../types';
+export declare function createCronRunEndpoint(options: BackupPluginOptions): Endpoint;

package/dist/endpoints/paths/cron-run.js

@@ -0,0 +1,45 @@
+import { after } from 'next/server';
+import { createBackup } from '../../core/backup';
+import { getResolvedCronBackupSettings, resolveBackupBlobAccess, resolveBackupBlobToken } from '../../core/backupSettings';
+import { requireCronBearer } from '../shared';
+export function createCronRunEndpoint(options) {
+    return {
+        handler: async (req)=>{
+            const cronErr = requireCronBearer(req);
+            if (cronErr) {
+                return cronErr;
+            }
+            const { payload } = req;
+            const settings = await getResolvedCronBackupSettings(payload);
+            const blobToken = resolveBackupBlobToken(settings);
+            const blobAccess = resolveBackupBlobAccess(settings);
+            if (!blobToken) {
+                return new Response('Service unavailable', {
+                    status: 503
+                });
+            }
+            payload.logger.info('[backup-endpoint] Cron backup request accepted');
+            after(createBackup(payload, {
+                backupsToKeep: options.backupsToKeep ?? settings.backupsToKeep,
+                blobAccess,
+                blobToken,
+                cron: true,
+                includeMedia: settings.includeMediaForCron,
+                skipCollections: settings.skipMongoCollections
+            }).catch((error)=>{
+                payload.logger.error({
+                    err: error
+                }, '[backup-endpoint] Cron backup failed');
+                throw error;
+            }));
+            payload.logger.info('[backup-endpoint] Cron backup queued');
+            return new Response('Backup creation started', {
+                status: 202
+            });
+        },
+        method: 'get',
+        path: '/backup-mongodb/cron/run'
+    };
+}
+
+//# sourceMappingURL=cron-run.js.map

package/dist/endpoints/paths/cron-run.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/endpoints/paths/cron-run.ts"],"sourcesContent":["import type { Endpoint } from 'payload'\n\nimport { after } from 'next/server'\n\nimport type { BackupPluginOptions } from '../../types'\n\nimport { createBackup } from '../../core/backup'\nimport {\n  getResolvedCronBackupSettings,\n  resolveBackupBlobAccess,\n  resolveBackupBlobToken,\n} from '../../core/backupSettings'\nimport { requireCronBearer } from '../shared'\n\nexport function createCronRunEndpoint(options: BackupPluginOptions): Endpoint {\n  return {\n    handler: async (req) => {\n      const cronErr = requireCronBearer(req)\n      if (cronErr) {\n        return cronErr\n      }\n\n      const { payload } = req\n      const settings = await getResolvedCronBackupSettings(payload)\n      const blobToken = resolveBackupBlobToken(settings)\n      const blobAccess = resolveBackupBlobAccess(settings)\n      if (!blobToken) {\n        return new Response('Service unavailable', { status: 503 })\n      }\n      payload.logger.info('[backup-endpoint] Cron backup request accepted')\n      after(\n        createBackup(payload, {\n          backupsToKeep: options.backupsToKeep ?? settings.backupsToKeep,\n          blobAccess,\n          blobToken,\n          cron: true,\n          includeMedia: settings.includeMediaForCron,\n          skipCollections: settings.skipMongoCollections,\n        }).catch((error) => {\n          payload.logger.error({ err: error }, '[backup-endpoint] Cron backup failed')\n          throw error\n        }),\n      )\n      payload.logger.info('[backup-endpoint] Cron backup queued')\n      return new Response('Backup creation started', { status: 202 })\n    },\n    method: 'get',\n    path: '/backup-mongodb/cron/run',\n  }\n}\n"],"names":["after","createBackup","getResolvedCronBackupSettings","resolveBackupBlobAccess","resolveBackupBlobToken","requireCronBearer","createCronRunEndpoint","options","handler","req","cronErr","payload","settings","blobToken","blobAccess","Response","status","logger","info","backupsToKeep","cron","includeMedia","includeMediaForCron","skipCollections","skipMongoCollections","catch","error","err","method","path"],"mappings":"AAEA,SAASA,KAAK,QAAQ,cAAa;AAInC,SAASC,YAAY,QAAQ,oBAAmB;AAChD,SACEC,6BAA6B,EAC7BC,uBAAuB,EACvBC,sBAAsB,QACjB,4BAA2B;AAClC,SAASC,iBAAiB,QAAQ,YAAW;AAE7C,OAAO,SAASC,sBAAsBC,OAA4B;IAChE,OAAO;QACLC,SAAS,OAAOC;YACd,MAAMC,UAAUL,kBAAkBI;YAClC,IAAIC,SAAS;gBACX,OAAOA;YACT;YAEA,MAAM,EAAEC,OAAO,EAAE,GAAGF;YACpB,MAAMG,WAAW,MAAMV,8BAA8BS;YACrD,MAAME,YAAYT,uBAAuBQ;YACzC,MAAME,aAAaX,wBAAwBS;YAC3C,IAAI,CAACC,WAAW;gBACd,OAAO,IAAIE,SAAS,uBAAuB;oBAAEC,QAAQ;gBAAI;YAC3D;YACAL,QAAQM,MAAM,CAACC,IAAI,CAAC;YACpBlB,MACEC,aAAaU,SAAS;gBACpBQ,eAAeZ,QAAQY,aAAa,IAAIP,SAASO,aAAa;gBAC9DL;gBACAD;gBACAO,MAAM;gBACNC,cAAcT,SAASU,mBAAmB;gBAC1CC,iBAAiBX,SAASY,oBAAoB;YAChD,GAAGC,KAAK,CAAC,CAACC;gBACRf,QAAQM,MAAM,CAACS,KAAK,CAAC;oBAAEC,KAAKD;gBAAM,GAAG;gBACrC,MAAMA;YACR;YAEFf,QAAQM,MAAM,CAACC,IAAI,CAAC;YACpB,OAAO,IAAIH,SAAS,2BAA2B;gBAAEC,QAAQ;YAAI;QAC/D;QACAY,QAAQ;QACRC,MAAM;IACR;AACF"}

package/dist/endpoints/shared.d.ts

@@ -0,0 +1,13 @@
+import type { PayloadRequest } from 'payload';
+import type { BackupPluginOptions } from '../types';
+export declare function readRequestJson(req: PayloadRequest): Promise<unknown>;
+/**
+ * Canonical JSON error response for admin-facing endpoints. The dashboard clients
+ * always parse responses as JSON, so plain-text bodies would crash `await res.json()`
+ * with `Unexpected token ... is not valid JSON`.
+ */
+export declare function jsonError(message: string, status: number): Response;
+export declare function requireBlobEnv(): null | Response;
+export declare function requireCronBearer(req: PayloadRequest): null | Response;
+export declare function getAuthorizedBackupAdmin(req: PayloadRequest, options: BackupPluginOptions): Promise<null | Record<string, unknown>>;
+export declare function requireBackupAdmin(req: PayloadRequest, options: BackupPluginOptions): Promise<Record<string, unknown> | Response>;

package/dist/endpoints/shared.js

@@ -0,0 +1,58 @@
+import { isUserAllowedByEnvRoles } from '../utils/dashboardRoleAccess';
+export async function readRequestJson(req) {
+    return req.json();
+}
+/**
+ * Canonical JSON error response for admin-facing endpoints. The dashboard clients
+ * always parse responses as JSON, so plain-text bodies would crash `await res.json()`
+ * with `Unexpected token ... is not valid JSON`.
+ */ export function jsonError(message, status) {
+    return Response.json({
+        error: message
+    }, {
+        status
+    });
+}
+export function requireBlobEnv() {
+    if (!process.env.BLOB_READ_WRITE_TOKEN) {
+        return jsonError('Service unavailable', 503);
+    }
+    return null;
+}
+export function requireCronBearer(req) {
+    // Security gate for cron/external backup routes: only a matching CRON_SECRET bearer may pass.
+    const authHeader = req.headers.get('authorization');
+    if (authHeader !== `Bearer ${process.env.CRON_SECRET}`) {
+        return new Response('Unauthorized', {
+            status: 401
+        });
+    }
+    return null;
+}
+export async function getAuthorizedBackupAdmin(req, options) {
+    const fromRequest = req.user;
+    const authUser = fromRequest ? fromRequest : (await req.payload.auth({
+        headers: req.headers
+    }))?.user;
+    const user = authUser;
+    if (!user) {
+        return null;
+    }
+    if (options.access) {
+        return options.access(user) ? user : null;
+    }
+    // Default access check stays in sync with the dashboard visibility rule:
+    // driven by `PAYLOAD_BACKUP_ALLOWED_ROLES` with backwards-compatible defaults
+    // (admin role required when roles exist, or allow when the project has no roles field).
+    return isUserAllowedByEnvRoles(user) ? user : null;
+}
+export async function requireBackupAdmin(req, options) {
+    // Security gate for admin routes: request must resolve to an authorized backup admin user.
+    const user = await getAuthorizedBackupAdmin(req, options);
+    if (!user) {
+        return jsonError('Unauthorized', 401);
+    }
+    return user;
+}
+
+//# sourceMappingURL=shared.js.map

package/dist/endpoints/shared.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/endpoints/shared.ts"],"sourcesContent":["import type { PayloadRequest } from 'payload'\n\nimport type { BackupPluginOptions } from '../types'\n\nimport { isUserAllowedByEnvRoles } from '../utils/dashboardRoleAccess'\n\nexport async function readRequestJson(req: PayloadRequest): Promise<unknown> {\n  return (req as unknown as Request).json() as Promise<unknown>\n}\n\n/**\n * Canonical JSON error response for admin-facing endpoints. The dashboard clients\n * always parse responses as JSON, so plain-text bodies would crash `await res.json()`\n * with `Unexpected token ... is not valid JSON`.\n */\nexport function jsonError(message: string, status: number): Response {\n  return Response.json({ error: message }, { status })\n}\n\nexport function requireBlobEnv(): null | Response {\n  if (!process.env.BLOB_READ_WRITE_TOKEN) {\n    return jsonError('Service unavailable', 503)\n  }\n  return null\n}\n\nexport function requireCronBearer(req: PayloadRequest): null | Response {\n  // Security gate for cron/external backup routes: only a matching CRON_SECRET bearer may pass.\n  const authHeader = req.headers.get('authorization')\n  if (authHeader !== `Bearer ${process.env.CRON_SECRET}`) {\n    return new Response('Unauthorized', { status: 401 })\n  }\n  return null\n}\n\nexport async function getAuthorizedBackupAdmin(\n  req: PayloadRequest,\n  options: BackupPluginOptions,\n): Promise<null | Record<string, unknown>> {\n  const fromRequest = (req as { user?: null | Record<string, unknown> } & PayloadRequest).user\n  const authUser = fromRequest\n    ? fromRequest\n    : ((await req.payload.auth({ headers: req.headers }))?.user as\n        | null\n        | Record<string, unknown>\n        | undefined)\n  const user = authUser\n  if (!user) {\n    return null\n  }\n  if (options.access) {\n    return options.access(user) ? user : null\n  }\n  // Default access check stays in sync with the dashboard visibility rule:\n  // driven by `PAYLOAD_BACKUP_ALLOWED_ROLES` with backwards-compatible defaults\n  // (admin role required when roles exist, or allow when the project has no roles field).\n  return isUserAllowedByEnvRoles(user) ? user : null\n}\n\nexport async function requireBackupAdmin(\n  req: PayloadRequest,\n  options: BackupPluginOptions,\n): Promise<Record<string, unknown> | Response> {\n  // Security gate for admin routes: request must resolve to an authorized backup admin user.\n  const user = await getAuthorizedBackupAdmin(req, options)\n  if (!user) {\n    return jsonError('Unauthorized', 401)\n  }\n  return user\n}\n"],"names":["isUserAllowedByEnvRoles","readRequestJson","req","json","jsonError","message","status","Response","error","requireBlobEnv","process","env","BLOB_READ_WRITE_TOKEN","requireCronBearer","authHeader","headers","get","CRON_SECRET","getAuthorizedBackupAdmin","options","fromRequest","user","authUser","payload","auth","access","requireBackupAdmin"],"mappings":"AAIA,SAASA,uBAAuB,QAAQ,+BAA8B;AAEtE,OAAO,eAAeC,gBAAgBC,GAAmB;IACvD,OAAO,AAACA,IAA2BC,IAAI;AACzC;AAEA;;;;CAIC,GACD,OAAO,SAASC,UAAUC,OAAe,EAAEC,MAAc;IACvD,OAAOC,SAASJ,IAAI,CAAC;QAAEK,OAAOH;IAAQ,GAAG;QAAEC;IAAO;AACpD;AAEA,OAAO,SAASG;IACd,IAAI,CAACC,QAAQC,GAAG,CAACC,qBAAqB,EAAE;QACtC,OAAOR,UAAU,uBAAuB;IAC1C;IACA,OAAO;AACT;AAEA,OAAO,SAASS,kBAAkBX,GAAmB;IACnD,8FAA8F;IAC9F,MAAMY,aAAaZ,IAAIa,OAAO,CAACC,GAAG,CAAC;IACnC,IAAIF,eAAe,CAAC,OAAO,EAAEJ,QAAQC,GAAG,CAACM,WAAW,EAAE,EAAE;QACtD,OAAO,IAAIV,SAAS,gBAAgB;YAAED,QAAQ;QAAI;IACpD;IACA,OAAO;AACT;AAEA,OAAO,eAAeY,yBACpBhB,GAAmB,EACnBiB,OAA4B;IAE5B,MAAMC,cAAc,AAAClB,IAAmEmB,IAAI;IAC5F,MAAMC,WAAWF,cACbA,cACE,CAAA,MAAMlB,IAAIqB,OAAO,CAACC,IAAI,CAAC;QAAET,SAASb,IAAIa,OAAO;IAAC,EAAC,GAAIM;IAIzD,MAAMA,OAAOC;IACb,IAAI,CAACD,MAAM;QACT,OAAO;IACT;IACA,IAAIF,QAAQM,MAAM,EAAE;QAClB,OAAON,QAAQM,MAAM,CAACJ,QAAQA,OAAO;IACvC;IACA,yEAAyE;IACzE,8EAA8E;IAC9E,wFAAwF;IACxF,OAAOrB,wBAAwBqB,QAAQA,OAAO;AAChD;AAEA,OAAO,eAAeK,mBACpBxB,GAAmB,EACnBiB,OAA4B;IAE5B,2FAA2F;IAC3F,MAAME,OAAO,MAAMH,yBAAyBhB,KAAKiB;IACjD,IAAI,CAACE,MAAM;QACT,OAAOjB,UAAU,gBAAgB;IACnC;IACA,OAAOiB;AACT"}

package/dist/exports/client.d.ts

@@ -0,0 +1 @@
+export * from '../client';

package/dist/exports/client.js

@@ -0,0 +1,3 @@
+export * from '../client';
+
+//# sourceMappingURL=client.js.map

package/dist/exports/client.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/exports/client.ts"],"sourcesContent":["export * from '../client'\n"],"names":[],"mappings":"AAAA,cAAc,YAAW"}

package/dist/exports/rsc.d.ts

@@ -0,0 +1 @@
+export { BackupDashboard } from '../components/BackupDashboard/index';

package/dist/exports/rsc.js

@@ -0,0 +1,3 @@
+export { BackupDashboard } from '../components/BackupDashboard/index';
+
+//# sourceMappingURL=rsc.js.map

package/dist/exports/rsc.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/exports/rsc.ts"],"sourcesContent":["export { BackupDashboard } from '../components/BackupDashboard/index'\n"],"names":["BackupDashboard"],"mappings":"AAAA,SAASA,eAAe,QAAQ,sCAAqC"}

package/dist/index.d.ts

@@ -0,0 +1,18 @@
+export { createTarGzip, resolveTarGzip } from './core/archive';
+export { createBackup, createMediaBackupFile, listBackups, resolveBackupListToken, } from './core/backup';
+export { getBackupSourcePreviewForManual } from './core/backupSourcePreview';
+export type { BackupSourcePreviewResponse } from './core/backupSourcePreview';
+export { getDb } from './core/db';
+export type { MongoDb } from './core/db';
+export { restoreBackup, restoreSeedMedia } from './core/restore';
+export type { RestoreBackupOptions } from './core/restore';
+export { buildCollectionPreviewGroups, buildRestorePreviewGroups, getRestorePreviewForAdminRestore, loadRestoreBackupIndex, navVisibleCollectionOrderIndex, } from './core/restorePreview';
+export type { RestorePreviewAdminHiddenReason, RestorePreviewFileKind, RestorePreviewGroup, RestorePreviewResponse, } from './core/restorePreview';
+export { completeBackupTask, createBackupTask, failBackupTask, getBackupTask, pollSecretsMatch, stripPollSecretForClient, updateBackupTask, } from './core/taskProgress';
+export type { BackupTaskKind, BackupTaskProgress, BackupTaskStatus, BackupTaskWithPollSecret, } from './core/taskProgress';
+export { backupMongodbPlugin } from './plugin';
+export { backupPluginPublicApiPaths } from './publicApiPaths';
+export type { BackupPluginOptions } from './types';
+export { createBlobName, getBackupSortTimeMs, transformBlobName } from './utils/blobName';
+export { formatBytes } from './utils/formatBytes';
+export { getCurrentDbName, getCurrentHostname } from './utils/hostname';

package/dist/index.js

@@ -0,0 +1,14 @@
+export { createTarGzip, resolveTarGzip } from './core/archive';
+export { createBackup, createMediaBackupFile, listBackups, resolveBackupListToken } from './core/backup';
+export { getBackupSourcePreviewForManual } from './core/backupSourcePreview';
+export { getDb } from './core/db';
+export { restoreBackup, restoreSeedMedia } from './core/restore';
+export { buildCollectionPreviewGroups, buildRestorePreviewGroups, getRestorePreviewForAdminRestore, loadRestoreBackupIndex, navVisibleCollectionOrderIndex } from './core/restorePreview';
+export { completeBackupTask, createBackupTask, failBackupTask, getBackupTask, pollSecretsMatch, stripPollSecretForClient, updateBackupTask } from './core/taskProgress';
+export { backupMongodbPlugin } from './plugin';
+export { backupPluginPublicApiPaths } from './publicApiPaths';
+export { createBlobName, getBackupSortTimeMs, transformBlobName } from './utils/blobName';
+export { formatBytes } from './utils/formatBytes';
+export { getCurrentDbName, getCurrentHostname } from './utils/hostname';
+
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/index.ts"],"sourcesContent":["export { createTarGzip, resolveTarGzip } from './core/archive'\nexport {\n  createBackup,\n  createMediaBackupFile,\n  listBackups,\n  resolveBackupListToken,\n} from './core/backup'\nexport { getBackupSourcePreviewForManual } from './core/backupSourcePreview'\n\nexport type { BackupSourcePreviewResponse } from './core/backupSourcePreview'\nexport { getDb } from './core/db'\nexport type { MongoDb } from './core/db'\nexport { restoreBackup, restoreSeedMedia } from './core/restore'\nexport type { RestoreBackupOptions } from './core/restore'\nexport {\n  buildCollectionPreviewGroups,\n  buildRestorePreviewGroups,\n  getRestorePreviewForAdminRestore,\n  loadRestoreBackupIndex,\n  navVisibleCollectionOrderIndex,\n} from './core/restorePreview'\nexport type {\n  RestorePreviewAdminHiddenReason,\n  RestorePreviewFileKind,\n  RestorePreviewGroup,\n  RestorePreviewResponse,\n} from './core/restorePreview'\nexport {\n  completeBackupTask,\n  createBackupTask,\n  failBackupTask,\n  getBackupTask,\n  pollSecretsMatch,\n  stripPollSecretForClient,\n  updateBackupTask,\n} from './core/taskProgress'\nexport type {\n  BackupTaskKind,\n  BackupTaskProgress,\n  BackupTaskStatus,\n  BackupTaskWithPollSecret,\n} from './core/taskProgress'\nexport { backupMongodbPlugin } from './plugin'\nexport { backupPluginPublicApiPaths } from './publicApiPaths'\nexport type { BackupPluginOptions } from './types'\n\nexport { createBlobName, getBackupSortTimeMs, transformBlobName } from './utils/blobName'\nexport { formatBytes } from './utils/formatBytes'\nexport { getCurrentDbName, getCurrentHostname } from './utils/hostname'\n"],"names":["createTarGzip","resolveTarGzip","createBackup","createMediaBackupFile","listBackups","resolveBackupListToken","getBackupSourcePreviewForManual","getDb","restoreBackup","restoreSeedMedia","buildCollectionPreviewGroups","buildRestorePreviewGroups","getRestorePreviewForAdminRestore","loadRestoreBackupIndex","navVisibleCollectionOrderIndex","completeBackupTask","createBackupTask","failBackupTask","getBackupTask","pollSecretsMatch","stripPollSecretForClient","updateBackupTask","backupMongodbPlugin","backupPluginPublicApiPaths","createBlobName","getBackupSortTimeMs","transformBlobName","formatBytes","getCurrentDbName","getCurrentHostname"],"mappings":"AAAA,SAASA,aAAa,EAAEC,cAAc,QAAQ,iBAAgB;AAC9D,SACEC,YAAY,EACZC,qBAAqB,EACrBC,WAAW,EACXC,sBAAsB,QACjB,gBAAe;AACtB,SAASC,+BAA+B,QAAQ,6BAA4B;AAG5E,SAASC,KAAK,QAAQ,YAAW;AAEjC,SAASC,aAAa,EAAEC,gBAAgB,QAAQ,iBAAgB;AAEhE,SACEC,4BAA4B,EAC5BC,yBAAyB,EACzBC,gCAAgC,EAChCC,sBAAsB,EACtBC,8BAA8B,QACzB,wBAAuB;AAO9B,SACEC,kBAAkB,EAClBC,gBAAgB,EAChBC,cAAc,EACdC,aAAa,EACbC,gBAAgB,EAChBC,wBAAwB,EACxBC,gBAAgB,QACX,sBAAqB;AAO5B,SAASC,mBAAmB,QAAQ,WAAU;AAC9C,SAASC,0BAA0B,QAAQ,mBAAkB;AAG7D,SAASC,cAAc,EAAEC,mBAAmB,EAAEC,iBAAiB,QAAQ,mBAAkB;AACzF,SAASC,WAAW,QAAQ,sBAAqB;AACjD,SAASC,gBAAgB,EAAEC,kBAAkB,QAAQ,mBAAkB"}

package/dist/plugin.d.ts

@@ -0,0 +1,3 @@
+import type { Plugin } from 'payload';
+import type { BackupPluginOptions } from './types';
+export declare const backupMongodbPlugin: (options?: BackupPluginOptions) => Plugin;

package/dist/plugin.js

@@ -0,0 +1,82 @@
+import { BackupSettingsCollection } from './collections/BackupSettings';
+import { BackupTasksCollection } from './collections/BackupTasks';
+import { BACKUP_SETTINGS_SLUG } from './core/backupSettings';
+import { createBackupMongodbEndpoints } from './endpoints/index';
+export const backupMongodbPlugin = (options = {})=>{
+    return (incomingConfig)=>{
+        if (options.enabled === false) {
+            return incomingConfig;
+        }
+        const existingAfterDashboard = incomingConfig.admin?.components?.afterDashboard || [];
+        const existingCollections = incomingConfig.collections || [];
+        const existingEndpoints = incomingConfig.endpoints ?? [];
+        const backupEndpoints = createBackupMongodbEndpoints(options);
+        return {
+            ...incomingConfig,
+            admin: {
+                ...incomingConfig.admin,
+                components: {
+                    ...incomingConfig.admin?.components,
+                    afterDashboard: [
+                        ...existingAfterDashboard,
+                        '@trieb.work/payload-plugin-backup-mongodb/rsc#BackupDashboard'
+                    ]
+                }
+            },
+            collections: [
+                ...existingCollections,
+                BackupTasksCollection,
+                BackupSettingsCollection
+            ],
+            endpoints: [
+                ...existingEndpoints,
+                ...backupEndpoints
+            ],
+            onInit: async (payload)=>{
+                await incomingConfig.onInit?.(payload);
+                try {
+                    const existing = await payload.count({
+                        collection: BACKUP_SETTINGS_SLUG,
+                        overrideAccess: true
+                    });
+                    if (existing.totalDocs === 0) {
+                        await payload.create({
+                            collection: BACKUP_SETTINGS_SLUG,
+                            data: {
+                                backupBlobAccess: null,
+                                backupBlobReadWriteToken: '',
+                                backupsToKeep: Number(process.env.BACKUPS_TO_KEEP) || 10,
+                                includeMediaForCron: true,
+                                skipMongoCollections: []
+                            },
+                            overrideAccess: true
+                        });
+                        payload.logger.info('[backup-plugin] Created default backup-settings document');
+                    }
+                } catch (err) {
+                    payload.logger.warn({
+                        err
+                    }, '[backup-plugin] Could not ensure backup-settings document');
+                }
+                try {
+                    if (payload.db.name === 'mongoose') {
+                        const mongooseDb = payload.db;
+                        const db = mongooseDb.connection?.db;
+                        if (db) {
+                            await db.collection('backup-tasks').createIndex({
+                                updatedAt: 1
+                            }, {
+                                background: true,
+                                expireAfterSeconds: 1800
+                            });
+                        }
+                    }
+                } catch  {
+                    payload.logger.warn('[backup-plugin] Could not create TTL index on backup-tasks');
+                }
+            }
+        };
+    };
+};
+
+//# sourceMappingURL=plugin.js.map

package/dist/plugin.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/plugin.ts"],"sourcesContent":["import type { Config, Plugin } from 'payload'\n\nimport type { BackupPluginOptions } from './types'\n\nimport { BackupSettingsCollection } from './collections/BackupSettings'\nimport { BackupTasksCollection } from './collections/BackupTasks'\nimport { BACKUP_SETTINGS_SLUG } from './core/backupSettings'\nimport { createBackupMongodbEndpoints } from './endpoints/index'\n\nexport const backupMongodbPlugin = (options: BackupPluginOptions = {}): Plugin => {\n  return (incomingConfig: Config): Config => {\n    if (options.enabled === false) {\n      return incomingConfig\n    }\n\n    const existingAfterDashboard = incomingConfig.admin?.components?.afterDashboard || []\n    const existingCollections = incomingConfig.collections || []\n    const existingEndpoints = incomingConfig.endpoints ?? []\n    const backupEndpoints = createBackupMongodbEndpoints(options)\n\n    return {\n      ...incomingConfig,\n      admin: {\n        ...incomingConfig.admin,\n        components: {\n          ...incomingConfig.admin?.components,\n          afterDashboard: [\n            ...existingAfterDashboard,\n            '@trieb.work/payload-plugin-backup-mongodb/rsc#BackupDashboard',\n          ],\n        },\n      },\n      collections: [...existingCollections, BackupTasksCollection, BackupSettingsCollection],\n      endpoints: [...existingEndpoints, ...backupEndpoints],\n      onInit: async (payload) => {\n        await incomingConfig.onInit?.(payload)\n        try {\n          const existing = await payload.count({\n            collection: BACKUP_SETTINGS_SLUG,\n            overrideAccess: true,\n          })\n          if (existing.totalDocs === 0) {\n            await payload.create({\n              collection: BACKUP_SETTINGS_SLUG,\n              data: {\n                backupBlobAccess: null,\n                backupBlobReadWriteToken: '',\n                backupsToKeep: Number(process.env.BACKUPS_TO_KEEP) || 10,\n                includeMediaForCron: true,\n                skipMongoCollections: [],\n              },\n              overrideAccess: true,\n            })\n            payload.logger.info('[backup-plugin] Created default backup-settings document')\n          }\n        } catch (err) {\n          payload.logger.warn({ err }, '[backup-plugin] Could not ensure backup-settings document')\n        }\n        try {\n          if (payload.db.name === 'mongoose') {\n            const mongooseDb = payload.db as {\n              connection?: {\n                db?: {\n                  collection: (name: string) => {\n                    createIndex: (\n                      keys: Record<string, number>,\n                      options?: { background?: boolean; expireAfterSeconds?: number },\n                    ) => Promise<string>\n                  }\n                }\n              }\n            }\n            const db = mongooseDb.connection?.db\n            if (db) {\n              await db.collection('backup-tasks').createIndex(\n                { updatedAt: 1 },\n                { background: true, expireAfterSeconds: 1800 },\n              )\n            }\n          }\n        } catch {\n          payload.logger.warn('[backup-plugin] Could not create TTL index on backup-tasks')\n        }\n      },\n    }\n  }\n}\n"],"names":["BackupSettingsCollection","BackupTasksCollection","BACKUP_SETTINGS_SLUG","createBackupMongodbEndpoints","backupMongodbPlugin","options","incomingConfig","enabled","existingAfterDashboard","admin","components","afterDashboard","existingCollections","collections","existingEndpoints","endpoints","backupEndpoints","onInit","payload","existing","count","collection","overrideAccess","totalDocs","create","data","backupBlobAccess","backupBlobReadWriteToken","backupsToKeep","Number","process","env","BACKUPS_TO_KEEP","includeMediaForCron","skipMongoCollections","logger","info","err","warn","db","name","mongooseDb","connection","createIndex","updatedAt","background","expireAfterSeconds"],"mappings":"AAIA,SAASA,wBAAwB,QAAQ,+BAA8B;AACvE,SAASC,qBAAqB,QAAQ,4BAA2B;AACjE,SAASC,oBAAoB,QAAQ,wBAAuB;AAC5D,SAASC,4BAA4B,QAAQ,oBAAmB;AAEhE,OAAO,MAAMC,sBAAsB,CAACC,UAA+B,CAAC,CAAC;IACnE,OAAO,CAACC;QACN,IAAID,QAAQE,OAAO,KAAK,OAAO;YAC7B,OAAOD;QACT;QAEA,MAAME,yBAAyBF,eAAeG,KAAK,EAAEC,YAAYC,kBAAkB,EAAE;QACrF,MAAMC,sBAAsBN,eAAeO,WAAW,IAAI,EAAE;QAC5D,MAAMC,oBAAoBR,eAAeS,SAAS,IAAI,EAAE;QACxD,MAAMC,kBAAkBb,6BAA6BE;QAErD,OAAO;YACL,GAAGC,cAAc;YACjBG,OAAO;gBACL,GAAGH,eAAeG,KAAK;gBACvBC,YAAY;oBACV,GAAGJ,eAAeG,KAAK,EAAEC,UAAU;oBACnCC,gBAAgB;2BACXH;wBACH;qBACD;gBACH;YACF;YACAK,aAAa;mBAAID;gBAAqBX;gBAAuBD;aAAyB;YACtFe,WAAW;mBAAID;mBAAsBE;aAAgB;YACrDC,QAAQ,OAAOC;gBACb,MAAMZ,eAAeW,MAAM,GAAGC;gBAC9B,IAAI;oBACF,MAAMC,WAAW,MAAMD,QAAQE,KAAK,CAAC;wBACnCC,YAAYnB;wBACZoB,gBAAgB;oBAClB;oBACA,IAAIH,SAASI,SAAS,KAAK,GAAG;wBAC5B,MAAML,QAAQM,MAAM,CAAC;4BACnBH,YAAYnB;4BACZuB,MAAM;gCACJC,kBAAkB;gCAClBC,0BAA0B;gCAC1BC,eAAeC,OAAOC,QAAQC,GAAG,CAACC,eAAe,KAAK;gCACtDC,qBAAqB;gCACrBC,sBAAsB,EAAE;4BAC1B;4BACAZ,gBAAgB;wBAClB;wBACAJ,QAAQiB,MAAM,CAACC,IAAI,CAAC;oBACtB;gBACF,EAAE,OAAOC,KAAK;oBACZnB,QAAQiB,MAAM,CAACG,IAAI,CAAC;wBAAED;oBAAI,GAAG;gBAC/B;gBACA,IAAI;oBACF,IAAInB,QAAQqB,EAAE,CAACC,IAAI,KAAK,YAAY;wBAClC,MAAMC,aAAavB,QAAQqB,EAAE;wBAY7B,MAAMA,KAAKE,WAAWC,UAAU,EAAEH;wBAClC,IAAIA,IAAI;4BACN,MAAMA,GAAGlB,UAAU,CAAC,gBAAgBsB,WAAW,CAC7C;gCAAEC,WAAW;4BAAE,GACf;gCAAEC,YAAY;gCAAMC,oBAAoB;4BAAK;wBAEjD;oBACF;gBACF,EAAE,OAAM;oBACN5B,QAAQiB,MAAM,CAACG,IAAI,CAAC;gBACtB;YACF;QACF;IACF;AACF,EAAC"}

package/dist/publicApiPaths.d.ts

@@ -0,0 +1,19 @@
+/**
+ * Browser-facing paths for the backup plugin (Payload custom REST under default {@code /api}).
+ * Must stay in sync with {@link createBackupMongodbEndpoints} in `endpoints/index.ts`.
+ */
+export declare const backupPluginPublicApiPaths: {
+    readonly adminBackupDownload: "/api/backup-mongodb/admin/backup-download";
+    readonly adminBackupPreview: "/api/backup-mongodb/admin/backup-preview";
+    readonly adminDelete: "/api/backup-mongodb/admin/delete";
+    readonly adminManual: "/api/backup-mongodb/admin/manual";
+    readonly adminRestore: "/api/backup-mongodb/admin/restore";
+    readonly adminRestorePreview: "/api/backup-mongodb/admin/restore-preview";
+    readonly adminSeed: "/api/backup-mongodb/admin/seed";
+    readonly adminSettings: "/api/backup-mongodb/admin/settings";
+    readonly adminTask: (id: string) => string;
+    readonly adminValidateBlobToken: "/api/backup-mongodb/admin/validate-blob-token";
+    readonly cron: "/api/backup-mongodb/cron/run";
+    readonly cronRestore: "/api/backup-mongodb/cron/restore";
+    readonly list: "/api/backup-mongodb/cron/list";
+};

package/dist/publicApiPaths.js

@@ -0,0 +1,20 @@
+/**
+ * Browser-facing paths for the backup plugin (Payload custom REST under default {@code /api}).
+ * Must stay in sync with {@link createBackupMongodbEndpoints} in `endpoints/index.ts`.
+ */ export const backupPluginPublicApiPaths = {
+    adminBackupDownload: '/api/backup-mongodb/admin/backup-download',
+    adminBackupPreview: '/api/backup-mongodb/admin/backup-preview',
+    adminDelete: '/api/backup-mongodb/admin/delete',
+    adminManual: '/api/backup-mongodb/admin/manual',
+    adminRestore: '/api/backup-mongodb/admin/restore',
+    adminRestorePreview: '/api/backup-mongodb/admin/restore-preview',
+    adminSeed: '/api/backup-mongodb/admin/seed',
+    adminSettings: '/api/backup-mongodb/admin/settings',
+    adminTask: (id)=>`/api/backup-mongodb/admin/task/${encodeURIComponent(id)}`,
+    adminValidateBlobToken: '/api/backup-mongodb/admin/validate-blob-token',
+    cron: '/api/backup-mongodb/cron/run',
+    cronRestore: '/api/backup-mongodb/cron/restore',
+    list: '/api/backup-mongodb/cron/list'
+};
+
+//# sourceMappingURL=publicApiPaths.js.map

package/dist/publicApiPaths.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/publicApiPaths.ts"],"sourcesContent":["/**\n * Browser-facing paths for the backup plugin (Payload custom REST under default {@code /api}).\n * Must stay in sync with {@link createBackupMongodbEndpoints} in `endpoints/index.ts`.\n */\nexport const backupPluginPublicApiPaths = {\n  adminBackupDownload: '/api/backup-mongodb/admin/backup-download',\n  adminBackupPreview: '/api/backup-mongodb/admin/backup-preview',\n  adminDelete: '/api/backup-mongodb/admin/delete',\n  adminManual: '/api/backup-mongodb/admin/manual',\n  adminRestore: '/api/backup-mongodb/admin/restore',\n  adminRestorePreview: '/api/backup-mongodb/admin/restore-preview',\n  adminSeed: '/api/backup-mongodb/admin/seed',\n  adminSettings: '/api/backup-mongodb/admin/settings',\n  adminTask: (id: string) => `/api/backup-mongodb/admin/task/${encodeURIComponent(id)}`,\n  adminValidateBlobToken: '/api/backup-mongodb/admin/validate-blob-token',\n  cron: '/api/backup-mongodb/cron/run',\n  cronRestore: '/api/backup-mongodb/cron/restore',\n  list: '/api/backup-mongodb/cron/list',\n} as const\n"],"names":["backupPluginPublicApiPaths","adminBackupDownload","adminBackupPreview","adminDelete","adminManual","adminRestore","adminRestorePreview","adminSeed","adminSettings","adminTask","id","encodeURIComponent","adminValidateBlobToken","cron","cronRestore","list"],"mappings":"AAAA;;;CAGC,GACD,OAAO,MAAMA,6BAA6B;IACxCC,qBAAqB;IACrBC,oBAAoB;IACpBC,aAAa;IACbC,aAAa;IACbC,cAAc;IACdC,qBAAqB;IACrBC,WAAW;IACXC,eAAe;IACfC,WAAW,CAACC,KAAe,CAAC,+BAA+B,EAAEC,mBAAmBD,KAAK;IACrFE,wBAAwB;IACxBC,MAAM;IACNC,aAAa;IACbC,MAAM;AACR,EAAU"}

package/dist/types.d.ts

@@ -0,0 +1,21 @@
+export type BackupPluginOptions = {
+    /**
+     * Custom access control function. Receives the user object from Payload and returns true
+     * if the user is allowed to see/use the backup dashboard.
+     *
+     * When omitted, visibility falls back to the `PAYLOAD_BACKUP_ALLOWED_ROLES` env var
+     * (comma-separated role slugs, or `*` for any authenticated user). If that env var is
+     * also unset, the historical default applies: user has a role with slug `admin`, or —
+     * for users collections that have no `roles` field — any authenticated user.
+     */
+    access?: (user: null | Record<string, unknown>) => boolean;
+    /** Number of automatic (cron) backups to keep. Default: process.env.BACKUPS_TO_KEEP or 10 */
+    backupsToKeep?: number;
+    /** Enable/disable the plugin entirely. Default: true */
+    enabled?: boolean;
+    /**
+     * When set, registers POST {@code /api/backup-mongodb/admin/seed} (demo DB + media seed).
+     * Omit to disable the seed endpoint entirely.
+     */
+    seedDemoDumpUrl?: string;
+};

package/dist/types.js

@@ -0,0 +1,3 @@
+export { };
+
+//# sourceMappingURL=types.js.map

package/dist/types.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/types.ts"],"sourcesContent":["export type BackupPluginOptions = {\n  /**\n   * Custom access control function. Receives the user object from Payload and returns true\n   * if the user is allowed to see/use the backup dashboard.\n   *\n   * When omitted, visibility falls back to the `PAYLOAD_BACKUP_ALLOWED_ROLES` env var\n   * (comma-separated role slugs, or `*` for any authenticated user). If that env var is\n   * also unset, the historical default applies: user has a role with slug `admin`, or —\n   * for users collections that have no `roles` field — any authenticated user.\n   */\n  access?: (user: null | Record<string, unknown>) => boolean\n  /** Number of automatic (cron) backups to keep. Default: process.env.BACKUPS_TO_KEEP or 10 */\n  backupsToKeep?: number\n  /** Enable/disable the plugin entirely. Default: true */\n  enabled?: boolean\n  /**\n   * When set, registers POST {@code /api/backup-mongodb/admin/seed} (demo DB + media seed).\n   * Omit to disable the seed endpoint entirely.\n   */\n  seedDemoDumpUrl?: string\n}\n"],"names":[],"mappings":"AAAA,WAoBC"}

package/dist/utils/backupSelection.d.ts

@@ -0,0 +1,6 @@
+import type { BackupSourcePreviewResponse } from '../core/backupSourcePreview';
+export declare function skipMongoNamesFromPreview(preview: BackupSourcePreviewResponse, selected: Record<string, boolean>): string[];
+/**
+ * Derives checkbox state from stored Mongo collection names to skip (cron / settings).
+ */
+export declare function selectedFromSkipMongoNames(preview: BackupSourcePreviewResponse, skipMongoNames: string[]): Record<string, boolean>;

package/dist/utils/backupSelection.js

@@ -0,0 +1,16 @@
+export function skipMongoNamesFromPreview(preview, selected) {
+    return preview.groups.filter((g)=>selected[g.groupId] === false).flatMap((g)=>g.mongoNames);
+}
+/**
+ * Derives checkbox state from stored Mongo collection names to skip (cron / settings).
+ */ export function selectedFromSkipMongoNames(preview, skipMongoNames) {
+    const skip = new Set(skipMongoNames);
+    const selected = {};
+    for (const g of preview.groups){
+        const allSkipped = g.mongoNames.length > 0 && g.mongoNames.every((m)=>skip.has(m));
+        selected[g.groupId] = !allSkipped;
+    }
+    return selected;
+}
+
+//# sourceMappingURL=backupSelection.js.map

package/dist/utils/backupSelection.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/utils/backupSelection.ts"],"sourcesContent":["import type { BackupSourcePreviewResponse } from '../core/backupSourcePreview'\n\nexport function skipMongoNamesFromPreview(\n  preview: BackupSourcePreviewResponse,\n  selected: Record<string, boolean>,\n): string[] {\n  return preview.groups.filter((g) => selected[g.groupId] === false).flatMap((g) => g.mongoNames)\n}\n\n/**\n * Derives checkbox state from stored Mongo collection names to skip (cron / settings).\n */\nexport function selectedFromSkipMongoNames(\n  preview: BackupSourcePreviewResponse,\n  skipMongoNames: string[],\n): Record<string, boolean> {\n  const skip = new Set(skipMongoNames)\n  const selected: Record<string, boolean> = {}\n  for (const g of preview.groups) {\n    const allSkipped = g.mongoNames.length > 0 && g.mongoNames.every((m) => skip.has(m))\n    selected[g.groupId] = !allSkipped\n  }\n  return selected\n}\n"],"names":["skipMongoNamesFromPreview","preview","selected","groups","filter","g","groupId","flatMap","mongoNames","selectedFromSkipMongoNames","skipMongoNames","skip","Set","allSkipped","length","every","m","has"],"mappings":"AAEA,OAAO,SAASA,0BACdC,OAAoC,EACpCC,QAAiC;IAEjC,OAAOD,QAAQE,MAAM,CAACC,MAAM,CAAC,CAACC,IAAMH,QAAQ,CAACG,EAAEC,OAAO,CAAC,KAAK,OAAOC,OAAO,CAAC,CAACF,IAAMA,EAAEG,UAAU;AAChG;AAEA;;CAEC,GACD,OAAO,SAASC,2BACdR,OAAoC,EACpCS,cAAwB;IAExB,MAAMC,OAAO,IAAIC,IAAIF;IACrB,MAAMR,WAAoC,CAAC;IAC3C,KAAK,MAAMG,KAAKJ,QAAQE,MAAM,CAAE;QAC9B,MAAMU,aAAaR,EAAEG,UAAU,CAACM,MAAM,GAAG,KAAKT,EAAEG,UAAU,CAACO,KAAK,CAAC,CAACC,IAAML,KAAKM,GAAG,CAACD;QACjFd,QAAQ,CAACG,EAAEC,OAAO,CAAC,GAAG,CAACO;IACzB;IACA,OAAOX;AACT"}

package/dist/utils/blobName.d.ts

@@ -0,0 +1,32 @@
+/** Max length for a user-supplied manual backup label (after sanitization). */
+export declare const BACKUP_LABEL_MAX_LENGTH = 64;
+/**
+ * Normalize a user-supplied manual backup label so it is safe to embed as a
+ * blob-name segment. Trims, collapses whitespace, removes characters that would
+ * confuse the separator, and enforces {@link BACKUP_LABEL_MAX_LENGTH}.
+ * Returns an empty string when nothing usable remains.
+ */
+export declare function sanitizeBackupLabel(raw: unknown): string;
+export interface TransformBlobNameResult {
+    collectionCount?: number;
+    date: string;
+    dbName: string;
+    fileType: 'json' | 'na' | 'tar.gz';
+    hostname: string;
+    label?: string;
+    type: string;
+}
+export declare function transformBlobName(blobName: string): TransformBlobNameResult;
+/**
+ * Backup blob pathname segment (without `backups/` prefix or extension).
+ * New format: `{collectionCount}-{timestampMs}` encodes included collection count + backup time.
+ * When a non-empty `label` is supplied it is appended as a separate URL-encoded segment
+ * (`---{encodedLabel}`) so older parsers that only read the first 4 segments still work.
+ */
+export declare function createBlobName(type: string, dbName: string, hostname: string, collectionCount: number, timestampMs: number, fileType: 'json' | 'tar.gz', label?: string): string;
+/**
+ * Prefer timestamp encoded in filename (stable across blob store migration); else blob upload time.
+ * Legacy tails are digits-only epoch values; if {@link TransformBlobNameResult.collectionCount}
+ * is absent, values below 1e12 are treated as **Unix seconds** (common older convention), else ms.
+ */
+export declare function getBackupSortTimeMs(parsed: TransformBlobNameResult, uploadedAt: Date): number;