Fix merge conflicts, bring oidc auth up to speed with identity ui changes

frontend/src/hooks/api/identities/constants.tsx

@@ -1,6 +1,7 @@
 import { IdentityAuthMethod } from "./enums";
 
 export const identityAuthToNameMap: { [I in IdentityAuthMethod]: string } = {
+  [IdentityAuthMethod.TOKEN_AUTH]: "Token Auth",
   [IdentityAuthMethod.UNIVERSAL_AUTH]: "Universal Auth",
   [IdentityAuthMethod.KUBERNETES_AUTH]: "Kubernetes Auth",
   [IdentityAuthMethod.GCP_AUTH]: "GCP Auth",

frontend/src/hooks/api/identities/enums.tsx

@@ -1,4 +1,5 @@
 export enum IdentityAuthMethod {
+  TOKEN_AUTH = "token-auth",
   UNIVERSAL_AUTH = "universal-auth",
   KUBERNETES_AUTH = "kubernetes-auth",
   GCP_AUTH = "gcp-auth",

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

@@ -6,25 +6,41 @@ export {
   useAddIdentityGcpAuth,
   useAddIdentityKubernetesAuth,
   useAddIdentityOidcAuth,
+  useAddIdentityTokenAuth,
   useAddIdentityUniversalAuth,
   useCreateIdentity,
   useCreateIdentityUniversalAuthClientSecret,
+  useCreateTokenIdentityTokenAuth,
   useDeleteIdentity,
+  useDeleteIdentityAwsAuth,
+  useDeleteIdentityAzureAuth,
+  useDeleteIdentityGcpAuth,
+  useDeleteIdentityKubernetesAuth,
+  useDeleteIdentityTokenAuth,
+  useDeleteIdentityUniversalAuth,
+  useDeleteIdentityOidcAuth,
+  useRevokeIdentityTokenAuthToken,
   useRevokeIdentityUniversalAuthClientSecret,
   useUpdateIdentity,
   useUpdateIdentityAwsAuth,
   useUpdateIdentityAzureAuth,
   useUpdateIdentityGcpAuth,
   useUpdateIdentityKubernetesAuth,
-  useUpdateIdentityOidcAuth,
-  useUpdateIdentityUniversalAuth
+  useUpdateIdentityTokenAuth,
+  useUpdateIdentityTokenAuthToken,
+  useUpdateIdentityUniversalAuth,
+  useUpdateIdentityOidcAuth
 } from "./mutations";
 export {
   useGetIdentityAwsAuth,
   useGetIdentityAzureAuth,
+  useGetIdentityById,
   useGetIdentityGcpAuth,
   useGetIdentityKubernetesAuth,
-  useGetIdentityOidcAuth,
+  useGetIdentityProjectMemberships,
+  useGetIdentityTokenAuth,
+  useGetIdentityTokensTokenAuth,
   useGetIdentityUniversalAuth,
-  useGetIdentityUniversalAuthClientSecrets
+  useGetIdentityUniversalAuthClientSecrets,
+  useGetIdentityOidcAuth
 } from "./queries";

frontend/src/hooks/api/identities/mutations.tsx

@@ -10,27 +10,43 @@ import {
   AddIdentityGcpAuthDTO,
   AddIdentityKubernetesAuthDTO,
   AddIdentityOidcAuthDTO,
+  AddIdentityTokenAuthDTO,
   AddIdentityUniversalAuthDTO,
   ClientSecretData,
   CreateIdentityDTO,
   CreateIdentityUniversalAuthClientSecretDTO,
   CreateIdentityUniversalAuthClientSecretRes,
+  CreateTokenIdentityTokenAuthDTO,
+  CreateTokenIdentityTokenAuthRes,
+  DeleteIdentityAwsAuthDTO,
+  DeleteIdentityAzureAuthDTO,
   DeleteIdentityDTO,
+  DeleteIdentityGcpAuthDTO,
+  DeleteIdentityKubernetesAuthDTO,
+  DeleteIdentityTokenAuthDTO,
   DeleteIdentityUniversalAuthClientSecretDTO,
+  DeleteIdentityUniversalAuthDTO,
+  DeleteIdentityOidcAuthDTO,
   Identity,
+  IdentityAccessToken,
   IdentityAwsAuth,
   IdentityAzureAuth,
   IdentityGcpAuth,
   IdentityKubernetesAuth,
   IdentityOidcAuth,
+  IdentityTokenAuth,
   IdentityUniversalAuth,
+  RevokeTokenDTO,
+  RevokeTokenRes,
   UpdateIdentityAwsAuthDTO,
   UpdateIdentityAzureAuthDTO,
   UpdateIdentityDTO,
   UpdateIdentityGcpAuthDTO,
   UpdateIdentityKubernetesAuthDTO,
   UpdateIdentityOidcAuthDTO,
-  UpdateIdentityUniversalAuthDTO
+  UpdateIdentityUniversalAuthDTO,
+  UpdateIdentityTokenAuthDTO,
+  UpdateTokenIdentityTokenAuthDTO
 } from "./types";
 
 export const useCreateIdentity = () => {
@@ -61,8 +77,9 @@ export const useUpdateIdentity = () => {
 
       return identity;
     },
-    onSuccess: (_, { organizationId }) => {
+    onSuccess: (_, { organizationId, identityId }) => {
       queryClient.invalidateQueries(organizationKeys.getOrgIdentityMemberships(organizationId));
+      queryClient.invalidateQueries(identitiesKeys.getIdentityById(identityId));
     }
   });
 };
@@ -106,8 +123,10 @@ export const useAddIdentityUniversalAuth = () => {
       });
       return identityUniversalAuth;
     },
