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

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 async function listServersRead(): Promise<ServerRead[]> {
  const rows = await listServerRows()
  return Promise.all(rows.map(async (server) => toServerRead(server, await getLatestSnapshot(server.id))))
}

export async function getServerReadById(id: number): Promise<ServerRead | undefined> {
  const row = await getServerRowById(id)
  if (!row) return undefined
  return toServerRead(row, await getLatestSnapshot(row.id))
}

export async function createServer(input: ServerCreate): Promise<ServerRead> {
  const now = new Date().toISOString()
  const { wanUplinks, ...rest } = input
  const inserted = await createServerRow({
    ...rest,
    wanUplinks: wanUplinks ?? [],
    createdAt: now,
    updatedAt: now,
  })
  return toServerRead(inserted, undefined)
}

export async function updateServer(id: number, input: ServerUpdate): Promise<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 = wanUplinks
  }
  const updated = await updateServerRowById(id, setPayload as never)
  return toServerRead(updated, await getLatestSnapshot(updated.id))
}

export async function deleteServer(id: number): Promise<void> {
  await deleteServerRowById(id)
}

export async function listServerSnapshots(id: number, limit: number): Promise<SnapshotRead[]> {
  return (await listSnapshotsByServerId(id, limit)).map(toSnapshotRead)
}