@easy-cms/core 0.31.0 → 0.32.0

package/dist/index.js

@@ -116,10 +116,10 @@ function cleanPermissions(value, known) {
   const pick = (group, slugs, operations) => {
     const out = {};
     if (typeof group !== "object" || group === null) return out;
-    for (const [slug, ops] of Object.entries(group)) {
-      if (!slugs.includes(slug) || API_KEY_EXCLUDED.has(slug) || !Array.isArray(ops)) continue;
+    for (const [slug2, ops] of Object.entries(group)) {
+      if (!slugs.includes(slug2) || API_KEY_EXCLUDED.has(slug2) || !Array.isArray(ops)) continue;
       const valid = operations.filter((op) => ops.includes(op));
-      if (valid.length) out[slug] = valid;
+      if (valid.length) out[slug2] = valid;
     }
     return out;
   };
@@ -293,22 +293,22 @@ async function stripFields(fields, doc, read2) {
   }
   return result;
 }
-async function filterInput(fields, data, update) {
+async function filterInput(fields, data, update2) {
   const result = { ...data };
   for (const field of fields) {
     if (!(field.name in result)) continue;
-    if (field.hidden || update && !await update.allows(field)) {
+    if (field.hidden || update2 && !await update2.allows(field)) {
       delete result[field.name];
       continue;
     }
     const value = result[field.name];
     if (field.type === "group" && value && typeof value === "object" && !Array.isArray(value)) {
-      result[field.name] = await filterInput(field.fields, value, update);
+      result[field.name] = await filterInput(field.fields, value, update2);
     } else if (hasRows(field) && Array.isArray(value)) {
       result[field.name] = await Promise.all(
         value.map((row) => {
           const fields2 = rowFields(field, row);
-          return fields2 && row && typeof row === "object" ? filterInput(fields2, row, update) : row;
+          return fields2 && row && typeof row === "object" ? filterInput(fields2, row, update2) : row;
         })
       );
     }
@@ -325,13 +325,15 @@ var VERSIONS = "document-versions";
 var SCHEDULED_JOBS = "scheduled-jobs";
 var WEBHOOK_DELIVERIES = "webhook-deliveries";
 var EMAIL_DELIVERIES = "email-deliveries";
+var DATABASE_BACKUPS = "database-backups";
 var INTERNAL_COLLECTIONS = /* @__PURE__ */ new Set([
   SESSIONS,
   LOGIN_ATTEMPTS,
   VERSIONS,
   SCHEDULED_JOBS,
   WEBHOOK_DELIVERIES,
-  EMAIL_DELIVERIES
+  EMAIL_DELIVERIES,
+  DATABASE_BACKUPS
 ]);
 var DEFAULT_ROLES = ["admin", "editor"];
 var adminOrSelf = ({ user }) => {
@@ -546,6 +548,25 @@ var webhookDeliveriesCollection = {
     { name: "error", type: "text" }
   ]
 };
+var databaseBackupsCollection = {
+  slug: DATABASE_BACKUPS,
+  access: { read: nobody, create: nobody, update: nobody, delete: nobody },
+  fields: [
+    // pending | running | done | failed
+    { name: "state", type: "text", required: true, index: true },
+    // manual | scheduled
+    { name: "trigger", type: "text", required: true },
+    { name: "filename", type: "text" },
+    { name: "size", type: "number" },
+    { name: "startedAt", type: "text", index: true },
+    { name: "finishedAt", type: "text" },
+    { name: "error", type: "text" },
+    // Who started it (email), for manual ones.
+    { name: "author", type: "text" },
+    { name: "downloadedBy", type: "text" },
+    { name: "downloadedAt", type: "text" }
+  ]
+};
 var emailDeliveriesCollection = {
   slug: EMAIL_DELIVERIES,
   access: { read: nobody, create: nobody, update: nobody, delete: nobody },
@@ -1089,6 +1110,386 @@ var Auth = class {
   }
 };
 
+// src/backups.ts
+import { mkdtemp, readFile as readFile2, rm as rm2 } from "fs/promises";
+import { tmpdir } from "os";
+import { join as join2 } from "path";
+import { promisify } from "util";
+import { gzip } from "zlib";
+
+// src/copy.ts
+var BATCH = 200;
+async function copyDatabase(source, target, options = {}) {
+  const from = source.transfer;
+  const to = target.transfer;
+  if (!from || !to) throw new EasyCMSError("This database adapter cannot copy databases", 400);
+  if (from.schemaHash !== to.schemaHash) {
+    throw new EasyCMSError(
+      "The two configs describe different collections or fields. Copy between configs with the same collections (import one config into the other and change only `db`).",
+      400
+    );
+  }
+  const tables = from.tables();
+  for (const table of tables) {
+    if (await to.count(table) > 0) {
+      throw new EasyCMSError(
+        `The target database is not empty ("${table}" has rows). Copy into a new, empty database.`,
+        400
+      );
+    }
+  }
+  let total = 0;
+  for (const table of tables) {
+    let copied = 0;
+    for (; ; ) {
+      const rows = await from.read(table, copied, BATCH);
+      if (rows.length === 0) break;
+      await to.write(table, rows);
+      copied += rows.length;
+      if (rows.length < BATCH) break;
+    }
+    total += copied;
+    options.onTable?.({ table, rows: copied });
+  }
+  await to.finish();
+  return { tables: tables.length, rows: total };
+}
+
+// src/storage.ts
+import { mkdir, readFile, rm, stat, writeFile } from "fs/promises";
+import { dirname, isAbsolute, join, normalize, resolve, sep } from "path";
+function localStorage(options = {}) {
+  let root = resolve(
+    /* turbopackIgnore: true */
+    options.dir ?? "uploads"
+  );
+  const pathOf = (key2) => {
+    const path = normalize(join(
+      /* turbopackIgnore: true */
+      root,
+      key2
+    ));
+    if (!path.startsWith(root + sep)) throw new Error(`Invalid storage key "${key2}"`);
+    return path;
+  };
+  return {
+    name: "local",
+    init({ cwd }) {
+      const dir = options.dir ?? "uploads";
+      root = isAbsolute(dir) ? dir : resolve(
+        /* turbopackIgnore: true */
+        cwd,
+        dir
+      );
+    },
+    async put(key2, data) {
+      const path = pathOf(key2);
+      await mkdir(dirname(path), { recursive: true });
+      await writeFile(path, data, { flag: "wx" });
+    },
+    async get(key2) {
+      const path = pathOf(key2);
+      const info = await stat(path).catch(() => void 0);
+      if (!info?.isFile()) return null;
+      return { body: new Uint8Array(await readFile(path)), size: info.size };
+    },
+    async delete(key2) {
+      await rm(pathOf(key2), { force: true });
+    }
+  };
+}
+
+// src/backups.ts
+var gzipAsync = promisify(gzip);
+var DEFAULT_BACKUP_TIME = "03:00";
+var DEFAULT_BACKUP_KEEP = 7;
+var DEFAULT_DIR = "backups";
+var STALE = 30 * 6e4;
+var PERIOD = { day: 864e5, week: 7 * 864e5 };
+var storages = /* @__PURE__ */ new WeakMap();
+function backupStorage(cms) {
+  let storage = storages.get(cms);
+  if (!storage) {
+    storage = (async () => {
+      const config = cms.config.backups;
+      const adapter = config?.storage ?? localStorage({ dir: config?.dir ?? DEFAULT_DIR });
+      await adapter.init?.({ cwd: cms.cwd });
+      return adapter;
+    })();
+    storages.set(cms, storage);
+  }
+  return storage;
+}
+function backupUnavailable(cms) {
+  if (cms.db.backup || cms.config.backups?.sqlite) return null;
+  return `The ${cms.config.db.name} database needs the SQLite adapter to write backups: backups: { sqlite } with sqlite from @easy-cms/db-sqlite`;
+}
+async function writeBackupFile(cms, file) {
+  if (cms.db.backup) return cms.db.backup(file);
+  const factory = cms.config.backups?.sqlite;
+  if (!factory) throw new EasyCMSError(backupUnavailable(cms), 400);
+  const prefix = cms.db.tablePrefix;
+  const scratch = `${file}.copy`;
+  const adapter = factory({ url: `file:${scratch}`, ...prefix ? { tablePrefix: prefix } : {} });
+  const target = await adapter.init({
+    config: { ...cms.config, db: adapter },
+    cwd: cms.cwd,
+    schema: "push",
+    logger: { ...cms.logger, info() {
+    } }
+  });
+  try {
+    await copyDatabase(cms.db, target);
+    if (!target.backup) throw new EasyCMSError("backups.sqlite must be the SQLite adapter", 400);
+    await target.backup(file);
+  } finally {
+    await target.destroy();
+    for (const suffix of ["", "-wal", "-shm"])
+      await rm2(`${scratch}${suffix}`, { force: true }).catch(() => {
+      });
+  }
+}
+var slug = (text) => text.normalize("NFKD").toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "").slice(0, 40) || "easy-cms";
+function filenameFor(cms, date) {
+  const pad = (n) => String(n).padStart(2, "0");
+  const stamp = `${date.getFullYear()}-${pad(date.getMonth() + 1)}-${pad(date.getDate())}-${pad(date.getHours())}${pad(date.getMinutes())}`;
+  return `${slug(cms.config.admin.brand.name || "easy-cms")}-${stamp}.db.gz`;
+}
+function toAdmin(row) {
+  const text = (value) => typeof value === "string" && value !== "" ? value : null;
+  return {
+    id: row.id,
+    state: ["pending", "running", "done", "failed"].includes(row.state) ? row.state : "failed",
+    trigger: row.trigger === "scheduled" ? "scheduled" : "manual",
+    filename: text(row.filename),
+    size: typeof row.size === "number" ? row.size : null,
+    startedAt: text(row.startedAt),
+    finishedAt: text(row.finishedAt),
+    error: text(row.error),
+    author: text(row.author),
+    downloadedBy: text(row.downloadedBy),
+    downloadedAt: text(row.downloadedAt)
+  };
+}
+async function update(cms, row, data) {
+  const { id, ...rest } = row;
+  const next = { ...rest, ...data, updatedAt: (/* @__PURE__ */ new Date()).toISOString() };
+  await cms.db.update({ collection: DATABASE_BACKUPS, id, data: next });
+  return { ...row, ...data };
+}
+async function listBackups(cms) {
+  const config = cms.config.backups;
+  const storage = await backupStorage(cms);
+  const { docs } = await cms.db.find({
+    collection: DATABASE_BACKUPS,
+    sort: ["-createdAt"],
+    limit: 0,
+    page: 1
+  });
+  return {
+    settings: {
+      every: config?.every ?? null,
+      at: config?.at ?? DEFAULT_BACKUP_TIME,
+      keep: config?.keep ?? DEFAULT_BACKUP_KEEP,
+      storage: storage.name,
+      dir: config?.storage ? null : config?.dir ?? DEFAULT_DIR,
+      database: cms.config.db.name,
+      unavailable: backupUnavailable(cms)
+    },
+    backups: docs.map(toAdmin)
+  };
+}
+async function inProgress(cms, now) {
+  const { docs } = await cms.db.find({
+    collection: DATABASE_BACKUPS,
+    where: { state: { in: ["pending", "running"] } },
+    sort: ["-createdAt"],
+    limit: 10,
+    page: 1
+  });
+  return docs.find((row) => now - Date.parse(String(row.createdAt)) < STALE);
+}
+async function startBackup(cms, trigger, author) {
+  const unavailable = backupUnavailable(cms);
+  if (unavailable) throw new EasyCMSError(unavailable, 400);
+  const now = /* @__PURE__ */ new Date();
+  if (await inProgress(cms, now.getTime()))
+    throw new EasyCMSError("A backup is already running", 409);
+  const stamp = now.toISOString();
+  const row = await cms.db.create({
+    collection: DATABASE_BACKUPS,
+    data: {
+      state: "pending",
+      trigger,
+      filename: null,
+      size: null,
+      startedAt: null,
+      finishedAt: null,
+      error: null,
+      author: author ?? null,
+      downloadedBy: null,
+      downloadedAt: null,
+      createdAt: stamp,
+      updatedAt: stamp
+    }
+  });
+  void runBackup(cms, row).catch(
+    (error) => cms.logger.error(`Backup failed: ${error.message}`)
+  );
+  return toAdmin(row);
+}
+async function runBackup(cms, record) {
+  const started = /* @__PURE__ */ new Date();
+  let row = await update(cms, record, { state: "running", startedAt: started.toISOString() });
+  const dir = await mkdtemp(join2(tmpdir(), "easy-cms-backup-"));
+  try {
+    const file = join2(dir, "backup.db");
+    await writeBackupFile(cms, file);
+    const data = new Uint8Array(await gzipAsync(await readFile2(file)));
+    const storage = await backupStorage(cms);
+    const filename = filenameFor(cms, started);
+    const key2 = await storage.get(filename) ? filename.replace(/\.db\.gz$/, `-${row.id}.db.gz`) : filename;
+    await storage.put(key2, data, { contentType: "application/gzip" });
+    row = await update(cms, row, {
+      state: "done",
+      filename: key2,
+      size: data.byteLength,
+      finishedAt: (/* @__PURE__ */ new Date()).toISOString()
+    });
+    cms.logger.info(`Backup ${key2} written (${data.byteLength} bytes)`);
+    await pruneBackups(cms);
+  } catch (error) {
+    await update(cms, row, {
+      state: "failed",
+      error: (error.message || String(error)).slice(0, 500),
+      finishedAt: (/* @__PURE__ */ new Date()).toISOString()
+    });
+    throw error;
+  } finally {
+    await rm2(dir, { recursive: true, force: true });
+  }
+}
+async function pruneBackups(cms) {
+  const keep = cms.config.backups?.keep ?? DEFAULT_BACKUP_KEEP;
+  const storage = await backupStorage(cms);
+  const { docs } = await cms.db.find({
+    collection: DATABASE_BACKUPS,
+    where: { state: { equals: "done" } },
+    sort: ["-createdAt"],
+    limit: 0,
+    page: 1
+  });
+  for (const row of docs.slice(keep)) {
+    if (typeof row.filename === "string") await storage.delete(row.filename).catch(() => {
+    });
+    await cms.db.delete({ collection: DATABASE_BACKUPS, id: row.id });
+  }
+  const old = new Date(Date.now() - 30 * 864e5).toISOString();
+  const failed = await cms.db.find({
+    collection: DATABASE_BACKUPS,
+    where: { and: [{ state: { equals: "failed" } }, { createdAt: { lt: old } }] },
+    sort: ["createdAt"],
+    limit: 100,
+    page: 1
+  });
+  for (const row of failed.docs) await cms.db.delete({ collection: DATABASE_BACKUPS, id: row.id });
+}
+function lastSlot(now, at) {
+  const [hours2, minutes] = at.split(":").map(Number);
+  const slot = new Date(now);
+  slot.setHours(hours2, minutes, 0, 0);
+  if (slot.getTime() > now.getTime()) slot.setDate(slot.getDate() - 1);
+  return slot;
+}
+async function runDueBackups(cms, now = /* @__PURE__ */ new Date()) {
+  if (backupUnavailable(cms)) return;
+  const { docs } = await cms.db.find({
+    collection: DATABASE_BACKUPS,
+    where: { state: { in: ["pending", "running"] } },
+    sort: ["createdAt"],
+    limit: 10,
+    page: 1
+  });
+  for (const row of docs) {
+    const age = now.getTime() - Date.parse(String(row.updatedAt ?? row.createdAt));
+    if (age < STALE) continue;
+    if (row.state === "pending") await runBackup(cms, row).catch(() => {
+    });
+    else
+      await update(cms, row, {
+        state: "failed",
+        error: "Interrupted: the server stopped during the backup",
+        finishedAt: now.toISOString()
+      });
+  }
+  const every = cms.config.backups?.every;
+  if (!every) return;
+  const slot = lastSlot(now, cms.config.backups?.at ?? DEFAULT_BACKUP_TIME);
+  const latest = await cms.db.find({
+    collection: DATABASE_BACKUPS,
+    where: { trigger: { equals: "scheduled" } },
+    sort: ["-createdAt"],
+    limit: 1,
+    page: 1
+  });
+  const last = latest.docs[0] ? Date.parse(String(latest.docs[0].createdAt)) : 0;
+  const due = every === "day" ? last < slot.getTime() : last < slot.getTime() - PERIOD.week + PERIOD.day;
+  if (!due) return;
+  if (await inProgress(cms, now.getTime())) return;
+  await startBackup(cms, "scheduled").catch(
+    (error) => cms.logger.error(`Scheduled backup could not start: ${error.message}`)
+  );
+}
+async function backupAttention(cms, now = Date.now()) {
+  const every = cms.config.backups?.every;
+  if (!every) return null;
+  const [scheduled, done] = await Promise.all([
+    cms.db.find({
+      collection: DATABASE_BACKUPS,
+      where: { trigger: { equals: "scheduled" } },
+      sort: ["-createdAt"],
+      limit: 1,
+      page: 1
+    }),
+    cms.db.find({
+      collection: DATABASE_BACKUPS,
+      where: { state: { equals: "done" } },
+      sort: ["-createdAt"],
+      limit: 1,
+      page: 1
+    })
+  ]);
+  const failed = scheduled.docs[0]?.state === "failed";
+  const lastDone = done.docs[0] ? String(done.docs[0].createdAt) : null;
+  let since = lastDone ? Date.parse(lastDone) : void 0;
+  if (since === void 0) {
+    const first = await cms.db.find({ collection: USERS, sort: ["createdAt"], limit: 1, page: 1 });
+    since = first.docs[0] ? Date.parse(String(first.docs[0].createdAt)) : now;
+  }
+  const overdue = now - since > 2 * PERIOD[every];
+  return failed || overdue ? { id: "backups", failed, lastDone } : null;
+}
+async function downloadBackup(cms, id, by) {
+  const row = await cms.db.findById({ collection: DATABASE_BACKUPS, id });
+  if (row?.state !== "done" || typeof row.filename !== "string")
+    throw new NotFoundError(DATABASE_BACKUPS, id);
+  const file = await (await backupStorage(cms)).get(row.filename);
+  if (!file)
+    throw new EasyCMSError(`The file ${row.filename} is no longer in the backup storage`, 404);
+  await update(cms, row, { downloadedBy: by, downloadedAt: (/* @__PURE__ */ new Date()).toISOString() });
+  return { filename: row.filename, body: file.body };
+}
+async function deleteBackup(cms, id) {
+  const row = await cms.db.findById({ collection: DATABASE_BACKUPS, id });
+  if (!row) throw new NotFoundError(DATABASE_BACKUPS, id);
+  if (row.state === "running" || row.state === "pending")
+    throw new EasyCMSError("A backup in progress cannot be deleted", 409);
+  if (typeof row.filename === "string")
+    await (await backupStorage(cms)).delete(row.filename).catch(() => {
+    });
+  await cms.db.delete({ collection: DATABASE_BACKUPS, id });
+}
+
 // src/config.ts
 var ADMIN_ICONS = [
   "file-text",
@@ -1175,44 +1576,6 @@ function configSignature(config) {
 }
 var signatures = /* @__PURE__ */ new WeakMap();
 
-// src/copy.ts
-var BATCH = 200;
-async function copyDatabase(source, target, options = {}) {
-  const from = source.transfer;
-  const to = target.transfer;
-  if (!from || !to) throw new EasyCMSError("This database adapter cannot copy databases", 400);
-  if (from.schemaHash !== to.schemaHash) {
-    throw new EasyCMSError(
-      "The two configs describe different collections or fields. Copy between configs with the same collections (import one config into the other and change only `db`).",
-      400
-    );
-  }
-  const tables = from.tables();
-  for (const table of tables) {
-    if (await to.count(table) > 0) {
-      throw new EasyCMSError(
-        `The target database is not empty ("${table}" has rows). Copy into a new, empty database.`,
-        400
-      );
-    }
-  }
-  let total = 0;
-  for (const table of tables) {
-    let copied = 0;
-    for (; ; ) {
-      const rows = await from.read(table, copied, BATCH);
-      if (rows.length === 0) break;
-      await to.write(table, rows);
-      copied += rows.length;
-      if (rows.length < BATCH) break;
-    }
-    total += copied;
-    options.onTable?.({ table, rows: copied });
-  }
-  await to.finish();
-  return { tables: tables.length, rows: total };
-}
-
 // src/document.ts
 import { randomUUID } from "crypto";
 var EMAIL_PATTERN = /^[^\s@]+@[^\s@]+\.[^\s@]+$/;
@@ -1802,7 +2165,7 @@ function applyFieldTypes(config) {
 
 // src/load-config.ts
 import { existsSync } from "fs";
-import { resolve } from "path";
+import { resolve as resolve2 } from "path";
 import { createJiti } from "jiti";
 
 // src/webhooks.ts
@@ -1994,6 +2357,8 @@ var RESERVED_SLUGS = /* @__PURE__ */ new Set([
   "document-versions",
   "scheduled-jobs",
   "webhook-deliveries",
+  "email-deliveries",
+  "database-backups",
   "api-keys",
   "jobs",
   "migrations",
@@ -2016,6 +2381,7 @@ function validateConfig(config) {
   validateAdmin(config, add);
   validateAdminViews(config, add);
   validateUpload(config, add);
+  validateBackups(config, add);
   validateAuth(config, add);
   validateCors(config.cors, add);
   validateLocalization(config, add);
@@ -2025,17 +2391,17 @@ function validateConfig(config) {
   const collectionSlugs = /* @__PURE__ */ new Set([...BUILTIN_COLLECTIONS]);
   const seenCollections = /* @__PURE__ */ new Set();
   collections.forEach((collection2, i) => {
-    const slug = checkSlug(collection2, `collections[${i}]`, seenCollections, add);
-    if (slug) collectionSlugs.add(slug);
+    const slug2 = checkSlug(collection2, `collections[${i}]`, seenCollections, add);
+    if (slug2) collectionSlugs.add(slug2);
   });
   const menu = config.admin?.menu;
   if (menu !== void 0) {
     if (!Array.isArray(menu)) {
       add("admin.menu", "must be an array of collection slugs", "e.g. menu: ['posts', 'media']");
     } else {
-      for (const [i, slug] of menu.entries()) {
-        if (typeof slug !== "string" || !collectionSlugs.has(slug))
-          add(`admin.menu[${i}]`, `unknown collection ${JSON.stringify(slug)}`);
+      for (const [i, slug2] of menu.entries()) {
+        if (typeof slug2 !== "string" || !collectionSlugs.has(slug2))
+          add(`admin.menu[${i}]`, `unknown collection ${JSON.stringify(slug2)}`);
       }
     }
   }
@@ -2376,10 +2742,10 @@ function validateWebhooks(config, add) {
       if (!WEBHOOK_EVENTS.includes(event))
         add(`${path}.events`, `unknown event "${event}"`, `use: ${WEBHOOK_EVENTS.join(", ")}`);
     }
-    for (const slug of hook?.collections ?? [])
-      if (!collections.has(slug)) add(`${path}.collections`, `unknown collection "${slug}"`);
-    for (const slug of hook?.globals ?? [])
-      if (!globals.has(slug)) add(`${path}.globals`, `unknown global "${slug}"`);
+    for (const slug2 of hook?.collections ?? [])
+      if (!collections.has(slug2)) add(`${path}.collections`, `unknown collection "${slug2}"`);
+    for (const slug2 of hook?.globals ?? [])
+      if (!globals.has(slug2)) add(`${path}.globals`, `unknown global "${slug2}"`);
   }
 }
 function validateCors(cors, add) {
@@ -2432,6 +2798,32 @@ function validateUpload(config, add) {
     add("upload.fromURL.allowPrivate", "must be true or false");
 }
 var HOST_PATTERN = /^(\*|(\*\.)?[a-z0-9]([a-z0-9-]*[a-z0-9])?(\.[a-z0-9]([a-z0-9-]*[a-z0-9])?)*)$/i;
+function validateBackups(config, add) {
+  const backups = config.backups;
+  if (backups === void 0) return;
+  if (typeof backups !== "object" || backups === null) {
+    add("backups", "must be an object", "e.g. backups: { every: 'day', keep: 7 }");
+    return;
+  }
+  const { every, at, keep, dir, storage, sqlite } = backups;
+  if (every !== void 0 && every !== "day" && every !== "week")
+    add("backups.every", 'must be "day" or "week"');
+  if (at !== void 0 && (typeof at !== "string" || !/^([01]\d|2[0-3]):[0-5]\d$/.test(at)))
+    add("backups.at", 'must be a time like "03:00"');
+  if (keep !== void 0 && !(Number.isInteger(keep) && keep >= 1))
+    add("backups.keep", "must be a whole number, 1 or more");
+  if (dir !== void 0 && (typeof dir !== "string" || dir.trim() === ""))
+    add("backups.dir", "must be a folder name");
+  if (typeof dir === "string" && dir.replace(/^\.\//, "").replace(/\/+$/, "") === (config.upload?.dir ?? "uploads").replace(/^\.\//, "").replace(/\/+$/, ""))
+    add("backups.dir", "must not be the uploads folder: uploads are served publicly");
+  if (storage !== void 0 && (typeof storage !== "object" || storage === null || typeof storage.put !== "function"))
+    add("backups.storage", "must be a storage adapter, e.g. s3Storage()");
+  if (sqlite !== void 0 && typeof sqlite !== "function")
+    add(
+      "backups.sqlite",
+      "must be the sqlite adapter, e.g. import { sqlite } from '@easy-cms/db-sqlite'"
+    );
+}
 function asArray(value, path, add) {
   if (value === void 0) return [];
   if (!Array.isArray(value)) {
@@ -2441,24 +2833,24 @@ function asArray(value, path, add) {
   return value;
 }
 function checkSlug(container, path, seen, add) {
-  const slug = container.slug;
-  if (typeof slug !== "string" || !SLUG_PATTERN.test(slug)) {
+  const slug2 = container.slug;
+  if (typeof slug2 !== "string" || !SLUG_PATTERN.test(slug2)) {
     add(
       `${path}.slug`,
-      `must be lowercase letters, digits, "-" or "_", starting with a letter (got ${JSON.stringify(slug)})`
+      `must be lowercase letters, digits, "-" or "_", starting with a letter (got ${JSON.stringify(slug2)})`
     );
     return void 0;
   }
-  if (RESERVED_SLUGS.has(slug)) {
-    add(`${path}.slug`, `"${slug}" is reserved by Easy CMS`, "choose another slug");
+  if (RESERVED_SLUGS.has(slug2)) {
+    add(`${path}.slug`, `"${slug2}" is reserved by Easy CMS`, "choose another slug");
     return void 0;
   }
-  if (seen.has(slug)) {
-    add(`${path}.slug`, `duplicate slug "${slug}"`);
+  if (seen.has(slug2)) {
+    add(`${path}.slug`, `duplicate slug "${slug2}"`);
     return void 0;
   }
-  seen.add(slug);
-  return slug;
+  seen.add(slug2);
+  return slug2;
 }
 function validateContainer(container, path, collectionSlugs, add) {
   if (!Array.isArray(container.fields)) {
@@ -2903,7 +3295,8 @@ async function resolveConfig(input) {
       ...usesSchedule(config) ? [scheduledJobsCollection] : [],
       ...(config.webhooks?.length ?? 0) > 0 ? [webhookDeliveriesCollection] : [],
       ...config.apiKeys ? [apiKeysCollection] : [],
-      ...config.email ? [emailDeliveriesCollection] : []
+      ...config.email ? [emailDeliveriesCollection] : [],
+      databaseBackupsCollection
     ],
     globals: config.globals ?? [],
     endpoints: config.endpoints ?? [],
@@ -2932,7 +3325,7 @@ var CONFIG_FILE_NAMES = [
 ];
 function findConfigFile(cwd = process.cwd()) {
   for (const name of CONFIG_FILE_NAMES) {
-    const path = resolve(
+    const path = resolve2(
       /* turbopackIgnore: true */
       cwd,
       name
@@ -2951,7 +3344,7 @@ async function importConfig(file) {
 }
 async function loadConfig(options = {}) {
   const cwd = options.cwd ?? process.cwd();
-  const file = options.configFile ? resolve(cwd, options.configFile) : findConfigFile(cwd);
+  const file = options.configFile ? resolve2(cwd, options.configFile) : findConfigFile(cwd);
   if (!file || !existsSync(file)) {
     const looked = options.configFile ?? CONFIG_FILE_NAMES.join(", ");
     throw new Error(
@@ -3190,12 +3583,12 @@ async function populate(load, collections, fields, docs, depth) {
   }
   const found = /* @__PURE__ */ new Map();
   await Promise.all(
-    [...wanted].map(async ([slug, ids]) => {
-      const collection2 = bySlug.get(slug);
+    [...wanted].map(async ([slug2, ids]) => {
+      const collection2 = bySlug.get(slug2);
       if (!collection2) return;
       const raw = await load(collection2, [...ids]);
       const populated = await populate(load, collections, collection2.fields, raw, depth - 1);
-      found.set(slug, new Map(populated.map((d) => [d.id, d])));
+      found.set(slug2, new Map(populated.map((d) => [d.id, d])));
     })
   );
   for (const slot of slots) slot.assign(found.get(slot.collection) ?? /* @__PURE__ */ new Map());
@@ -3448,50 +3841,6 @@ function read(response, maxBytes, deadline) {
   });
 }
 
-// src/storage.ts
-import { mkdir, readFile, rm, stat, writeFile } from "fs/promises";
-import { dirname, isAbsolute, join, normalize, resolve as resolve2, sep } from "path";
-function localStorage(options = {}) {
-  let root = resolve2(
-    /* turbopackIgnore: true */
-    options.dir ?? "uploads"
-  );
-  const pathOf = (key2) => {
-    const path = normalize(join(
-      /* turbopackIgnore: true */
-      root,
-      key2
-    ));
-    if (!path.startsWith(root + sep)) throw new Error(`Invalid storage key "${key2}"`);
-    return path;
-  };
-  return {
-    name: "local",
-    init({ cwd }) {
-      const dir = options.dir ?? "uploads";
-      root = isAbsolute(dir) ? dir : resolve2(
-        /* turbopackIgnore: true */
-        cwd,
-        dir
-      );
-    },
-    async put(key2, data) {
-      const path = pathOf(key2);
-      await mkdir(dirname(path), { recursive: true });
-      await writeFile(path, data, { flag: "wx" });
-    },
-    async get(key2) {
-      const path = pathOf(key2);
-      const info = await stat(path).catch(() => void 0);
-      if (!info?.isFile()) return null;
-      return { body: new Uint8Array(await readFile(path)), size: info.size };
-    },
-    async delete(key2) {
-      await rm(pathOf(key2), { force: true });
-    }
-  };
-}
-
 // src/versions.ts
 var DEFAULT_MAX_VERSIONS = 50;
 function versionLimit(config) {
@@ -3499,8 +3848,8 @@ function versionLimit(config) {
   if (!versions) return void 0;
   return versions === true ? DEFAULT_MAX_VERSIONS : versions.max ?? DEFAULT_MAX_VERSIONS;
 }
-var collectionParent = (slug) => slug;
-var globalParent = (slug) => `global:${slug}`;
+var collectionParent = (slug2) => slug2;
+var globalParent = (slug2) => `global:${slug2}`;
 function snapshotOf(fields, doc) {
   const hidden = new Set(fields.filter((f) => f.hidden).map((f) => f.name));
   const snapshot = {};
@@ -4022,17 +4371,17 @@ var EasyCMS = class {
     return token ? verifyPreviewToken(this.config.secret, token) : null;
   }
   /** Live preview of a global. See `preview`. */
-  async previewGlobal(slug, data, options = {}) {
-    const config = this.global(slug);
+  async previewGlobal(slug2, data, options = {}) {
+    const config = this.global(slug2);
     const guard = guardOf(options);
     await this.checkGlobalAccess(config, "update", guard);
-    const raw = asObject(data, slug);
+    const raw = asObject(data, slug2);
     const input = await filterInput(
       config.fields,
       raw,
       this.fieldChecker("update", guard, void 0, raw)
     );
-    const saved = await this.db.findGlobal({ slug }) ?? {};
+    const saved = await this.db.findGlobal({ slug: slug2 }) ?? {};
     const current = await this.globalDraft(config, saved);
     const merged = generateSlugs(
       config.fields,
@@ -4202,11 +4551,11 @@ var EasyCMS = class {
     const [out] = await this.output(config, [existing], guard, { depth: 0, draft: true });
     return out;
   }
-  async findGlobal(slug, options = {}) {
-    const config = this.global(slug);
+  async findGlobal(slug2, options = {}) {
+    const config = this.global(slug2);
     const guard = guardOf(options);
     await this.checkGlobalAccess(config, "read", guard);
-    const saved = await this.db.findGlobal({ slug });
+    const saved = await this.db.findGlobal({ slug: slug2 });
     const stored = saved && options.draft ? await this.globalDraft(config, saved) : saved;
     const data = fillMissing(
       config.fields,
@@ -4220,33 +4569,33 @@ var EasyCMS = class {
     const { id: _id, ...doc } = out;
     return doc;
   }
-  async updateGlobal(slug, data, options = {}) {
-    return this.saveGlobal(slug, asObject(data, slug), options);
+  async updateGlobal(slug2, data, options = {}) {
+    return this.saveGlobal(slug2, asObject(data, slug2), options);
   }
   /** Takes a global off the site (`status: 'draft'`). See `unpublish`. */
-  async unpublishGlobal(slug, options = {}) {
-    if (!this.global(slug).drafts) throw new QueryError(`"${slug}" has no drafts`);
-    return this.saveGlobal(slug, { status: "draft" }, options, "unpublish");
+  async unpublishGlobal(slug2, options = {}) {
+    if (!this.global(slug2).drafts) throw new QueryError(`"${slug2}" has no drafts`);
+    return this.saveGlobal(slug2, { status: "draft" }, options, "unpublish");
   }
   /** Throws away the unpublished draft of a published global. */
-  async discardGlobalDraft(slug, options = {}) {
-    const config = this.global(slug);
+  async discardGlobalDraft(slug2, options = {}) {
+    const config = this.global(slug2);
     const guard = guardOf(options);
     await this.checkGlobalAccess(config, "update", guard);
-    const saved = await this.db.findGlobal({ slug });
+    const saved = await this.db.findGlobal({ slug: slug2 });
     if (saved && await this.globalDraft(config, saved) !== saved) {
-      await this.saveVersion(config, globalParent(slug), 0, saved, guard);
+      await this.saveVersion(config, globalParent(slug2), 0, saved, guard);
     }
-    return this.findGlobal(slug, { ...options, draft: true });
+    return this.findGlobal(slug2, { ...options, draft: true });
   }
   /** Saved versions of a global, newest first. Needs update access. */
-  async findGlobalVersions(slug, options = {}) {
-    await this.globalVersionTarget(slug, options);
-    return this.versions.list(globalParent(slug), 0, options.limit ?? 20, options.page ?? 1);
+  async findGlobalVersions(slug2, options = {}) {
+    await this.globalVersionTarget(slug2, options);
+    return this.versions.list(globalParent(slug2), 0, options.limit ?? 20, options.page ?? 1);
   }
-  async findGlobalVersion(slug, versionId, options = {}) {
-    const config = await this.globalVersionTarget(slug, options);
-    const version = await this.versions.get(globalParent(slug), 0, versionId);
+  async findGlobalVersion(slug2, versionId, options = {}) {
+    const config = await this.globalVersionTarget(slug2, options);
+    const version = await this.versions.get(globalParent(slug2), 0, versionId);
     if (!version) return null;
     const data = fillMissing(
       config.fields,
@@ -4260,21 +4609,21 @@ var EasyCMS = class {
     return { ...version, data: { ...doc, updatedAt: version.createdAt } };
   }
   /** Makes an old version of a global current (as a draft when the global has drafts). */
-  async restoreGlobalVersion(slug, versionId, options = {}) {
-    const config = await this.globalVersionTarget(slug, options);
-    const version = await this.versions.get(globalParent(slug), 0, versionId);
-    if (!version) throw new NotFoundError(`${slug} version`, versionId);
+  async restoreGlobalVersion(slug2, versionId, options = {}) {
+    const config = await this.globalVersionTarget(slug2, options);
+    const version = await this.versions.get(globalParent(slug2), 0, versionId);
+    if (!version) throw new NotFoundError(`${slug2} version`, versionId);
     const { status: _status, ...data } = version.data;
     return this.saveGlobal(
-      slug,
+      slug2,
       config.drafts ? { ...data, status: "draft" } : data,
       options,
       "restore"
     );
   }
-  async globalVersionTarget(slug, options) {
-    const config = this.global(slug);
-    if (!versionLimit(config)) throw new QueryError(`"${slug}" has no versions`);
+  async globalVersionTarget(slug2, options) {
+    const config = this.global(slug2);
+    if (!versionLimit(config)) throw new QueryError(`"${slug2}" has no versions`);
     await this.checkGlobalAccess(config, "update", guardOf(options));
     return config;
   }
@@ -4285,18 +4634,18 @@ var EasyCMS = class {
     if (version?.status !== "draft") return saved;
     return { ...version.data, updatedAt: version.createdAt, status: "draft" };
   }
-  async saveGlobal(slug, raw, options, mode = "save") {
-    const config = this.global(slug);
+  async saveGlobal(slug2, raw, options, mode = "save") {
+    const config = this.global(slug2);
     const guard = guardOf(options);
     await this.checkGlobalAccess(config, "update", guard);
     if (config.drafts && (mode === "unpublish" || raw.status === "published"))
-      this.checkKey(guard, { global: slug }, "publish");
+      this.checkKey(guard, { global: slug2 }, "publish");
     const input = await filterInput(
       config.fields,
       raw,
       this.fieldChecker("update", guard, void 0, raw)
     );
-    const existing = await this.db.findGlobal({ slug }) ?? {};
+    const existing = await this.db.findGlobal({ slug: slug2 }) ?? {};
     const current = await this.globalDraft(config, existing);
     const localized = mode === "restore" ? input : this.toMaps(config, input, current, options);
     const merged = generateSlugs(
@@ -4320,26 +4669,26 @@ var EasyCMS = class {
     const now = (/* @__PURE__ */ new Date()).toISOString();
     if (mode !== "unpublish" && this.separateDrafts(config) && existing.status === "published" && prepared.status === "draft") {
       const draft = { ...prepared, updatedAt: now };
-      await this.saveVersion(config, globalParent(slug), 0, draft, guard);
-      await this.notify(config.hooks?.afterChange, "afterChange", slug, {
+      await this.saveVersion(config, globalParent(slug2), 0, draft, guard);
+      await this.notify(config.hooks?.afterChange, "afterChange", slug2, {
         ...base,
         doc: draft,
         previousDoc: current,
         operation: "update"
       });
       this.emit(config, "draft", draft);
-      return this.findGlobal(slug, { ...options, draft: true });
+      return this.findGlobal(slug2, { ...options, draft: true });
     }
-    const doc = await this.db.updateGlobal({ slug, data: { ...prepared, updatedAt: now } });
-    await this.saveVersion(config, globalParent(slug), 0, doc, guard);
-    await this.notify(config.hooks?.afterChange, "afterChange", slug, {
+    const doc = await this.db.updateGlobal({ slug: slug2, data: { ...prepared, updatedAt: now } });
+    await this.saveVersion(config, globalParent(slug2), 0, doc, guard);
+    await this.notify(config.hooks?.afterChange, "afterChange", slug2, {
       ...base,
       doc,
       previousDoc: current,
       operation: "update"
     });
     this.emit(config, "update", doc, existing.status);
-    return this.findGlobal(slug, { ...options, draft: true });
+    return this.findGlobal(slug2, { ...options, draft: true });
   }
   /**
    * What `user` may do with one document. Resolves `where`-style access
@@ -4442,6 +4791,9 @@ var EasyCMS = class {
   async runJobs(now = /* @__PURE__ */ new Date()) {
     const scheduled = await this.runScheduled(now);
     await this.pruneFailedDeliveries(now);
+    await runDueBackups(this, now).catch(
+      (error) => this.logger.error(`Backups: ${error.message}`)
+    );
     return {
       ...scheduled,
       webhooks: await this.retryWebhooks(now),
@@ -4511,9 +4863,9 @@ var EasyCMS = class {
       const action = row.action;
       try {
         if (parent.startsWith("global:")) {
-          const slug = parent.slice("global:".length);
-          if (action === "publish") await this.saveGlobal(slug, { status: "published" }, {});
-          else await this.saveGlobal(slug, { status: "draft" }, {}, "unpublish");
+          const slug2 = parent.slice("global:".length);
+          if (action === "publish") await this.saveGlobal(slug2, { status: "published" }, {});
+          else await this.saveGlobal(slug2, { status: "draft" }, {}, "unpublish");
         } else if (action === "publish") {
           await this.updateDocument(parent, row.doc, { status: "published" }, { depth: 0 });
         } else {
@@ -4557,17 +4909,17 @@ var EasyCMS = class {
     const { parsed } = await this.scheduleTarget(collection2, id, options);
     await this.removeJob(collection2, parsed, jobId);
   }
-  async scheduleGlobal(slug, job, options = {}) {
-    await this.globalScheduleTarget(slug, options);
-    return this.addJob(`global:${slug}`, 0, job, options);
+  async scheduleGlobal(slug2, job, options = {}) {
+    await this.globalScheduleTarget(slug2, options);
+    return this.addJob(`global:${slug2}`, 0, job, options);
   }
-  async scheduledGlobal(slug, options = {}) {
-    await this.globalScheduleTarget(slug, options);
-    return this.pendingJobs(`global:${slug}`, 0);
+  async scheduledGlobal(slug2, options = {}) {
+    await this.globalScheduleTarget(slug2, options);
+    return this.pendingJobs(`global:${slug2}`, 0);
   }
-  async cancelGlobalSchedule(slug, jobId, options = {}) {
-    await this.globalScheduleTarget(slug, options);
-    await this.removeJob(`global:${slug}`, 0, jobId);
+  async cancelGlobalSchedule(slug2, jobId, options = {}) {
+    await this.globalScheduleTarget(slug2, options);
+    await this.removeJob(`global:${slug2}`, 0, jobId);
   }
   async scheduleTarget(collection2, id, options) {
     const config = this.collection(collection2);
@@ -4579,11 +4931,11 @@ var EasyCMS = class {
     this.checkKey(guardOf(options), { collection: collection2 }, "publish");
     return { config, parsed };
   }
-  async globalScheduleTarget(slug, options) {
-    const config = this.global(slug);
-    if (!config.schedule) throw new QueryError(`"${slug}" has no schedule`);
+  async globalScheduleTarget(slug2, options) {
+    const config = this.global(slug2);
+    if (!config.schedule) throw new QueryError(`"${slug2}" has no schedule`);
     await this.checkGlobalAccess(config, "update", guardOf(options));
-    this.checkKey(guardOf(options), { global: slug }, "publish");
+    this.checkKey(guardOf(options), { global: slug2 }, "publish");
   }
   async addJob(parent, doc, job, options) {
     const runAt = new Date(job.at);
@@ -4717,14 +5069,14 @@ var EasyCMS = class {
   }
   // -------------------------------------------------------------------------
   /** @internal */
-  collection(slug) {
-    const config = this.config.collections.find((c) => c.slug === slug);
-    if (!config) throw new QueryError(`Unknown collection "${slug}"`);
+  collection(slug2) {
+    const config = this.config.collections.find((c) => c.slug === slug2);
+    if (!config) throw new QueryError(`Unknown collection "${slug2}"`);
     return config;
   }
-  global(slug) {
-    const config = this.config.globals.find((g) => g.slug === slug);
-    if (!config) throw new QueryError(`Unknown global "${slug}"`);
+  global(slug2) {
+    const config = this.config.globals.find((g) => g.slug === slug2);
+    if (!config) throw new QueryError(`Unknown global "${slug2}"`);
     return config;
   }
   /** Refuses what a request's API key does not allow (see `ApiKeyPermissions`). */
@@ -4974,13 +5326,13 @@ var EasyCMS = class {
     return current;
   }
   /** Runs hooks after the change is saved: failures are logged, never undo the save (NFR-REL-03). */
-  async notify(hooks, name, slug, args) {
+  async notify(hooks, name, slug2, args) {
     for (const hook of hooks ?? []) {
       try {
         await hook(args);
       } catch (error) {
         this.logger.error(
-          `${name} hook of "${slug}" failed: ${error instanceof Error ? error.message : String(error)}`
+          `${name} hook of "${slug2}" failed: ${error instanceof Error ? error.message : String(error)}`
         );
       }
     }
@@ -5082,9 +5434,9 @@ var EasyCMS = class {
       const value = data[field.name];
       if (field.localized && value && typeof value === "object") {
         const map = { ...value };
-        for (const [locale, slug] of Object.entries(map)) {
-          if (typeof slug === "string" && slug !== "")
-            map[locale] = await unique(`${field.name}.${locale}`, slug);
+        for (const [locale, slug2] of Object.entries(map)) {
+          if (typeof slug2 === "string" && slug2 !== "")
+            map[locale] = await unique(`${field.name}.${locale}`, slug2);
         }
         data[field.name] = map;
       } else if (typeof value === "string" && value !== "") {
@@ -5223,11 +5575,11 @@ function asObject(data, name) {
 
 // src/rest/admin-modules.ts
 import { createHash as createHash3 } from "crypto";
-import { readFile as readFile2 } from "fs/promises";
+import { readFile as readFile3 } from "fs/promises";
 import { createRequire } from "module";
-import { join as join2 } from "path";
+import { join as join3 } from "path";
 function resolveAdminModule(specifier, cwd = process.cwd()) {
-  const bases = [join2(cwd, "package.json")];
+  const bases = [join3(cwd, "package.json")];
   const entry = process.argv[1];
   if (entry && !specifier.startsWith(".")) bases.push(entry);
   for (const base of bases) {
@@ -5261,7 +5613,7 @@ function adminModuleUrls(cms) {
 async function readAdminModule(cms, index) {
   const file = files(cms)[index];
   if (!file) return void 0;
-  const body = await readFile2(file, "utf8").catch(() => void 0);
+  const body = await readFile3(file, "utf8").catch(() => void 0);
   if (body === void 0) return void 0;
   return { body, etag: `"${createHash3("sha1").update(body).digest("base64url")}"` };
 }
@@ -5279,7 +5631,7 @@ function parse(text) {
     return {};
   }
 }
-function toAdmin(kind, row) {
+function toAdmin2(kind, row) {
   const base = {
     id: row.id,
     state: row.state === "failed" ? "failed" : "pending",
@@ -5327,7 +5679,7 @@ async function listDeliveries(cms, kind, state, page) {
     cms.db.count({ collection: collection2, where: { state: { equals: "pending" } } })
   ]);
   return {
-    docs: found.docs.map((row) => toAdmin(kind, row)),
+    docs: found.docs.map((row) => toAdmin2(kind, row)),
     totalDocs: found.totalDocs,
     page: found.page,
     totalPages: found.totalPages,
@@ -5468,7 +5820,7 @@ function componentRef(component) {
 async function allowed(access, user) {
   return await evaluateAccess(access, { user }) !== false;
 }
-async function serializeFields(fields, update, localized) {
+async function serializeFields(fields, update2, localized) {
   const out = [];
   for (const field of fields) {
     if (field.hidden) continue;
@@ -5477,7 +5829,7 @@ async function serializeFields(fields, update, localized) {
     if (field.required) f.required = true;
     if (field.unique) f.unique = true;
     if (field.defaultValue !== void 0) f.defaultValue = field.defaultValue;
-    if (!await update.allows(field)) f.readOnly = true;
+    if (!await update2.allows(field)) f.readOnly = true;
     if (field.localized && localized) f.localized = true;
     if (field.position === "sidebar") f.position = "sidebar";
     if (field.admin?.component || field.admin?.after?.length || field.admin?.cell) {
@@ -5524,7 +5876,7 @@ async function serializeFields(fields, update, localized) {
       case "array":
         if (field.minRows !== void 0) f.minRows = field.minRows;
         if (field.maxRows !== void 0) f.maxRows = field.maxRows;
-        f.fields = await serializeFields(field.fields, update, localized);
+        f.fields = await serializeFields(field.fields, update2, localized);
         break;
       case "blocks":
         if (field.minRows !== void 0) f.minRows = field.minRows;
@@ -5533,12 +5885,12 @@ async function serializeFields(fields, update, localized) {
           field.blocks.map(async (block) => ({
             slug: block.slug,
             ...block.labels ? { labels: block.labels } : {},
-            fields: await serializeFields(block.fields, update, localized)
+            fields: await serializeFields(block.fields, update2, localized)
           }))
         );
         break;
       case "group":
-        f.fields = await serializeFields(field.fields, update, localized);
+        f.fields = await serializeFields(field.fields, update2, localized);
         break;
     }
     out.push(f);
@@ -5652,11 +6004,11 @@ async function widgets(cms, user) {
 }
 
 // src/version.ts
-var VERSION = true ? "0.31.0" : "0.0.0-dev";
+var VERSION = true ? "0.32.0" : "0.0.0-dev";
 
 // src/rest/admin-status.ts
 var DAY = 864e5;
-var has = (cms, slug) => cms.config.collections.some((c) => c.slug === slug);
+var has = (cms, slug2) => cms.config.collections.some((c) => c.slug === slug2);
 async function adminStatus(cms) {
   const config = cms.config;
   const attention = [];
@@ -5709,6 +6061,8 @@ async function adminStatus(cms) {
     });
     if (count > 0) attention.push({ id: "scheduled", count });
   }
+  const backups = await backupAttention(cms);
+  if (backups) attention.push(backups);
   if (!config.email) attention.push({ id: "no-email" });
   if (!config.serverURL && process.env.NODE_ENV === "production")
     attention.push({ id: "no-server-url" });
@@ -5743,8 +6097,8 @@ async function pickerFilter(cms, url, target, user) {
   const spec = forCollection ?? forGlobal;
   if (spec === null) return void 0;
   const dot = spec.indexOf(".");
-  const slug = dot > 0 ? spec.slice(0, dot) : "";
-  const owner = forCollection !== null ? cms.config.collections.find((c) => c.slug === slug) : cms.config.globals.find((g) => g.slug === slug);
+  const slug2 = dot > 0 ? spec.slice(0, dot) : "";
+  const owner = forCollection !== null ? cms.config.collections.find((c) => c.slug === slug2) : cms.config.globals.find((g) => g.slug === slug2);
   const field = owner ? fieldAt(owner.fields, spec.slice(dot + 1)) : void 0;
   if (field?.type !== "relationship" || field.to !== target)
     throw new QueryError(`filterFor: no relationship to "${target}" at "${spec}"`);
@@ -6092,6 +6446,38 @@ async function route(cms, ctx, method, segments, options) {
     }
     return { body: await cms.runJobs() };
   }
+  if (first === "admin" && second === "backups") {
+    if (!ctx.user) throw new UnauthorizedError();
+    if (ctx.user.role !== "admin" || ctx.user.apiKey) throw new ForbiddenError();
+    const [, , id2, action, extra] = segments;
+    if (extra !== void 0) throw new HttpError("Not found", 404);
+    if (id2 === void 0) {
+      if (method === "GET") return { body: await listBackups(cms) };
+      if (method === "POST")
+        return { status: 202, body: await startBackup(cms, "manual", ctx.user.email) };
+      throw methodNotAllowed(ctx, "GET, POST");
+    }
+    const parsed = parseId(id2);
+    if (parsed === void 0) throw new HttpError("Not found", 404);
+    if (action === "download") {
+      if (method !== "GET") throw methodNotAllowed(ctx, "GET");
+      const file = await downloadBackup(cms, parsed, ctx.user.email);
+      return {
+        body: new Response(file.body, {
+          headers: {
+            "content-type": "application/gzip",
+            "content-disposition": `attachment; filename="${file.filename}"`,
+            "cache-control": "no-store",
+            "x-content-type-options": "nosniff"
+          }
+        })
+      };
+    }
+    if (action !== void 0) throw new HttpError("Not found", 404);
+    if (method !== "DELETE") throw methodNotAllowed(ctx, "DELETE");
+    await deleteBackup(cms, parsed);
+    return { body: { deleted: 1 } };
+  }
   if (first === "admin" && second === "email") {
     if (!ctx.user) throw new UnauthorizedError();
     if (ctx.user.role !== "admin" || ctx.user.apiKey) throw new ForbiddenError();
@@ -6348,47 +6734,47 @@ async function documentAction(cms, ctx, method, collection2, id, path) {
   }
   throw new HttpError("Not found", 404);
 }
-async function globalAction(cms, ctx, method, slug, path) {
+async function globalAction(cms, ctx, method, slug2, path) {
   const access = { overrideAccess: false, user: ctx.user, ...parseLocale(ctx.url) };
   const depth = parseDepth(ctx.url);
   const [action, versionId, extra] = path;
   if (action === "versions" && versionId === void 0) {
     if (method !== "GET") throw methodNotAllowed(ctx, "GET");
-    return { body: await cms.findGlobalVersions(slug, { ...access, ...parsePage(ctx.url) }) };
+    return { body: await cms.findGlobalVersions(slug2, { ...access, ...parsePage(ctx.url) }) };
   }
   if (action === "versions" && versionId !== void 0 && extra === void 0) {
     if (method !== "GET") throw methodNotAllowed(ctx, "GET");
-    const version = await cms.findGlobalVersion(slug, versionId, { ...access, ...depth });
-    if (!version) throw new NotFoundError(`${slug} version`, versionId);
+    const version = await cms.findGlobalVersion(slug2, versionId, { ...access, ...depth });
+    if (!version) throw new NotFoundError(`${slug2} version`, versionId);
     return { body: version };
   }
   if (action === "versions" && versionId !== void 0 && extra === "restore" && path.length === 3) {
     if (method !== "POST") throw methodNotAllowed(ctx, "POST");
-    return { body: await cms.restoreGlobalVersion(slug, versionId, { ...access, ...depth }) };
+    return { body: await cms.restoreGlobalVersion(slug2, versionId, { ...access, ...depth }) };
   }
   if (action === "schedule" && path.length <= 2) {
     if (path.length === 2) {
       if (method !== "DELETE") throw methodNotAllowed(ctx, "DELETE");
-      await cms.cancelGlobalSchedule(slug, versionId, access);
+      await cms.cancelGlobalSchedule(slug2, versionId, access);
       return { body: { message: "Cancelled" } };
     }
-    if (method === "GET") return { body: await cms.scheduledGlobal(slug, access) };
+    if (method === "GET") return { body: await cms.scheduledGlobal(slug2, access) };
     if (method !== "POST") throw methodNotAllowed(ctx, "GET, POST");
     const body = await readJson(ctx.request);
-    return { status: 201, body: await cms.scheduleGlobal(slug, scheduleJob(body), access) };
+    return { status: 201, body: await cms.scheduleGlobal(slug2, scheduleJob(body), access) };
   }
   if (path.length === 1 && action === "preview") {
     if (method !== "POST") throw methodNotAllowed(ctx, "POST");
     const body = await readJson(ctx.request);
-    const result = await cms.previewGlobal(slug, body, { ...access, ...depth });
-    const token = cms.createPreviewToken({ global: slug });
+    const result = await cms.previewGlobal(slug2, body, { ...access, ...depth });
+    const token = cms.createPreviewToken({ global: slug2 });
     return { body: { ...result, url: result.url && withPreviewToken(result.url, token) } };
   }
   if (path.length === 1 && (action === "unpublish" || action === "discard-draft")) {
     if (method !== "POST") throw methodNotAllowed(ctx, "POST");
     const options = { ...access, ...depth };
     return {
-      body: action === "unpublish" ? await cms.unpublishGlobal(slug, options) : await cms.discardGlobalDraft(slug, options)
+      body: action === "unpublish" ? await cms.unpublishGlobal(slug2, options) : await cms.discardGlobalDraft(slug2, options)
     };
   }
   throw new HttpError("Not found", 404);
@@ -6721,7 +7107,7 @@ function generateTypes(config) {
   for (const global2 of config.globals) {
     parts.push("", globalInterface(global2, n.globals.get(global2.slug), n));
   }
-  const map = (entries) => [...entries].map(([slug, name]) => `  ${key(slug)}: ${name}`).join("\n");
+  const map = (entries) => [...entries].map(([slug2, name]) => `  ${key(slug2)}: ${name}`).join("\n");
   parts.push(
     "",
     "/** Document type by collection slug. */",
@@ -6820,5 +7206,6 @@ export {
   sniffMimeType,
   validateConfig,
   validateFields,
-  verifyPassword
+  verifyPassword,
+  writeBackupFile
 };