feat(ui): added new react-query hooks for settings page

frontend/src/hooks/api/index.tsx

@@ -1 +1,5 @@
-export { useGetAuthToken } from './auth';
+export * from './auth';
+export * from './keys';
+export * from './serviceTokens';
+export * from './subscriptions';
+export * from './workspace';

frontend/src/hooks/api/keys/index.tsx

@@ -0,0 +1 @@
+export { useGetUserWsKey } from './queries';

frontend/src/hooks/api/keys/queries.tsx

@@ -0,0 +1,24 @@
+import { useQuery } from '@tanstack/react-query';
+
+import { apiRequest } from '@app/config/request';
+
+import { UserWsKeyPair } from './types';
+
+const encKeyKeys = {
+  getUserWorkspaceKey: (workspaceID: string) => ['worksapce-key-pair', { workspaceID }] as const
+};
+
+const fetchUserWsKey = async (workspaceID: string) => {
+  const { data } = await apiRequest.get<{ latestKey: UserWsKeyPair }>(
+    `/api/v1/key/${workspaceID}/latest`
+  );
+
+  return data.latestKey;
+};
+
+export const useGetUserWsKey = (workspaceID: string) =>
+  useQuery({
+    queryKey: encKeyKeys.getUserWorkspaceKey(workspaceID),
+    queryFn: () => fetchUserWsKey(workspaceID),
+    enabled: Boolean(workspaceID)
+  });

frontend/src/hooks/api/keys/types.ts

@@ -0,0 +1,22 @@
+export type UserWsKeyPair = {
+  _id: string;
+  encryptedKey: string;
+  nonce: string;
+  sender: Sender;
+  receiver: string;
+  workspace: string;
+  createdAt: string;
+  updatedAt: string;
+  __v: number;
+};
+
+export type Sender = {
+  _id: string;
+  email: string;
+  createdAt: string;
+  updatedAt: string;
+  __v: number;
+  firstName: string;
+  lastName: string;
+  publicKey: string;
+};

frontend/src/hooks/api/serviceTokens/index.ts

@@ -0,0 +1 @@
+export { useCreateServiceToken, useDeleteServiceToken, useGetUserWsServiceTokens } from './queries';

frontend/src/hooks/api/serviceTokens/queries.tsx

@@ -0,0 +1,60 @@
+import { useMutation, useQuery, useQueryClient } from '@tanstack/react-query';
+
+import { apiRequest } from '@app/config/request';
+
+import {
+  CreateServiceTokenDTO,
+  CreateServiceTokenRes,
+  DeleteServiceTokenRes,
+  ServiceToken
+} from './types';
+
+const serviceTokenKeys = {
+  getAllWorkspaceServiceToken: (workspaceID: string) => [{ workspaceID }, 'service-tokens'] as const
+};
+
+const fetchWorkspaceServiceTokens = async (workspaceID: string) => {
+  const { data } = await apiRequest.get<{ serviceTokenData: ServiceToken[] }>(
+    `/api/v2/workspace/${workspaceID}/service-token-data`
+  );
+
+  return data.serviceTokenData;
+};
+
+type UseGetWorkspaceServiceTokensProps = { workspaceID: string };
+
+export const useGetUserWsServiceTokens = ({ workspaceID }: UseGetWorkspaceServiceTokensProps) =>
+  useQuery({
+    queryKey: serviceTokenKeys.getAllWorkspaceServiceToken(workspaceID),
+    queryFn: () => fetchWorkspaceServiceTokens(workspaceID),
+    enabled: Boolean(workspaceID)
+  });
+
+// mutation
+export const useCreateServiceToken = () => {
+  const queryClient = useQueryClient();
+
+  return useMutation<CreateServiceTokenRes, {}, CreateServiceTokenDTO>({
+    mutationFn: async (body) => {
+      const { data } = await apiRequest.post('/api/v2/service-token/', body);
+      return data;
+    },
+    onSuccess: ({ serviceTokenData: { workspace } }) => {
+      queryClient.invalidateQueries(serviceTokenKeys.getAllWorkspaceServiceToken(workspace));
+    }
+  });
+};
+
+export const useDeleteServiceToken = () => {
+  const queryClient = useQueryClient();
+
+  return useMutation<DeleteServiceTokenRes, {}, string>({
+    mutationFn: async (serviceTokenId) => {
+      const { data } = await apiRequest.delete(`/api/v2/service-token/${serviceTokenId}`);
+      return data;
+    },
+    onSuccess: ({ serviceTokenData: { workspace } }) => {
+      queryClient.invalidateQueries(serviceTokenKeys.getAllWorkspaceServiceToken(workspace));
+    }
+  });
+};

frontend/src/hooks/api/serviceTokens/types.ts

