Build/Refactor: lint pre-commit hook and reformat repo to spec (#314)

* build/refactor: move lint/prettier packages to project root, install husky, add pre-commit hook

* refactor: reformat files

* build: put full eslintrc back with all rules

client/src/data-provider/api-endpoints.ts

@@ -28,56 +28,56 @@ export const deleteConversation = () => {
 
 export const search = (q: string, pageNumber: string) => {
   return `/api/search?q=${q}&pageNumber=${pageNumber}`;
-}
+};
 
 export const searchEnabled = () => {
   return `/api/search/enable`;
-}
+};
 
 export const presets = () => {
   return `/api/presets`;
-}
+};
 
 export const deletePreset = () => {
   return `/api/presets/delete`;
-}
+};
 
 export const aiEndpoints = () => {
   return `/api/endpoints`;
-}
+};
 
 export const tokenizer = () => {
   return `/api/tokenizer`;
-}
+};
 
 export const login = () => {
   return '/api/auth/login';
-}
+};
 
 export const logout = () => {
   return '/api/auth/logout';
-}
+};
 
 export const register = () => {
   return '/api/auth/register';
-}
+};
 
 export const loginFacebook = () => {
   return '/api/auth/facebook';
-}
+};
 
 export const loginGoogle = () => {
   return '/api/auth/google';
-}
+};
 
 export const refreshToken = () => {
   return '/api/auth/refresh';
-}
+};
 
 export const requestPasswordReset = () => {
   return '/api/auth/requestPasswordReset';
-}
+};
 
 export const resetPassword = () => {
   return '/api/auth/resetPassword';
-}
+};

client/src/data-provider/data-service.ts

@@ -6,17 +6,21 @@ export function getConversations(pageNumber: string): Promise<t.TGetConversation
   return request.get(endpoints.conversations(pageNumber));
 }
 
-export function abortRequestWithMessage(endpoint: string, abortKey: string, message: string): Promise<void> {
-  return request.post(endpoints.abortRequest(endpoint), { arg: {abortKey, message} });
+export function abortRequestWithMessage(
+  endpoint: string,
+  abortKey: string,
+  message: string
+): Promise<void> {
+  return request.post(endpoints.abortRequest(endpoint), { arg: { abortKey, message } });
 }
 
 export function deleteConversation(payload: t.TDeleteConversationRequest) {
   //todo: this should be a DELETE request
-  return request.post(endpoints.deleteConversation(), {arg: payload});
+  return request.post(endpoints.deleteConversation(), { arg: payload });
 }
 
 export function clearAllConversations(): Promise<unknown> {
-  return request.post(endpoints.deleteConversation(), {arg: {}});
+  return request.post(endpoints.deleteConversation(), { arg: {} });
 }
 
 export function getMessagesByConvoId(id: string): Promise<t.TMessage[]> {
@@ -30,7 +34,7 @@ export function getConversationById(id: string): Promise<t.TConversation> {
 export function updateConversation(
   payload: t.TUpdateConversationRequest
 ): Promise<t.TUpdateConversationResponse> {
-  return request.post(endpoints.updateConversation(), {arg: payload});
+  return request.post(endpoints.updateConversation(), { arg: payload });
 }
 
 export function getPresets(): Promise<t.TPreset[]> {
@@ -57,42 +61,45 @@ export function getUser(): Promise<t.TUser> {
   return request.get(endpoints.user());
 }
 
-export const searchConversations = async(q: string, pageNumber: string): Promise<t.TSearchResults> => {
+export const searchConversations = async (
+  q: string,
+  pageNumber: string
+): Promise<t.TSearchResults> => {
   return request.get(endpoints.search(q, pageNumber));
-}
+};
 
 export const getAIEndpoints = () => {
   return request.get(endpoints.aiEndpoints());
-}
+};
 
-export const updateTokenCount = (text: string) => { 
-  return request.post(endpoints.tokenizer(), {arg: text});
-}
+export const updateTokenCount = (text: string) => {
+  return request.post(endpoints.tokenizer(), { arg: text });
+};
 
 export const login = (payload: t.TLoginUser) => {
   return request.post(endpoints.login(), payload);
-}
+};
 
 export const logout = () => {
   return request.post(endpoints.logout());
-}
+};
 
 export const register = (payload: t.TRegisterUser) => {
   return request.post(endpoints.register(), payload);
-}
+};
 
 export const refreshToken = () => {
   return request.post(endpoints.refreshToken());
-}
+};
 
 export const getLoginGoogle = () => {
   return request.get(endpoints.loginGoogle());
-}
+};
 
 export const requestPasswordReset = (payload: t.TRequestPasswordReset) => {
   return request.post(endpoints.requestPasswordReset(), payload);
-}
+};
 
 export const resetPassword = (payload: t.TResetPassword) => {
   return request.post(endpoints.resetPassword(), payload);
-}
+};