-    onSuccess: (_, { organizationId }) => {
+    onSuccess: (_, { identityId, organizationId }) => {
       queryClient.invalidateQueries(organizationKeys.getOrgIdentityMemberships(organizationId));
+      queryClient.invalidateQueries(identitiesKeys.getIdentityById(identityId));
+      queryClient.invalidateQueries(identitiesKeys.getIdentityUniversalAuth(identityId));
     }
   });
 };
@@ -134,8 +153,27 @@ export const useUpdateIdentityUniversalAuth = () => {
       });
       return identityUniversalAuth;
     },
-    onSuccess: (_, { organizationId }) => {
+    onSuccess: (_, { identityId, organizationId }) => {
       queryClient.invalidateQueries(organizationKeys.getOrgIdentityMemberships(organizationId));
+      queryClient.invalidateQueries(identitiesKeys.getIdentityById(identityId));
+      queryClient.invalidateQueries(identitiesKeys.getIdentityUniversalAuth(identityId));
+    }
+  });
+};
+
+export const useDeleteIdentityUniversalAuth = () => {
+  const queryClient = useQueryClient();
+  return useMutation<IdentityUniversalAuth, {}, DeleteIdentityUniversalAuthDTO>({
+    mutationFn: async ({ identityId }) => {
+      const {
+        data: { identityUniversalAuth }
+      } = await apiRequest.delete(`/api/v1/auth/universal-auth/identities/${identityId}`);
+      return identityUniversalAuth;
+    },
+    onSuccess: (_, { organizationId, identityId }) => {
+      queryClient.invalidateQueries(organizationKeys.getOrgIdentityMemberships(organizationId));
+      queryClient.invalidateQueries(identitiesKeys.getIdentityById(identityId));
+      queryClient.invalidateQueries(identitiesKeys.getIdentityUniversalAuth(identityId));
     }
   });
 };
@@ -217,8 +255,10 @@ export const useAddIdentityGcpAuth = () => {
 
       return identityGcpAuth;
     },
-    onSuccess: (_, { organizationId }) => {
+    onSuccess: (_, { identityId, organizationId }) => {
       queryClient.invalidateQueries(organizationKeys.getOrgIdentityMemberships(organizationId));
+      queryClient.invalidateQueries(identitiesKeys.getIdentityById(identityId));
+      queryClient.invalidateQueries(identitiesKeys.getIdentityGcpAuth(identityId));
     }
   });
 };
@@ -255,8 +295,27 @@ export const useUpdateIdentityGcpAuth = () => {
 
       return identityGcpAuth;
     },