@@ -0,0 +1,28 @@
+export type ServiceToken = {
+  _id: string;
+  name: string;
+  workspace: string;
+  environment: string;
+  user: string;
+  expiresAt: string;
+  createdAt: string;
+  updatedAt: string;
+  __v: number;
+};
+
+export type CreateServiceTokenDTO = {
+  name: string;
+  workspaceId: string;
+  environment: string;
+  expiresIn: number;
+  encryptedKey: string;
+  iv: string;
+  tag: string;
+};
+
+export type CreateServiceTokenRes = {
+  serviceToken: string;
+  serviceTokenData: ServiceToken;
+};
+
+export type DeleteServiceTokenRes = { serviceTokenData: ServiceToken };

frontend/src/hooks/api/subscriptions/index.tsx

@@ -0,0 +1 @@
+export { useGetOrgSubscription } from './queries';

frontend/src/hooks/api/subscriptions/queries.tsx

@@ -0,0 +1,30 @@
+import { useQuery } from '@tanstack/react-query';
+
+import { apiRequest } from '@app/config/request';
+
+import { GetSubscriptionPlan } from './types';
+
+// import { Workspace } from './types';
+
+const subscriptionKeys = {
+  getOrgSubsription: (orgID: string) => ['subscription', { orgID }] as const
+};
+
+const fetchOrgSubscription = async (orgID: string) => {
+  const { data } = await apiRequest.get<{ subscriptions: GetSubscriptionPlan }>(
+    `/api/v1/organization/${orgID}/subscriptions`
+  );
+
+  return data.subscriptions;
+};
+
+type UseGetOrgSubscriptionProps = {
+  orgID: string;
+};
+
+export const useGetOrgSubscription = ({ orgID }: UseGetOrgSubscriptionProps) =>
+  useQuery({
+    queryKey: subscriptionKeys.getOrgSubsription(orgID),
+    queryFn: () => fetchOrgSubscription(orgID),
+    enabled: Boolean(orgID)
+  });

frontend/src/hooks/api/subscriptions/types.ts

@@ -0,0 +1,25 @@
+export type GetSubscriptionPlan = {
+  data: { plan: SubscriptionPlan }[];
+};
+
+export type SubscriptionPlan = {
+  id: string;
+  object: string;
+  active: boolean;
+  aggregate_usage: unknown;
+  amount: 1400;
+  amount_decimal: 1400;
+  billing_scheme: string;
+  created: 1674833546;
+  currency: string;
+  interval: string;
+  interval_count: 1;
+  livemode: false;
+  metadata: {};
+  nickname: null;
+  product: string;
+  tiers_mode: unknown;
+  transform_usage: unknown;
+  trial_period_days: unknown;
+  usage_type: string;
+};

frontend/src/hooks/api/types.ts

@@ -0,0 +1,13 @@
+export type { GetAuthTokenAPI } from './auth/types';
+export type { UserWsKeyPair } from './keys/types';
+export type { CreateServiceTokenDTO, ServiceToken } from './serviceTokens/types';
+export type { GetSubscriptionPlan, SubscriptionPlan } from './subscriptions/types';
+export type {
+  CreateEnvironmentDTO,
+  DeleteEnvironmentDTO,
+  DeleteWorkspaceDTO,
+  RenameWorkspaceDTO,
+  UpdateEnvironmentDTO,
+  Workspace,
+  WorkspaceEnv
+} from './workspace/types';

frontend/src/hooks/api/workspace/index.tsx

@@ -0,0 +1,8 @@
+export {
+  useCreateWsEnvironment,
+  useDeleteWorkspace,
+  useDeleteWsEnvironment,
+  useGetUserWorkspaces,
+  useRenameWorkspace,
+  useUpdateWsEnvironment
+} from './queries';

frontend/src/hooks/api/workspace/queries.tsx

