flxn-app/src/features/telemetry/queries.ts

import { useServerSuspenseQuery } from "@/lib/tanstack-query/hooks";
import {
  getClientErrorGroups,
  getRollupRange,
  getSessionTimeline,
  getTelemetryRuntimeStatus,
  listSessions,
  listTelemetryAlerts,
  searchClientErrors,
  searchClientEvents,
} from "./server";
import type { ClientErrorSearchParams, ClientEventSearchParams } from "./types";

interface ErrorGroupParams {
  from: string;
  to: string;
  includeResolved?: boolean;
  limit?: number;
}

interface RollupRangeParams {
  metrics: string[];
  from: string;
  to: string;
  dim?: string;
}

export const telemetryKeys = {
  all: ["telemetry"] as const,
  events: (params: ClientEventSearchParams) => ["telemetry", "events", params] as const,
  errors: (params: ClientErrorSearchParams) => ["telemetry", "errors", params] as const,
  errorGroups: (params: ErrorGroupParams) => ["telemetry", "errorGroups", params] as const,
  rollups: (params: RollupRangeParams) => ["telemetry", "rollups", params] as const,
  alerts: (page: number) => ["telemetry", "alerts", page] as const,
  sessions: (params: { days?: number; page?: number }) =>
    ["telemetry", "sessions", params] as const,
  sessionTimeline: (sessionId: string) =>
    ["telemetry", "sessionTimeline", sessionId] as const,
  runtimeStatus: ["telemetry", "runtimeStatus"] as const,
};

export const telemetryQueries = {
  events: (params: ClientEventSearchParams = {}) => ({
    queryKey: telemetryKeys.events(params),
    queryFn: () => searchClientEvents({ data: params }),
  }),
  errors: (params: ClientErrorSearchParams = {}) => ({
    queryKey: telemetryKeys.errors(params),
    queryFn: () => searchClientErrors({ data: params }),
  }),
  errorGroups: (params: ErrorGroupParams) => ({
    queryKey: telemetryKeys.errorGroups(params),
    queryFn: () => getClientErrorGroups({ data: params }),
  }),
  rollups: (params: RollupRangeParams) => ({
    queryKey: telemetryKeys.rollups(params),
    queryFn: () => getRollupRange({ data: params }),
  }),
  alerts: (page = 1) => ({
    queryKey: telemetryKeys.alerts(page),
    queryFn: () => listTelemetryAlerts({ data: { page } }),
  }),
  sessions: (params: { days?: number; page?: number } = {}) => ({
    queryKey: telemetryKeys.sessions(params),
    queryFn: () => listSessions({ data: params }),
  }),
  sessionTimeline: (sessionId: string) => ({
    queryKey: telemetryKeys.sessionTimeline(sessionId),
    queryFn: () => getSessionTimeline({ data: { sessionId } }),
  }),
  runtimeStatus: () => ({
    queryKey: telemetryKeys.runtimeStatus,
    queryFn: () => getTelemetryRuntimeStatus(),
  }),
};

export const useClientEvents = (params: ClientEventSearchParams = {}) =>
  useServerSuspenseQuery(telemetryQueries.events(params));

export const useClientErrors = (params: ClientErrorSearchParams = {}) =>
  useServerSuspenseQuery(telemetryQueries.errors(params));

export const useClientErrorGroups = (params: ErrorGroupParams) =>
  useServerSuspenseQuery(telemetryQueries.errorGroups(params));

export const useRollupRange = (params: RollupRangeParams) =>
  useServerSuspenseQuery(telemetryQueries.rollups(params));

export const useSessions = (params: { days?: number; page?: number } = {}) =>
  useServerSuspenseQuery(telemetryQueries.sessions(params));

export const useSessionTimeline = (sessionId: string) =>
  useServerSuspenseQuery(telemetryQueries.sessionTimeline(sessionId));

export const useTelemetryRuntimeStatus = () =>
  useServerSuspenseQuery(telemetryQueries.runtimeStatus());