import { useMutation, useQuery, useQueryClient, type QueryClient, } from "@tanstack/react-query"; import { toast } from "sonner"; import { connectInstance, deleteInstance, exportInstanceToken, getInstance, getInstanceConnectivity, importInstance, listInstances, switchInstance, updateInstance, } from "@/services/instances"; import type { ConnectInstancePayload, ImportInstancePayload, UpdateInstancePayload, } from "@/types/instance"; import { RUNTIME_CONTEXT_QUERY_KEY, invalidateInstanceScopedQueries, queryKeys, resetInstanceScopedQueries, } from "@/lib/query-keys"; import { markDashboardRuntimeContextChange, useRuntimeContext, } from "@/providers/runtime-context-provider"; import { useI18n } from "@/i18n/i18n-context"; import type { RuntimeContext } from "@/types/runtime-context"; export const INSTANCES_QUERY_KEY = ["instances"] as const; export function resolveDisplayedInstanceName( context: Pick< RuntimeContext, "activeInstance" | "credentialSource" | "instanceName" >, configuredActiveInstance: string | null, ): string | null { return ( context.activeInstance ?? context.instanceName ?? configuredActiveInstance ); } /** Invalidate every cache whose data depends on the active instance. * Used after non-switch mutations (connect / import / update / delete) where * the current session can keep the existing data while a refetch lands. */ function invalidateInstanceScopedCaches(queryClient: QueryClient) { invalidateInstanceScopedQueries(queryClient); } /** Hard-reset every cache whose data is scoped to the active instance. * `removeQueries` evicts the entries outright instead of marking them * stale, so observers on the next render fetch from scratch — no stale * data flash from the previous instance during the brief refetch window. * Mirrors the pattern recommended by TanStack Query maintainers for * logout / tenant-switch flows. */ function resetInstanceScopedCaches(queryClient: QueryClient) { resetInstanceScopedQueries(queryClient); } function refreshRuntimeContext(queryClient: QueryClient) { void queryClient.invalidateQueries({ queryKey: RUNTIME_CONTEXT_QUERY_KEY }); } function invalidateInstanceConnectivity(queryClient: QueryClient) { void queryClient.invalidateQueries({ queryKey: ["instance-connectivity"] }); } export function useInstances() { const { context, ready } = useRuntimeContext(); return useQuery({ queryKey: queryKeys.instances(context.dataScopeKey), queryFn: listInstances, select: (data) => ({ ...data, activeInstance: resolveDisplayedInstanceName( context, data.activeInstance, ), }), enabled: ready, staleTime: 30 * 1000, }); } export function useInstanceConnectivity() { const { context, ready } = useRuntimeContext(); return useQuery({ queryKey: queryKeys.instanceConnectivity(context.dataScopeKey), queryFn: getInstanceConnectivity, enabled: ready, staleTime: 30 * 1000, refetchInterval: 30 * 1000, }); } export function useInstance(name: string | null | undefined) { const { context, ready } = useRuntimeContext(); return useQuery({ queryKey: queryKeys.instance(context.dataScopeKey, name), queryFn: () => getInstance(name as string), enabled: ready && !!name, staleTime: 30 * 1000, }); } export function useConnectInstance() { const queryClient = useQueryClient(); const { t } = useI18n(); return useMutation({ mutationFn: (payload: ConnectInstancePayload) => connectInstance(payload), onSuccess: () => { resetInstanceScopedCaches(queryClient); invalidateInstanceConnectivity(queryClient); refreshRuntimeContext(queryClient); toast.success(t("instance.toast.created")); }, onError: (error) => { toast.error( error instanceof Error ? error.message : t("instance.toast.createFailed"), ); }, }); } export function useImportInstance() { const queryClient = useQueryClient(); const { t } = useI18n(); return useMutation({ mutationFn: (payload: ImportInstancePayload) => importInstance(payload), onSuccess: () => { resetInstanceScopedCaches(queryClient); invalidateInstanceConnectivity(queryClient); refreshRuntimeContext(queryClient); toast.success(t("instance.toast.tokenImported")); }, onError: (error) => { toast.error( error instanceof Error ? error.message : t("instance.toast.tokenImportFailed"), ); }, }); } export function useUpdateInstance(name: string) { const queryClient = useQueryClient(); const { t } = useI18n(); return useMutation({ mutationFn: (patch: UpdateInstancePayload) => updateInstance(name, patch), onSuccess: () => { invalidateInstanceScopedCaches(queryClient); queryClient.invalidateQueries({ queryKey: ["instance"] }); invalidateInstanceConnectivity(queryClient); refreshRuntimeContext(queryClient); toast.success(t("instance.toast.updated")); }, onError: (error) => { toast.error( error instanceof Error ? error.message : t("instance.toast.updateFailed"), ); }, }); } export function useDeleteInstance() { const queryClient = useQueryClient(); const { t } = useI18n(); return useMutation({ mutationFn: (name: string) => deleteInstance(name), onSuccess: () => { invalidateInstanceScopedCaches(queryClient); invalidateInstanceConnectivity(queryClient); refreshRuntimeContext(queryClient); toast.success(t("instance.toast.deleted")); }, onError: (error) => { toast.error( error instanceof Error ? error.message : t("instance.toast.deleteFailed"), ); }, }); } export function useSwitchInstance() { const queryClient = useQueryClient(); const { context } = useRuntimeContext(); const { t } = useI18n(); return useMutation({ mutationFn: (name: string) => switchInstance(name), onSuccess: ({ activeInstance }) => { if (typeof window !== "undefined") { markDashboardRuntimeContextChange(window.sessionStorage, { previousDataScopeKey: context.dataScopeKey, targetActiveInstance: activeInstance, }); } // Switching the active instance is conceptually a tenant change: // every instance-scoped cache must be evicted (not just invalidated) // so the new instance never inherits the old one's KB / memory / // provider rows for even a single render. resetInstanceScopedCaches(queryClient); refreshRuntimeContext(queryClient); toast.success(t("instance.toast.switched")); }, onError: (error) => { toast.error( error instanceof Error ? error.message : t("instance.toast.switchFailed"), ); }, }); } export function useExportInstanceToken() { const { t } = useI18n(); return useMutation({ mutationFn: (name: string) => exportInstanceToken(name), onError: (error) => { toast.error( error instanceof Error ? error.message : t("instance.toast.exportFailed"), ); }, }); }