Files
Homelab-manager/server/src/routes/dependencies.ts
T
bobbanandClaude Sonnet 5.5 18ceed62e8 Racks, notes and to-do, OS support, suggested dependencies, Nginx Proxy Manager and Home Assistant
- Racks page and a network diagram (UniFi tree with servers, printable)
- Notes on servers and devices; To do list shown in Coming up and My work
- Agents report the operating system (Linux 7, Windows 6); end-of-life badge and alert
- Suggested dependencies from where a service is reached
- Nginx Proxy Manager integration: proxy hosts page, certificate and host alerts, suggested checks
- Home Assistant integration: watch chosen entities, history chart, limit and unavailable alerts
- TimeChart gets a "value" scale that fits negatives; docs updated

Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com>
2026-10-20 21:47:56 +02:00

177 lines
10 KiB
TypeScript

import { Router } from "express";
import { eq } from "drizzle-orm";
import { z } from "zod";
import { db } from "../db/client.js";
import { dependencies, networkDevices, servers } from "../db/schema.js";
import { requireAuth, requireRole } from "../auth/middleware.js";
import { recordAudit } from "../services/audit.js";
import { invalidateAlertsCache } from "../services/alerts.js";
import { dependentsOf, impactOf, loadGraph, nodeKey, nodeTypes, wouldLoop } from "../services/dependencies.js";
import { getSettings } from "../services/settingsStore.js";
import { loadDependencySuggestions, loadDismissedDependencies, saveDismissedDependencies } from "../services/dependencySuggestions.js";
import { getSourceStatus } from "../services/integrationHealthMonitor.js";
import { serverStatus, type MapStatus } from "../services/topology.js";
import { asyncHandler } from "../utils/asyncHandler.js";
export const dependenciesRouter = Router();
dependenciesRouter.use(requireAuth);
const edgeSchema = z.object({
fromType: z.enum(nodeTypes),
fromId: z.number().int().positive(),
toType: z.enum(nodeTypes),
toId: z.number().int().positive(),
});
// Everything signed in people may see: what needs what, with the "runs on" links of servers alongside (those are set on the server itself).
dependenciesRouter.get("/", asyncHandler(async (_req, res) => {
const graph = await loadGraph();
const written = new Set(graph.rows.map((r) => `${nodeKey(r.fromType, r.fromId)}>${nodeKey(r.toType, r.toId)}`));
const runsOn: { from: string; to: string }[] = [];
for (const [from, tos] of graph.edges) for (const to of tos) if (!written.has(`${from}>${to}`)) runsOn.push({ from, to });
const nodes = [...graph.names.entries()]
.map(([key, name]) => {
const [type, id] = key.split(":");
return { key, type, id: Number(id), name };
})
.sort((a, b) => a.type.localeCompare(b.type) || a.name.localeCompare(b.name));
res.json({
dependencies: graph.rows
.filter((r) => graph.names.has(nodeKey(r.fromType, r.fromId)) && graph.names.has(nodeKey(r.toType, r.toId)))
.map((r) => ({ id: r.id, from: { type: r.fromType, id: r.fromId, name: graph.names.get(nodeKey(r.fromType, r.fromId))! }, to: { type: r.toType, id: r.toId, name: graph.names.get(nodeKey(r.toType, r.toId))! }, createdAt: r.createdAt })),
runsOn: runsOn.map((r) => ({ from: { key: r.from, name: graph.names.get(r.from) ?? r.from }, to: { key: r.to, name: graph.names.get(r.to) ?? r.to } })),
nodes,
});
}));
// Dependencies worth writing, from what the app already knows (an integration reached at a server's own address). Everyone signed in can see them; operators
// add or dismiss them, as they would any dependency.
dependenciesRouter.get("/suggestions", asyncHandler(async (_req, res) => {
res.json(await loadDependencySuggestions());
}));
const keysSchema = z.object({ keys: z.array(z.string().min(1).max(100)).min(1).max(200) });
dependenciesRouter.post("/suggestions/add", requireRole("operator"), asyncHandler(async (req, res) => {
const parsed = keysSchema.safeParse(req.body);
if (!parsed.success) return res.status(400).json({ error: "invalid_body" });
const { suggestions } = await loadDependencySuggestions();
const wanted = new Set(parsed.data.keys);
const added: { id: number; from: string; to: string }[] = [];
for (const s of suggestions.filter((x) => wanted.has(x.key))) {
const [row] = await db.insert(dependencies).values({ fromType: "integration", fromId: s.from.id, toType: "server", toId: s.to.id }).returning();
await recordAudit({ actor: req.currentUser!, category: "dependency", action: "create", targetType: "dependency", targetId: row.id, detail: { from: s.from.name, to: s.to.name, fromKey: `integration:${s.from.id}`, toKey: `server:${s.to.id}`, suggested: true } });
added.push({ id: row.id, from: s.from.name, to: s.to.name });
}
if (added.length > 0) invalidateAlertsCache();
res.json({ added, ...(await loadDependencySuggestions()) });
}));
dependenciesRouter.post("/suggestions/dismiss", requireRole("operator"), asyncHandler(async (req, res) => {
const parsed = keysSchema.safeParse(req.body);
if (!parsed.success) return res.status(400).json({ error: "invalid_body" });
const dismissed = await loadDismissedDependencies();
for (const k of parsed.data.keys) dismissed.add(k);
await saveDismissedDependencies(dismissed);
res.json(await loadDependencySuggestions());
}));
dependenciesRouter.post("/suggestions/restore", requireRole("operator"), asyncHandler(async (_req, res) => {
await saveDismissedDependencies(new Set());
res.json(await loadDependencySuggestions());
}));
// What a thing would take with it, and what it needs itself: for the maintenance and update pages, which say so before it is done.
dependenciesRouter.get("/impact", asyncHandler(async (req, res) => {
const type = nodeTypes.find((t) => t === req.query.type);
const id = typeof req.query.id === "string" && /^\d+$/.test(req.query.id) ? Number(req.query.id) : NaN;
if (!type || !Number.isInteger(id)) return res.status(400).json({ error: "invalid_query", message: "Say which server or integration." });
const impact = await impactOf(type, id);
if (!impact) return res.status(404).json({ error: "not_found" });
res.json(impact);
}));
// The graph for the Map page: the servers and integrations that take part in any dependency, how each is doing, and who needs whom. An edge runs
// from the thing that is needed to the thing that needs it, so the foundations come first.
dependenciesRouter.get("/graph", asyncHandler(async (_req, res) => {
const graph = await loadGraph();
const written = new Set(graph.rows.map((r) => `${nodeKey(r.fromType, r.fromId)}>${nodeKey(r.toType, r.toId)}`));
const edges: { from: string; to: string; kind: "written" | "runs-on" | "uplink" }[] = [];
const taking = new Set<string>();
for (const [needing, needed] of graph.edges) {
for (const n of needed) {
// A device connected through another is an uplink (the controller says so); a server's "runs on" is the other kind of link nobody wrote.
edges.push({ from: n, to: needing, kind: written.has(`${needing}>${n}`) ? "written" : n.startsWith("device:") ? "uplink" : "runs-on" });
taking.add(needing);
taking.add(n);
}
}
const { healthChecks } = await getSettings();
const now = new Date();
const serverRows = await db.select({ id: servers.id, lastSeenAt: servers.lastSeenAt, thresholds: servers.thresholds }).from(servers);
const serverById = new Map(serverRows.map((s) => [s.id, s]));
const intById = new Map(graph.intRows.map((i) => [i.id, i]));
const deviceById = new Map((await db.select({ id: networkDevices.id, state: networkDevices.state }).from(networkDevices)).map((d) => [d.id, d]));
const nodes = [...taking]
.map((key) => {
const [type, rawId] = key.split(":");
const id = Number(rawId);
let status: MapStatus = "unknown";
if (type === "server") {
const s = serverById.get(id);
if (s) status = serverStatus(s, healthChecks.serverOfflineMinutes, now);
} else if (type === "device") {
const d = deviceById.get(id);
if (d) status = d.state === "online" ? "ok" : d.state === "offline" ? "bad" : d.state === "updating" ? "warn" : "unknown";
} else {
const i = intById.get(id);
if (i?.enabled) {
const st = getSourceStatus(i.type).status;
status = st === "failing" ? "bad" : st === "ok" ? "ok" : "unknown";
}
}
return { key, type: type as "server" | "integration" | "device", id, name: graph.names.get(key) ?? key, status, href: type === "server" ? `/servers/${id}` : type === "device" ? "/network/devices" : "/integrations" };
})
.sort((a, b) => a.name.localeCompare(b.name));
res.json({ nodes, edges });
}));
dependenciesRouter.post("/", requireRole("operator"), asyncHandler(async (req, res) => {
const parsed = edgeSchema.safeParse(req.body);
if (!parsed.success) return res.status(400).json({ error: "invalid_body", message: "Say what needs what: a server or an integration each.", details: parsed.error.flatten() });
const d = parsed.data;
const graph = await loadGraph();
const from = nodeKey(d.fromType, d.fromId);
const to = nodeKey(d.toType, d.toId);
if (!graph.names.has(from) || !graph.names.has(to)) return res.status(400).json({ error: "unknown_node", message: "One of those doesn't exist." });
if (from === to) return res.status(400).json({ error: "self", message: "Something can't depend on itself." });
if (graph.edges.get(from)?.includes(to)) return res.status(409).json({ error: "duplicate", message: "That is already so." });
if (wouldLoop(graph.edges, from, to)) {
return res.status(409).json({ error: "loop", message: `${graph.names.get(to)} already depends on ${graph.names.get(from)}, so this would make them wait for each other.` });
}
const [row] = await db.insert(dependencies).values(d).returning();
await recordAudit({ actor: req.currentUser!, category: "dependency", action: "create", targetType: "dependency", targetId: row.id, detail: { from: graph.names.get(from), to: graph.names.get(to), fromKey: from, toKey: to } });
invalidateAlertsCache();
res.status(201).json({ id: row.id });
}));
dependenciesRouter.delete("/:id", requireRole("operator"), asyncHandler(async (req, res) => {
const id = /^\d+$/.test(req.params.id) ? Number(req.params.id) : NaN;
if (!Number.isInteger(id)) return res.status(400).json({ error: "invalid_id" });
const [before] = await db.select().from(dependencies).where(eq(dependencies.id, id)).limit(1);
if (!before) return res.status(404).json({ error: "not_found" });
const graph = await loadGraph();
await db.delete(dependencies).where(eq(dependencies.id, id));
await recordAudit({
actor: req.currentUser!,
category: "dependency",
action: "delete",
targetType: "dependency",
targetId: id,
detail: { from: graph.names.get(nodeKey(before.fromType as "server", before.fromId)) ?? `${before.fromType} #${before.fromId}`, to: graph.names.get(nodeKey(before.toType as "server", before.toId)) ?? `${before.toType} #${before.toId}`, fromKey: `${before.fromType}:${before.fromId}`, toKey: `${before.toType}:${before.toId}` },
});
invalidateAlertsCache();
res.status(204).end();
}));