-    onSuccess: (_, { organizationId }) => {
+    onSuccess: (_, { identityId, organizationId }) => {
       queryClient.invalidateQueries(organizationKeys.getOrgIdentityMemberships(organizationId));
+      queryClient.invalidateQueries(identitiesKeys.getIdentityById(identityId));
+      queryClient.invalidateQueries(identitiesKeys.getIdentityGcpAuth(identityId));
+    }
+  });
+};
+
+export const useDeleteIdentityGcpAuth = () => {
+  const queryClient = useQueryClient();
+  return useMutation<IdentityGcpAuth, {}, DeleteIdentityGcpAuthDTO>({
+    mutationFn: async ({ identityId }) => {
+      const {
+        data: { identityGcpAuth }
+      } = await apiRequest.delete(`/api/v1/auth/gcp-auth/identities/${identityId}`);
+      return identityGcpAuth;
+    },
+    onSuccess: (_, { organizationId, identityId }) => {
+      queryClient.invalidateQueries(organizationKeys.getOrgIdentityMemberships(organizationId));
+      queryClient.invalidateQueries(identitiesKeys.getIdentityById(identityId));
+      queryClient.invalidateQueries(identitiesKeys.getIdentityGcpAuth(identityId));
     }
   });
 };
@@ -291,8 +350,10 @@ export const useAddIdentityAwsAuth = () => {
 
       return identityAwsAuth;
     },
-    onSuccess: (_, { organizationId }) => {
+    onSuccess: (_, { identityId, organizationId }) => {
       queryClient.invalidateQueries(organizationKeys.getOrgIdentityMemberships(organizationId));
+      queryClient.invalidateQueries(identitiesKeys.getIdentityById(identityId));
+      queryClient.invalidateQueries(identitiesKeys.getIdentityAwsAuth(identityId));
     }
   });
 };
@@ -327,8 +388,27 @@ export const useUpdateIdentityAwsAuth = () => {
 
       return identityAwsAuth;
     },
-    onSuccess: (_, { organizationId }) => {
+    onSuccess: (_, { identityId, organizationId }) => {
       queryClient.invalidateQueries(organizationKeys.getOrgIdentityMemberships(organizationId));
+      queryClient.invalidateQueries(identitiesKeys.getIdentityById(identityId));
+      queryClient.invalidateQueries(identitiesKeys.getIdentityAwsAuth(identityId));
+    }
+  });
+};
+
+export const useDeleteIdentityAwsAuth = () => {
+  const queryClient = useQueryClient();
+  return useMutation<IdentityAwsAuth, {}, DeleteIdentityAwsAuthDTO>({
+    mutationFn: async ({ identityId }) => {
+      const {
+        data: { identityAwsAuth }
+      } = await apiRequest.delete(`/api/v1/auth/aws-auth/identities/${identityId}`);
+      return identityAwsAuth;
+    },
+    onSuccess: (_, { organizationId, identityId }) => {
+      queryClient.invalidateQueries(organizationKeys.getOrgIdentityMemberships(organizationId));
+      queryClient.invalidateQueries(identitiesKeys.getIdentityById(identityId));
+      queryClient.invalidateQueries(identitiesKeys.getIdentityAwsAuth(identityId));
     }
   });
 };
@@ -369,8 +449,10 @@ export const useUpdateIdentityOidcAuth = () => {
 
       return identityOidcAuth;
     },
-    onSuccess: (_, { organizationId }) => {
+    onSuccess: (_, { identityId, organizationId }) => {
       queryClient.invalidateQueries(organizationKeys.getOrgIdentityMemberships(organizationId));
+      queryClient.invalidateQueries(identitiesKeys.getIdentityById(identityId));
+      queryClient.invalidateQueries(identitiesKeys.getIdentityOidcAuth(identityId));
     }
   });
 };
@@ -411,8 +493,27 @@ export const useAddIdentityOidcAuth = () => {
 
       return identityOidcAuth;
     },