client/src/data-provider/index.ts

@@ -4,4 +4,4 @@ export * from './request';
 export * from './types';
 export * from './react-query-service';
 export * from './headers-helpers';
-// export * from './events';
+// export * from './events';

client/src/data-provider/react-query-service.ts

@@ -4,59 +4,53 @@ import {
   useMutation,
   useQueryClient,
   UseMutationResult,
-  QueryObserverResult,
-} from "@tanstack/react-query";
-import * as t from "./types";
-import * as dataService from "./data-service";
+  QueryObserverResult
+} from '@tanstack/react-query';
+import * as t from './types';
+import * as dataService from './data-service';
 import axios from 'axios';
 
 export enum QueryKeys {
-  messages = "messsages",
-  allConversations = "allConversations",
-  conversation = "conversation",
-  searchEnabled = "searchEnabled",
-  user = "user",
-  endpoints = "endpoints",
-  presets = "presets",
-  searchResults = "searchResults",
-  tokenCount = "tokenCount",
+  messages = 'messsages',
+  allConversations = 'allConversations',
+  conversation = 'conversation',
+  searchEnabled = 'searchEnabled',
+  user = 'user',
+  endpoints = 'endpoints',
+  presets = 'presets',
+  searchResults = 'searchResults',
+  tokenCount = 'tokenCount'
 }
 
