Use req/conn/msg models in unary/server

src-web/hooks/useDeleteAnyRequest.tsx

@@ -7,7 +7,7 @@ import type { HttpRequest } from '../lib/models';
 import { getHttpRequest } from '../lib/store';
 import { useConfirm } from './useConfirm';
 import { httpRequestsQueryKey } from './useHttpRequests';
-import { responsesQueryKey } from './useResponses';
+import { httpResponsesQueryKey } from './useHttpResponses';
 
 export function useDeleteAnyRequest() {
   const queryClient = useQueryClient();
@@ -35,7 +35,7 @@ export function useDeleteAnyRequest() {
       if (request === null) return;
 
       const { workspaceId, id: requestId } = request;
-      queryClient.setQueryData(responsesQueryKey({ requestId }), []); // Responses were deleted
+      queryClient.setQueryData(httpResponsesQueryKey({ requestId }), []); // Responses were deleted
       queryClient.setQueryData<HttpRequest[]>(httpRequestsQueryKey({ workspaceId }), (requests) =>
         (requests ?? []).filter((r) => r.id !== requestId),
       );

src-web/hooks/useDeleteResponse.ts

@@ -2,7 +2,7 @@ import { useMutation, useQueryClient } from '@tanstack/react-query';
 import { invoke } from '@tauri-apps/api';
 import { trackEvent } from '../lib/analytics';
 import type { HttpResponse } from '../lib/models';
-import { responsesQueryKey } from './useResponses';
+import { httpResponsesQueryKey } from './useHttpResponses';
 
 export function useDeleteResponse(id: string | null) {
   const queryClient = useQueryClient();
@@ -12,7 +12,7 @@ export function useDeleteResponse(id: string | null) {
     },
     onSettled: () => trackEvent('HttpResponse', 'Delete'),
     onSuccess: ({ requestId, id: responseId }) => {
-      queryClient.setQueryData<HttpResponse[]>(responsesQueryKey({ requestId }), (responses) =>
+      queryClient.setQueryData<HttpResponse[]>(httpResponsesQueryKey({ requestId }), (responses) =>
         (responses ?? []).filter((response) => response.id !== responseId),
       );
     },

src-web/hooks/useDeleteResponses.ts

@@ -1,7 +1,7 @@
 import { useMutation, useQueryClient } from '@tanstack/react-query';
 import { invoke } from '@tauri-apps/api';
 import { trackEvent } from '../lib/analytics';
-import { responsesQueryKey } from './useResponses';
+import { httpResponsesQueryKey } from './useHttpResponses';
 
 export function useDeleteResponses(requestId?: string) {
   const queryClient = useQueryClient();
@@ -13,7 +13,7 @@ export function useDeleteResponses(requestId?: string) {
     onSettled: () => trackEvent('HttpResponse', 'DeleteMany'),
     onSuccess: async () => {
       if (requestId === undefined) return;
-      queryClient.setQueryData(responsesQueryKey({ requestId }), []);
+      queryClient.setQueryData(httpResponsesQueryKey({ requestId }), []);
     },
   });
 }

src-web/hooks/useDuplicateGrpcRequest.ts

@@ -0,0 +1,41 @@
+import { useMutation, useQueryClient } from '@tanstack/react-query';
+import { invoke } from '@tauri-apps/api';
+import { trackEvent } from '../lib/analytics';
+import type { GrpcRequest } from '../lib/models';
+import { useActiveEnvironmentId } from './useActiveEnvironmentId';
+import { useActiveWorkspaceId } from './useActiveWorkspaceId';
+import { useAppRoutes } from './useAppRoutes';
+import { grpcRequestsQueryKey } from './useGrpcRequests';
+
+export function useDuplicateGrpcRequest({
+  id,
+  navigateAfter,
+}: {
+  id: string | null;
+  navigateAfter: boolean;
+}) {
+  const activeWorkspaceId = useActiveWorkspaceId();
+  const activeEnvironmentId = useActiveEnvironmentId();
+  const routes = useAppRoutes();
+  const queryClient = useQueryClient();
+  return useMutation<GrpcRequest, string>({
+    mutationFn: async () => {
+      if (id === null) throw new Error("Can't duplicate a null grpc request");
+      return invoke('cmd_duplicate_grpc_request', { id });
+    },
+    onSettled: () => trackEvent('GrpcRequest', 'Duplicate'),
+    onSuccess: async (request) => {
+      queryClient.setQueryData<GrpcRequest[]>(
+        grpcRequestsQueryKey({ workspaceId: request.workspaceId }),
+        (requests) => [...(requests ?? []), request],
+      );
+      if (navigateAfter && activeWorkspaceId !== null) {
+        routes.navigate('request', {
+          workspaceId: activeWorkspaceId,
+          requestId: request.id,
+          environmentId: activeEnvironmentId ?? undefined,
+        });
+      }
+    },
+  });
+}

src-web/hooks/useDuplicateHttpRequest.ts

@@ -7,7 +7,7 @@ import { useActiveWorkspaceId } from './useActiveWorkspaceId';
 import { useAppRoutes } from './useAppRoutes';
 import { httpRequestsQueryKey } from './useHttpRequests';
 
-export function useDuplicateRequest({
+export function useDuplicateHttpRequest({
   id,
   navigateAfter,
 }: {

src-web/hooks/useGrpc.ts

@@ -3,8 +3,7 @@ import { invoke } from '@tauri-apps/api';
 import type { UnlistenFn } from '@tauri-apps/api/event';
 import { emit, listen } from '@tauri-apps/api/event';
 import { useEffect, useRef, useState } from 'react';
-import { tryFormatJson } from '../lib/formatters';
-import type { GrpcRequest } from '../lib/models';
+import type { GrpcConnection, GrpcMessage, GrpcRequest } from '../lib/models';
 import { useKeyValue } from './useKeyValue';
 
 interface ReflectResponseService {
@@ -12,12 +11,6 @@ interface ReflectResponseService {
   methods: { name: string; schema: string; serverStreaming: boolean; clientStreaming: boolean }[];
 }
 
-export interface GrpcMessage {
-  message: string;
-  timestamp: string;
-  type: 'server' | 'client' | 'info';
-}
-
 export function useGrpc(url: string | null, requestId: string | null) {
   const messages = useKeyValue<GrpcMessage[]>({
     namespace: 'debug',
@@ -25,54 +18,30 @@ export function useGrpc(url: string | null, requestId: string | null) {
     defaultValue: [],
   });
   const [activeConnectionId, setActiveConnectionId] = useState<string | null>(null);
-  const unlisten = useRef<UnlistenFn | null>(null);
 
   useEffect(() => {
     setActiveConnectionId(null);
-    unlisten.current?.();
   }, [requestId]);
 
-  const unary = useMutation<string, string, GrpcRequest>({
+  const unary = useMutation<GrpcMessage, string, string>({
     mutationKey: ['grpc_unary', url],
-    mutationFn: async ({ service, method, message, url }) => {
-      if (url === null) throw new Error('No URL provided');
-      return (await invoke('cmd_grpc_call_unary', {
-        endpoint: url,
-        service,
-        method,
-        message,
-      })) as string;
+    mutationFn: async (id) => {
+      const message = (await invoke('cmd_grpc_call_unary', {
+        requestId: id,
+      })) as GrpcMessage;
+      await messages.set([message]);
+      console.log('MESSAGE', message);
+      return message;
     },
   });
 
-  const serverStreaming = useMutation<void, string, GrpcRequest>({
+  const serverStreaming = useMutation<void, string, string>({
     mutationKey: ['grpc_server_streaming', url],
-    mutationFn: async ({ service, method, message, url }) => {
+    mutationFn: async (requestId) => {
       if (url === null) throw new Error('No URL provided');
-      await messages.set([
-        {
-          type: 'client',
-          message: JSON.stringify(JSON.parse(message)),
-          timestamp: new Date().toISOString(),
-        },
-      ]);
-      const id: string = await invoke('cmd_grpc_server_streaming', {
-        endpoint: url,
-        service,
-        method,
-        message,
-      });
-      unlisten.current = await listen(`grpc_server_msg_${id}`, async (event) => {
-        await messages.set((prev) => [
-          ...prev,
-          {
-            message: tryFormatJson(event.payload as string, false),
-            timestamp: new Date().toISOString(),
-            type: 'server',
-          },
-        ]);
-      });
-      setActiveConnectionId(id);
+      await messages.set([]);
+      const c = (await invoke('cmd_grpc_server_streaming', { requestId })) as GrpcConnection;
+      setActiveConnectionId(c.id);
     },
   });
 
@@ -86,20 +55,8 @@ export function useGrpc(url: string | null, requestId: string | null) {
         method,
         message,
       });
-      await messages.set([
-        { type: 'info', message: `Started connection ${id}`, timestamp: new Date().toISOString() },
-      ]);
+      await messages.set([]);
       setActiveConnectionId(id);
-      unlisten.current = await listen(`grpc_server_msg_${id}`, (event) => {
-        messages.set((prev) => [
-          ...prev,
-          {
-            message: tryFormatJson(event.payload as string, false),
-            timestamp: new Date().toISOString(),
-            type: 'server',
-          },
-        ]);
-      });
     },
   });
 
@@ -107,9 +64,10 @@ export function useGrpc(url: string | null, requestId: string | null) {
     mutationKey: ['grpc_send', url],
     mutationFn: async ({ message }: { message: string }) => {
       if (activeConnectionId == null) throw new Error('No active connection');
-      await messages.set((m) => {
-        return [...m, { type: 'client', message, timestamp: new Date().toISOString() }];
-      });
+      await messages.set([]);
+      // await messages.set((m) => {
+      //   return [...m, { type: 'client', message, timestamp: new Date().toISOString() }];
+      // });
       await emit(`grpc_client_msg_${activeConnectionId}`, { Message: message });
     },
   });
@@ -118,12 +76,7 @@ export function useGrpc(url: string | null, requestId: string | null) {
     mutationKey: ['grpc_cancel', url],
     mutationFn: async () => {
       setActiveConnectionId(null);
-      unlisten.current?.();
-      await emit('grpc_message_in', 'Cancel');
-      await messages.set((m) => [
-        ...m,
-        { type: 'info', message: 'Cancelled by client', timestamp: new Date().toISOString() },
-      ]);
+      await emit(`grpc_client_msg_${activeConnectionId}`, 'Cancel');
     },
   });
 
@@ -141,7 +94,6 @@ export function useGrpc(url: string | null, requestId: string | null) {
     bidiStreaming,
     services: reflect.data,
     cancel,
-    messages,
     isStreaming: activeConnectionId !== null,
     send,
   };

src-web/hooks/useGrpcConnections.ts

@@ -0,0 +1,23 @@
+import { useQuery } from '@tanstack/react-query';
+import { invoke } from '@tauri-apps/api';
+import type { GrpcConnection } from '../lib/models';
+
+export function grpcConnectionsQueryKey({ requestId }: { requestId: string }) {
+  return ['grpc_connections', { requestId }];
+}
+
+export function useGrpcConnections(requestId: string | null) {
+  return (
+    useQuery<GrpcConnection[]>({
+      enabled: requestId !== null,
+      initialData: [],
+      queryKey: grpcConnectionsQueryKey({ requestId: requestId ?? 'n/a' }),
+      queryFn: async () => {
+        return (await invoke('cmd_list_grpc_connections', {
+          requestId,
+          limit: 200,
+        })) as GrpcConnection[];
+      },
+    }).data ?? []
+  );
+}

src-web/hooks/useGrpcMessages.ts

@@ -0,0 +1,23 @@
+import { useQuery } from '@tanstack/react-query';
+import { invoke } from '@tauri-apps/api';
+import type { GrpcMessage } from '../lib/models';
+
+export function grpcMessagesQueryKey({ connectionId }: { connectionId: string }) {
+  return ['grpc_messages', { connectionId }];
+}
+
+export function useGrpcMessages(connectionId: string | null) {
+  return (
+    useQuery<GrpcMessage[]>({
+      enabled: connectionId !== null,
+      initialData: [],
+      queryKey: grpcMessagesQueryKey({ connectionId: connectionId ?? 'n/a' }),
+      queryFn: async () => {
+        return (await invoke('cmd_list_grpc_messages', {
+          connectionId,
+          limit: 200,
+        })) as GrpcMessage[];
+      },
+    }).data ?? []
+  );
+}

src-web/hooks/useHttpResponses.ts

@@ -2,18 +2,18 @@ import { useQuery } from '@tanstack/react-query';
 import { invoke } from '@tauri-apps/api';
 import type { HttpResponse } from '../lib/models';
 
-export function responsesQueryKey({ requestId }: { requestId: string }) {
+export function httpResponsesQueryKey({ requestId }: { requestId: string }) {
   return ['http_responses', { requestId }];
 }
 
-export function useResponses(requestId: string | null) {
+export function useHttpResponses(requestId: string | null) {
   return (
     useQuery<HttpResponse[]>({
       enabled: requestId !== null,
       initialData: [],
-      queryKey: responsesQueryKey({ requestId: requestId ?? 'n/a' }),
+      queryKey: httpResponsesQueryKey({ requestId: requestId ?? 'n/a' }),
       queryFn: async () => {
-        return (await invoke('cmd_list_responses', { requestId, limit: 200 })) as HttpResponse[];
+        return (await invoke('cmd_list_http_responses', { requestId, limit: 200 })) as HttpResponse[];
       },
     }).data ?? []
   );

src-web/hooks/useLatestResponse.ts

@@ -1,7 +1,7 @@
 import type { HttpResponse } from '../lib/models';
-import { useResponses } from './useResponses';
+import { useHttpResponses } from './useHttpResponses';
 
 export function useLatestResponse(requestId: string | null): HttpResponse | null {
-  const responses = useResponses(requestId);
+  const responses = useHttpResponses(requestId);
   return responses[0] ?? null;
 }