-    onSuccess: (_, { organizationId }) => {
+    onSuccess: (_, { identityId, organizationId }) => {
       queryClient.invalidateQueries(organizationKeys.getOrgIdentityMemberships(organizationId));
+      queryClient.invalidateQueries(identitiesKeys.getIdentityById(identityId));
+      queryClient.invalidateQueries(identitiesKeys.getIdentityOidcAuth(identityId));
+    }
+  });
+};
+
+export const useDeleteIdentityOidcAuth = () => {
+  const queryClient = useQueryClient();
+  return useMutation<IdentityTokenAuth, {}, DeleteIdentityOidcAuthDTO>({
+    mutationFn: async ({ identityId }) => {
+      const {
+        data: { identityOidcAuth }
+      } = await apiRequest.delete(`/api/v1/auth/oidc-auth/identities/${identityId}`);
+      return identityOidcAuth;
+    },
+    onSuccess: (_, { organizationId, identityId }) => {
+      queryClient.invalidateQueries(organizationKeys.getOrgIdentityMemberships(organizationId));
+      queryClient.invalidateQueries(identitiesKeys.getIdentityById(identityId));
+      queryClient.invalidateQueries(identitiesKeys.getIdentityOidcAuth(identityId));
     }
   });
 };
@@ -447,8 +548,10 @@ export const useAddIdentityAzureAuth = () => {
 
       return identityAzureAuth;
     },
-    onSuccess: (_, { organizationId }) => {
+    onSuccess: (_, { identityId, organizationId }) => {
       queryClient.invalidateQueries(organizationKeys.getOrgIdentityMemberships(organizationId));
+      queryClient.invalidateQueries(identitiesKeys.getIdentityById(identityId));
+      queryClient.invalidateQueries(identitiesKeys.getIdentityKubernetesAuth(identityId));
     }
   });
 };
@@ -489,8 +592,10 @@ export const useAddIdentityKubernetesAuth = () => {
 
       return identityKubernetesAuth;
     },
-    onSuccess: (_, { organizationId }) => {
+    onSuccess: (_, { identityId, organizationId }) => {
       queryClient.invalidateQueries(organizationKeys.getOrgIdentityMemberships(organizationId));
+      queryClient.invalidateQueries(identitiesKeys.getIdentityById(identityId));
+      queryClient.invalidateQueries(identitiesKeys.getIdentityAzureAuth(identityId));
     }
   });
 };
@@ -525,8 +630,27 @@ export const useUpdateIdentityAzureAuth = () => {
 
       return identityAzureAuth;
     },
-    onSuccess: (_, { organizationId }) => {
+    onSuccess: (_, { identityId, organizationId }) => {
       queryClient.invalidateQueries(organizationKeys.getOrgIdentityMemberships(organizationId));
+      queryClient.invalidateQueries(identitiesKeys.getIdentityById(identityId));
+      queryClient.invalidateQueries(identitiesKeys.getIdentityAzureAuth(identityId));
+    }
+  });
+};
+
+export const useDeleteIdentityAzureAuth = () => {
+  const queryClient = useQueryClient();
+  return useMutation<IdentityAzureAuth, {}, DeleteIdentityAzureAuthDTO>({
+    mutationFn: async ({ identityId }) => {
+      const {
+        data: { identityAzureAuth }
+      } = await apiRequest.delete(`/api/v1/auth/azure-auth/identities/${identityId}`);
+      return identityAzureAuth;
+    },
+    onSuccess: (_, { organizationId, identityId }) => {
+      queryClient.invalidateQueries(organizationKeys.getOrgIdentityMemberships(organizationId));
+      queryClient.invalidateQueries(identitiesKeys.getIdentityById(identityId));
+      queryClient.invalidateQueries(identitiesKeys.getIdentityAzureAuth(identityId));
     }
   });
 };
@@ -567,8 +691,164 @@ export const useUpdateIdentityKubernetesAuth = () => {
 
       return identityKubernetesAuth;
     },