-export const useAbortRequestWithMessage = (): UseMutationResult<void, Error, { endpoint: string; abortKey: string; message: string }> => {
-  return useMutation(({ endpoint, abortKey, message }) => dataService.abortRequestWithMessage(endpoint, abortKey, message));
+export const useAbortRequestWithMessage = (): UseMutationResult<
+  void,
+  Error,
+  { endpoint: string; abortKey: string; message: string }
+> => {
+  return useMutation(({ endpoint, abortKey, message }) =>
+    dataService.abortRequestWithMessage(endpoint, abortKey, message)
+  );
 };
 
-export const useGetUserQuery = (config?: UseQueryOptions<t.TUser>): QueryObserverResult<t.TUser> => {
+export const useGetUserQuery = (
+  config?: UseQueryOptions<t.TUser>
+): QueryObserverResult<t.TUser> => {
   return useQuery<t.TUser>([QueryKeys.user], () => dataService.getUser(), {
     refetchOnWindowFocus: false,
     refetchOnReconnect: false,
     refetchOnMount: false,
     retry: false,
-    ...config,
+    ...config
   });
 };
 
 export const useGetMessagesByConvoId = (
-  id: string, 
+  id: string,
   config?: UseQueryOptions<t.TMessage[]>
 ): QueryObserverResult<t.TMessage[]> => {
-  return useQuery<t.TMessage[]>([QueryKeys.messages, id], () =>
-    dataService.getMessagesByConvoId(id), 
-    {
-      refetchOnWindowFocus: false,
-      refetchOnReconnect: false,
-      refetchOnMount: false,
-      ...config,
-    }
-  );
-};
-
-export const useGetConversationByIdQuery = (
-  id: string, 
-  config?: UseQueryOptions<t.TConversation> 
-  ): QueryObserverResult<t.TConversation> => {
-  return useQuery<t.TConversation>([QueryKeys.conversation, id], () =>
-    dataService.getConversationById(id), 
+  return useQuery<t.TMessage[]>(
+    [QueryKeys.messages, id],
+    () => dataService.getMessagesByConvoId(id),
     {
       refetchOnWindowFocus: false,
       refetchOnReconnect: false,
@@ -64,52 +58,71 @@ export const useGetConversationByIdQuery = (
       ...config
     }
   );
-}
-
-//This isn't ideal because its just a query and we're using mutation, but it was the only way
-//to make it work with how the Chat component is structured
-export const useGetConversationByIdMutation = (
-  id: string,
-): UseMutationResult<t.TConversation> => {
-  const queryClient = useQueryClient();
-  return useMutation(() => dataService.getConversationById(id),
-    {
-      onSuccess: (res: t.TConversation) => {
-       queryClient.invalidateQueries([QueryKeys.conversation, id]);
-      },
-    }   
-  );
 };
 
-export const useUpdateConversationMutation = (
-  id: string
-): UseMutationResult<t.TUpdateConversationResponse, unknown, t.TUpdateConversationRequest, unknown> => {
-  const queryClient = useQueryClient();
-  return useMutation(
-    (payload: t.TUpdateConversationRequest) =>
-      dataService.updateConversation(payload),
+export const useGetConversationByIdQuery = (
+  id: string,
+  config?: UseQueryOptions<t.TConversation>
+): QueryObserverResult<t.TConversation> => {
+  return useQuery<t.TConversation>(
+    [QueryKeys.conversation, id],
+    () => dataService.getConversationById(id),
     {
-      onSuccess: () => {
-        queryClient.invalidateQueries([QueryKeys.conversation, id]);
-        queryClient.invalidateQueries([QueryKeys.allConversations]);
-      },
+      refetchOnWindowFocus: false,
+      refetchOnReconnect: false,
+      refetchOnMount: false,
+      ...config
     }
   );
 };
 
+//This isn't ideal because its just a query and we're using mutation, but it was the only way
+//to make it work with how the Chat component is structured
+export const useGetConversationByIdMutation = (id: string): UseMutationResult<t.TConversation> => {
+  const queryClient = useQueryClient();
+  return useMutation(() => dataService.getConversationById(id), {
+    onSuccess: (res: t.TConversation) => {
+      queryClient.invalidateQueries([QueryKeys.conversation, id]);
+    }
+  });
+};
 
-export const useDeleteConversationMutation = (
-  id?: string
-): UseMutationResult<t.TDeleteConversationResponse, unknown, t.TDeleteConversationRequest, unknown> => {
+export const useUpdateConversationMutation = (
+  id: string
+): UseMutationResult<
+  t.TUpdateConversationResponse,
+  unknown,
+  t.TUpdateConversationRequest,
+  unknown
+> => {
   const queryClient = useQueryClient();
   return useMutation(
-    (payload: t.TDeleteConversationRequest) =>
-      dataService.deleteConversation(payload),
+    (payload: t.TUpdateConversationRequest) => dataService.updateConversation(payload),
     {
       onSuccess: () => {
         queryClient.invalidateQueries([QueryKeys.conversation, id]);
         queryClient.invalidateQueries([QueryKeys.allConversations]);
-      },
+      }
+    }
+  );
+};
+
+export const useDeleteConversationMutation = (
+  id?: string
+): UseMutationResult<
+  t.TDeleteConversationResponse,
+  unknown,
+  t.TDeleteConversationRequest,
+  unknown
+> => {
+  const queryClient = useQueryClient();
+  return useMutation(
+    (payload: t.TDeleteConversationRequest) => dataService.deleteConversation(payload),
+    {
+      onSuccess: () => {
+        queryClient.invalidateQueries([QueryKeys.conversation, id]);
+        queryClient.invalidateQueries([QueryKeys.allConversations]);
+      }
     }
   );
 };
@@ -119,162 +132,181 @@ export const useClearConversationsMutation = (): UseMutationResult<unknown> => {
   return useMutation(() => dataService.clearAllConversations(), {
     onSuccess: () => {
       queryClient.invalidateQueries([QueryKeys.allConversations]);
-    },
+    }
   });
 };
 
-export const useGetConversationsQuery = (pageNumber: string, config?: UseQueryOptions<t.TConversation[]>): QueryObserverResult<t.TConversation[]> => {
-  return useQuery<t.TConversation[]>([QueryKeys.allConversations, pageNumber], () =>
-    dataService.getConversations(pageNumber), {
+export const useGetConversationsQuery = (
+  pageNumber: string,
+  config?: UseQueryOptions<t.TConversation[]>
+): QueryObserverResult<t.TConversation[]> => {
+  return useQuery<t.TConversation[]>(
+    [QueryKeys.allConversations, pageNumber],
+    () => dataService.getConversations(pageNumber),
+    {
       refetchOnReconnect: false,
       refetchOnMount: false,
       retry: 1,
-      ...config,
+      ...config
     }
   );
-}
+};
 
-export const useGetSearchEnabledQuery = (config?: UseQueryOptions<boolean>): QueryObserverResult<boolean> => {
-  return useQuery<boolean>([QueryKeys.searchEnabled], () =>
-    dataService.getSearchEnabled(), {
-      refetchOnWindowFocus: false,
-      refetchOnReconnect: false,
-      refetchOnMount: false,
-      ...config,
-    }
-  );
-}
+export const useGetSearchEnabledQuery = (
+  config?: UseQueryOptions<boolean>
+): QueryObserverResult<boolean> => {
+  return useQuery<boolean>([QueryKeys.searchEnabled], () => dataService.getSearchEnabled(), {
+    refetchOnWindowFocus: false,
+    refetchOnReconnect: false,
+    refetchOnMount: false,
+    ...config
+  });
+};
 
 export const useGetEndpointsQuery = (): QueryObserverResult<t.TEndpoints> => {
-  return useQuery([QueryKeys.endpoints], () =>
-    dataService.getAIEndpoints(), {
-      refetchOnWindowFocus: false,
-      refetchOnReconnect: false,
-      refetchOnMount: false,
-    }
-  );
-}
-
-export const useCreatePresetMutation = (): UseMutationResult<t.TPreset[], unknown, t.TPreset, unknown> => {
-  const queryClient = useQueryClient();
-  return useMutation(
-    (payload: t.TPreset) =>
-      dataService.createPreset(payload),
-    {
-      onSuccess: () => {
-        queryClient.invalidateQueries([QueryKeys.presets]);
-      },
-    }
-  );
+  return useQuery([QueryKeys.endpoints], () => dataService.getAIEndpoints(), {
+    refetchOnWindowFocus: false,
+    refetchOnReconnect: false,
+    refetchOnMount: false
+  });
 };
 
-export const useUpdatePresetMutation = (): UseMutationResult<t.TPreset[], unknown, t.TPreset, unknown> => {
+export const useCreatePresetMutation = (): UseMutationResult<
+  t.TPreset[],
+  unknown,
+  t.TPreset,
+  unknown
+> => {
   const queryClient = useQueryClient();
-  return useMutation(
-    (payload: t.TPreset) =>
-      dataService.updatePreset(payload),
-    {
-      onSuccess: () => {
-        queryClient.invalidateQueries([QueryKeys.presets]);
-      },
+  return useMutation((payload: t.TPreset) => dataService.createPreset(payload), {
+    onSuccess: () => {
+      queryClient.invalidateQueries([QueryKeys.presets]);
     }
-  );
+  });
 };
 
-export const useGetPresetsQuery = (config?: UseQueryOptions<t.TPreset[]>): QueryObserverResult<t.TPreset[], unknown> => {
+export const useUpdatePresetMutation = (): UseMutationResult<
+  t.TPreset[],
+  unknown,
+  t.TPreset,
+  unknown
+> => {
+  const queryClient = useQueryClient();
+  return useMutation((payload: t.TPreset) => dataService.updatePreset(payload), {
+    onSuccess: () => {
+      queryClient.invalidateQueries([QueryKeys.presets]);
+    }
+  });
+};
+
+export const useGetPresetsQuery = (
+  config?: UseQueryOptions<t.TPreset[]>
+): QueryObserverResult<t.TPreset[], unknown> => {
   return useQuery<t.TPreset[]>([QueryKeys.presets], () => dataService.getPresets(), {
     refetchOnWindowFocus: false,
     refetchOnReconnect: false,
     refetchOnMount: false,
-    ...config,
+    ...config
   });
 };
 
-export const useDeletePresetMutation = (): UseMutationResult<t.TPreset[], unknown, t.TPreset | {}, unknown> => {
+export const useDeletePresetMutation = (): UseMutationResult<
+  t.TPreset[],
+  unknown,
+  t.TPreset | {},
+  unknown
+> => {
   const queryClient = useQueryClient();
-  return useMutation(
-    (payload: t.TPreset | {}) => 
-      dataService.deletePreset(payload), 
-    {
-      onSuccess: () => {
-        queryClient.invalidateQueries([QueryKeys.presets]);
-      },
+  return useMutation((payload: t.TPreset | {}) => dataService.deletePreset(payload), {
+    onSuccess: () => {
+      queryClient.invalidateQueries([QueryKeys.presets]);
     }
-  );
-}
+  });
+};
 
 export const useSearchQuery = (
-  searchQuery: string, 
-  pageNumber: string, 
+  searchQuery: string,
+  pageNumber: string,
   config?: UseQueryOptions<t.TSearchResults>
-  ): QueryObserverResult<t.TSearchResults> => {
-  return useQuery<t.TSearchResults>([QueryKeys.searchResults, pageNumber, searchQuery], () =>
-    dataService.searchConversations(searchQuery, pageNumber), {
+): QueryObserverResult<t.TSearchResults> => {
+  return useQuery<t.TSearchResults>(
+    [QueryKeys.searchResults, pageNumber, searchQuery],
+    () => dataService.searchConversations(searchQuery, pageNumber),
+    {
       refetchOnWindowFocus: false,
       refetchOnReconnect: false,
       refetchOnMount: false,
       ...config
     }
   );
-}
+};
 
-export const useUpdateTokenCountMutation = (): UseMutationResult<t.TUpdateTokenCountResponse, unknown, string, unknown> => {
+export const useUpdateTokenCountMutation = (): UseMutationResult<
+  t.TUpdateTokenCountResponse,
+  unknown,
+  string,
+  unknown
+> => {
   const queryClient = useQueryClient();
-  return useMutation(
-    (text: string) =>
-      dataService.updateTokenCount(text),
-    {
-      onSuccess: () => {
-        queryClient.invalidateQueries([QueryKeys.tokenCount]);
-      },
+  return useMutation((text: string) => dataService.updateTokenCount(text), {
+    onSuccess: () => {
+      queryClient.invalidateQueries([QueryKeys.tokenCount]);
     }
-  );
-}
+  });
+};
 
-export const useLoginUserMutation = (): UseMutationResult<t.TLoginUserResponse, unknown, t.TLoginUserRequest, unknown> => {
+export const useLoginUserMutation = (): UseMutationResult<
+  t.TLoginUserResponse,
+  unknown,
+  t.TLoginUserRequest,
+  unknown
+> => {
   const queryClient = useQueryClient();
-  return useMutation(
-    (payload: t.TLoginUserRequest) =>
-      dataService.login(payload),
-    {
-      onSuccess: () => {
-        queryClient.invalidateQueries([QueryKeys.user]);
-      },
+  return useMutation((payload: t.TLoginUserRequest) => dataService.login(payload), {
+    onSuccess: () => {
+      queryClient.invalidateQueries([QueryKeys.user]);
     }
-  );
-}
+  });
+};
 
-export const useRegisterUserMutation = (): UseMutationResult<t.TRegisterUserResponse, unknown, t.TRegisterUser, unknown> => {
+export const useRegisterUserMutation = (): UseMutationResult<
+  t.TRegisterUserResponse,
+  unknown,
+  t.TRegisterUser,
+  unknown
+> => {
   const queryClient = useQueryClient();
-  return useMutation(
-    (payload: t.TRegisterUser) =>
-      dataService.register(payload),
-    {
-      onSuccess: () => {
-        queryClient.invalidateQueries([QueryKeys.user]);
-      },
+  return useMutation((payload: t.TRegisterUser) => dataService.register(payload), {
+    onSuccess: () => {
+      queryClient.invalidateQueries([QueryKeys.user]);
     }
-  );
-}
+  });
+};
 
 export const useLogoutUserMutation = (): UseMutationResult<unknown> => {
   const queryClient = useQueryClient();
   return useMutation(() => dataService.logout(), {
     onSuccess: () => {
       queryClient.invalidateQueries([QueryKeys.user]);
-    },
+    }
   });
-}
+};
 
-export const useRefreshTokenMutation = (): UseMutationResult<t.TRefreshTokenResponse, unknown, unknown, unknown> => {
-  return useMutation(() => dataService.refreshToken(), {
-  });
-}
+export const useRefreshTokenMutation = (): UseMutationResult<
+  t.TRefreshTokenResponse,
+  unknown,
+  unknown,
+  unknown
+> => {
+  return useMutation(() => dataService.refreshToken(), {});
+};
 
 export const useRequestPasswordResetMutation = (): UseMutationResult<unknown> => {
-  return useMutation((payload: t.TRequestPasswordReset) => dataService.requestPasswordReset(payload));
-}
+  return useMutation((payload: t.TRequestPasswordReset) =>
+    dataService.requestPasswordReset(payload)
+  );
+};
 
 export const useResetPasswordMutation = (): UseMutationResult<unknown> => {
   return useMutation((payload: t.TResetPassword) => dataService.resetPassword(payload));
-}
+};

client/src/data-provider/request.ts

@@ -1,32 +1,28 @@
-import axios, { AxiosRequestConfig } from "axios";
+import axios, { AxiosRequestConfig } from 'axios';
 
 async function _get<T>(url: string, options?: AxiosRequestConfig): Promise<T> {
-  const response = await axios.get(url, { ...options});
+  const response = await axios.get(url, { ...options });
   return response.data;
 }
 
 async function _post(url: string, data?: any) {
   const response = await axios.post(url, JSON.stringify(data), {
-    headers: { "Content-Type": "application/json" },
+    headers: { 'Content-Type': 'application/json' }
   });
   return response.data;
 }
 
-async function _postMultiPart(
-  url: string,
-  formData: FormData,
-  options?: AxiosRequestConfig
-) {
+async function _postMultiPart(url: string, formData: FormData, options?: AxiosRequestConfig) {
   const response = await axios.post(url, formData, {
     ...options,
-    headers: { "Content-Type": "multipart/form-data" },
+    headers: { 'Content-Type': 'multipart/form-data' }
   });
   return response.data;
 }
 
 async function _put(url: string, data?: any) {
   const response = await axios.put(url, JSON.stringify(data), {
-    headers: { "Content-Type": "application/json" },
+    headers: { 'Content-Type': 'application/json' }
   });
   return response.data;
 }
@@ -36,17 +32,14 @@ async function _delete<T>(url: string): Promise<T> {
   return response.data;
 }
 
-async function _deleteWithOptions<T>(
-  url: string,
-  options?: AxiosRequestConfig
-): Promise<T> {
-  const response = await axios.delete(url, {...options});
+async function _deleteWithOptions<T>(url: string, options?: AxiosRequestConfig): Promise<T> {
+  const response = await axios.delete(url, { ...options });
   return response.data;
 }
 
 async function _patch(url: string, data?: any) {
   const response = await axios.patch(url, JSON.stringify(data), {
-    headers: { "Content-Type": "application/json" },
+    headers: { 'Content-Type': 'application/json' }
   });
   return response.data;
 }
@@ -58,5 +51,5 @@ export default {
   put: _put,
   delete: _delete,
   deleteWithOptions: _deleteWithOptions,
-  patch: _patch,
+  patch: _patch
 };

client/src/data-provider/types.ts

@@ -1,19 +1,19 @@
 export type TMessage = {
-  messageId: string,
-  conversationId: string,
-  clientId: string,
-  parentMessageId: string,
-  sender: string,
-  text: string,
-  isCreatedByUser: boolean,
-  error: boolean,
-  createdAt: string,
-  updatedAt: string,
+  messageId: string;
+  conversationId: string;
+  clientId: string;
+  parentMessageId: string;
+  sender: string;
+  text: string;
+  isCreatedByUser: boolean;
+  error: boolean;
+  createdAt: string;
+  updatedAt: string;
 };
 
 export type TExample = {
-  input: string,
-  output: string,
+  input: string;
+  output: string;
 };
 
 export type TSubmission = {
@@ -40,16 +40,15 @@ export type TSubmission = {
   top_p?: number;
   presence_penalty?: number;
   frequence_penalty?: number;
-}
-
+};
 
 export enum EModelEndpoint {
-  azureOpenAI = 'azureOpenAI', 
+  azureOpenAI = 'azureOpenAI',
   openAI = 'openAI',
   bingAI = 'bingAI',
   chatGPT = 'chatGPT',
   chatGPTBrowser = 'chatGPTBrowser',
-  google = 'google',
+  google = 'google'
 }
 
 export type TConversation = {
@@ -84,127 +83,127 @@ export type TConversation = {
   clientId?: string;
   invocationId?: string;
   toneStyle?: string;
-}
+};
 
 export type TPreset = {
-  title: string,
-  endpoint: EModelEndpoint,
-  conversationSignature?: string,
-  createdAt?: string,
-  updatedAt?: string,
-  presetId?: string,
-  user?: string,
+  title: string;
+  endpoint: EModelEndpoint;
+  conversationSignature?: string;
+  createdAt?: string;
+  updatedAt?: string;
+  presetId?: string;
+  user?: string;
   // for azureOpenAI, openAI only
-  chatGptLabel?: string,
-  frequence_penalty?: number,
-  model?: string,
-  presence_penalty?: number,
-  promptPrefix?: string,
-  temperature?: number,
-  top_p?: number,
+  chatGptLabel?: string;
+  frequence_penalty?: number;
+  model?: string;
+  presence_penalty?: number;
+  promptPrefix?: string;
+  temperature?: number;
+  top_p?: number;
   //for BingAI
-  clientId?: string,
-  invocationId?: number,
-  jailbreak?: boolean,
-  jailbreakPresetId?: string,
-  presetSignature?: string,
-  toneStyle?: string,
-}
+  clientId?: string;
+  invocationId?: number;
+  jailbreak?: boolean;
+  jailbreakPresetId?: string;
+  presetSignature?: string;
+  toneStyle?: string;
+};
 
 export type TUser = {
-  id: string,
-  username: string,
-  email: string,
-  name: string,
-  avatar: string,
-  role: string,
-  createdAt: string,
-  updatedAt: string,
+  id: string;
+  username: string;
+  email: string;
+  name: string;
+  avatar: string;
+  role: string;
+  createdAt: string;
+  updatedAt: string;
 };
 
 export type TGetConversationsResponse = {
-  conversations: TConversation[],
-  pageNumber: string,
-  pageSize: string | number,
-  pages: string | number
+  conversations: TConversation[];
+  pageNumber: string;
+  pageSize: string | number;
+  pages: string | number;
 };
 
 export type TUpdateConversationRequest = {
-  conversationId: string,
-  title: string,
+  conversationId: string;
+  title: string;
 };
 
 export type TUpdateConversationResponse = {
-  data: TConversation
+  data: TConversation;
 };
 
 export type TDeleteConversationRequest = {
-  conversationId?: string,
-  source?: string
-}
+  conversationId?: string;
+  source?: string;
+};
 
 export type TDeleteConversationResponse = {
-  acknowledged: boolean,
-  deletedCount: number,
+  acknowledged: boolean;
+  deletedCount: number;
   messages: {
-    acknowledged: boolean,
-    deletedCount: number
-  }
+    acknowledged: boolean;
+    deletedCount: number;
+  };
 };
 
 export type TSearchResults = {
-  conversations: TConversation[],
-  messages: TMessage[],
-  pageNumber: string,
-  pageSize: string | number,
-  pages: string | number
-  filter: {}
+  conversations: TConversation[];
+  messages: TMessage[];
+  pageNumber: string;
+  pageSize: string | number;
+  pages: string | number;
+  filter: {};
 };
 
 export type TEndpoints = {
-  azureOpenAI: boolean,
-  bingAI: boolean,
+  azureOpenAI: boolean;
+  bingAI: boolean;
   ChatGptBrowser: {
-    availableModels: []
-  }
+    availableModels: [];
+  };
   OpenAI: {
-    availableModels: []
-  }
+    availableModels: [];
+  };
 };
 
 export type TUpdateTokenCountResponse = {
-  count: number,
+  count: number;
 };
 
-export type TMessageTreeNode = {}
+export type TMessageTreeNode = {};
 
-export type TSearchMessage = {}
+export type TSearchMessage = {};
 
-export type TSearchMessageTreeNode = {}
+export type TSearchMessageTreeNode = {};
 
 export type TRegisterUser = {
-  name: string,
-  email: string,
-  username: string,
-  password: string,
-}
+  name: string;
+  email: string;
+  username: string;
+  password: string;
+};
 
 export type TLoginUser = {
-  email: string,
-  password: string,
-}
+  email: string;
+  password: string;
+};
 
 export type TLoginResponse = {
-  token: string,
-  user: TUser
-}
+  token: string;
+  user: TUser;
+};
 
 export type TRequestPasswordReset = {
-  email: string,
-}
+  email: string;
+};
 
 export type TResetPassword = {
-  userId: string,
-  token: string,
-  password: string,
-}
+  userId: string;
+  token: string;
+  password: string;
+};