@@ -0,0 +1,94 @@
+import { useMutation, useQuery, useQueryClient } from '@tanstack/react-query';
+
+import { apiRequest } from '@app/config/request';
+
+import {
+  CreateEnvironmentDTO,
+  DeleteEnvironmentDTO,
+  DeleteWorkspaceDTO,
+  RenameWorkspaceDTO,
+  UpdateEnvironmentDTO,
+  Workspace
+} from './types';
+
+const workspaceKeys = {
+  getAllUserWorkspace: ['workspaces'] as const
+};
+
+const fetchUserWorkspaces = async () => {
+  const { data } = await apiRequest.get<{ workspaces: Workspace[] }>('/api/v1/workspace');
+
+  return data.workspaces;
+};
+
+export const useGetUserWorkspaces = () =>
+  useQuery(workspaceKeys.getAllUserWorkspace, fetchUserWorkspaces);
+
+// mutation
+export const useRenameWorkspace = () => {
+  const queryClient = useQueryClient();
+
+  return useMutation<{}, {}, RenameWorkspaceDTO>({
+    mutationFn: ({ workspaceID, newWorkspaceName }) =>
+      apiRequest.post(`/api/v1/workspace/${workspaceID}/name`, { name: newWorkspaceName }),
+    onSuccess: () => {
+      queryClient.invalidateQueries(workspaceKeys.getAllUserWorkspace);
+    }
+  });
+};
+
+export const useDeleteWorkspace = () => {
+  const queryClient = useQueryClient();
+
+  return useMutation<{}, {}, DeleteWorkspaceDTO>({
+    mutationFn: ({ workspaceID }) => apiRequest.delete(`/api/v1/workspace/${workspaceID}`),
+    onSuccess: () => {
+      queryClient.invalidateQueries(workspaceKeys.getAllUserWorkspace);
+    }
+  });
+};
+
+export const useCreateWsEnvironment = () => {
+  const queryClient = useQueryClient();
+
+  return useMutation<{}, {}, CreateEnvironmentDTO>({
+    mutationFn: ({ workspaceID, environmentName, environmentSlug }) =>
+      apiRequest.post(`/api/v2/workspace/${workspaceID}/environments`, {
+        environmentName,
+        environmentSlug
+      }),
+    onSuccess: () => {
+      queryClient.invalidateQueries(workspaceKeys.getAllUserWorkspace);
+    }
+  });
+};
+
+export const useUpdateWsEnvironment = () => {
+  const queryClient = useQueryClient();
+
+  return useMutation<{}, {}, UpdateEnvironmentDTO>({
+    mutationFn: ({ workspaceID, environmentName, environmentSlug, oldEnvironmentSlug }) =>
+      apiRequest.put(`/api/v2/workspace/${workspaceID}/environments`, {
+        environmentName,
+        environmentSlug,
+        oldEnvironmentSlug
+      }),
+    onSuccess: () => {
+      queryClient.invalidateQueries(workspaceKeys.getAllUserWorkspace);
+    }
+  });
+};
+
+export const useDeleteWsEnvironment = () => {
+  const queryClient = useQueryClient();
+
+  return useMutation<{}, {}, DeleteEnvironmentDTO>({
+    mutationFn: ({ workspaceID, environmentSlug }) =>
+      apiRequest.delete(`/api/v2/workspace/${workspaceID}/environments`, {
+        data: { environmentSlug }
+      }),
+    onSuccess: () => {
+      queryClient.invalidateQueries(workspaceKeys.getAllUserWorkspace);
+    }
+  });
+};

frontend/src/hooks/api/workspace/types.ts

@@ -0,0 +1,29 @@
+export type Workspace = {
+  __v: number;
+  _id: string;
+  name: string;
+  organization: string;
+  environments: WorkspaceEnv[];
+};
+
+export type WorkspaceEnv = { name: string; slug: string };
+
+// mutation dto
+export type RenameWorkspaceDTO = { workspaceID: string; newWorkspaceName: string };
+
+export type DeleteWorkspaceDTO = { workspaceID: string };
+
+export type CreateEnvironmentDTO = {
+  workspaceID: string;
+  environmentSlug: string;
+  environmentName: string;
+};
+
+export type UpdateEnvironmentDTO = {
+  workspaceID: string;
+  oldEnvironmentSlug: string;
+  environmentSlug: string;
+  environmentName: string;
+};
+
+export type DeleteEnvironmentDTO = { workspaceID: string; environmentSlug: string };

frontend/src/hooks/usePopUp.tsx

@@ -21,7 +21,7 @@ interface UsePopUpReturn<T extends Readonly<string[]> | UsePopUpProps[]> {
   popUp: UsePopUpState<T>;
   handlePopUpOpen: (popUpName: keyof UsePopUpState<T>, data?: unknown) => void;
   handlePopUpClose: (popUpName: keyof UsePopUpState<T>) => void;
-  handlePopUpToggle: (popUpName: keyof UsePopUpState<T>) => void;
+  handlePopUpToggle: (popUpName: keyof UsePopUpState<T>, state?: boolean) => void;
 }
 
 /**
@@ -50,10 +50,10 @@ export const usePopUp = <T extends Readonly<string[]> | UsePopUpProps[]>(
     setPopUp((oldState) => ({ ...oldState, [popUpName]: { isOpen: false } }));
   }, []);
 
-  const handlePopUpToggle = useCallback((popUpName: keyof UsePopUpState<T>) => {
+  const handlePopUpToggle = useCallback((popUpName: keyof UsePopUpState<T>, state?: boolean) => {
     setPopUp((oldState) => ({
       ...oldState,
-      [popUpName]: { isOpen: !oldState[popUpName].isOpen }
+      [popUpName]: { isOpen: typeof state === 'undefined' ? !oldState[popUpName].isOpen : state }
     }));
   }, []);