-    onSuccess: (_, { organizationId }) => {
+    onSuccess: (_, { identityId, organizationId }) => {
       queryClient.invalidateQueries(organizationKeys.getOrgIdentityMemberships(organizationId));
+      queryClient.invalidateQueries(identitiesKeys.getIdentityById(identityId));
+      queryClient.invalidateQueries(identitiesKeys.getIdentityKubernetesAuth(identityId));
+    }
+  });
+};
+
+export const useDeleteIdentityKubernetesAuth = () => {
+  const queryClient = useQueryClient();
+  return useMutation<IdentityTokenAuth, {}, DeleteIdentityKubernetesAuthDTO>({
+    mutationFn: async ({ identityId }) => {
+      const {
+        data: { identityKubernetesAuth }
+      } = await apiRequest.delete(`/api/v1/auth/kubernetes-auth/identities/${identityId}`);
+      return identityKubernetesAuth;
+    },
+    onSuccess: (_, { organizationId, identityId }) => {
+      queryClient.invalidateQueries(organizationKeys.getOrgIdentityMemberships(organizationId));
+      queryClient.invalidateQueries(identitiesKeys.getIdentityById(identityId));
+      queryClient.invalidateQueries(identitiesKeys.getIdentityKubernetesAuth(identityId));
+    }
+  });
+};
+
+export const useAddIdentityTokenAuth = () => {
+  const queryClient = useQueryClient();
+  return useMutation<IdentityTokenAuth, {}, AddIdentityTokenAuthDTO>({
+    mutationFn: async ({
+      identityId,
+      accessTokenTTL,
+      accessTokenMaxTTL,
+      accessTokenNumUsesLimit,
+      accessTokenTrustedIps
+    }) => {
+      const {
+        data: { identityTokenAuth }
+      } = await apiRequest.post<{ identityTokenAuth: IdentityTokenAuth }>(
+        `/api/v1/auth/token-auth/identities/${identityId}`,
+        {
+          accessTokenTTL,
+          accessTokenMaxTTL,
+          accessTokenNumUsesLimit,
+          accessTokenTrustedIps
+        }
+      );
+
+      return identityTokenAuth;
+    },
+    onSuccess: (_, { identityId, organizationId }) => {
+      queryClient.invalidateQueries(organizationKeys.getOrgIdentityMemberships(organizationId));
+      queryClient.invalidateQueries(identitiesKeys.getIdentityById(identityId));
+      queryClient.invalidateQueries(identitiesKeys.getIdentityUniversalAuth(identityId));
+    }
+  });
+};
+
+export const useUpdateIdentityTokenAuth = () => {
+  const queryClient = useQueryClient();
+  return useMutation<IdentityTokenAuth, {}, UpdateIdentityTokenAuthDTO>({
+    mutationFn: async ({
+      identityId,
+      accessTokenTTL,
+      accessTokenMaxTTL,
+      accessTokenNumUsesLimit,
+      accessTokenTrustedIps
+    }) => {
+      const {
+        data: { identityTokenAuth }
+      } = await apiRequest.patch<{ identityTokenAuth: IdentityTokenAuth }>(
+        `/api/v1/auth/token-auth/identities/${identityId}`,
+        {
+          accessTokenTTL,
+          accessTokenMaxTTL,
+          accessTokenNumUsesLimit,
+          accessTokenTrustedIps
+        }
+      );
+
+      return identityTokenAuth;
+    },
+    onSuccess: (_, { identityId, organizationId }) => {
+      queryClient.invalidateQueries(organizationKeys.getOrgIdentityMemberships(organizationId));
+      queryClient.invalidateQueries(identitiesKeys.getIdentityById(identityId));
+      queryClient.invalidateQueries(identitiesKeys.getIdentityUniversalAuth(identityId));
+    }
+  });
+};
+
+export const useDeleteIdentityTokenAuth = () => {
+  const queryClient = useQueryClient();
+  return useMutation<IdentityTokenAuth, {}, DeleteIdentityTokenAuthDTO>({
+    mutationFn: async ({ identityId }) => {
+      const {
+        data: { identityTokenAuth }
+      } = await apiRequest.delete(`/api/v1/auth/token-auth/identities/${identityId}`);
+      return identityTokenAuth;
+    },
+    onSuccess: (_, { organizationId, identityId }) => {
+      queryClient.invalidateQueries(organizationKeys.getOrgIdentityMemberships(organizationId));
+      queryClient.invalidateQueries(identitiesKeys.getIdentityById(identityId));
+      queryClient.invalidateQueries(identitiesKeys.getIdentityTokenAuth(identityId));
+    }
+  });
+};
+
+export const useCreateTokenIdentityTokenAuth = () => {
+  const queryClient = useQueryClient();
+  return useMutation<CreateTokenIdentityTokenAuthRes, {}, CreateTokenIdentityTokenAuthDTO>({
+    mutationFn: async ({ identityId, name }) => {
+      const { data } = await apiRequest.post<CreateTokenIdentityTokenAuthRes>(
+        `/api/v1/auth/token-auth/identities/${identityId}/tokens`,
+        {
+          name
+        }
+      );
+
+      return data;
+    },
+    onSuccess: (_, { identityId }) => {
+      queryClient.invalidateQueries(identitiesKeys.getIdentityTokensTokenAuth(identityId));
+    }
+  });
+};
+
+export const useUpdateIdentityTokenAuthToken = () => {
+  const queryClient = useQueryClient();
+  return useMutation<IdentityAccessToken, {}, UpdateTokenIdentityTokenAuthDTO>({
+    mutationFn: async ({ tokenId, name }) => {
+      const {
+        data: { token }
+      } = await apiRequest.patch<{ token: IdentityAccessToken }>(
+        `/api/v1/auth/token-auth/tokens/${tokenId}`,
+        {
+          name
+        }
+      );
+
+      return token;
+    },
+    onSuccess: (_, { identityId }) => {
+      queryClient.invalidateQueries(identitiesKeys.getIdentityTokensTokenAuth(identityId));
+    }
+  });
+};
+
+export const useRevokeIdentityTokenAuthToken = () => {
+  const queryClient = useQueryClient();
+  return useMutation<RevokeTokenRes, {}, RevokeTokenDTO>({
+    mutationFn: async ({ tokenId }) => {
+      const { data } = await apiRequest.post<RevokeTokenRes>(
+        `/api/v1/auth/token-auth/tokens/${tokenId}/revoke`
+      );
+
+      return data;
+    },
+    onSuccess: (_, { identityId }) => {
+      queryClient.invalidateQueries(identitiesKeys.getIdentityTokensTokenAuth(identityId));
     }
   });
 };

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

