@syncular/console 0.0.6-159 → 0.0.6-165

package/dist/hooks/useConsoleApi.js

@@ -1,9 +1,8 @@
 /**
  * React Query hooks for Console API
  */
-import { unwrap } from '@syncular/transport-http';
 import { useMutation, useQuery, useQueryClient } from '@tanstack/react-query';
-import { useApiClient, useConnection } from './ConnectionContext.js';
+import { useConnection } from './ConnectionContext.js';
 import { useInstanceContext } from './useInstanceContext.js';
 const queryKeys = {
     stats: (params) => ['console', 'stats', params],
@@ -26,668 +25,517 @@ function resolveRefetchInterval(refreshIntervalMs, defaultValueMs) {
         return false;
     return refreshIntervalMs ?? defaultValueMs;
 }
-function withInstanceQuery(query, instanceId) {
-    if (!instanceId)
-        return query;
-    return { ...query, instanceId };
+function buildQueryString(query) {
+    const params = new URLSearchParams();
+    if (!query)
+        return params;
+    for (const [key, value] of Object.entries(query)) {
+        if (value === undefined || value === null)
+            continue;
+        params.set(key, String(value));
+    }
+    return params;
 }
-function serializePathSegment(value) {
-    return encodeURIComponent(String(value));
-}
-function buildConsoleUrl(serverUrl, path, queryString) {
+function buildConsoleUrl(serverUrl, path, query) {
     const baseUrl = serverUrl.endsWith('/') ? serverUrl.slice(0, -1) : serverUrl;
+    const queryString = buildQueryString(query);
     const suffix = queryString?.toString();
     return `${baseUrl}${path}${suffix ? `?${suffix}` : ''}`;
 }
-export function useStats(options = {}) {
-    const client = useApiClient();
-    const { instanceId: selectedInstanceId } = useInstanceContext();
-    const instanceId = options.instanceId ?? selectedInstanceId;
-    const query = withInstanceQuery(options.partitionId ? { partitionId: options.partitionId } : {}, instanceId);
+function requireConnection(connectionConfig, isConnected) {
+    if (!isConnected || !connectionConfig)
+        throw new Error('Not connected');
+    return connectionConfig;
+}
+async function fetchConsoleJson(args) {
+    const headers = {
+        Authorization: `Bearer ${args.connectionConfig.token}`,
+    };
+    if (args.body !== undefined) {
+        headers['Content-Type'] = 'application/json';
+    }
+    const response = await fetch(buildConsoleUrl(args.connectionConfig.serverUrl, args.path, args.query), {
+        method: args.method ?? 'GET',
+        headers,
+        body: args.body === undefined ? undefined : JSON.stringify(args.body),
+    });
+    if (!response.ok)
+        throw new Error(args.errorMessage);
+    return response.json();
+}
+async function fetchConsoleBlob(args) {
+    const response = await fetch(buildConsoleUrl(args.connectionConfig.serverUrl, args.path, args.query), {
+        method: 'GET',
+        headers: { Authorization: `Bearer ${args.connectionConfig.token}` },
+    });
+    if (!response.ok)
+        throw new Error(args.errorMessage);
+    return response.blob();
+}
+function useConsoleJsonQuery(options) {
+    const { config: connectionConfig, isConnected } = useConnection();
     return useQuery({
-        queryKey: queryKeys.stats({
-            partitionId: options.partitionId,
-            instanceId,
+        queryKey: options.queryKey,
+        queryFn: () => fetchConsoleJson({
+            connectionConfig: requireConnection(connectionConfig, isConnected),
+            path: options.path,
+            query: options.query,
+            method: options.method,
+            errorMessage: options.errorMessage,
         }),
+        enabled: (options.enabled ?? true) && isConnected && !!connectionConfig,
+        refetchInterval: options.refetchInterval,
+    });
+}
+function useConsoleEntityQuery(options) {
+    const { config: connectionConfig, isConnected } = useConnection();
+    return useQuery({
+        queryKey: options.queryKey,
         queryFn: () => {
-            if (!client)
-                throw new Error('Not connected');
-            return unwrap(client.GET('/console/stats', { params: { query } }));
+            if (options.id === undefined)
+                throw new Error(options.requiredMessage);
+            return fetchConsoleJson({
+                connectionConfig: requireConnection(connectionConfig, isConnected),
+                path: options.path(options.id),
+                query: options.query,
+                errorMessage: options.errorMessage,
+            });
         },
-        enabled: !!client,
+        enabled: (options.enabled ?? true) &&
+            options.id !== undefined &&
+            isConnected &&
+            !!connectionConfig,
+    });
+}
+function invalidateConsoleQueries(queryClient, queryKeysToInvalidate) {
+    for (const queryKey of queryKeysToInvalidate) {
+        queryClient.invalidateQueries({ queryKey });
+    }
+}
+function useEffectiveInstanceId(instanceId) {
+    const { instanceId: selectedInstanceId } = useInstanceContext();
+    return instanceId ?? selectedInstanceId;
+}
+function useConsoleJsonMutation(options) {
+    const { config: connectionConfig, isConnected } = useConnection();
+    const { instanceId: selectedInstanceId } = useInstanceContext();
+    const queryClient = useQueryClient();
+    return useMutation({
+        mutationFn: (variables) => options.mutationFn({
+            connectionConfig: requireConnection(connectionConfig, isConnected),
+            variables,
+            selectedInstanceId,
+        }),
+        onSuccess: () => {
+            if (!options.invalidateQueryKeys)
+                return;
+            invalidateConsoleQueries(queryClient, options.invalidateQueryKeys);
+        },
+    });
+}
+export function useStats(options = {}) {
+    const instanceId = useEffectiveInstanceId(options.instanceId);
+    return useConsoleJsonQuery({
+        queryKey: queryKeys.stats({ partitionId: options.partitionId, instanceId }),
+        path: '/console/stats',
+        query: {
+            partitionId: options.partitionId,
+            instanceId,
+        },
+        errorMessage: 'Failed to fetch stats',
         refetchInterval: resolveRefetchInterval(options.refetchIntervalMs, 5000),
     });
 }
 export function useTimeseriesStats(params = {}, options = {}) {
-    const client = useApiClient();
-    const { config: connectionConfig } = useConnection();
-    const { instanceId: selectedInstanceId } = useInstanceContext();
-    const instanceId = params.instanceId ?? selectedInstanceId;
-    return useQuery({
+    const instanceId = useEffectiveInstanceId(params.instanceId);
+    return useConsoleJsonQuery({
         queryKey: queryKeys.timeseries({ ...params, instanceId }),
-        queryFn: async () => {
-            if (!client || !connectionConfig)
-                throw new Error('Not connected');
-            // Use fetch directly since this endpoint may not be in OpenAPI yet
-            const queryString = new URLSearchParams();
-            if (params.interval)
-                queryString.set('interval', params.interval);
-            if (params.range)
-                queryString.set('range', params.range);
-            if (params.partitionId)
-                queryString.set('partitionId', params.partitionId);
-            if (instanceId)
-                queryString.set('instanceId', instanceId);
-            const response = await fetch(`${connectionConfig.serverUrl}/console/stats/timeseries?${queryString}`, { headers: { Authorization: `Bearer ${connectionConfig.token}` } });
-            if (!response.ok)
-                throw new Error('Failed to fetch timeseries stats');
-            return response.json();
+        path: '/console/stats/timeseries',
+        query: {
+            interval: params.interval,
+            range: params.range,
+            partitionId: params.partitionId,
+            instanceId,
         },
-        enabled: (options.enabled ?? true) && !!client && !!connectionConfig,
+        errorMessage: 'Failed to fetch timeseries stats',
+        enabled: options.enabled,
         refetchInterval: resolveRefetchInterval(options.refetchIntervalMs, 30000),
     });
 }
 export function useLatencyStats(params = {}, options = {}) {
-    const client = useApiClient();
-    const { config: connectionConfig } = useConnection();
-    const { instanceId: selectedInstanceId } = useInstanceContext();
-    const instanceId = params.instanceId ?? selectedInstanceId;
-    return useQuery({
+    const instanceId = useEffectiveInstanceId(params.instanceId);
+    return useConsoleJsonQuery({
         queryKey: queryKeys.latency({ ...params, instanceId }),
-        queryFn: async () => {
-            if (!client || !connectionConfig)
-                throw new Error('Not connected');
-            // Use fetch directly since this endpoint may not be in OpenAPI yet
-            const queryString = new URLSearchParams();
-            if (params.range)
-                queryString.set('range', params.range);
-            if (params.partitionId)
-                queryString.set('partitionId', params.partitionId);
-            if (instanceId)
-                queryString.set('instanceId', instanceId);
-            const response = await fetch(`${connectionConfig.serverUrl}/console/stats/latency?${queryString}`, { headers: { Authorization: `Bearer ${connectionConfig.token}` } });
-            if (!response.ok)
-                throw new Error('Failed to fetch latency stats');
-            return response.json();
+        path: '/console/stats/latency',
+        query: {
+            range: params.range,
+            partitionId: params.partitionId,
+            instanceId,
         },
-        enabled: (options.enabled ?? true) && !!client && !!connectionConfig,
+        errorMessage: 'Failed to fetch latency stats',
+        enabled: options.enabled,
         refetchInterval: resolveRefetchInterval(options.refetchIntervalMs, 30000),
     });
 }
 export function useCommits(params = {}, options = {}) {
-    const client = useApiClient();
-    const { instanceId: selectedInstanceId } = useInstanceContext();
-    const instanceId = params.instanceId ?? selectedInstanceId;
-    const query = withInstanceQuery({
-        limit: params.limit,
-        offset: params.offset,
-        partitionId: params.partitionId,
-    }, instanceId);
-    return useQuery({
+    const instanceId = useEffectiveInstanceId(params.instanceId);
+    return useConsoleJsonQuery({
         queryKey: queryKeys.commits({ ...params, instanceId }),
-        queryFn: () => {
-            if (!client)
-                throw new Error('Not connected');
-            return unwrap(client.GET('/console/commits', { params: { query } }));
+        path: '/console/commits',
+        query: {
+            limit: params.limit,
+            offset: params.offset,
+            partitionId: params.partitionId,
+            instanceId,
         },
-        enabled: (options.enabled ?? true) && !!client,
+        errorMessage: 'Failed to fetch commits',
+        enabled: options.enabled,
         refetchInterval: resolveRefetchInterval(options.refetchIntervalMs, 10000),
     });
 }
 export function useCommitDetail(seq, options = {}) {
-    const client = useApiClient();
-    const { config: connectionConfig } = useConnection();
-    const { instanceId: selectedInstanceId } = useInstanceContext();
-    const instanceId = options.instanceId ?? selectedInstanceId;
-    return useQuery({
+    const instanceId = useEffectiveInstanceId(options.instanceId);
+    return useConsoleEntityQuery({
         queryKey: queryKeys.commitDetail(seq, options.partitionId, instanceId),
-        queryFn: async () => {
-            if (!client || !connectionConfig)
-                throw new Error('Not connected');
-            if (seq === undefined)
-                throw new Error('Commit sequence is required');
-            const queryString = new URLSearchParams();
-            if (options.partitionId)
-                queryString.set('partitionId', options.partitionId);
-            if (instanceId)
-                queryString.set('instanceId', instanceId);
-            const suffix = queryString.toString();
-            const response = await fetch(`${connectionConfig.serverUrl}/console/commits/${serializePathSegment(seq)}${suffix ? `?${suffix}` : ''}`, { headers: { Authorization: `Bearer ${connectionConfig.token}` } });
-            if (!response.ok)
-                throw new Error('Failed to fetch commit detail');
-            return response.json();
+        id: seq,
+        requiredMessage: 'Commit sequence is required',
+        path: (value) => `/console/commits/${encodeURIComponent(String(value))}`,
+        query: {
+            partitionId: options.partitionId,
+            instanceId,
         },
-        enabled: (options.enabled ?? true) && seq !== undefined && !!client,
+        errorMessage: 'Failed to fetch commit detail',
+        enabled: options.enabled,
     });
 }
 export function useTimeline(params = {}, options = {}) {
-    const client = useApiClient();
-    const { instanceId: selectedInstanceId } = useInstanceContext();
-    const instanceId = params.instanceId ?? selectedInstanceId;
-    const query = withInstanceQuery({
-        limit: params.limit,
-        offset: params.offset,
-        partitionId: params.partitionId,
-        view: params.view,
-        eventType: params.eventType,
-        actorId: params.actorId,
-        clientId: params.clientId,
-        requestId: params.requestId,
-        traceId: params.traceId,
-        table: params.table,
-        outcome: params.outcome,
-        search: params.search,
-        from: params.from,
-        to: params.to,
-    }, instanceId);
-    return useQuery({
+    const instanceId = useEffectiveInstanceId(params.instanceId);
+    return useConsoleJsonQuery({
         queryKey: queryKeys.timeline({ ...params, instanceId }),
-        queryFn: () => {
-            if (!client)
-                throw new Error('Not connected');
-            return unwrap(client.GET('/console/timeline', { params: { query } }));
+        path: '/console/timeline',
+        query: {
+            limit: params.limit,
+            offset: params.offset,
+            partitionId: params.partitionId,
+            view: params.view,
+            eventType: params.eventType,
+            actorId: params.actorId,
+            clientId: params.clientId,
+            requestId: params.requestId,
+            traceId: params.traceId,
+            table: params.table,
+            outcome: params.outcome,
+            search: params.search,
+            from: params.from,
+            to: params.to,
+            instanceId,
         },
-        enabled: (options.enabled ?? true) && !!client,
+        errorMessage: 'Failed to fetch timeline',
+        enabled: options.enabled,
         refetchInterval: resolveRefetchInterval(options.refetchIntervalMs, 10000),
     });
 }
 export function useClients(params = {}, options = {}) {
-    const client = useApiClient();
-    const { instanceId: selectedInstanceId } = useInstanceContext();
-    const instanceId = params.instanceId ?? selectedInstanceId;
-    const query = withInstanceQuery({
-        limit: params.limit,
-        offset: params.offset,
-        partitionId: params.partitionId,
-    }, instanceId);
-    return useQuery({
+    const instanceId = useEffectiveInstanceId(params.instanceId);
+    return useConsoleJsonQuery({
         queryKey: queryKeys.clients({ ...params, instanceId }),
-        queryFn: () => {
-            if (!client)
-                throw new Error('Not connected');
-            return unwrap(client.GET('/console/clients', { params: { query } }));
+        path: '/console/clients',
+        query: {
+            limit: params.limit,
+            offset: params.offset,
+            partitionId: params.partitionId,
+            instanceId,
         },
-        enabled: (options.enabled ?? true) && !!client,
+        errorMessage: 'Failed to fetch clients',
+        enabled: options.enabled,
         refetchInterval: resolveRefetchInterval(options.refetchIntervalMs, 10000),
     });
 }
 export function useRequestEventDetail(id, options = {}) {
-    const client = useApiClient();
-    const { config: connectionConfig } = useConnection();
-    const { instanceId: selectedInstanceId } = useInstanceContext();
-    const instanceId = options.instanceId ?? selectedInstanceId;
-    return useQuery({
+    const instanceId = useEffectiveInstanceId(options.instanceId);
+    return useConsoleEntityQuery({
         queryKey: queryKeys.eventDetail(id, options.partitionId, instanceId),
-        queryFn: async () => {
-            if (!client || !connectionConfig)
-                throw new Error('Not connected');
-            if (id === undefined)
-                throw new Error('Event id is required');
-            const queryString = new URLSearchParams();
-            if (options.partitionId)
-                queryString.set('partitionId', options.partitionId);
-            if (instanceId)
-                queryString.set('instanceId', instanceId);
-            const suffix = queryString.toString();
-            const response = await fetch(`${connectionConfig.serverUrl}/console/events/${serializePathSegment(id)}${suffix ? `?${suffix}` : ''}`, { headers: { Authorization: `Bearer ${connectionConfig.token}` } });
-            if (!response.ok)
-                throw new Error('Failed to fetch event detail');
-            return response.json();
+        id,
+        requiredMessage: 'Event id is required',
+        path: (value) => `/console/events/${encodeURIComponent(String(value))}`,
+        query: {
+            partitionId: options.partitionId,
+            instanceId,
         },
-        enabled: (options.enabled ?? true) && id !== undefined && !!client,
+        errorMessage: 'Failed to fetch event detail',
+        enabled: options.enabled,
     });
 }
 export function useRequestEventPayload(id, options = {}) {
-    const client = useApiClient();
-    const { config: connectionConfig } = useConnection();
-    const { instanceId: selectedInstanceId } = useInstanceContext();
-    const instanceId = options.instanceId ?? selectedInstanceId;
-    return useQuery({
+    const instanceId = useEffectiveInstanceId(options.instanceId);
+    return useConsoleEntityQuery({
         queryKey: queryKeys.eventPayload(id, options.partitionId, instanceId),
-        queryFn: async () => {
-            if (!client || !connectionConfig)
-                throw new Error('Not connected');
-            if (id === undefined)
-                throw new Error('Event id is required');
-            const queryString = new URLSearchParams();
-            if (options.partitionId)
-                queryString.set('partitionId', options.partitionId);
-            if (instanceId)
-                queryString.set('instanceId', instanceId);
-            const suffix = queryString.toString();
-            const response = await fetch(`${connectionConfig.serverUrl}/console/events/${serializePathSegment(id)}/payload${suffix ? `?${suffix}` : ''}`, { headers: { Authorization: `Bearer ${connectionConfig.token}` } });
-            if (!response.ok)
-                throw new Error('Failed to fetch event payload');
-            return response.json();
+        id,
+        requiredMessage: 'Event id is required',
+        path: (value) => `/console/events/${encodeURIComponent(String(value))}/payload`,
+        query: {
+            partitionId: options.partitionId,
+            instanceId,
         },
-        enabled: (options.enabled ?? true) && id !== undefined && !!client,
+        errorMessage: 'Failed to fetch event payload',
+        enabled: options.enabled,
     });
 }
 export function useHandlers(options = {}) {
-    const client = useApiClient();
-    const { config: connectionConfig } = useConnection();
-    const { instanceId: selectedInstanceId } = useInstanceContext();
-    const instanceId = options.instanceId ?? selectedInstanceId;
-    return useQuery({
+    const instanceId = useEffectiveInstanceId(options.instanceId);
+    return useConsoleJsonQuery({
         queryKey: queryKeys.handlers(instanceId),
-        queryFn: async () => {
-            if (!client || !connectionConfig)
-                throw new Error('Not connected');
-            const queryString = new URLSearchParams();
-            if (instanceId)
-                queryString.set('instanceId', instanceId);
-            const response = await fetch(buildConsoleUrl(connectionConfig.serverUrl, '/console/handlers', queryString), {
-                headers: { Authorization: `Bearer ${connectionConfig.token}` },
-            });
-            if (!response.ok)
-                throw new Error('Failed to fetch handlers');
-            return response.json();
-        },
-        enabled: !!client && !!connectionConfig,
+        path: '/console/handlers',
+        query: { instanceId },
+        errorMessage: 'Failed to fetch handlers',
     });
 }
 export function usePrunePreview(options = {}) {
-    const client = useApiClient();
-    const { config: connectionConfig } = useConnection();
-    const { instanceId: selectedInstanceId } = useInstanceContext();
-    const instanceId = options.instanceId ?? selectedInstanceId;
-    return useQuery({
+    const instanceId = useEffectiveInstanceId(options.instanceId);
+    return useConsoleJsonQuery({
         queryKey: queryKeys.prunePreview(instanceId),
-        queryFn: async () => {
-            if (!client || !connectionConfig)
-                throw new Error('Not connected');
-            const queryString = new URLSearchParams();
-            if (instanceId)
-                queryString.set('instanceId', instanceId);
-            const response = await fetch(buildConsoleUrl(connectionConfig.serverUrl, '/console/prune/preview', queryString), {
-                method: 'POST',
-                headers: { Authorization: `Bearer ${connectionConfig.token}` },
-            });
-            if (!response.ok)
-                throw new Error('Failed to fetch prune preview');
-            return response.json();
-        },
-        enabled: !!client && !!connectionConfig && (options.enabled ?? true),
+        path: '/console/prune/preview',
+        query: { instanceId },
+        method: 'POST',
+        errorMessage: 'Failed to fetch prune preview',
+        enabled: options.enabled,
     });
 }
 export function useOperationEvents(params = {}, options = {}) {
-    const client = useApiClient();
-    const { instanceId: selectedInstanceId } = useInstanceContext();
-    const instanceId = params.instanceId ?? selectedInstanceId;
-    const query = withInstanceQuery({
-        limit: params.limit,
-        offset: params.offset,
-        operationType: params.operationType,
-        partitionId: params.partitionId,
-    }, instanceId);
-    return useQuery({
+    const instanceId = useEffectiveInstanceId(params.instanceId);
+    return useConsoleJsonQuery({
         queryKey: queryKeys.operations({ ...params, instanceId }),
-        queryFn: () => {
-            if (!client)
-                throw new Error('Not connected');
-            return unwrap(client.GET('/console/operations', { params: { query } }));
+        path: '/console/operations',
+        query: {
+            limit: params.limit,
+            offset: params.offset,
+            operationType: params.operationType,
+            partitionId: params.partitionId,
+            instanceId,
         },
-        enabled: (options.enabled ?? true) && !!client,
+        errorMessage: 'Failed to fetch operations',
+        enabled: options.enabled,
         refetchInterval: resolveRefetchInterval(options.refetchIntervalMs, 10000),
     });
 }
+export function useClearEventsMutation() {
+    return useConsoleJsonMutation({
+        mutationFn: async ({ connectionConfig, selectedInstanceId }) => fetchConsoleJson({
+            connectionConfig,
+            path: '/console/events',
+            query: { instanceId: selectedInstanceId },
+            method: 'DELETE',
+            errorMessage: 'Failed to clear events',
+        }),
+        invalidateQueryKeys: [['console', 'events']],
+    });
+}
 export function useEvictClientMutation() {
-    const client = useApiClient();
-    const { config: connectionConfig } = useConnection();
-    const { instanceId: selectedInstanceId } = useInstanceContext();
-    const queryClient = useQueryClient();
-    return useMutation({
-        mutationFn: async ({ clientId, partitionId, instanceId }) => {
-            if (!client || !connectionConfig)
-                throw new Error('Not connected');
-            const effectiveInstanceId = instanceId ?? selectedInstanceId;
-            const queryString = new URLSearchParams();
-            if (partitionId)
-                queryString.set('partitionId', partitionId);
-            if (effectiveInstanceId)
-                queryString.set('instanceId', effectiveInstanceId);
-            const response = await fetch(buildConsoleUrl(connectionConfig.serverUrl, `/console/clients/${serializePathSegment(clientId)}`, queryString), {
+    return useConsoleJsonMutation({
+        mutationFn: async ({ connectionConfig, variables, selectedInstanceId }) => {
+            const effectiveInstanceId = variables.instanceId ?? selectedInstanceId;
+            return fetchConsoleJson({
+                connectionConfig,
+                path: `/console/clients/${encodeURIComponent(variables.clientId)}`,
+                query: {
+                    partitionId: variables.partitionId,
+                    instanceId: effectiveInstanceId,
+                },
                 method: 'DELETE',
-                headers: { Authorization: `Bearer ${connectionConfig.token}` },
+                errorMessage: 'Failed to evict client',
             });
-            if (!response.ok)
-                throw new Error('Failed to evict client');
-            return response.json();
-        },
-        onSuccess: () => {
-            queryClient.invalidateQueries({ queryKey: ['console', 'clients'] });
-            queryClient.invalidateQueries({ queryKey: ['console', 'stats'] });
-            queryClient.invalidateQueries({ queryKey: ['console', 'operations'] });
         },
+        invalidateQueryKeys: [
+            ['console', 'clients'],
+            ['console', 'stats'],
+            ['console', 'operations'],
+        ],
     });
 }
 export function usePruneMutation() {
-    const client = useApiClient();
-    const { config: connectionConfig } = useConnection();
-    const { instanceId } = useInstanceContext();
-    const queryClient = useQueryClient();
-    return useMutation({
-        mutationFn: async () => {
-            if (!client || !connectionConfig)
-                throw new Error('Not connected');
-            const queryString = new URLSearchParams();
-            if (instanceId)
-                queryString.set('instanceId', instanceId);
-            const response = await fetch(buildConsoleUrl(connectionConfig.serverUrl, '/console/prune', queryString), {
-                method: 'POST',
-                headers: { Authorization: `Bearer ${connectionConfig.token}` },
-            });
-            if (!response.ok)
-                throw new Error('Failed to prune');
-            return response.json();
-        },
-        onSuccess: () => {
-            queryClient.invalidateQueries({ queryKey: ['console', 'stats'] });
-            queryClient.invalidateQueries({ queryKey: ['console', 'commits'] });
-            queryClient.invalidateQueries({ queryKey: ['console', 'timeline'] });
-            queryClient.invalidateQueries({
-                queryKey: ['console', 'prune', 'preview'],
-            });
-            queryClient.invalidateQueries({ queryKey: ['console', 'operations'] });
-        },
+    return useConsoleJsonMutation({
+        mutationFn: async ({ connectionConfig, selectedInstanceId }) => fetchConsoleJson({
+            connectionConfig,
+            path: '/console/prune',
+            query: { instanceId: selectedInstanceId },
+            method: 'POST',
+            errorMessage: 'Failed to prune',
+        }),
+        invalidateQueryKeys: [
+            ['console', 'stats'],
+            ['console', 'commits'],
+            ['console', 'timeline'],
+            ['console', 'prune', 'preview'],
+            ['console', 'operations'],
+        ],
     });
 }
 export function useCompactMutation() {
-    const client = useApiClient();
-    const { config: connectionConfig } = useConnection();
-    const { instanceId } = useInstanceContext();
-    const queryClient = useQueryClient();
-    return useMutation({
-        mutationFn: async () => {
-            if (!client || !connectionConfig)
-                throw new Error('Not connected');
-            const queryString = new URLSearchParams();
-            if (instanceId)
-                queryString.set('instanceId', instanceId);
-            const response = await fetch(buildConsoleUrl(connectionConfig.serverUrl, '/console/compact', queryString), {
-                method: 'POST',
-                headers: { Authorization: `Bearer ${connectionConfig.token}` },
-            });
-            if (!response.ok)
-                throw new Error('Failed to compact');
-            return response.json();
-        },
-        onSuccess: () => {
-            queryClient.invalidateQueries({ queryKey: ['console', 'stats'] });
-            queryClient.invalidateQueries({ queryKey: ['console', 'operations'] });
-        },
+    return useConsoleJsonMutation({
+        mutationFn: async ({ connectionConfig, selectedInstanceId }) => fetchConsoleJson({
+            connectionConfig,
+            path: '/console/compact',
+            query: { instanceId: selectedInstanceId },
+            method: 'POST',
+            errorMessage: 'Failed to compact',
+        }),
+        invalidateQueryKeys: [
+            ['console', 'stats'],
+            ['console', 'operations'],
+        ],
     });
 }
 export function useNotifyDataChangeMutation() {
-    const client = useApiClient();
-    const { config: connectionConfig } = useConnection();
-    const { instanceId: selectedInstanceId } = useInstanceContext();
-    const queryClient = useQueryClient();
-    return useMutation({
-        mutationFn: async (request) => {
-            if (!client || !connectionConfig)
-                throw new Error('Not connected');
-            const effectiveInstanceId = request.instanceId ?? selectedInstanceId;
-            const queryString = new URLSearchParams();
-            if (effectiveInstanceId)
-                queryString.set('instanceId', effectiveInstanceId);
-            const response = await fetch(buildConsoleUrl(connectionConfig.serverUrl, '/console/notify-data-change', queryString), {
+    return useConsoleJsonMutation({
+        mutationFn: async ({ connectionConfig, variables, selectedInstanceId }) => {
+            const effectiveInstanceId = variables.instanceId ?? selectedInstanceId;
+            return fetchConsoleJson({
+                connectionConfig,
+                path: '/console/notify-data-change',
+                query: { instanceId: effectiveInstanceId },
                 method: 'POST',
-                headers: {
-                    Authorization: `Bearer ${connectionConfig.token}`,
-                    'Content-Type': 'application/json',
+                body: {
+                    tables: variables.tables,
+                    partitionId: variables.partitionId,
                 },
-                body: JSON.stringify({
-                    tables: request.tables,
-                    partitionId: request.partitionId,
-                }),
+                errorMessage: 'Failed to notify data change',
             });
-            if (!response.ok)
-                throw new Error('Failed to notify data change');
-            return response.json();
-        },
-        onSuccess: () => {
-            queryClient.invalidateQueries({ queryKey: ['console', 'stats'] });
-            queryClient.invalidateQueries({ queryKey: ['console', 'commits'] });
-            queryClient.invalidateQueries({ queryKey: ['console', 'timeline'] });
-            queryClient.invalidateQueries({ queryKey: ['console', 'operations'] });
         },
+        invalidateQueryKeys: [
+            ['console', 'stats'],
+            ['console', 'commits'],
+            ['console', 'timeline'],
+            ['console', 'operations'],
+        ],
     });
 }
 export function useApiKeys(params = {}) {
-    const client = useApiClient();
-    const { config: connectionConfig } = useConnection();
-    const { instanceId: selectedInstanceId } = useInstanceContext();
-    const instanceId = params.instanceId ?? selectedInstanceId;
-    return useQuery({
+    const instanceId = useEffectiveInstanceId(params.instanceId);
+    return useConsoleJsonQuery({
         queryKey: queryKeys.apiKeys({ ...params, instanceId }),
-        queryFn: async () => {
-            if (!client || !connectionConfig)
-                throw new Error('Not connected');
-            const queryString = new URLSearchParams();
-            if (params.limit !== undefined)
-                queryString.set('limit', String(params.limit));
-            if (params.offset !== undefined)
-                queryString.set('offset', String(params.offset));
-            if (params.type)
-                queryString.set('type', params.type);
-            if (params.status)
-                queryString.set('status', params.status);
-            if (params.expiresWithinDays !== undefined) {
-                queryString.set('expiresWithinDays', String(params.expiresWithinDays));
-            }
-            if (instanceId)
-                queryString.set('instanceId', instanceId);
-            const response = await fetch(buildConsoleUrl(connectionConfig.serverUrl, '/console/api-keys', queryString), {
-                headers: { Authorization: `Bearer ${connectionConfig.token}` },
-            });
-            if (!response.ok)
-                throw new Error('Failed to fetch API keys');
-            return response.json();
+        path: '/console/api-keys',
+        query: {
+            limit: params.limit,
+            offset: params.offset,
+            type: params.type,
+            status: params.status,
+            expiresWithinDays: params.expiresWithinDays,
+            instanceId,
         },
-        enabled: !!client && !!connectionConfig,
+        errorMessage: 'Failed to fetch API keys',
     });
 }
 export function useCreateApiKeyMutation() {
-    const client = useApiClient();
-    const { config: connectionConfig } = useConnection();
-    const { instanceId } = useInstanceContext();
-    const queryClient = useQueryClient();
-    return useMutation({
-        mutationFn: async (request) => {
-            if (!client || !connectionConfig)
-                throw new Error('Not connected');
-            const queryString = new URLSearchParams();
-            if (instanceId)
-                queryString.set('instanceId', instanceId);
-            const response = await fetch(buildConsoleUrl(connectionConfig.serverUrl, '/console/api-keys', queryString), {
+    return useConsoleJsonMutation({
+        mutationFn: async ({ connectionConfig, variables, selectedInstanceId }) => {
+            return fetchConsoleJson({
+                connectionConfig,
+                path: '/console/api-keys',
+                query: { instanceId: selectedInstanceId },
                 method: 'POST',
-                headers: {
-                    Authorization: `Bearer ${connectionConfig.token}`,
-                    'Content-Type': 'application/json',
-                },
-                body: JSON.stringify(request),
+                body: variables,
+                errorMessage: 'Failed to create API key',
             });
-            if (!response.ok)
-                throw new Error('Failed to create API key');
-            return response.json();
-        },
-        onSuccess: () => {
-            queryClient.invalidateQueries({ queryKey: ['console', 'api-keys'] });
         },
+        invalidateQueryKeys: [['console', 'api-keys']],
     });
 }
 export function useRevokeApiKeyMutation() {
-    const client = useApiClient();
-    const { config: connectionConfig } = useConnection();
-    const { instanceId } = useInstanceContext();
-    const queryClient = useQueryClient();
-    return useMutation({
-        mutationFn: async (keyId) => {
-            if (!client || !connectionConfig)
-                throw new Error('Not connected');
-            const queryString = new URLSearchParams();
-            if (instanceId)
-                queryString.set('instanceId', instanceId);
-            const response = await fetch(buildConsoleUrl(connectionConfig.serverUrl, `/console/api-keys/${serializePathSegment(keyId)}`, queryString), {
+    return useConsoleJsonMutation({
+        mutationFn: async ({ connectionConfig, variables, selectedInstanceId }) => {
+            return fetchConsoleJson({
+                connectionConfig,
+                path: `/console/api-keys/${encodeURIComponent(variables)}`,
+                query: { instanceId: selectedInstanceId },
                 method: 'DELETE',
-                headers: { Authorization: `Bearer ${connectionConfig.token}` },
+                errorMessage: 'Failed to revoke API key',
             });
-            if (!response.ok)
-                throw new Error('Failed to revoke API key');
-            return response.json();
-        },
-        onSuccess: () => {
-            queryClient.invalidateQueries({ queryKey: ['console', 'api-keys'] });
         },
+        invalidateQueryKeys: [['console', 'api-keys']],
     });
 }
 export function useBulkRevokeApiKeysMutation() {
-    const client = useApiClient();
-    const { config: connectionConfig } = useConnection();
-    const { instanceId } = useInstanceContext();
-    const queryClient = useQueryClient();
-    return useMutation({
-        mutationFn: async (request) => {
-            if (!client || !connectionConfig)
-                throw new Error('Not connected');
-            const queryString = new URLSearchParams();
-            if (instanceId)
-                queryString.set('instanceId', instanceId);
-            const response = await fetch(buildConsoleUrl(connectionConfig.serverUrl, '/console/api-keys/bulk-revoke', queryString), {
+    return useConsoleJsonMutation({
+        mutationFn: async ({ connectionConfig, variables, selectedInstanceId }) => {
+            return fetchConsoleJson({
+                connectionConfig,
+                path: '/console/api-keys/bulk-revoke',
+                query: { instanceId: selectedInstanceId },
                 method: 'POST',
-                headers: {
-                    Authorization: `Bearer ${connectionConfig.token}`,
-                    'Content-Type': 'application/json',
-                },
-                body: JSON.stringify(request),
+                body: variables,
+                errorMessage: 'Failed to bulk revoke API keys',
             });
-            if (!response.ok)
-                throw new Error('Failed to bulk revoke API keys');
-            return response.json();
-        },
-        onSuccess: () => {
-            queryClient.invalidateQueries({ queryKey: ['console', 'api-keys'] });
         },
+        invalidateQueryKeys: [['console', 'api-keys']],
     });
 }
 export function useRotateApiKeyMutation() {
-    const client = useApiClient();
-    const { config: connectionConfig } = useConnection();
-    const { instanceId } = useInstanceContext();
-    const queryClient = useQueryClient();
-    return useMutation({
-        mutationFn: async (keyId) => {
-            if (!client || !connectionConfig)
-                throw new Error('Not connected');
-            const queryString = new URLSearchParams();
-            if (instanceId)
-                queryString.set('instanceId', instanceId);
-            const response = await fetch(buildConsoleUrl(connectionConfig.serverUrl, `/console/api-keys/${serializePathSegment(keyId)}/rotate`, queryString), {
+    return useConsoleJsonMutation({
+        mutationFn: async ({ connectionConfig, variables, selectedInstanceId }) => {
+            return fetchConsoleJson({
+                connectionConfig,
+                path: `/console/api-keys/${encodeURIComponent(variables)}/rotate`,
+                query: { instanceId: selectedInstanceId },
                 method: 'POST',
-                headers: { Authorization: `Bearer ${connectionConfig.token}` },
+                errorMessage: 'Failed to rotate API key',
             });
-            if (!response.ok)
-                throw new Error('Failed to rotate API key');
-            return response.json();
-        },
-        onSuccess: () => {
-            queryClient.invalidateQueries({ queryKey: ['console', 'api-keys'] });
         },
+        invalidateQueryKeys: [['console', 'api-keys']],
     });
 }
 export function useStageRotateApiKeyMutation() {
-    const client = useApiClient();
-    const { config: connectionConfig } = useConnection();
-    const { instanceId } = useInstanceContext();
-    const queryClient = useQueryClient();
-    return useMutation({
-        mutationFn: async (keyId) => {
-            if (!client || !connectionConfig)
-                throw new Error('Not connected');
-            const queryString = new URLSearchParams();
-            if (instanceId)
-                queryString.set('instanceId', instanceId);
-            const response = await fetch(buildConsoleUrl(connectionConfig.serverUrl, `/console/api-keys/${serializePathSegment(keyId)}/rotate/stage`, queryString), {
+    return useConsoleJsonMutation({
+        mutationFn: async ({ connectionConfig, variables, selectedInstanceId }) => {
+            return fetchConsoleJson({
+                connectionConfig,
+                path: `/console/api-keys/${encodeURIComponent(variables)}/rotate/stage`,
+                query: { instanceId: selectedInstanceId },
                 method: 'POST',
-                headers: { Authorization: `Bearer ${connectionConfig.token}` },
+                errorMessage: 'Failed to stage-rotate API key',
             });
-            if (!response.ok)
-                throw new Error('Failed to stage-rotate API key');
-            return response.json();
-        },
-        onSuccess: () => {
-            queryClient.invalidateQueries({ queryKey: ['console', 'api-keys'] });
         },
+        invalidateQueryKeys: [['console', 'api-keys']],
     });
 }
 // ---------------------------------------------------------------------------
 // Blob storage hooks
 // ---------------------------------------------------------------------------
 export function useBlobs(options = {}) {
-    const { config: connectionConfig } = useConnection();
-    return useQuery({
+    return useConsoleJsonQuery({
         queryKey: queryKeys.storage({
             prefix: options.prefix,
             cursor: options.cursor,
             limit: options.limit,
         }),
-        queryFn: async () => {
-            if (!connectionConfig)
-                throw new Error('Not connected');
-            const queryString = new URLSearchParams();
-            if (options.prefix)
-                queryString.set('prefix', options.prefix);
-            if (options.cursor)
-                queryString.set('cursor', options.cursor);
-            if (options.limit)
-                queryString.set('limit', String(options.limit));
-            const response = await fetch(buildConsoleUrl(connectionConfig.serverUrl, '/console/storage', queryString), {
-                method: 'GET',
-                headers: { Authorization: `Bearer ${connectionConfig.token}` },
-            });
-            if (!response.ok)
-                throw new Error('Failed to list blobs');
-            return response.json();
+        path: '/console/storage',
+        query: {
+            prefix: options.prefix,
+            cursor: options.cursor,
+            limit: options.limit,
         },
-        enabled: !!connectionConfig,
+        errorMessage: 'Failed to list blobs',
         refetchInterval: resolveRefetchInterval(options.refetchIntervalMs, 30000),
     });
 }
 export function useDeleteBlobMutation() {
-    const { config: connectionConfig } = useConnection();
-    const queryClient = useQueryClient();
-    return useMutation({
-        mutationFn: async (key) => {
-            if (!connectionConfig)
-                throw new Error('Not connected');
-            const encodedKey = encodeURIComponent(key);
-            const response = await fetch(buildConsoleUrl(connectionConfig.serverUrl, `/console/storage/${encodedKey}`, new URLSearchParams()), {
-                method: 'DELETE',
-                headers: { Authorization: `Bearer ${connectionConfig.token}` },
-            });
-            if (!response.ok)
-                throw new Error('Failed to delete blob');
-            return response.json();
-        },
-        onSuccess: () => {
-            queryClient.invalidateQueries({ queryKey: ['console', 'storage'] });
-        },
+    return useConsoleJsonMutation({
+        mutationFn: async ({ connectionConfig, variables }) => fetchConsoleJson({
+            connectionConfig,
+            path: `/console/storage/${encodeURIComponent(variables)}`,
+            method: 'DELETE',
+            errorMessage: 'Failed to delete blob',
+        }),
+        invalidateQueryKeys: [['console', 'storage']],
     });
 }
 export function useBlobDownload() {
-    const { config: connectionConfig } = useConnection();
+    const { config: connectionConfig, isConnected } = useConnection();
     return async (key) => {
-        if (!connectionConfig)
-            throw new Error('Not connected');
-        const encodedKey = encodeURIComponent(key);
-        const response = await fetch(buildConsoleUrl(connectionConfig.serverUrl, `/console/storage/${encodedKey}/download`, new URLSearchParams()), {
-            method: 'GET',
-            headers: { Authorization: `Bearer ${connectionConfig.token}` },
+        const blob = await fetchConsoleBlob({
+            connectionConfig: requireConnection(connectionConfig, isConnected),
+            path: `/console/storage/${encodeURIComponent(key)}/download`,
+            errorMessage: 'Failed to download blob',
         });
-        if (!response.ok)
-            throw new Error('Failed to download blob');
-        const blob = await response.blob();
         const url = URL.createObjectURL(blob);
         const a = document.createElement('a');
         a.href = url;