Merge branch 'main' into gitlab-sso

frontend/src/hooks/api/index.tsx

@@ -6,6 +6,7 @@ export * from "./integrationAuth";
 export * from "./integrations";
 export * from "./keys";
 export * from "./organization";
+export * from "./roles";
 export * from "./secretFolders";
 export * from "./secretImports";
 export * from "./secrets";

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

@@ -9,6 +9,8 @@ import {
   Environment, 
   IntegrationAuth, 
   NorthflankSecretGroup,
+  Org,
+  Project,
   Service, 
   Team, 
   TeamCityBuildConfig} from "./types";
@@ -27,6 +29,31 @@ const integrationAuthKeys = {
     integrationAuthId: string;
     appId: string;
   }) => [{ integrationAuthId, appId }, "integrationAuthVercelBranches"] as const,
+  getIntegrationAuthQoveryOrgs: (integrationAuthId: string) => 
+  [{ integrationAuthId }, "integrationAuthQoveryOrgs"] as const,
+  getIntegrationAuthQoveryProjects: ({
+    integrationAuthId,
+    orgId
+  }: {
+    integrationAuthId: string;
+    orgId: string;
+  }) => [{ integrationAuthId, orgId }, "integrationAuthQoveryProjects"] as const,
+  getIntegrationAuthQoveryEnvironments: ({
+    integrationAuthId,
+    projectId
+  }: {
+    integrationAuthId: string;
+    projectId: string;
+  }) => [{ integrationAuthId, projectId }, "integrationAuthQoveryEnvironments"] as const,
+  getIntegrationAuthQoveryScopes: ({
+    integrationAuthId,
+    environmentId,
+    scope
+  }: {
+    integrationAuthId: string;
+    environmentId: string;
+    scope: "job" | "application" | "container";
+  }) => [{ integrationAuthId, environmentId, scope }, "integrationAuthQoveryScopes"] as const,
   getIntegrationAuthRailwayEnvironments: ({
     integrationAuthId,
     appId
@@ -120,6 +147,121 @@ const fetchIntegrationAuthVercelBranches = async ({
   return branches;
 };
 
+const fetchIntegrationAuthQoveryOrgs = async (integrationAuthId: string) => {
+  const {
+    data: { orgs }
+  } = await apiRequest.get<{ orgs: Org[] }>(
+    `/api/v1/integration-auth/${integrationAuthId}/qovery/orgs`
+  );
+
+  return orgs;
+};
+
+const fetchIntegrationAuthQoveryProjects = async ({
+  integrationAuthId,
+  orgId
+}: {
+  integrationAuthId: string;
+  orgId: string;
+}) => {
+  if (orgId === "none") return [];
+  
+  const {
+    data: { projects }
+  } = await apiRequest.get<{ projects: Project[] }>(
+    `/api/v1/integration-auth/${integrationAuthId}/qovery/projects`,
+    {
+      params: {
+        orgId
+      }
+    }
+  );
+
+  return projects;
+};
+
+const fetchIntegrationAuthQoveryEnvironments = async ({
+  integrationAuthId,
+  projectId
+}: {
+  integrationAuthId: string;
+  projectId: string;
+}) => {
+  if (projectId === "none") return [];
+
+  const {
+    data: { environments }
+  } = await apiRequest.get<{ environments: Environment[] }>(
+    `/api/v1/integration-auth/${integrationAuthId}/qovery/environments`,
+    {
+      params: {
+        projectId
+      }
+    }
+  );
+
+  return environments;
+};
+
+const fetchIntegrationAuthQoveryScopes = async ({
+  integrationAuthId,
+  environmentId,
+  scope
+}: {
+  integrationAuthId: string;
+  environmentId: string;
+  scope: "job" | "application" | "container";
+}) => {
+  if (environmentId === "none") return [];
+  
+  if (scope === "application") {
+    const {
+      data: { apps }
+    } = await apiRequest.get<{ apps: App[] }>(
+      `/api/v1/integration-auth/${integrationAuthId}/qovery/apps`,
+      {
+        params: {
+          environmentId
+        }
+      }
+    );
+
+    return apps;
+  } 
+  
+  if (scope === "container") {
+    const {
+      data: { containers }
+    } = await apiRequest.get<{ containers: App[] }>(
+      `/api/v1/integration-auth/${integrationAuthId}/qovery/containers`,
+      {
+        params: {
+          environmentId
+        }
+      }
+    );
+
+    return containers;
+  }
+
+  if (scope === "job") {
+    const {
+      data: { jobs }
+    } = await apiRequest.get<{ jobs: App[] }>(
+      `/api/v1/integration-auth/${integrationAuthId}/qovery/jobs`,
+      {
+        params: {
+          environmentId
+        }
+      }
+    );
+
+    return jobs;
+  }
+
+  return undefined;
+};
+
 const fetchIntegrationAuthRailwayEnvironments = async ({
   integrationAuthId,
   appId
@@ -197,6 +339,8 @@ const fetchIntegrationAuthTeamCityBuildConfigs = async ({
   integrationAuthId: string;
   appId: string;
 }) => {
+  if (appId === "") return [];
+
   const {
     data: { buildConfigs }
   } = await apiRequest.get<{ buildConfigs: TeamCityBuildConfig[] }>(
@@ -269,6 +413,82 @@ export const useGetIntegrationAuthVercelBranches = ({
   });
 };
 
+export const useGetIntegrationAuthQoveryOrgs = (integrationAuthId: string) => {
+  return useQuery({
+    queryKey: integrationAuthKeys.getIntegrationAuthQoveryOrgs(integrationAuthId),
+    queryFn: () =>
+      fetchIntegrationAuthQoveryOrgs(integrationAuthId),
+    enabled: true
+  });
+};
+
+export const useGetIntegrationAuthQoveryProjects = ({
+  integrationAuthId,
+  orgId
+}: {
+  integrationAuthId: string;
+  orgId: string;
+}) => {
+  return useQuery({
+    queryKey: integrationAuthKeys.getIntegrationAuthQoveryProjects({
+      integrationAuthId,
+      orgId
+    }),
+    queryFn: () =>
+      fetchIntegrationAuthQoveryProjects({
+        integrationAuthId,
+        orgId
+      }),
+    enabled: true
+  });
+};
+
+export const useGetIntegrationAuthQoveryEnvironments = ({
+  integrationAuthId,
+  projectId
+}: {
+  integrationAuthId: string;
+  projectId: string;
+}) => {
+  return useQuery({
+    queryKey: integrationAuthKeys.getIntegrationAuthQoveryEnvironments({
+      integrationAuthId,
+      projectId
+    }),
+    queryFn: () =>
+      fetchIntegrationAuthQoveryEnvironments({
+        integrationAuthId,
+        projectId
+      }),
+    enabled: true
+  });
+};
+
+export const useGetIntegrationAuthQoveryScopes = ({
+  integrationAuthId,
+  environmentId,
+  scope
+}: {
+  integrationAuthId: string;
+  environmentId: string;
+  scope: "job" | "application" | "container";
+}) => {
+  return useQuery({
+    queryKey: integrationAuthKeys.getIntegrationAuthQoveryScopes({
+      integrationAuthId,
+      environmentId,
+      scope
+    }),
+    queryFn: () =>
+      fetchIntegrationAuthQoveryScopes({
+        integrationAuthId,
+        environmentId,
+        scope
+      }),
+    enabled: true
+  });
+};
+
 export const useGetIntegrationAuthRailwayEnvironments = ({
   integrationAuthId,
   appId
@@ -367,16 +587,19 @@ export const useAuthorizeIntegration = () => {
     mutationFn: async ({
       workspaceId,
       code,
-      integration
+      integration,
+      url
     }: {
       workspaceId: string;
       code: string;
       integration: string;
+      url?: string;
     }) => {
       const { data: { integrationAuth } } = await apiRequest.post("/api/v1/integration-auth/oauth-token", {
         workspaceId,
         code,
-        integration
+        integration,
+        url
       });
 
       return integrationAuth;
@@ -394,6 +617,7 @@ export const useSaveIntegrationAccessToken = () => {
     mutationFn: async ({
       workspaceId,
       integration,
+      refreshToken,
       accessId,
       accessToken,
       url,
@@ -401,14 +625,16 @@ export const useSaveIntegrationAccessToken = () => {
     }: {
       workspaceId: string | null;
       integration: string | undefined;
-      accessId: string | null;
-      accessToken: string;
-      url: string | null;
-      namespace: string | null;
+      refreshToken?: string;
+      accessId?: string;
+      accessToken?: string;
+      url?: string;
+      namespace?: string;
     }) => {
       const { data: { integrationAuth } } = await apiRequest.post("/api/v1/integration-auth/access-token", {
         workspaceId,
         integration,
+        refreshToken,
         accessId,
         accessToken,
         url,

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

@@ -26,6 +26,21 @@ export type Environment = {
   environmentId: string;
 };
 
+export type Container = {
+  name: string;
+  containerId: string;
+};
+
+export type Org = {
+  name: string;
+  orgId: string;
+};
+
+export type Project = {
+  name: string;
+  projectId: string;
+};
+
 export type Service = {
   name: string;
   serviceId: string;

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

@@ -40,23 +40,26 @@ export const useCreateIntegration = () => {
       owner,
       path,
       region,
+      scope,
       secretPath,
       metadata
     }: {
       integrationAuthId: string;
       isActive: boolean;
       secretPath: string;
-      app: string | null;
-      appId: string | null;
+      app?: string;
+      appId?: string;
       sourceEnvironment: string;
-      targetEnvironment: string | null;
-      targetEnvironmentId: string | null;
-      targetService: string | null;
-      targetServiceId: string | null;
-      owner: string | null;
-      path: string | null;
-      region: string | null;
+      targetEnvironment?: string;
+      targetEnvironmentId?: string;
+      targetService?: string;
+      targetServiceId?: string;
+      owner?: string;
+      path?: string;
+      region?: string;
+      scope?: string;
       metadata?: {
+        secretPrefix?: string;
         secretSuffix?: string;
       }
     }) => {
@@ -72,6 +75,7 @@ export const useCreateIntegration = () => {
         targetServiceId,
         owner,
         path,
+        scope,
         region,
         secretPath,
         metadata

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

@@ -32,5 +32,9 @@ export type TIntegration = {
   __v: number;
   metadata?: {
     secretSuffix?: string;
+    scope: string; 
+    org: string;
+    project: string;
+    environment: string;
   }
 };

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

@@ -0,0 +1,2 @@
+export { useCreateRole, useDeleteRole, useUpdateRole } from "./mutation";
+export { useGetRoles, useGetUserOrgPermissions,useGetUserProjectPermissions } from "./queries";

frontend/src/hooks/api/roles/mutation.tsx

@@ -0,0 +1,42 @@
+import { useMutation, useQueryClient } from "@tanstack/react-query";
+
+import { apiRequest } from "@app/config/request";
+
+import { roleQueryKeys } from "./queries";
+import { TCreateRoleDTO, TDeleteRoleDTO, TUpdateRoleDTO } from "./types";
+
+export const useCreateRole = <T extends string | undefined>() => {
+  const queryClient = useQueryClient();
+
+  return useMutation({
+    mutationFn: (dto: TCreateRoleDTO<T>) => apiRequest.post("/api/v1/roles", dto),
+    onSuccess: (_, { orgId, workspaceId }) => {
+      queryClient.invalidateQueries(roleQueryKeys.getRoles({ orgId, workspaceId }));
+    }
+  });
+};
+
+export const useUpdateRole = <T extends string | undefined>() => {
+  const queryClient = useQueryClient();
+
+  return useMutation({
+    mutationFn: ({ id, ...dto }: TUpdateRoleDTO<T>) => apiRequest.patch(`/api/v1/roles/${id}`, dto),
+    onSuccess: (_, { orgId, workspaceId }) => {
+      queryClient.invalidateQueries(roleQueryKeys.getRoles({ orgId, workspaceId }));
+    }
+  });
+};
+
+export const useDeleteRole = () => {
+  const queryClient = useQueryClient();
+
+  return useMutation({
+    mutationFn: ({ orgId, id }: TDeleteRoleDTO) =>
+      apiRequest.delete(`/api/v1/roles/${id}`, {
+        data: { orgId }
+      }),
+    onSuccess: (_, { orgId, workspaceId }) => {
+      queryClient.invalidateQueries(roleQueryKeys.getRoles({ orgId, workspaceId }));
+    }
+  });
+};

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

@@ -0,0 +1,103 @@
+import { buildMongoQueryMatcher, createMongoAbility, MongoAbility, RawRuleOf } from "@casl/ability";
+import { PackRule, unpackRules } from "@casl/ability/extra";
+import { useQuery } from "@tanstack/react-query";
+import { FieldCondition, FieldInstruction, JsInterpreter } from "@ucast/mongo2js";
+import picomatch from "picomatch";
+
+import { apiRequest } from "@app/config/request";
+import { OrgPermissionSet } from "@app/context/OrgPermissionContext/types";
+import { ProjectPermissionSet } from "@app/context/ProjectPermissionContext/types";
+
+import {
+  TGetRolesDTO,
+  TGetUserOrgPermissionsDTO,
+  TGetUserProjectPermissionDTO,
+  TRole
+} from "./types";
+
+const $glob: FieldInstruction<string> = {
+  type: "field",
+  validate(instruction, value) {
+    if (typeof value !== "string") {
+      throw new Error(`"${instruction.name}" expects value to be a string`);
+    }
+  }
+};
+
+const glob: JsInterpreter<FieldCondition<string>> = (node, object, context) => {
+  const secretPath = context.get(object, node.field);
+  const permissionSecretGlobPath = node.value;
+  if (!secretPath) return false;
+  return picomatch.isMatch(secretPath, permissionSecretGlobPath, { strictSlashes: false });
+};
+
+const conditionsMatcher = buildMongoQueryMatcher({ $glob }, { glob });
+
+export const roleQueryKeys = {
+  getRoles: ({ orgId, workspaceId }: TGetRolesDTO) => ["roles", { orgId, workspaceId }] as const,
+  getUserOrgPermissions: ({ orgId }: TGetUserOrgPermissionsDTO) =>
+    ["user-permissions", { orgId }] as const,
+  getUserProjectPermissions: ({ workspaceId }: TGetUserProjectPermissionDTO) =>
+    ["user-project-permissions", { workspaceId }] as const
+};
+
+const getRoles = async ({ orgId, workspaceId }: TGetRolesDTO) => {
+  const { data } = await apiRequest.get<{ data: { roles: TRole<typeof workspaceId>[] } }>(
+    "/api/v1/roles",
+    {
+      params: {
+        workspaceId,
+        orgId
+      }
+    }
+  );
+
+  return data.data.roles;
+};
+
+export const useGetRoles = ({ orgId, workspaceId }: TGetRolesDTO) =>
+  useQuery({
+    queryKey: roleQueryKeys.getRoles({ orgId, workspaceId }),
+    queryFn: () => getRoles({ orgId, workspaceId }),
+    enabled: Boolean(orgId)
+  });
+
+const getUserOrgPermissions = async ({ orgId }: TGetUserOrgPermissionsDTO) => {
+  const { data } = await apiRequest.get<{
+    data: { permissions: PackRule<RawRuleOf<MongoAbility<OrgPermissionSet>>>[] };
+  }>(`/api/v1/roles/organization/${orgId}/permissions`, {});
+
+  return data.data.permissions;
+};
+
+export const useGetUserOrgPermissions = ({ orgId }: TGetUserOrgPermissionsDTO) =>
+  useQuery({
+    queryKey: roleQueryKeys.getUserOrgPermissions({ orgId }),
+    queryFn: () => getUserOrgPermissions({ orgId }),
+    enabled: Boolean(orgId),
+    select: (data) => {
+      const rule = unpackRules<RawRuleOf<MongoAbility<OrgPermissionSet>>>(data);
+      const ability = createMongoAbility<OrgPermissionSet>(rule, { conditionsMatcher });
+      return ability;
+    }
+  });
+
+const getUserProjectPermissions = async ({ workspaceId }: TGetUserProjectPermissionDTO) => {
+  const { data } = await apiRequest.get<{
+    data: { permissions: PackRule<RawRuleOf<MongoAbility<OrgPermissionSet>>>[] };
+  }>(`/api/v1/roles/workspace/${workspaceId}/permissions`, {});
+
+  return data.data.permissions;
+};
+
+export const useGetUserProjectPermissions = ({ workspaceId }: TGetUserProjectPermissionDTO) =>
+  useQuery({
+    queryKey: roleQueryKeys.getUserProjectPermissions({ workspaceId }),
+    queryFn: () => getUserProjectPermissions({ workspaceId }),
+    enabled: Boolean(workspaceId),
+    select: (data) => {
+      const rule = unpackRules<RawRuleOf<MongoAbility<ProjectPermissionSet>>>(data);
+      const ability = createMongoAbility<ProjectPermissionSet>(rule, { conditionsMatcher });
+      return ability;
+    }
+  });

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

@@ -0,0 +1,57 @@
+export type TGetRolesDTO = {
+  orgId: string;
+  workspaceId?: string;
+};
+
+export type TRole<T extends string | undefined> = {
+  _id: string;
+  organization: string;
+  workspace: T;
+  name: string;
+  description: string;
+  slug: string;
+  permissions: T extends string ? TProjectPermission[] : TPermission[];
+  createdAt: string;
+  updatedAt: string;
+};
+
+export type TPermission = {
+  conditions?: Record<string, any>;
+  action: string;
+  subject: string;
+};
+
+export type TProjectPermission = {
+  conditions?: Record<string, any>;
+  action: string;
+  subject: string;
+};
+
+export type TCreateRoleDTO<T extends string | undefined> = {
+  orgId: string;
+  workspaceId?: T;
+  name: string;
+  description?: string;
+  slug: string;
+  permissions: T extends string ? TProjectPermission[] : TPermission[];
+};
+
+export type TUpdateRoleDTO<T extends string | undefined> = {
+  orgId: string;
+  id: string;
+  workspaceId?: T;
+} & Partial<Omit<TCreateRoleDTO<T>, "orgId" | "workspaceId">>;
+
+export type TDeleteRoleDTO = {
+  orgId: string;
+  id: string;
+  workspaceId?: string;
+};
+
+export type TGetUserOrgPermissionsDTO = {
+  orgId: string;
+};
+
+export type TGetUserProjectPermissionDTO = {
+  workspaceId: string;
+};

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

@@ -8,6 +8,7 @@ import { apiRequest } from "@app/config/request";
 import { setAuthToken } from "@app/reactQuery";
 
 import { useUploadWsKey } from "../keys/queries";
+import { workspaceKeys } from "../workspace/queries";
 import {
   AddUserToOrgDTO,
   AddUserToWsDTO,
@@ -55,27 +56,27 @@ export const useRenameUser = () => {
 
   return useMutation<{}, {}, RenameUserDTO>({
     mutationFn: ({ newName }) =>
-      apiRequest.patch("/api/v2/users/me/name", { firstName: newName?.split(" ")[0], lastName: newName?.split(" ").slice(1).join(" ") }),
+      apiRequest.patch("/api/v2/users/me/name", {
+        firstName: newName?.split(" ")[0],
+        lastName: newName?.split(" ").slice(1).join(" ")
+      }),
     onSuccess: () => {
       queryClient.invalidateQueries(userKeys.getUser);
     }
   });
 };
 
-
 export const useUpdateUserAuthMethods = () => {
   const queryClient = useQueryClient();
 
   return useMutation({
-    mutationFn: async ({
-      authMethods
-    }: {
-      authMethods: AuthMethod[];
-    }) => {
-      const { data: { user } } = await apiRequest.put("/api/v2/users/me/auth-methods", { 
+    mutationFn: async ({ authMethods }: { authMethods: AuthMethod[] }) => {
+      const {
+        data: { user }
+      } = await apiRequest.put("/api/v2/users/me/auth-methods", {
         authMethods
       });
-      
+
       return user;
     },
     onSuccess: () => {
@@ -108,6 +109,7 @@ export const useGetOrgUsers = (orgId: string) =>
 // mutation
 export const useAddUserToWs = () => {
   const uploadWsKey = useUploadWsKey();
+  const queryClient = useQueryClient();
 
   return useMutation<{ data: AddUserToWsRes }, {}, AddUserToWsDTO>({
     mutationFn: ({ email, workspaceId }) =>
@@ -136,18 +138,20 @@ export const useAddUserToWs = () => {
         userId: data.invitee._id,
         workspaceId
       });
+
+      queryClient.invalidateQueries(workspaceKeys.getWorkspaceUsers(workspaceId));
     }
   });
 };
 
 export const useAddUserToOrg = () => {
   const queryClient = useQueryClient();
-  type Response  = {
+  type Response = {
     data: {
-      message: string, 
-      completeInviteLink: string | undefined
-    }
-  }
+      message: string;
+      completeInviteLink: string | undefined;
+    };
+  };
 
   return useMutation<Response, {}, AddUserToOrgDTO>({
     mutationFn: (dto) => {
@@ -164,7 +168,7 @@ export const useDeleteOrgMembership = () => {
 
   return useMutation<{}, {}, DeletOrgMembershipDTO>({
     mutationFn: ({ membershipId, orgId }) => {
-      return apiRequest.delete(`/api/v2/organizations/${orgId}/memberships/${membershipId}`)
+      return apiRequest.delete(`/api/v2/organizations/${orgId}/memberships/${membershipId}`);
     },
     onSuccess: (_, { orgId }) => {
       queryClient.invalidateQueries(userKeys.getOrgUsers(orgId));
@@ -177,9 +181,12 @@ export const useUpdateOrgUserRole = () => {
 
   return useMutation<{}, {}, UpdateOrgUserRoleDTO>({
     mutationFn: ({ organizationId, membershipId, role }) => {
-      return apiRequest.patch(`/api/v2/organizations/${organizationId}/memberships/${membershipId}`, {
-        role
-      });
+      return apiRequest.patch(
+        `/api/v2/organizations/${organizationId}/memberships/${membershipId}`,
+        {
+          role
+        }
+      );
     },
     onSuccess: (_, { organizationId }) => {
       queryClient.invalidateQueries(userKeys.getOrgUsers(organizationId));
@@ -218,64 +225,49 @@ export const useLogoutUser = () =>
   });
 
 export const useGetMyIp = () => {
- return useQuery({
+  return useQuery({
     queryKey: userKeys.myIp,
     queryFn: async () => {
-      const { data } = await apiRequest.get<{ ip: string; }>(
-        "/api/v1/users/me/ip"
-      );
+      const { data } = await apiRequest.get<{ ip: string }>("/api/v1/users/me/ip");
       return data.ip;
     },
     enabled: true
-  }); 
-}
+  });
+};
 
 export const useGetMyAPIKeys = () => {
   return useQuery({
     queryKey: userKeys.myAPIKeys,
     queryFn: async () => {
-      const { data } = await apiRequest.get<APIKeyData[]>(
-        "/api/v2/users/me/api-keys"
-      );
+      const { data } = await apiRequest.get<APIKeyData[]>("/api/v2/users/me/api-keys");
       return data;
     },
     enabled: true
   });
-}
+};
 
 export const useCreateAPIKey = () => {
   const queryClient = useQueryClient();
   return useMutation({
-    mutationFn: async ({
-      name,
-      expiresIn
-    }: {
-      name: string;
-      expiresIn: number;
-    }) => {
-      const { data } = await apiRequest.post<CreateAPIKeyRes>(
-        "/api/v2/users/me/api-keys",
-        {
-          name,
-          expiresIn
-        }
-      );
-      
+    mutationFn: async ({ name, expiresIn }: { name: string; expiresIn: number }) => {
+      const { data } = await apiRequest.post<CreateAPIKeyRes>("/api/v2/users/me/api-keys", {
+        name,
+        expiresIn
+      });
+
       return data;
     },
     onSuccess() {
       queryClient.invalidateQueries(userKeys.myAPIKeys);
     }
   });
-}
+};
 
 export const useDeleteAPIKey = () => {
   const queryClient = useQueryClient();
   return useMutation({
     mutationFn: async (apiKeyDataId: string) => {
-      const { data } = await apiRequest.delete(
-        `/api/v2/users/me/api-keys/${apiKeyDataId}`
-      );
+      const { data } = await apiRequest.delete(`/api/v2/users/me/api-keys/${apiKeyDataId}`);
 
       return data;
     },
@@ -283,29 +275,25 @@ export const useDeleteAPIKey = () => {
       queryClient.invalidateQueries(userKeys.myAPIKeys);
     }
   });
-}
+};
 
 export const useGetMySessions = () => {
   return useQuery({
     queryKey: userKeys.mySessions,
     queryFn: async () => {
-      const { data } = await apiRequest.get<TokenVersion[]>(
-        "/api/v2/users/me/sessions"
-      );
+      const { data } = await apiRequest.get<TokenVersion[]>("/api/v2/users/me/sessions");
 
       return data;
     },
     enabled: true
   });
-}
+};
 
 export const useRevokeMySessions = () => {
   const queryClient = useQueryClient();
   return useMutation({
     mutationFn: async () => {
-      const { data } = await apiRequest.delete(
-        "/api/v2/users/me/sessions"
-      );
+      const { data } = await apiRequest.delete("/api/v2/users/me/sessions");
 
       return data;
     },
@@ -313,22 +301,17 @@ export const useRevokeMySessions = () => {
       queryClient.invalidateQueries(userKeys.mySessions);
     }
   });
-}
+};
 
 export const useUpdateMfaEnabled = () => {
   const queryClient = useQueryClient();
   return useMutation({
-    mutationFn: async ({
-      isMfaEnabled
-    }: {
-      isMfaEnabled: boolean;
-    }) => {
-      const { data: { user } } = await apiRequest.patch(
-        "/api/v2/users/me/mfa",
-        {
-          isMfaEnabled
-        }
-      );
+    mutationFn: async ({ isMfaEnabled }: { isMfaEnabled: boolean }) => {
+      const {
+        data: { user }
+      } = await apiRequest.patch("/api/v2/users/me/mfa", {
+        isMfaEnabled
+      });
 
       return user;
     },
@@ -336,15 +319,15 @@ export const useUpdateMfaEnabled = () => {
       queryClient.invalidateQueries(userKeys.getUser);
     }
   });
-}
+};
 
 export const fetchMyOrganizationProjects = async (orgId: string) => {
-  const { data: { workspaces } } = await apiRequest.get(
-    `/api/v1/organization/${orgId}/my-workspaces`
-  );
+  const {
+    data: { workspaces }
+  } = await apiRequest.get(`/api/v1/organization/${orgId}/my-workspaces`);
 
   return workspaces;
-}
+};
 
 export const useGetMyOrganizationProjects = (orgId: string) => {
   return useQuery({
@@ -354,4 +337,4 @@ export const useGetMyOrganizationProjects = (orgId: string) => {
     },
     enabled: true
   });
-}
+};

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

@@ -1,8 +1,8 @@
 import { UserWsKeyPair } from "../keys/types";
 
 export enum AuthMethod {
-	EMAIL = "email",
-	GOOGLE = "google",
+  EMAIL = "email",
+  GOOGLE = "google",
   GITHUB = "github",
   GITLAB = "gitlab",
 	OKTA_SAML = "okta-saml",
@@ -43,11 +43,14 @@ export type OrgUser = {
   };
   inviteEmail: string;
   organization: string;
-  role: "owner" | "admin" | "member";
+  role: "owner" | "admin" | "member" | "custom";
   status: "invited" | "accepted" | "verified" | "completed";
   deniedPermissions: any[];
+  customRole: string;
 };
 
+export type TWorkspaceUser = OrgUser;
+
 export type AddUserToWsDTO = {
   workspaceId: string;
   email: string;
@@ -77,7 +80,7 @@ export type AddUserToOrgDTO = {
 export type CreateAPIKeyRes = {
   apiKey: string;
   apiKeyData: APIKeyData;
-}
+};
 
 export type RenameUserDTO = {
   newName: string;
@@ -90,7 +93,7 @@ export type APIKeyData = {
   lastUsed: string;
   createdAt: string;
   expiresAt: string;
-}
+};
 
 export type TokenVersion = {
   _id: string;
@@ -100,4 +103,4 @@ export type TokenVersion = {
   lastUsed: string;
   createdAt: string;
   updatedAt: string;
-}
+};

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

@@ -5,6 +5,7 @@ import { apiRequest } from "@app/config/request";
 import { IntegrationAuth } from "../integrationAuth/types";
 import { TIntegration } from "../integrations/types";
 import { EncryptedSecret } from "../secrets/types";
+import { TWorkspaceUser } from "../users/types";
 import {
   CreateEnvironmentDTO,
   CreateWorkspaceDTO,
@@ -173,16 +174,17 @@ export const createWorkspace = ({
   workspaceName
 }: CreateWorkspaceDTO): Promise<{ data: { workspace: Workspace } }> => {
   return apiRequest.post("/api/v1/workspace", { workspaceName, organizationId });
-}
+};
 
 export const useCreateWorkspace = () => {
   const queryClient = useQueryClient();
 
   return useMutation<{ data: { workspace: Workspace } }, {}, CreateWorkspaceDTO>({
-    mutationFn: async ({ organizationId, workspaceName }) => createWorkspace({
-      organizationId,
-      workspaceName
-    }),
+    mutationFn: async ({ organizationId, workspaceName }) =>
+      createWorkspace({
+        organizationId,
+        workspaceName
+      }),
     onSuccess: () => {
       queryClient.invalidateQueries(workspaceKeys.getAllUserWorkspace);
     }
@@ -296,32 +298,30 @@ export const useGetWorkspaceUsers = (workspaceId: string) => {
   return useQuery({
     queryKey: workspaceKeys.getWorkspaceUsers(workspaceId),
     queryFn: async () => {
-      const { data: { users } } = await apiRequest.get(
+      const {
+        data: { users }
+      } = await apiRequest.get<{ users: TWorkspaceUser[] }>(
         `/api/v1/workspace/${workspaceId}/users`
       );
       return users;
     },
     enabled: true
   });
-}
+};
 
 export const useAddUserToWorkspace = () => {
   const queryClient = useQueryClient();
 
   return useMutation({
-    mutationFn: async ({
-      email,
-      workspaceId
-    }: {
-      email: string;
-      workspaceId: string;
-    }) => {
-      const { data: { invitee, latestKey } } = await apiRequest.post(`/api/v1/workspace/${workspaceId}/invite-signup`, { email });
-      
-      return ({
+    mutationFn: async ({ email, workspaceId }: { email: string; workspaceId: string }) => {
+      const {
+        data: { invitee, latestKey }
+      } = await apiRequest.post(`/api/v1/workspace/${workspaceId}/invite-signup`, { email });
+
+      return {
         invitee,
         latestKey
-      });
+      };
     },
     onSuccess: (_, dto) => {
       queryClient.invalidateQueries(workspaceKeys.getWorkspaceUsers(dto.workspaceId));
@@ -334,7 +334,9 @@ export const useDeleteUserFromWorkspace = () => {
 
   return useMutation({
     mutationFn: async (membershipId: string) => {
-      const { data: { deletedMembership } } = await apiRequest.delete(`/api/v1/membership/${membershipId}`);
+      const {
+        data: { deletedMembership }
+      } = await apiRequest.delete(`/api/v1/membership/${membershipId}`);
       return deletedMembership;
     },
     onSuccess: (res) => {
@@ -346,14 +348,10 @@ export const useDeleteUserFromWorkspace = () => {
 export const useUpdateUserWorkspaceRole = () => {
   const queryClient = useQueryClient();
   return useMutation({
-    mutationFn: async ({
-      membershipId,
-      role
-    }: {
-      membershipId: string;
-      role: string;
-    }) => {
-      const { data: { membership } } = await apiRequest.post(`/api/v1/membership/${membershipId}/change-role`, {
+    mutationFn: async ({ membershipId, role }: { membershipId: string; role: string }) => {
+      const {
+        data: { membership }
+      } = await apiRequest.post(`/api/v1/membership/${membershipId}/change-role`, {
         role
       });
       return membership;