@@ -4,15 +4,19 @@ import { apiRequest } from "@app/config/request";
 
 import {
   ClientSecretData,
+  IdentityAccessToken,
   IdentityAwsAuth,
   IdentityAzureAuth,
   IdentityGcpAuth,
   IdentityKubernetesAuth,
-  IdentityOidcAuth,
-  IdentityUniversalAuth
+  IdentityMembershipOrg,
+  IdentityTokenAuth,
+  IdentityUniversalAuth,
+  IdentityOidcAuth
 } from "./types";
 
 export const identitiesKeys = {
+  getIdentityById: (identityId: string) => [{ identityId }, "identity"] as const,
   getIdentityUniversalAuth: (identityId: string) =>
     [{ identityId }, "identity-universal-auth"] as const,
   getIdentityUniversalAuthClientSecrets: (identityId: string) =>
@@ -22,7 +26,40 @@ export const identitiesKeys = {
   getIdentityGcpAuth: (identityId: string) => [{ identityId }, "identity-gcp-auth"] as const,
   getIdentityOidcAuth: (identityId: string) => [{ identityId }, "identity-oidc-auth"] as const,
   getIdentityAwsAuth: (identityId: string) => [{ identityId }, "identity-aws-auth"] as const,
-  getIdentityAzureAuth: (identityId: string) => [{ identityId }, "identity-azure-auth"] as const
+  getIdentityAzureAuth: (identityId: string) => [{ identityId }, "identity-azure-auth"] as const,
+  getIdentityTokenAuth: (identityId: string) => [{ identityId }, "identity-token-auth"] as const,
+  getIdentityTokensTokenAuth: (identityId: string) =>
+    [{ identityId }, "identity-tokens-token-auth"] as const,
+  getIdentityProjectMemberships: (identityId: string) =>
+    [{ identityId }, "identity-project-memberships"] as const
+};
+
+export const useGetIdentityById = (identityId: string) => {
+  return useQuery({
+    enabled: Boolean(identityId),
+    queryKey: identitiesKeys.getIdentityById(identityId),
+    queryFn: async () => {
+      const {
+        data: { identity }
+      } = await apiRequest.get<{ identity: IdentityMembershipOrg }>(
+        `/api/v1/identities/${identityId}`
+      );
+      return identity;
+    }
+  });
+};
+
+export const useGetIdentityProjectMemberships = (identityId: string) => {
+  return useQuery({
+    enabled: Boolean(identityId),
+    queryKey: identitiesKeys.getIdentityProjectMemberships(identityId),
+    queryFn: async () => {
+      const {
+        data: { identityMemberships }
+      } = await apiRequest.get(`/api/v1/identities/${identityId}/identity-memberships`);
+      return identityMemberships;
+    }
+  });
 };
 
 export const useGetIdentityUniversalAuth = (identityId: string) => {
@@ -36,7 +73,9 @@ export const useGetIdentityUniversalAuth = (identityId: string) => {
         `/api/v1/auth/universal-auth/identities/${identityId}`
       );
       return identityUniversalAuth;
-    }
+    },
+    staleTime: 0,
+    cacheTime: 0
   });
 };
 
