@syncular/console 0.0.0 → 0.0.4-25

package/dist/hooks/useConsoleApi.js

@@ -0,0 +1,623 @@
+/**
+ * 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 { useInstanceContext } from './useInstanceContext.js';
+const queryKeys = {
+    stats: (params) => ['console', 'stats', params],
+    timeseries: (params) => ['console', 'stats', 'timeseries', params],
+    latency: (params) => ['console', 'stats', 'latency', params],
+    commits: (params) => ['console', 'commits', params],
+    commitDetail: (seq, partitionId, instanceId) => ['console', 'commit-detail', seq, partitionId, instanceId],
+    timeline: (params) => ['console', 'timeline', params],
+    clients: (params) => ['console', 'clients', params],
+    eventDetail: (id, partitionId, instanceId) => ['console', 'event-detail', id, partitionId, instanceId],
+    eventPayload: (id, partitionId, instanceId) => ['console', 'event-payload', id, partitionId, instanceId],
+    handlers: (instanceId) => ['console', 'handlers', instanceId],
+    prunePreview: (instanceId) => ['console', 'prune', 'preview', instanceId],
+    operations: (params) => ['console', 'operations', params],
+    apiKeys: (params) => ['console', 'api-keys', params],
+};
+function resolveRefetchInterval(refreshIntervalMs, defaultValueMs) {
+    if (refreshIntervalMs === 0)
+        return false;
+    return refreshIntervalMs ?? defaultValueMs;
+}
+function withInstanceQuery(query, instanceId) {
+    if (!instanceId)
+        return query;
+    return { ...query, instanceId };
+}
+function serializePathSegment(value) {
+    return encodeURIComponent(String(value));
+}
+function buildConsoleUrl(serverUrl, path, queryString) {
+    const baseUrl = serverUrl.endsWith('/') ? serverUrl.slice(0, -1) : serverUrl;
+    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);
+    return useQuery({
+        queryKey: queryKeys.stats({
+            partitionId: options.partitionId,
+            instanceId,
+        }),
+        queryFn: () => {
+            if (!client)
+                throw new Error('Not connected');
+            return unwrap(client.GET('/console/stats', { params: { query } }));
+        },
+        enabled: !!client,
+        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({
+        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();
+        },
+        enabled: (options.enabled ?? true) && !!client && !!connectionConfig,
+        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({
+        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();
+        },
+        enabled: (options.enabled ?? true) && !!client && !!connectionConfig,
+        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({
+        queryKey: queryKeys.commits({ ...params, instanceId }),
+        queryFn: () => {
+            if (!client)
+                throw new Error('Not connected');
+            return unwrap(client.GET('/console/commits', { params: { query } }));
+        },
+        enabled: (options.enabled ?? true) && !!client,
+        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({
+        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();
+        },
+        enabled: (options.enabled ?? true) && seq !== undefined && !!client,
+    });
+}
+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({
+        queryKey: queryKeys.timeline({ ...params, instanceId }),
+        queryFn: () => {
+            if (!client)
+                throw new Error('Not connected');
+            return unwrap(client.GET('/console/timeline', { params: { query } }));
+        },
+        enabled: (options.enabled ?? true) && !!client,
+        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({
+        queryKey: queryKeys.clients({ ...params, instanceId }),
+        queryFn: () => {
+            if (!client)
+                throw new Error('Not connected');
+            return unwrap(client.GET('/console/clients', { params: { query } }));
+        },
+        enabled: (options.enabled ?? true) && !!client,
+        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({
+        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();
+        },
+        enabled: (options.enabled ?? true) && id !== undefined && !!client,
+    });
+}
+export function useRequestEventPayload(id, options = {}) {
+    const client = useApiClient();
+    const { config: connectionConfig } = useConnection();
+    const { instanceId: selectedInstanceId } = useInstanceContext();
+    const instanceId = options.instanceId ?? selectedInstanceId;
+    return useQuery({
+        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();
+        },
+        enabled: (options.enabled ?? true) && id !== undefined && !!client,
+    });
+}
+export function useHandlers(options = {}) {
+    const client = useApiClient();
+    const { config: connectionConfig } = useConnection();
+    const { instanceId: selectedInstanceId } = useInstanceContext();
+    const instanceId = options.instanceId ?? selectedInstanceId;
+    return useQuery({
+        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,
+    });
+}
+export function usePrunePreview(options = {}) {
+    const client = useApiClient();
+    const { config: connectionConfig } = useConnection();
+    const { instanceId: selectedInstanceId } = useInstanceContext();
+    const instanceId = options.instanceId ?? selectedInstanceId;
+    return useQuery({
+        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),
+    });
+}
+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({
+        queryKey: queryKeys.operations({ ...params, instanceId }),
+        queryFn: () => {
+            if (!client)
+                throw new Error('Not connected');
+            return unwrap(client.GET('/console/operations', { params: { query } }));
+        },
+        enabled: (options.enabled ?? true) && !!client,
+        refetchInterval: resolveRefetchInterval(options.refetchIntervalMs, 10000),
+    });
+}
+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), {
+                method: 'DELETE',
+                headers: { Authorization: `Bearer ${connectionConfig.token}` },
+            });
+            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'] });
+        },
+    });
+}
+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'] });
+        },
+    });
+}
+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'] });
+        },
+    });
+}
+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), {
+                method: 'POST',
+                headers: {
+                    Authorization: `Bearer ${connectionConfig.token}`,
+                    'Content-Type': 'application/json',
+                },
+                body: JSON.stringify({
+                    tables: request.tables,
+                    partitionId: request.partitionId,
+                }),
+            });
+            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'] });
+        },
+    });
+}
+export function useApiKeys(params = {}) {
+    const client = useApiClient();
+    const { config: connectionConfig } = useConnection();
+    const { instanceId: selectedInstanceId } = useInstanceContext();
+    const instanceId = params.instanceId ?? selectedInstanceId;
+    return useQuery({
+        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();
+        },
+        enabled: !!client && !!connectionConfig,
+    });
+}
+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), {
+                method: 'POST',
+                headers: {
+                    Authorization: `Bearer ${connectionConfig.token}`,
+                    'Content-Type': 'application/json',
+                },
+                body: JSON.stringify(request),
+            });
+            if (!response.ok)
+                throw new Error('Failed to create API key');
+            return response.json();
+        },
+        onSuccess: () => {
+            queryClient.invalidateQueries({ queryKey: ['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), {
+                method: 'DELETE',
+                headers: { Authorization: `Bearer ${connectionConfig.token}` },
+            });
+            if (!response.ok)
+                throw new Error('Failed to revoke API key');
+            return response.json();
+        },
+        onSuccess: () => {
+            queryClient.invalidateQueries({ queryKey: ['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), {
+                method: 'POST',
+                headers: {
+                    Authorization: `Bearer ${connectionConfig.token}`,
+                    'Content-Type': 'application/json',
+                },
+                body: JSON.stringify(request),
+            });
+            if (!response.ok)
+                throw new Error('Failed to bulk revoke API keys');
+            return response.json();
+        },
+        onSuccess: () => {
+            queryClient.invalidateQueries({ queryKey: ['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), {
+                method: 'POST',
+                headers: { Authorization: `Bearer ${connectionConfig.token}` },
+            });
+            if (!response.ok)
+                throw new Error('Failed to rotate API key');
+            return response.json();
+        },
+        onSuccess: () => {
+            queryClient.invalidateQueries({ queryKey: ['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), {
+                method: 'POST',
+                headers: { Authorization: `Bearer ${connectionConfig.token}` },
+            });
+            if (!response.ok)
+                throw new Error('Failed to stage-rotate API key');
+            return response.json();
+        },
+        onSuccess: () => {
+            queryClient.invalidateQueries({ queryKey: ['console', 'api-keys'] });
+        },
+    });
+}
+//# sourceMappingURL=useConsoleApi.js.map