refactor: replace custom API fetch logic with requestJson utility across multiple pages

Updated the API fetching mechanism in various components to utilize the new requestJson function for improved consistency and error handling. This change affects the alerts, dashboard, data collection, filters, gre, network map, probes, recursive routes, route optimizer, servers, settings, traffic, and uptime pages.

backend/src/modules/servers/mapper/servers-mapper.ts

@@ -0,0 +1,61 @@
+import type { ServerRead, WanUplinkRead } from "../../../types/server.js"
+import type { ServerRow, SnapshotRow } from "../repository/servers-repository.js"
+
+function parseWanUplinksJson(raw: string | null | undefined): WanUplinkRead[] {
+  if (raw == null || raw === "") return []
+  try {
+    const data = JSON.parse(raw) as unknown
+    if (!Array.isArray(data)) return []
+    const out: WanUplinkRead[] = []
+    for (const row of data) {
+      if (typeof row !== "object" || row === null) continue
+      const r = row as Record<string, unknown>
+      out.push({
+        id: typeof r.id === "string" ? r.id : "",
+        name: typeof r.name === "string" ? r.name : "",
+        isp: typeof r.isp === "string" ? r.isp : "",
+        iface: typeof r.iface === "string" ? r.iface : "",
+        ip: typeof r.ip === "string" ? r.ip : "",
+        maxDl: typeof r.maxDl === "number" && Number.isFinite(r.maxDl) ? r.maxDl : 0,
+        maxUl: typeof r.maxUl === "number" && Number.isFinite(r.maxUl) ? r.maxUl : 0,
+      })
+    }
+    return out
+  } catch {
+    return []
+  }
+}
+
+export function toServerRead(server: ServerRow, snap: SnapshotRow | undefined): ServerRead {
+  return {
+    id: server.id,
+    name: server.name || server.host,
+    host: server.host,
+    port: server.port,
+    useSsl: server.useSsl,
+    verifySsl: server.verifySsl,
+    username: server.username,
+    password: server.password,
+    type: server.type,
+    site: server.site,
+    country: server.country,
+    asn: server.asn,
+    comment: server.comment,
+    enabled: server.enabled,
+    lanSubnet: server.lanSubnet ?? "",
+    wanUplinks: parseWanUplinksJson(server.wanUplinks),
+    createdAt: server.createdAt,
+    updatedAt: server.updatedAt,
+    status: snap ? snap.status : null,
+    latency: snap?.latencyMs ?? null,
+    os: snap?.rosVersion ?? null,
+    model: snap?.boardName ?? null,
+    uptime: snap?.uptime ?? null,
+    cpuLoad: snap?.cpuLoad ?? null,
+    freeMemory: snap?.freeMemory ?? null,
+    totalMemory: snap?.totalMemory ?? null,
+    identityName: snap?.identityName ?? null,
+    sessions: 0,
+    polledAt: snap?.polledAt ?? null,
+  }
+}

backend/src/modules/servers/repository/servers-repository.ts

@@ -0,0 +1,53 @@
+import { desc, eq } from "drizzle-orm"
+import { db } from "../../../db/index.js"
+import { serverSnapshots, servers } from "../../../db/schema.js"
+
+export type ServerRow = typeof servers.$inferSelect
+export type SnapshotRow = typeof serverSnapshots.$inferSelect
+
+export function listServerRows(): ServerRow[] {
+  return db.select().from(servers).all()
+}
+
+export function getServerRowById(id: number): ServerRow | undefined {
+  return db.select().from(servers).where(eq(servers.id, id)).limit(1).all()[0]
+}
+
+export function createServerRow(
+  values: Omit<typeof servers.$inferInsert, "id">,
+): ServerRow {
+  const [inserted] = db.insert(servers).values(values).returning().all()
+  return inserted
+}
+
+export function updateServerRowById(
+  id: number,
+  values: Partial<ServerRow>,
+): ServerRow {
+  const [updated] = db.update(servers).set(values).where(eq(servers.id, id)).returning().all()
+  return updated
+}
+
+export function deleteServerRowById(id: number): void {
+  db.delete(servers).where(eq(servers.id, id)).run()
+}
+
+export function listSnapshotsByServerId(serverId: number, limit: number): SnapshotRow[] {
+  return db
+    .select()
+    .from(serverSnapshots)
+    .where(eq(serverSnapshots.serverId, serverId))
+    .orderBy(desc(serverSnapshots.polledAt))
+    .limit(limit)
+    .all()
+}
+
+export function getLatestSnapshot(serverId: number): SnapshotRow | undefined {
+  return db
+    .select()
+    .from(serverSnapshots)
+    .where(eq(serverSnapshots.serverId, serverId))
+    .orderBy(desc(serverSnapshots.polledAt))
+    .limit(1)
+    .all()[0]
+}

backend/src/modules/servers/service/servers-service.ts

@@ -0,0 +1,55 @@
+import { toSnapshotRead } from "../../../services/poller.js"
+import {
+  createServerRow,
+  deleteServerRowById,
+  getLatestSnapshot,
+  getServerRowById,
+  listServerRows,
+  listSnapshotsByServerId,
+  updateServerRowById,
+} from "../repository/servers-repository.js"
+import { toServerRead } from "../mapper/servers-mapper.js"
+import type { ServerCreate, ServerRead, ServerUpdate, SnapshotRead } from "../../../types/server.js"
+
+export function listServersRead(): ServerRead[] {
+  return listServerRows().map((server) => toServerRead(server, getLatestSnapshot(server.id)))
+}
+
+export function getServerReadById(id: number): ServerRead | undefined {
+  const row = getServerRowById(id)
+  if (!row) return undefined
+  return toServerRead(row, getLatestSnapshot(row.id))
+}
+
+export function createServer(input: ServerCreate): ServerRead {
+  const now = new Date().toISOString()
+  const { wanUplinks, ...rest } = input
+  const inserted = createServerRow({
+    ...rest,
+    wanUplinks: JSON.stringify(wanUplinks ?? []),
+    createdAt: now,
+    updatedAt: now,
+  })
+  return toServerRead(inserted, undefined)
+}
+
+export function updateServer(id: number, input: ServerUpdate): ServerRead {
+  const { wanUplinks, ...rest } = input
+  const setPayload: Record<string, unknown> = { updatedAt: new Date().toISOString() }
+  for (const [k, v] of Object.entries(rest)) {
+    if (v !== undefined) setPayload[k] = v
+  }
+  if (wanUplinks !== undefined) {
+    setPayload.wanUplinks = JSON.stringify(wanUplinks)
+  }
+  const updated = updateServerRowById(id, setPayload as never)
+  return toServerRead(updated, getLatestSnapshot(updated.id))
+}
+
+export function deleteServer(id: number): void {
+  deleteServerRowById(id)
+}
+
+export function listServerSnapshots(id: number, limit: number): SnapshotRead[] {
+  return listSnapshotsByServerId(id, limit).map(toSnapshotRead)
+}