@@ -66,7 +105,9 @@ export const useGetIdentityGcpAuth = (identityId: string) => {
         `/api/v1/auth/gcp-auth/identities/${identityId}`
       );
       return identityGcpAuth;
-    }
+    },
+    staleTime: 0,
+    cacheTime: 0
   });
 };
 
@@ -81,7 +122,9 @@ export const useGetIdentityAwsAuth = (identityId: string) => {
         `/api/v1/auth/aws-auth/identities/${identityId}`
       );
       return identityAwsAuth;
-    }
+    },
+    staleTime: 0,
+    cacheTime: 0
   });
 };
 
@@ -96,7 +139,9 @@ export const useGetIdentityAzureAuth = (identityId: string) => {
         `/api/v1/auth/azure-auth/identities/${identityId}`
       );
       return identityAzureAuth;
-    }
+    },
+    staleTime: 0,
+    cacheTime: 0
   });
 };
 
@@ -111,6 +156,40 @@ export const useGetIdentityKubernetesAuth = (identityId: string) => {
         `/api/v1/auth/kubernetes-auth/identities/${identityId}`
       );
       return identityKubernetesAuth;
+    },
+    staleTime: 0,
+    cacheTime: 0
+  });
+};
+
+export const useGetIdentityTokenAuth = (identityId: string) => {
+  return useQuery({
+    enabled: Boolean(identityId),
+    queryKey: identitiesKeys.getIdentityTokenAuth(identityId),
+    queryFn: async () => {
+      const {
+        data: { identityTokenAuth }
+      } = await apiRequest.get<{ identityTokenAuth: IdentityTokenAuth }>(
+        `/api/v1/auth/token-auth/identities/${identityId}`
+      );
+      return identityTokenAuth;
+    },
+    staleTime: 0,
+    cacheTime: 0
+  });
+};
+
+export const useGetIdentityTokensTokenAuth = (identityId: string) => {
+  return useQuery({
+    enabled: Boolean(identityId),
+    queryKey: identitiesKeys.getIdentityTokensTokenAuth(identityId),
+    queryFn: async () => {
+      const {
+        data: { tokens }
+      } = await apiRequest.get<{ tokens: IdentityAccessToken[] }>(
+        `/api/v1/auth/token-auth/identities/${identityId}/tokens`
+      );
+      return tokens;
     }
   });
 };
@@ -126,6 +205,8 @@ export const useGetIdentityOidcAuth = (identityId: string) => {
         `/api/v1/auth/oidc-auth/identities/${identityId}`
       );
       return identityOidcAuth;
-    }
+    },
+    staleTime: 0,
+    cacheTime: 0
   });
 };

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

@@ -16,6 +16,22 @@ export type Identity = {
   updatedAt: string;
 };
 
