Files
bookmanager/src/lib/backup.ts
T
bobbanandClaude Sonnet 5.5 4e8d79ee10 Säkerhetskopior, papperskorg, historik, härdning, adminsida och snabbsök
- Automatisk nattlig säkerhetskopiering (zip per bok med bilder), schemaläggare via
  instrumentation, adminsida med manuell körning och nedladdning
- Papperskorg för poster (ögonblicksbild med relationer, scheman, markeringar) och
  böcker (zip), återställning och automatisk rensning
- Ändringshistorik för poster med fältvis diff och återställning
- Härdning: säkerhetsrubriker och CSP via middleware, hastighetsbegränsning, lagringskvot
  per användare, konfigurerbar sessionstid
- Bildoptimering med sharp (EXIF-rotation, nedskalning, metadata borttagen) och miniatyrer
- Strukturerade JSON-loggar, onRequestError och Prometheus-mätvärden på /api/metrics
- Snabbsök och kommandopalett (Ctrl+K) med sökning i poster och mallfält
- Migration 0005_system, nya volymer och miljövariabler, versionsinfo via build-args
- README, .env.example och TODO uppdaterade

Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com>
2026-10-27 23:04:05 +01:00

113 lines
5.3 KiB
TypeScript

import { mkdir, readdir, rm, stat, writeFile } from "node:fs/promises";
import path from "node:path";
import { strToU8, zipSync, type Zippable } from "fflate";
import { buildExport } from "./book-transfer";
import { prisma } from "./db";
import { log } from "./log";
// Automatisk säkerhetskopiering. Varje körning sparar en zip per bok (samma format som exporten, med bilder)
// i en mapp med tidsstämpel. Zip-filerna kan importeras igen via Importera bok. De senaste BACKUP_KEEP körningarna behålls.
export const BACKUP_DIR = path.resolve(process.env.BACKUP_DIR ?? "./data/backups");
export const BACKUP_ENABLED = process.env.BACKUP_ENABLED !== "false";
export const BACKUP_KEEP = Number(process.env.BACKUP_KEEP) || 14;
const hour = Number(process.env.BACKUP_HOUR);
export const BACKUP_HOUR = Number.isInteger(hour) && hour >= 0 && hour <= 23 ? hour : 3;
export const FOLDER_PATTERN = /^\d{4}-\d{2}-\d{2}T\d{2}-\d{2}-\d{2}$/;
export const BACKUP_FILE_PATTERN = /^[A-Za-z0-9._-]{1,120}\.(zip|json)$/;
const safeName = (title: string) => title.replace(/[^\p{L}\p{N}]+/gu, "-").replace(/^-|-$/g, "").slice(0, 50) || "bok";
/** Kör en säkerhetskopiering av alla böcker. Returnerar körningens id. */
export async function runBackup(trigger: "schedule" | "manual"): Promise<string> {
const run = await prisma.backupRun.create({ data: { trigger, status: "running" } });
log.info("Säkerhetskopiering startad", { runId: run.id, trigger });
try {
const folder = new Date().toISOString().slice(0, 19).replace(/:/g, "-");
const dir = path.join(BACKUP_DIR, folder);
await mkdir(dir, { recursive: true });
const books = await prisma.book.findMany({
select: { id: true, title: true, owner: { select: { name: true, email: true } } },
orderBy: { createdAt: "asc" },
});
let bytes = 0;
const index: { bookId: string; title: string; owner: string | null; file: string; megabytes: number }[] = [];
for (const book of books) {
const { data, files } = await buildExport(book.id, true);
const entries: Zippable = { "book.json": strToU8(JSON.stringify(data)) };
for (const [name, content] of files) entries[`files/${name}`] = [content, { level: 0 }];
const zip = zipSync(entries);
const file = `${safeName(book.title)}-${book.id.slice(0, 8)}.zip`;
await writeFile(path.join(dir, file), zip);
bytes += zip.length;
index.push({ bookId: book.id, title: book.title, owner: book.owner.name ?? book.owner.email, file, megabytes: Math.round((zip.length / 1048576) * 100) / 100 });
}
await writeFile(path.join(dir, "index.json"), JSON.stringify({ createdAt: new Date().toISOString(), books: index }, null, 2));
await pruneBackups();
const done = await prisma.backupRun.update({
where: { id: run.id },
data: { status: "ok", finishedAt: new Date(), books: books.length, megabytes: Math.round((bytes / 1048576) * 100) / 100, folder },
});
log.info("Säkerhetskopiering klar", { runId: run.id, books: books.length, megabytes: done.megabytes, folder });
} catch (error) {
await prisma.backupRun.update({
where: { id: run.id },
data: { status: "error", finishedAt: new Date(), error: error instanceof Error ? error.message.slice(0, 500) : "Okänt fel" },
});
log.error("Säkerhetskopiering misslyckades", { runId: run.id, error });
}
return run.id;
}
export type BackupFolder = { folder: string; files: { name: string; bytes: number }[]; bytes: number };
export async function listBackups(): Promise<BackupFolder[]> {
let folders: string[];
try {
folders = (await readdir(BACKUP_DIR)).filter((f) => FOLDER_PATTERN.test(f)).sort().reverse();
} catch {
return [];
}
const result: BackupFolder[] = [];
for (const folder of folders) {
const names = (await readdir(path.join(BACKUP_DIR, folder))).filter((n) => BACKUP_FILE_PATTERN.test(n)).sort();
const files = await Promise.all(names.map(async (name) => ({ name, bytes: (await stat(path.join(BACKUP_DIR, folder, name))).size })));
result.push({ folder, files, bytes: files.reduce((sum, f) => sum + f.bytes, 0) });
}
return result;
}
async function pruneBackups() {
const folders = (await readdir(BACKUP_DIR)).filter((f) => FOLDER_PATTERN.test(f)).sort().reverse();
for (const folder of folders.slice(BACKUP_KEEP)) {
await rm(path.join(BACKUP_DIR, folder), { recursive: true, force: true });
log.info("Gammal säkerhetskopia borttagen", { folder });
}
}
/** Sant om det är dags för nattens säkerhetskopia: klockan har passerat BACKUP_HOUR och ingen körning har gjorts i dag. */
export async function backupDue(now = new Date()): Promise<boolean> {
if (!BACKUP_ENABLED || now.getHours() < BACKUP_HOUR) return false;
const startOfDay = new Date(now);
startOfDay.setHours(0, 0, 0, 0);
const recent = await prisma.backupRun.findFirst({
where: { startedAt: { gte: startOfDay }, OR: [{ status: "ok" }, { status: "running" }] },
select: { id: true },
});
return !recent;
}
/** Körningar som fastnat som "running" (t.ex. efter en omstart) markeras som misslyckade. */
export async function failStaleRuns() {
const limit = new Date(Date.now() - 60 * 60 * 1000);
await prisma.backupRun.updateMany({
where: { status: "running", startedAt: { lt: limit } },
data: { status: "error", finishedAt: new Date(), error: "Avbröts (servern startades om)" },
});
}