@easy-cms/core 0.30.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;
   };
@@ -150,8 +150,8 @@ ${lines.join("\n")}`;
 };
 var EasyCMSError = class extends Error {
   status;
-  constructor(message, status) {
-    super(message);
+  constructor(message2, status) {
+    super(message2);
     this.name = "EasyCMSError";
     this.status = status;
   }
@@ -172,38 +172,38 @@ var NotFoundError = class extends EasyCMSError {
   }
 };
 var QueryError = class extends EasyCMSError {
-  constructor(message) {
-    super(message, 400);
+  constructor(message2) {
+    super(message2, 400);
     this.name = "QueryError";
   }
 };
 var SchemaError = class extends EasyCMSError {
-  constructor(message) {
-    super(message, 500);
+  constructor(message2) {
+    super(message2, 500);
     this.name = "SchemaError";
   }
 };
 var UnauthorizedError = class extends EasyCMSError {
-  constructor(message = "You must be logged in") {
-    super(message, 401);
+  constructor(message2 = "You must be logged in") {
+    super(message2, 401);
     this.name = "UnauthorizedError";
   }
 };
 var ForbiddenError = class extends EasyCMSError {
-  constructor(message = "You are not allowed to do this") {
-    super(message, 403);
+  constructor(message2 = "You are not allowed to do this") {
+    super(message2, 403);
     this.name = "ForbiddenError";
   }
 };
 var TooManyRequestsError = class extends EasyCMSError {
-  constructor(message) {
-    super(message, 429);
+  constructor(message2) {
+    super(message2, 429);
     this.name = "TooManyRequestsError";
   }
 };
 var PayloadTooLargeError = class extends EasyCMSError {
-  constructor(message) {
-    super(message, 413);
+  constructor(message2) {
+    super(message2, 413);
     this.name = "PayloadTooLargeError";
   }
 };
@@ -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@]+$/;
@@ -1331,7 +1694,7 @@ async function validateFields(fields, input, options, prefix = "") {
   for (const field of fields) {
     const path = prefix + field.name;
     const raw = input[field.name];
-    const fail = (message) => errors.push({ field: path, message });
+    const fail = (message2) => errors.push({ field: path, message: message2 });
     if (field.type === "group") {
       if (!isEmpty(raw) && !isPlainObject(raw)) {
         fail("must be an object");
@@ -1360,7 +1723,7 @@ async function validateFields(fields, input, options, prefix = "") {
       for (const locale of localization.locales) {
         const own = locale === written;
         const localePath = own ? path : `${path}.${locale}`;
-        const failLocale = (message) => errors.push({ field: localePath, message });
+        const failLocale = (message2) => errors.push({ field: localePath, message: message2 });
         const value2 = map[locale];
         if (isEmpty(value2) || Array.isArray(value2) && value2.length === 0) {
           if (own && field.required && !options.skipRequired) failLocale("is required");
@@ -1543,17 +1906,19 @@ function consoleEmail(options = {}) {
   const sent = [];
   const adapter = {
     name: "console",
+    // `log`: the admin says it prints to the server log instead of sending.
+    describe: () => [{ key: "delivery", value: "log" }],
     from: options.from ?? "Easy CMS <no-reply@localhost>",
     sent,
-    async send(message) {
-      sent.push(message);
+    async send(message2) {
+      sent.push(message2);
       const list = (value) => value === void 0 ? void 0 : typeof value === "string" ? value : value.join(", ");
       const lines = [
-        `Email to ${list(message.to)}${message.cc ? `, cc ${list(message.cc)}` : ""}`,
-        `From: ${message.from}${message.replyTo ? ` (reply to ${message.replyTo})` : ""}`,
-        `Subject: ${message.subject}`,
+        `Email to ${list(message2.to)}${message2.cc ? `, cc ${list(message2.cc)}` : ""}`,
+        `From: ${message2.from}${message2.replyTo ? ` (reply to ${message2.replyTo})` : ""}`,
+        `Subject: ${message2.subject}`,
         "",
-        message.text ?? message.html ?? ""
+        message2.text ?? message2.html ?? ""
       ];
       (options.log ?? console.log)(lines.join("\n"));
     }
@@ -1581,14 +1946,14 @@ var Mailer = class {
    * for the sending too. Without an `email` adapter in the config, the email is skipped with a
    * warning.
    */
-  async send(message) {
+  async send(message2) {
     if (!this.adapter) {
       this.logger.warn(
-        `Email "${message.subject}" not sent: set \`email\` in the config (e.g. consoleEmail() in development)`
+        `Email "${message2.subject}" not sent: set \`email\` in the config (e.g. consoleEmail() in development)`
       );
       return;
     }