+export type IdentityAccessToken = {
+  id: string;
+  accessTokenTTL: number;
+  accessTokenMaxTTL: number;
+  accessTokenNumUses: number;
+  accessTokenNumUsesLimit: number;
+  accessTokenLastUsedAt: string | null;
+  accessTokenLastRenewedAt: string | null;
+  isAccessTokenRevoked: boolean;
+  identityUAClientSecretId: string | null;
+  identityId: string;
+  createdAt: string;
+  updatedAt: string;
+  name: string | null;
+};
+
 export type IdentityMembershipOrg = {
   id: string;
   identity: Identity;
@@ -113,6 +129,11 @@ export type UpdateIdentityUniversalAuthDTO = {
   }[];
 };
 
+export type DeleteIdentityUniversalAuthDTO = {
+  organizationId: string;
+  identityId: string;
+};
+
 export type IdentityGcpAuth = {
   identityId: string;
   type: "iam" | "gce";
@@ -155,6 +176,11 @@ export type UpdateIdentityGcpAuthDTO = {
   }[];
 };
 
+export type DeleteIdentityGcpAuthDTO = {
+  organizationId: string;
+  identityId: string;
+};
+
 export type IdentityOidcAuth = {
   identityId: string;
   oidcDiscoveryUrl: string;
@@ -203,6 +229,11 @@ export type UpdateIdentityOidcAuthDTO = {
   }[];
 };
 
+export type DeleteIdentityOidcAuthDTO = {
+  organizationId: string;
+  identityId: string;
+};
+
 export type IdentityAwsAuth = {
   identityId: string;
   type: "iam";
@@ -243,6 +274,11 @@ export type UpdateIdentityAwsAuthDTO = {
   }[];
 };
 
+export type DeleteIdentityAwsAuthDTO = {
+  organizationId: string;
+  identityId: string;
+};
+
 export type IdentityAzureAuth = {
   identityId: string;
   tenantId: string;
@@ -282,6 +318,11 @@ export type UpdateIdentityAzureAuthDTO = {
   }[];
 };
 
+export type DeleteIdentityAzureAuthDTO = {
+  organizationId: string;
+  identityId: string;
+};
+
 export type IdentityKubernetesAuth = {
   identityId: string;
   kubernetesHost: string;
@@ -330,6 +371,11 @@ export type UpdateIdentityKubernetesAuthDTO = {
   }[];
 };
 
+export type DeleteIdentityKubernetesAuthDTO = {
+  organizationId: string;
+  identityId: string;
+};
+
 export type CreateIdentityUniversalAuthClientSecretDTO = {
   identityId: string;
   description?: string;
@@ -359,3 +405,65 @@ export type DeleteIdentityUniversalAuthClientSecretDTO = {
   identityId: string;
   clientSecretId: string;
 };
+
+export type IdentityTokenAuth = {
+  identityId: string;
+  accessTokenTTL: number;
+  accessTokenMaxTTL: number;
+  accessTokenNumUsesLimit: number;
+  accessTokenTrustedIps: IdentityTrustedIp[];
+};
+
+export type AddIdentityTokenAuthDTO = {
+  organizationId: string;
+  identityId: string;
+  accessTokenTTL: number;
+  accessTokenMaxTTL: number;
+  accessTokenNumUsesLimit: number;
+  accessTokenTrustedIps: {
+    ipAddress: string;
+  }[];
+};
+
+export type UpdateIdentityTokenAuthDTO = {
+  organizationId: string;
+  identityId: string;
+  accessTokenTTL?: number;
+  accessTokenMaxTTL?: number;
+  accessTokenNumUsesLimit?: number;
+  accessTokenTrustedIps?: {
+    ipAddress: string;
+  }[];
+};
+
+export type DeleteIdentityTokenAuthDTO = {
+  organizationId: string;
+  identityId: string;
+};
+
+export type CreateTokenIdentityTokenAuthDTO = {
+  identityId: string;
+  name: string;
+};
+
+export type CreateTokenIdentityTokenAuthRes = {
+  accessToken: string;
+  tokenType: string;
+  expiresIn: number;
+  accessTokenMaxTTL: number;
+};
+
+export type UpdateTokenIdentityTokenAuthDTO = {
+  identityId: string;
+  tokenId: string;
+  name?: string;
+};
+
+export type RevokeTokenDTO = {
+  identityId: string;
+  tokenId: string;
+};
+
+export type RevokeTokenRes = {
+  message: string;
+};