-    const body = JSON.stringify(message);
+    const body = JSON.stringify(message2);
     let id;
     try {
       id = await this.queue?.add({
@@ -1601,7 +1966,7 @@ var Mailer = class {
     } catch (error) {
       this.logger.error(`Could not save email: ${error.message}`);
     }
-    this.track(this.deliver(message, body, id));
+    this.track(this.deliver(message2, body, id));
   }
   /** Waits for emails being sent, e.g. before a serverless function returns. */
   async flush() {
@@ -1637,25 +2002,25 @@ var Mailer = class {
     return { sent, failed };
   }
   /** One attempt now for a saved email (the admin's Retry): `undefined` when sent, else the error. */
-  async sendNow(message) {
+  async sendNow(message2) {
     if (!this.adapter) return "email is not set up (`email` in the config)";
-    return this.attempt(JSON.parse(message));
+    return this.attempt(JSON.parse(message2));
   }
   track(delivery) {
     const tracked = delivery.catch((error) => this.logger.error(`Email queue failed: ${error.message}`)).finally(() => this.pending.delete(tracked));
     this.pending.add(tracked);
   }
-  async deliver(message, body, id) {
-    const error = await this.attempt(message);
+  async deliver(message2, body, id) {
+    const error = await this.attempt(message2);
     if (!error) {
       if (id !== void 0) await this.queue?.remove(id);
       return;
     }
     if (id === void 0 || !this.queue) {
-      this.logger.error(`Email "${message.subject}" failed: ${error}`);
+      this.logger.error(`Email "${message2.subject}" failed: ${error}`);
       return;
     }
-    this.logger.warn(`Email "${message.subject}" failed, retrying later: ${error}`);
+    this.logger.warn(`Email "${message2.subject}" failed, retrying later: ${error}`);
     await this.queue.update(id, {
       message: body,
       attempts: 1,
@@ -1665,12 +2030,12 @@ var Mailer = class {
     });
   }
   /** `undefined` when sent, else the error. */
-  async attempt(message) {
+  async attempt(message2) {
     const adapter = this.adapter;
-    const from = message.from ?? adapter.from;
+    const from = message2.from ?? adapter.from;
     if (!from) return "no sender: set `from` on the message or the email adapter";
     try {
-      await adapter.send({ ...message, from });
+      await adapter.send({ ...message2, from });
       return void 0;
     } catch (error) {
       return error.message || String(error);
@@ -1800,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
@@ -1992,6 +2357,8 @@ var RESERVED_SLUGS = /* @__PURE__ */ new Set([
   "document-versions",
   "scheduled-jobs",
   "webhook-deliveries",
+  "email-deliveries",
+  "database-backups",
   "api-keys",
   "jobs",
   "migrations",
@@ -2002,7 +2369,7 @@ var SLUG_PATTERN = /^[a-z][a-z0-9_-]*$/;
 var FIELD_NAME_PATTERN = /^[A-Za-z_][A-Za-z0-9_]*$/;
 function validateConfig(config) {
   const issues = [];
-  const add = (path, message, hint) => issues.push(hint ? { path, message, hint } : { path, message });
+  const add = (path, message2, hint) => issues.push(hint ? { path, message: message2, hint } : { path, message: message2 });
   if (typeof config !== "object" || config === null) {
     add("config", "must be an object", "export default defineConfig({ ... })");
     return issues;
@@ -2014,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);
@@ -2023,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)}`);
       }
     }
   }
@@ -2374,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) {
@@ -2430,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)) {
@@ -2439,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)) {
@@ -2901,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 ?? [],
@@ -2930,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
@@ -2949,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(
@@ -3067,9 +3462,9 @@ function localizeSort(fields, sort, locale, locales = []) {
 
 // src/logger.ts
 var consoleLogger = {
-  info: (message) => console.info(`[easy-cms] ${message}`),
-  warn: (message) => console.warn(`[easy-cms] ${message}`),
-  error: (message) => console.error(`[easy-cms] ${message}`)
+  info: (message2) => console.info(`[easy-cms] ${message2}`),
+  warn: (message2) => console.warn(`[easy-cms] ${message2}`),
+  error: (message2) => console.error(`[easy-cms] ${message2}`)
 };
 var silentLogger = { info() {
 }, warn() {
@@ -3188,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());
@@ -3248,8 +3643,8 @@ import { BlockList, isIP } from "net";
 var RemoteFileError = class extends Error {
   /** `413` when the file is too large, otherwise `400`. */
   status;
-  constructor(message, status = 400) {
-    super(message);
+  constructor(message2, status = 400) {
+    super(message2);
     this.name = "RemoteFileError";
     this.status = status;
   }
@@ -3446,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) {
@@ -3497,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 = {};
@@ -4020,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,
@@ -4200,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,
@@ -4218,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,
@@ -4258,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;
   }
@@ -4283,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(
@@ -4318,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
@@ -4370,8 +4721,8 @@ var EasyCMS = class {
    * the email is queued; it is sent in the background and retried from the queue if sending
    * fails. Without `email` in the config, the email is skipped with a warning.
    */
-  sendEmail(message) {
-    return this.mailer.send(message);
+  sendEmail(message2) {
+    return this.mailer.send(message2);
   }
   /** Waits for emails being sent, e.g. before a serverless function returns. */
   flushEmails() {
@@ -4440,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),
@@ -4509,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 {
@@ -4530,12 +4884,12 @@ var EasyCMS = class {
         });
       } catch (error) {
         failed++;
-        const message = error.message;
-        this.logger.error(`Scheduled ${action} of ${parent} ${row.doc} failed: ${message}`);
+        const message2 = error.message;
+        this.logger.error(`Scheduled ${action} of ${parent} ${row.doc} failed: ${message2}`);
         await this.db.update({
           collection: SCHEDULED_JOBS,
           id: row.id,
-          data: { ...row, state: "failed", error: message.slice(0, 500) }
+          data: { ...row, state: "failed", error: message2.slice(0, 500) }
         });
       }
     }
@@ -4555,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);
@@ -4577,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);
@@ -4715,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`). */
@@ -4972,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)}`
         );
       }
     }
@@ -5080,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 !== "") {
@@ -5221,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) {
@@ -5259,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")}"` };
 }
@@ -5277,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",
@@ -5300,13 +5654,13 @@ function toAdmin(kind, row) {
       body: String(row.body ?? "")
     };
   }
-  const message = parse(row.message);
-  const to = message.to;
+  const message2 = parse(row.message);
+  const to = message2.to;
   return {
     ...base,
     kind,
     to: Array.isArray(to) ? to.map(String) : typeof to === "string" ? [to] : [],
-    subject: String(message.subject ?? "")
+    subject: String(message2.subject ?? "")
   };
 }
 async function listDeliveries(cms, kind, state, page) {
@@ -5325,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,
@@ -5381,6 +5735,82 @@ async function deleteFailedDeliveries(cms, kind) {
   return { deleted };
 }
 
+// src/rest/admin-email.ts
+var EMAIL = /^[^\s@]+@[^\s@]+\.[^\s@]+$/;
+var LIMIT = 5;
+var WINDOW = 10 * 6e4;
+var sentAt = /* @__PURE__ */ new WeakMap();
+var message = (error) => error instanceof Error ? error.message || error.name : String(error);
+function adminEmail(cms) {
+  const adapter = cms.config.email;
+  if (!adapter) return { configured: false, name: null, from: null, settings: [], canVerify: false };
+  let settings = [];
+  try {
+    settings = [...adapter.describe?.() ?? []].map((s) => ({
+      key: String(s.key),
+      value: s.value === null || s.value === void 0 ? null : String(s.value),
+      ...s.source ? { source: String(s.source) } : {}
+    }));
+  } catch {
+  }
+  return {
+    configured: true,
+    name: adapter.name ?? "custom",
+    from: adapter.from ?? null,
+    settings,
+    canVerify: typeof adapter.verify === "function"
+  };
+}
+async function verifyEmail(cms) {
+  const adapter = cms.config.email;
+  if (!adapter?.verify)
+    return { ok: false, error: "This email adapter cannot check its connection" };
+  try {
+    await adapter.verify();
+    return { ok: true };
+  } catch (error) {
+    return { ok: false, error: message(error) };
+  }
+}
+async function sendTestEmail(cms, user, to, locale) {
+  const adapter = cms.config.email;
+  if (!adapter) return { ok: false, error: "Email is not set up (`email` in the config)" };
+  const address = typeof to === "string" && to.trim() ? to.trim() : user.email;
+  if (!EMAIL.test(address))
+    throw new ValidationError("email", [{ field: "to", message: "must be an email address" }]);
+  const times = sentAt.get(cms) ?? /* @__PURE__ */ new Map();
+  sentAt.set(cms, times);
+  const key2 = String(user.id);
+  const now = Date.now();
+  const recent = (times.get(key2) ?? []).filter((t) => now - t < WINDOW);
+  if (recent.length >= LIMIT)
+    throw new TooManyRequestsError("Too many test emails: try again in a few minutes");
+  times.set(key2, [...recent, now]);
+  const from = adapter.from;
+  if (!from) return { ok: false, error: "No sender: set `from` on the email adapter" };
+  const site = cms.config.admin.brand.name || "Easy CMS";
+  const th = locale === "th" || locale !== "en" && cms.config.admin.locale === "th";
+  const time = (/* @__PURE__ */ new Date()).toISOString();
+  const subject = th ? `\u0E2D\u0E35\u0E40\u0E21\u0E25\u0E17\u0E14\u0E2A\u0E2D\u0E1A\u0E08\u0E32\u0E01 ${site}` : `Test email from ${site}`;
+  const text = th ? `\u0E2D\u0E35\u0E40\u0E21\u0E25\u0E19\u0E35\u0E49\u0E2A\u0E48\u0E07\u0E08\u0E32\u0E01\u0E2B\u0E19\u0E49\u0E32 \u0E15\u0E31\u0E49\u0E07\u0E04\u0E48\u0E32 \u2192 \u0E2D\u0E35\u0E40\u0E21\u0E25 \u0E02\u0E2D\u0E07 ${site} \u0E40\u0E1E\u0E37\u0E48\u0E2D\u0E17\u0E14\u0E2A\u0E2D\u0E1A\u0E01\u0E32\u0E23\u0E15\u0E31\u0E49\u0E07\u0E04\u0E48\u0E32
+
+\u0E2A\u0E48\u0E07\u0E42\u0E14\u0E22: ${user.email}
+Adapter: ${adapter.name ?? "custom"}
+\u0E1C\u0E39\u0E49\u0E2A\u0E48\u0E07: ${from}
+\u0E40\u0E27\u0E25\u0E32: ${time}` : `This email was sent from Settings \u2192 Email in ${site} to test the settings.
+
+Sent by: ${user.email}
+Adapter: ${adapter.name ?? "custom"}
+From: ${from}
+Time: ${time}`;
+  try {
+    await adapter.send({ to: address, subject, text, from });
+    return { ok: true };
+  } catch (error) {
+    return { ok: false, error: message(error) };
+  }
+}
+
 // src/rest/admin-schema.ts
 var SETTINGS = /* @__PURE__ */ new Set([USERS, API_KEYS]);
 function componentRef(component) {
@@ -5390,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;
@@ -5399,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) {
@@ -5446,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;
@@ -5455,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);
@@ -5574,11 +6004,11 @@ async function widgets(cms, user) {
 }
 
 // src/version.ts
-var VERSION = true ? "0.30.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 = [];
@@ -5631,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" });
@@ -5665,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}"`);
@@ -6014,6 +6446,55 @@ 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();
+    const [, , action, extra] = segments;
+    if (extra !== void 0) throw new HttpError("Not found", 404);
+    if (action === void 0) {
+      if (method !== "GET") throw methodNotAllowed(ctx, "GET");
+      return { body: adminEmail(cms) };
+    }
+    if (method !== "POST") throw methodNotAllowed(ctx, "POST");
+    if (action === "verify") return { body: await verifyEmail(cms) };
+    if (action === "test") {
+      const body = await readJson(ctx.request);
+      return { body: await sendTestEmail(cms, ctx.user, body.to, body.locale) };
+    }
+    throw new HttpError("Not found", 404);
+  }
   if (first === "admin" && second === "deliveries") {
     if (!ctx.user) throw new UnauthorizedError();
     if (ctx.user.role !== "admin" || ctx.user.apiKey) throw new ForbiddenError();
@@ -6253,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);
@@ -6471,11 +6952,11 @@ function errorResponse(cms, error, headers, production) {
     if (error instanceof UnauthorizedError) headers.set("www-authenticate", "Bearer");
     return new Response(JSON.stringify({ errors }), { status: error.status, headers });
   }
-  const message = error instanceof Error ? error.message : String(error);
+  const message2 = error instanceof Error ? error.message : String(error);
   cms.logger.error(
-    `REST request failed: ${error instanceof Error ? error.stack ?? message : message}`
+    `REST request failed: ${error instanceof Error ? error.stack ?? message2 : message2}`
   );
-  const body = { errors: [{ message: production ? "Internal Server Error" : message }] };
+  const body = { errors: [{ message: production ? "Internal Server Error" : message2 }] };
   return new Response(JSON.stringify(body), { status: 500, headers });
 }
 
@@ -6626,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. */",
@@ -6725,5 +7206,6 @@ export {
   sniffMimeType,
   validateConfig,
   validateFields,
-  verifyPassword
+  verifyPassword,
+  writeBackupFile
 };