Restructure MIs to more generic Identity

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

@@ -16,9 +16,17 @@ export const eventToNameMap: { [K in EventType]: string } = {
     [EventType.DELETE_TRUSTED_IP]: "Delete trusted IP",
     [EventType.CREATE_SERVICE_TOKEN]: "Create service token",
     [EventType.DELETE_SERVICE_TOKEN]: "Delete service token",
-    [EventType.CREATE_MACHINE_IDENTITY]: "Create machine identity",
-    [EventType.UPDATE_MACHINE_IDENTITY]: "Update machine identity",
-    [EventType.DELETE_MACHINE_IDENTITY]: "Delete machine identity",
+    [EventType.CREATE_IDENTITY]: "Create identity",
+    [EventType.UPDATE_IDENTITY]: "Update identity",
+    [EventType.DELETE_IDENTITY]: "Delete identity",
+    [EventType.LOGIN_IDENTITY_UNIVERSAL_AUTH]: "Login via universal auth",
+    [EventType.ADD_IDENTITY_UNIVERSAL_AUTH]: "Add universal auth",
+    [EventType.UPDATE_IDENTITY_UNIVERSAL_AUTH]: "Update universal auth",
+    [EventType.GET_IDENTITY_UNIVERSAL_AUTH]: "Get universal auth",
+    [EventType.CREATE_IDENTITY_UNIVERSAL_AUTH_CLIENT_SECRET]: "Create universal auth client secret",
+    [EventType.REVOKE_IDENTITY_UNIVERSAL_AUTH_CLIENT_SECRET]: "Revoke universal auth client secret",
+    [EventType.GET_IDENTITY_UNIVERSAL_AUTH_CLIENT_SECRETS]: "Get universal auth client secrets",
+    [EventType.GET_IDENTITY_UNIVERSAL_AUTH]: "Get universal auth",
     [EventType.CREATE_ENVIRONMENT]: "Create environment",
     [EventType.UPDATE_ENVIRONMENT]: "Update environment",
     [EventType.DELETE_ENVIRONMENT]: "Delete environment",

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

@@ -1,7 +1,7 @@
 export enum ActorType {
   USER = "user",
   SERVICE = "service",
-  MACHINE = "machine"
+  IDENTITY = "identity"
 }
 
 export enum UserAgentType {
@@ -27,9 +27,16 @@ export enum EventType {
   DELETE_TRUSTED_IP = "delete-trusted-ip",
   CREATE_SERVICE_TOKEN = "create-service-token", // v2
   DELETE_SERVICE_TOKEN = "delete-service-token", // v2
-  CREATE_MACHINE_IDENTITY = "create-machine-identity",
-  UPDATE_MACHINE_IDENTITY = "update-machine-identity",
-  DELETE_MACHINE_IDENTITY = "delete-machine-identity",
+  CREATE_IDENTITY = "create-identity",
+  UPDATE_IDENTITY = "update-identity",
+  DELETE_IDENTITY = "delete-identity",
+  LOGIN_IDENTITY_UNIVERSAL_AUTH = "login-identity-universal-auth",
+  ADD_IDENTITY_UNIVERSAL_AUTH = "add-identity-universal-auth",
+  UPDATE_IDENTITY_UNIVERSAL_AUTH = "update-identity-universal-auth",
+  GET_IDENTITY_UNIVERSAL_AUTH = "get-identity-universal-auth",
+  CREATE_IDENTITY_UNIVERSAL_AUTH_CLIENT_SECRET = "create-identity-universal-auth-client-secret",
+  REVOKE_IDENTITY_UNIVERSAL_AUTH_CLIENT_SECRET =  "revoke-identity-universal-auth-client-secret",
+  GET_IDENTITY_UNIVERSAL_AUTH_CLIENT_SECRETS = "get-identity-universal-auth-client-secret",
   CREATE_ENVIRONMENT = "create-environment",
   UPDATE_ENVIRONMENT = "update-environment",
   DELETE_ENVIRONMENT = "delete-environment",

frontend/src/hooks/api/auditLogs/types.tsx

@@ -1,3 +1,4 @@
+import { IdentityTrustedIp } from "../identities/types";
 import { ActorType, EventType, UserAgentType } from "./enums";
 
 interface UserActorMetadata {
@@ -10,8 +11,8 @@ interface ServiceActorMetadata {
   name: string;
 }
 
-interface MachineActorMetadata {
-  machineId: string;
+interface IdentityActorMetadata {
+  identityId: string;
   name: string;
 }
 
@@ -25,12 +26,12 @@ export interface ServiceActor {
   metadata: ServiceActorMetadata;
 }
 
-export interface MachineActor {
-  type: ActorType.MACHINE;
-  metadata: MachineActorMetadata;
+export interface IdentityActor {
+  type: ActorType.IDENTITY;
+  metadata: IdentityActorMetadata;
 }
 
-export type Actor = UserActor | ServiceActor | MachineActor;
+export type Actor = UserActor | ServiceActor | IdentityActor;
 
 interface GetSecretsEvent {
   type: EventType.GET_SECRETS;
@@ -193,34 +194,91 @@ interface DeleteServiceTokenEvent {
   };
 }
 
-interface CreateMachineIdentityEvent {
-    type: EventType.CREATE_MACHINE_IDENTITY;
-    metadata: {
-        name: string;
-        isActive: boolean;
-        role: string;
-        expiresAt?: Date;
-    }
+interface CreateIdentityEvent { // note: currently not logging org-role
+  type: EventType.CREATE_IDENTITY;
+  metadata: {
+    identityId: string;
+    name: string;
+  };
 }
 
-interface UpdateMachineIdentityEvent {
-    type: EventType.UPDATE_MACHINE_IDENTITY;
-    metadata: {
-        name?: string;
-        isActive?: boolean;
-        role?: string;
-        expiresAt?: Date;
-    }
+interface UpdateIdentityEvent {
+  type: EventType.UPDATE_IDENTITY;
+  metadata: {
+    identityId: string;
+    name?: string;
+  };
 }
 
-interface DeleteMachineIdentityEvent {
-    type: EventType.DELETE_MACHINE_IDENTITY;
-    metadata: {
-        name: string;
-        isActive: boolean;
-        role?: string;
-        expiresAt?: Date;
-    }
+interface DeleteIdentityEvent {
+  type: EventType.DELETE_IDENTITY;
+  metadata: {
+    identityId: string;
+  };
+}
+
+interface LoginIdentityUniversalAuthEvent {
+  type: EventType.LOGIN_IDENTITY_UNIVERSAL_AUTH ;
+  metadata: {
+    identityId: string;
+    clientSecretId: string;
+    identityAccessTokenId: string;
+  };
+}
+
+interface AddIdentityUniversalAuthEvent {
+  type: EventType.ADD_IDENTITY_UNIVERSAL_AUTH;
+  metadata: {
+    identityId: string;
+    clientSecretTrustedIps: Array<IdentityTrustedIp>;
+    accessTokenTTL: number;
+    accessTokenMaxTTL: number;
+    accessTokenNumUsesLimit: number;
+    accessTokenTrustedIps: Array<IdentityTrustedIp>;
+  };
+}
+
+interface UpdateIdentityUniversalAuthEvent {
+  type: EventType.UPDATE_IDENTITY_UNIVERSAL_AUTH;
+  metadata: {
+    identityId: string;
+    clientSecretTrustedIps?: Array<IdentityTrustedIp>;
+    accessTokenTTL?: number;
+    accessTokenMaxTTL?: number;
+    accessTokenNumUsesLimit?: number;
+    accessTokenTrustedIps?: Array<IdentityTrustedIp>;
+  };
+}
+
+interface GetIdentityUniversalAuthEvent {
+  type: EventType.GET_IDENTITY_UNIVERSAL_AUTH;
+  metadata: {
+    identityId: string;
+  };
+}
+
+interface CreateIdentityUniversalAuthClientSecretEvent {
+  type: EventType.CREATE_IDENTITY_UNIVERSAL_AUTH_CLIENT_SECRET ;
+  metadata: {
+    identityId: string;
+    clientSecretId: string;
+  };
+}
+
+interface GetIdentityUniversalAuthClientSecretsEvent {
+  type: EventType.GET_IDENTITY_UNIVERSAL_AUTH_CLIENT_SECRETS;
+  metadata: {
+    identityId: string;
+  };
+}
+
+
+interface RevokeIdentityUniversalAuthClientSecretEvent {
+  type: EventType.REVOKE_IDENTITY_UNIVERSAL_AUTH_CLIENT_SECRET ;
+  metadata: {
+    identityId: string;
+    clientSecretId: string;
+  };
 }
 
 interface CreateEnvironmentEvent {
@@ -419,9 +477,16 @@ export type Event =
   | DeleteTrustedIPEvent
   | CreateServiceTokenEvent
   | DeleteServiceTokenEvent
-  | CreateMachineIdentityEvent
-  | UpdateMachineIdentityEvent
-  | DeleteMachineIdentityEvent
+  | CreateIdentityEvent
+  | UpdateIdentityEvent
+  | DeleteIdentityEvent
+  | LoginIdentityUniversalAuthEvent
+  | AddIdentityUniversalAuthEvent
+  | UpdateIdentityUniversalAuthEvent
+  | GetIdentityUniversalAuthEvent
+  | CreateIdentityUniversalAuthClientSecretEvent
+  | GetIdentityUniversalAuthClientSecretsEvent
+  | RevokeIdentityUniversalAuthClientSecretEvent
   | CreateEnvironmentEvent
   | UpdateEnvironmentEvent
   | DeleteEnvironmentEvent

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

@@ -0,0 +1,5 @@
+import { IdentityAuthMethod } from "./enums";
+
+export const identityAuthToNameMap: { [I in IdentityAuthMethod]: string } = {
+    [IdentityAuthMethod.UNIVERSAL_AUTH]: "Universal Auth"
+};

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

@@ -0,0 +1,3 @@
+export enum IdentityAuthMethod {
+    UNIVERSAL_AUTH = "universal-auth"
+}

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

@@ -0,0 +1,14 @@
+export { identityAuthToNameMap } from "./constants";
+export { IdentityAuthMethod } from "./enums";
+export {
+    useAddIdentityUniversalAuth,
+    useCreateIdentity,
+    useCreateIdentityUniversalAuthClientSecret,
+    useDeleteIdentity,
+    useDeleteIdentityUniversalAuthClientSecret,
+    useUpdateIdentity,
+    useUpdateIdentityUniversalAuth} from "./mutations";
+export {
+    useGetIdentityUniversalAuth,
+    useGetIdentityUniversalAuthClientSecrets
+} from "./queries";

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

@@ -0,0 +1,163 @@
+import { useMutation, useQueryClient } from "@tanstack/react-query";
+
+import { apiRequest } from "@app/config/request";
+
+import { organizationKeys } from "../organization/queries";
+import { identitiesKeys } from "./queries";
+import { 
+    AddIdentityUniversalAuthDTO,
+    CreateIdentityDTO, 
+    CreateIdentityUniversalAuthClientSecretDTO,
+    CreateIdentityUniversalAuthClientSecretRes,
+    DeleteIdentityDTO,
+    DeleteIdentityUniversalAuthClientSecretDTO,
+    Identity,
+    IdentityUniversalAuth,
+    UpdateIdentityDTO,
+    UpdateIdentityUniversalAuthDTO} from "./types";
+
+export const useCreateIdentity = () => {
+    const queryClient = useQueryClient();
+    return useMutation<Identity, {}, CreateIdentityDTO>({
+        mutationFn: async (body) => {
+            const { data: { identity } } = await apiRequest.post("/api/v1/identities/", body);
+            return identity;
+        },
+        onSuccess: (_, { organizationId }) => {
+            queryClient.invalidateQueries(organizationKeys.getOrgIdentityMemberships(organizationId));
+        }
+    });
+};
+
+export const useUpdateIdentity = () => {
+    const queryClient = useQueryClient();
+    return useMutation<Identity, {}, UpdateIdentityDTO>({
+        mutationFn: async ({
+            identityId,
+            name,
+            role
+        }) => {
+            
+            const { data: { identity } } = await apiRequest.patch(`/api/v1/identities/${identityId}`, {
+                name,
+                role
+            });
+
+            return identity;
+        },
+        onSuccess: (_, { organizationId }) => {
+            queryClient.invalidateQueries(organizationKeys.getOrgIdentityMemberships(organizationId));
+        }
+    });
+}
+
+export const useDeleteIdentity = () => {
+    const queryClient = useQueryClient();
+    return useMutation<Identity, {}, DeleteIdentityDTO>({
+        mutationFn: async ({
+            identityId,
+        }) => {
+            const { data: { identity } } = await apiRequest.delete(`/api/v1/identities/${identityId}`);
+            return identity;
+        },
+        onSuccess: (_, { organizationId }) => {
+            queryClient.invalidateQueries(organizationKeys.getOrgIdentityMemberships(organizationId));
+        }
+    });
+};
+
+// TODO: move these to /auth
+
+export const useAddIdentityUniversalAuth = () => {
+    const queryClient = useQueryClient();
+    return useMutation<IdentityUniversalAuth, {}, AddIdentityUniversalAuthDTO>({
+        mutationFn: async ({
+            identityId,
+            clientSecretTrustedIps,
+            accessTokenTTL,
+            accessTokenMaxTTL,
+            accessTokenNumUsesLimit,
+            accessTokenTrustedIps,
+        }) => {
+            const { data: { identityUniversalAuth } } = await apiRequest.post(`/api/v1/auth/universal-auth/identities/${identityId}`,
+                {
+                    clientSecretTrustedIps,
+                    accessTokenTTL,
+                    accessTokenMaxTTL,
+                    accessTokenNumUsesLimit,
+                    accessTokenTrustedIps,
+                }
+            );
+            return identityUniversalAuth;
+        },
+        onSuccess: (_, { organizationId }) => {
+            queryClient.invalidateQueries(organizationKeys.getOrgIdentityMemberships(organizationId));
+        }
+    });
+};
+
+export const useUpdateIdentityUniversalAuth = () => {
+    const queryClient = useQueryClient();
+    return useMutation<IdentityUniversalAuth, {}, UpdateIdentityUniversalAuthDTO>({
+        mutationFn: async ({
+            identityId,
+            clientSecretTrustedIps,
+            accessTokenTTL,
+            accessTokenMaxTTL,
+            accessTokenNumUsesLimit,
+            accessTokenTrustedIps,
+        }) => {
+            const { data: { identityUniversalAuth } } = await apiRequest.patch(`/api/v1/auth/universal-auth/identities/${identityId}`,
+                {
+                    clientSecretTrustedIps,
+                    accessTokenTTL,
+                    accessTokenMaxTTL,
+                    accessTokenNumUsesLimit,
+                    accessTokenTrustedIps,
+                }
+            );
+            return identityUniversalAuth;
+        },
+        onSuccess: (_, { organizationId }) => {
+            queryClient.invalidateQueries(organizationKeys.getOrgIdentityMemberships(organizationId));
+        }
+    });
+};
+
+export const useCreateIdentityUniversalAuthClientSecret = () => {
+    const queryClient = useQueryClient();
+    return useMutation<CreateIdentityUniversalAuthClientSecretRes, {}, CreateIdentityUniversalAuthClientSecretDTO>({
+        mutationFn: async ({
+            identityId,
+            description,
+            ttl,
+            numUsesLimit
+        }) => {
+            const { data } = await apiRequest.post(`/api/v1/auth/universal-auth/identities/${identityId}/client-secrets`, {
+                description,
+                ttl,
+                numUsesLimit
+            });
+            return data;
+        },
+        onSuccess: (_, { identityId }) => {
+            queryClient.invalidateQueries(identitiesKeys.getIdentityUniversalAuthClientSecrets(identityId));
+        }
+    });
+};
+
+export const useDeleteIdentityUniversalAuthClientSecret = () => {
+    const queryClient = useQueryClient();
+    return useMutation<Identity, {}, DeleteIdentityUniversalAuthClientSecretDTO>({
+        mutationFn: async ({
+            identityId,
+            clientSecretId
+        }) => {
+            const { data: { identity } } = await apiRequest.delete(`/api/v1/auth/universal-auth/identities/${identityId}/client-secrets/${clientSecretId}`);
+            return identity;
+        },
+        onSuccess: (_, { identityId }) => {
+            queryClient.invalidateQueries(identitiesKeys.getIdentityUniversalAuthClientSecrets(identityId));
+        }
+    });
+};

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

@@ -0,0 +1,40 @@
+import { useQuery } from "@tanstack/react-query";
+
+import { apiRequest } from "@app/config/request";
+
+import { ClientSecretData , IdentityUniversalAuth } from "./types";
+
+export const identitiesKeys = {
+    getIdentityUniversalAuth: (identityId: string) => [{ identityId }, "identity-universal-auth"] as const,
+    getIdentityUniversalAuthClientSecrets: (identityId: string) => [{ identityId }, "identity-universal-auth-client-secrets"] as const
+}
+
+export const useGetIdentityUniversalAuth = (identityId: string) => {
+    return useQuery({
+        queryKey: identitiesKeys.getIdentityUniversalAuth(identityId),
+        queryFn: async () => {
+            if (identityId === "") return undefined;
+
+            const { data: { identityUniversalAuth } } = await apiRequest.get<{ identityUniversalAuth: IdentityUniversalAuth }>(
+                `/api/v1/auth/universal-auth/identities/${identityId}`
+            );
+        
+            return identityUniversalAuth;
+        }
+    });
+}
+
+export const useGetIdentityUniversalAuthClientSecrets = (identityId: string) => {
+    return useQuery({
+        queryKey: identitiesKeys.getIdentityUniversalAuthClientSecrets(identityId),
+        queryFn: async () => {
+            if (identityId === "") return [];
+
+            const { data: { clientSecretData } } = await apiRequest.get<{ clientSecretData: ClientSecretData[] }>(
+                `/api/v1/auth/universal-auth/identities/${identityId}/client-secrets`
+            );
+        
+            return clientSecretData;
+        }
+    });
+}

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

@@ -1,29 +1,108 @@
 import { TRole } from "../roles/types";
+import { IdentityAuthMethod } from "./enums";
 
-export type MachineTrustedIp = {
+export type IdentityTrustedIp = {
     _id: string;
     ipAddress: string;
     type: "ipv4" | "ipv6";
     prefix?: number;
 }
 
-export type MachineIdentity = {
+export type Identity = {
     _id: string;
-    clientId: string;
     name: string;
-    organization: string;
-    accessTokenTTL: number;
-    accessTokenMaxTTL: number;
-    accessTokenNumUsesLimit: number;
-    clientSecretTrustedIps: MachineTrustedIp[];
-    accessTokenTrustedIps: MachineTrustedIp[];
+    authMethod?: IdentityAuthMethod;
     createdAt: string;
     updatedAt: string;
 };
 
-export type MachineIdentityClientSecret = {
+export type IdentityMembershipOrg = {
     _id: string;
-    machineIdentity: string;
+    identity: Identity;
+    organization: string;
+    role: "admin" | "member" | "viewer" | "no-access" | "custom";
+    customRole?: TRole<string>;
+    createdAt: string;
+    updatedAt: string;
+}
+
+export type IdentityMembership = {
+    _id: string;
+    identity: Identity;
+    organization: string;
+    role: "admin" | "member" | "viewer" | "no-access" | "custom";
+    customRole?: TRole<string>;
+    createdAt: string;
+    updatedAt: string;
+}
+
+export type CreateIdentityDTO = {
+    name: string;
+    organizationId: string;
+    role?: string;
+}
+
+export type UpdateIdentityDTO = {
+    identityId: string;
+    name?: string;
+    role?: string;
+    organizationId: string;
+}
+
+export type DeleteIdentityDTO = {
+    identityId: string;
+    organizationId: string;
+}
+
+export type IdentityUniversalAuth = {
+    identityId: string;
+    clientId: string;
+    clientSecretTrustedIps: IdentityTrustedIp[];
+    accessTokenTTL: number;
+    accessTokenMaxTTL: number;
+    accessTokenNumUsesLimit: number;
+    accessTokenTrustedIps: IdentityTrustedIp[];
+}
+
+export type AddIdentityUniversalAuthDTO = {
+    organizationId: string;
+    identityId: string;
+    clientSecretTrustedIps: {
+        ipAddress: string;
+    }[];
+    accessTokenTTL: number;
+    accessTokenMaxTTL: number;
+    accessTokenNumUsesLimit: number;
+    accessTokenTrustedIps: {
+        ipAddress: string;
+    }[];
+}
+
+export type UpdateIdentityUniversalAuthDTO = {
+    organizationId: string;
+    identityId: string;
+    clientSecretTrustedIps?: {
+        ipAddress: string;
+    }[];
+    accessTokenTTL?: number;
+    accessTokenMaxTTL?: number;
+    accessTokenNumUsesLimit?: number;
+    accessTokenTrustedIps?: {
+        ipAddress: string;
+    }[];
+}
+
+export type CreateIdentityUniversalAuthClientSecretDTO = {
+    identityId: string;
+    description?: string;
+    ttl?: number;
+    numUsesLimit?: number;
+}
+
+export type ClientSecretData = {
+    _id: string;
+    identityUniversalAuth: string;
+    isClientSecretRevoked: boolean;
     description: string;
     clientSecretPrefix: string;
     clientSecretNumUses: number;
@@ -31,80 +110,14 @@ export type MachineIdentityClientSecret = {
     clientSecretTTL: number;
     createdAt: string;
     updatedAt: string;
-    isClientSecretRevoked: boolean;
 }
 
-export type MachineMembershipOrg = {
-    _id: string;
-    machineIdentity: MachineIdentity;
-    organization: string;
-    role: "admin" | "member" | "viewer" | "no-access" | "custom";
-    customRole?: TRole<string>;
-    createdAt: string;
-    updatedAt: string;
-}
-
-export type MachineMembership = {
-    _id: string;
-    machineIdentity: MachineIdentity;
-    organization: string;
-    role: "admin" | "member" | "viewer" | "no-access" | "custom";
-    customRole?: TRole<string>;
-    createdAt: string;
-    updatedAt: string;
-}
-
-export type CreateMachineIdentityDTO = {
-    name: string;
-    organizationId: string;
-    role?: string;
-    clientSecretTrustedIps: {
-      ipAddress: string;
-    }[];
-    accessTokenTrustedIps: {
-      ipAddress: string;
-    }[];
-    accessTokenTTL: number;
-    accessTokenMaxTTL: number;
-    accessTokenNumUsesLimit: number;
-}
-
-export type CreateMachineIdentityClientSecretDTO = {
-    machineId: string;
-    description?: string;
-    ttl?: number;
-    numUsesLimit?: number;
-}
-
-export type CreateMachineIdentityClientSecretRes = {
+export type CreateIdentityUniversalAuthClientSecretRes = {
     clientSecret: string;
-    machineIdentity: string;
-    isActive: boolean;
-    description: string;
-    clientSecretNumUses: number;
-    clientSecretNumUsesLimit: number;
-    expiresAt?: Date;
+    clientSecretData: ClientSecretData;
 }
 
-export type CreateMachineIdentityRes = {
-    machineIdentity: MachineIdentity;
-}
-
-export type UpdateMachineIdentityDTO = {
-    machineId: string;
-    name?: string;
-    role?: string;
-    clientSecretTrustedIps?: {
-        ipAddress: string;
-    }[];
-    accessTokenTrustedIps?: {
-        ipAddress: string;
-    }[];
-    accessTokenTTL?: number;
-    accessTokenMaxTTL?: number;
-    accessTokenNumUsesLimit?: number;
-}
-
-export type DeleteMachineIdentityDTO = {
-    machineId: string;
+export type DeleteIdentityUniversalAuthClientSecretDTO = {
+    identityId: string;
+    clientSecretId: string;
 }

frontend/src/hooks/api/index.tsx

@@ -3,11 +3,11 @@ export * from "./apiKeys";
 export * from "./auditLogs";
 export * from "./auth";
 export * from "./bots";
+export * from "./identities";
 export * from "./incidentContacts";
 export * from "./integrationAuth";
 export * from "./integrations";
 export * from "./keys";
-export * from "./machineIdentities";
 export * from "./organization";
 export * from "./roles";
 export * from "./secretApproval";

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

@@ -1,9 +0,0 @@
-export {
-    useCreateMachineIdentity,
-    useCreateMachineIdentityClientSecret,
-    useDeleteMachineIdentity,
-    useDeleteMachineIdentityClientSecret,
-    useUpdateMachineIdentity} from "./mutations";
-export {
-    useGetMachineIdentityClientSecrets
-} from "./queries";

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

@@ -1,119 +0,0 @@
-import { useMutation, useQueryClient } from "@tanstack/react-query";
-
-import { apiRequest } from "@app/config/request";
-
-import { organizationKeys } from "../organization/queries";
-import { machineIdentityKeys } from "./queries";
-import {
-    CreateMachineIdentityClientSecretDTO,
-    CreateMachineIdentityClientSecretRes,
-    CreateMachineIdentityDTO,
-    CreateMachineIdentityRes,
-    DeleteMachineIdentityDTO,
-    MachineIdentity,
-    UpdateMachineIdentityDTO,
-} from "./types";
-
-export const useCreateMachineIdentity = () => {
-    const queryClient = useQueryClient();
-    return useMutation<CreateMachineIdentityRes, {}, CreateMachineIdentityDTO>({
-        mutationFn: async (body) => {
-            const { data } = await apiRequest.post("/api/v1/machine-identities/", body);
-            return data;
-        },
-        onSuccess: ({ machineIdentity }) => {
-            queryClient.invalidateQueries(organizationKeys.getOrgServiceMemberships(machineIdentity.organization));
-        }
-    });
-};
-
-export const useCreateMachineIdentityClientSecret = () => {
-    const queryClient = useQueryClient();
-    return useMutation<CreateMachineIdentityClientSecretRes, {}, CreateMachineIdentityClientSecretDTO>({
-        mutationFn: async ({
-            machineId,
-            description,
-            ttl,
-            numUsesLimit
-        }) => {
-
-            const { data } = await apiRequest.post(`/api/v1/machine-identities/${machineId}/client-secrets`, {
-                machineId,
-                description,
-                ttl,
-                numUsesLimit
-            });
-
-            return data;
-        },
-        onSuccess: (_, { machineId }) => {
-            queryClient.invalidateQueries(machineIdentityKeys.getMachineIdentityClientSecrets(machineId));
-        }
-    });
-};
-
-export const useDeleteMachineIdentityClientSecret = () => {
-    const queryClient = useQueryClient();
-    return useMutation({
-        mutationFn: async ({
-            machineId,
-            clientSecretId
-        }: {
-            machineId:string;
-            clientSecretId: string;
-        }) => {
-            const { data } = await apiRequest.post(`/api/v1/machine-identities/${machineId}/client-secrets/${clientSecretId}/revoke`);
-            return data;
-        },
-        onSuccess: (_, { machineId }) => {
-            queryClient.invalidateQueries(machineIdentityKeys.getMachineIdentityClientSecrets(machineId));
-        }
-    });
-};
-
-export const useUpdateMachineIdentity = () => {
-    const queryClient = useQueryClient();
-    return useMutation<MachineIdentity, {}, UpdateMachineIdentityDTO>({
-        mutationFn: async ({
-            machineId,
-            name,
-            role,
-            clientSecretTrustedIps,
-            accessTokenTrustedIps,
-            accessTokenTTL,
-            accessTokenNumUsesLimit,
-            accessTokenMaxTTL
-        }) => {
-            
-            const { data: { machineIdentity } } = await apiRequest.patch(`/api/v1/machine-identities/${machineId}`, {
-                name,
-                role,
-                clientSecretTrustedIps,
-                accessTokenTrustedIps,
-                accessTokenTTL,
-                accessTokenNumUsesLimit,
-                accessTokenMaxTTL
-            });
-
-            return machineIdentity;
-        },
-        onSuccess: ({ organization }) => {
-            queryClient.invalidateQueries(organizationKeys.getOrgServiceMemberships(organization));
-        }
-    });
-};
-
-export const useDeleteMachineIdentity = () => {
-    const queryClient = useQueryClient();
-    return useMutation<MachineIdentity, {}, DeleteMachineIdentityDTO>({
-        mutationFn: async ({
-            machineId
-        }) => {
-            const { data: { machineIdentity } } = await apiRequest.delete(`/api/v1/machine-identities/${machineId}`);
-            return machineIdentity;
-        },
-        onSuccess: ({ organization }) => {
-            queryClient.invalidateQueries(organizationKeys.getOrgServiceMemberships(organization));
-        }
-    });
-};

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

@@ -1,26 +0,0 @@
-import { useQuery } from "@tanstack/react-query";
-
-import { apiRequest } from "@app/config/request";
-
-import {
-    MachineIdentityClientSecret
-} from "./types";
-
-export const machineIdentityKeys = {
-    getMachineIdentityClientSecrets: (machineId: string) => [{ machineId }, "machine-identity-client-secrets"] as const
-}
-
-export const useGetMachineIdentityClientSecrets = (machineId: string) => {
-    return useQuery({
-        queryKey: machineIdentityKeys.getMachineIdentityClientSecrets(machineId),
-        queryFn: async () => {
-            if (machineId === "") return [];
-
-            const { data: { clientSecretData } } = await apiRequest.get<{ clientSecretData: MachineIdentityClientSecret[] }>(
-                `/api/v1/machine-identities/${machineId}/client-secrets`
-            );
-        
-            return clientSecretData;
-        }
-    });
-}

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

@@ -6,7 +6,7 @@ export {
     useDeleteOrgById,
     useDeleteOrgPmtMethod,
     useDeleteOrgTaxId,
-    useGetMachineMembershipOrgs,
+    useGetIdentityMembershipOrgs,
     useGetOrganizations, 
     useGetOrgBillingDetails,
     useGetOrgInvoices,
@@ -18,4 +18,5 @@ export {
     useGetOrgTaxIds,
     useGetOrgTrialUrl,
     useRenameOrg, 
-    useUpdateOrgBillingDetails} from "./queries";
+    useUpdateOrgBillingDetails
+} from "./queries";

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

@@ -2,7 +2,7 @@ import { useMutation, useQuery, useQueryClient } from "@tanstack/react-query";
 
 import { apiRequest } from "@app/config/request";
 
-import { MachineMembershipOrg } from "../machineIdentities/types";
+import { IdentityMembershipOrg } from "../identities/types";
 import {
   BillingDetails,
   Invoice,
@@ -27,7 +27,7 @@ export const organizationKeys = {
   getOrgTaxIds: (orgId: string) => [{ orgId }, "organization-tax-ids"] as const,
   getOrgInvoices: (orgId: string) => [{ orgId }, "organization-invoices"] as const,
   getOrgLicenses: (orgId: string) => [{ orgId }, "organization-licenses"] as const,
-  getOrgServiceMemberships: (orgId: string) => [{ orgId }, "organization-service-memberships"] as const,
+  getOrgIdentityMemberships: (orgId: string) => [{ orgId }, "organization-identity-memberships"] as const,
 };
 
 export const fetchOrganizations = async () => {
@@ -351,17 +351,17 @@ export const useGetOrgLicenses = (organizationId: string) => {
   });
 };
 
-export const useGetMachineMembershipOrgs = (organizationId: string) => {
+export const useGetIdentityMembershipOrgs = (organizationId: string) => {
   return useQuery({
-    queryKey: organizationKeys.getOrgServiceMemberships(organizationId),
+    queryKey: organizationKeys.getOrgIdentityMemberships(organizationId),
     queryFn: async () => {
       const {
-        data: { machineMemberships }
-      } = await apiRequest.get<{ machineMemberships: MachineMembershipOrg[] }>(
-        `/api/v2/organizations/${organizationId}/machine-memberships`
+        data: { identityMemberships }
+      } = await apiRequest.get<{ identityMemberships: IdentityMembershipOrg[] }>(
+        `/api/v2/organizations/${organizationId}/identity-memberships`
       );
 
-      return machineMemberships;
+      return identityMemberships;
     },
     enabled: true
   });

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

@@ -1,9 +1,9 @@
 export {
-  useAddMachineToWorkspace,
+  useAddIdentityToWorkspace,
   useAddUserToWorkspace,
   useCreateWorkspace,
   useCreateWsEnvironment,
-  useDeleteMachineFromWorkspace,
+  useDeleteIdentityFromWorkspace,
   useDeleteUserFromWorkspace,
   useDeleteWorkspace,
   useDeleteWsEnvironment,
@@ -11,15 +11,15 @@ export {
   useGetUserWorkspaces,
   useGetWorkspaceAuthorizations,
   useGetWorkspaceById,
+  useGetWorkspaceIdentityMemberships,
   useGetWorkspaceIndexStatus,
   useGetWorkspaceIntegrations,
-  useGetWorkspaceMachineMemberships,
   useGetWorkspaceSecrets,
   useGetWorkspaceUsers,
   useNameWorkspaceSecrets,
   useRenameWorkspace,
   useReorderWsEnvironment,
   useToggleAutoCapitalization,
-  useUpdateMachineWorkspaceRole,
+  useUpdateIdentityWorkspaceRole,
   useUpdateUserWorkspaceRole,
   useUpdateWsEnvironment} from "./queries";

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

@@ -2,9 +2,9 @@ import { useMutation, useQuery, useQueryClient } from "@tanstack/react-query";
 
 import { apiRequest } from "@app/config/request";
 
+import { IdentityMembership } from "../identities/types";
 import { IntegrationAuth } from "../integrationAuth/types";
 import { TIntegration } from "../integrations/types";
-import { MachineMembership } from "../machineIdentities/types";
 import { EncryptedSecret } from "../secrets/types";
 import { TWorkspaceUser } from "../users/types";
 import {
@@ -31,7 +31,7 @@ export const workspaceKeys = {
   getAllUserWorkspace: ["workspaces"] as const,
   getWorkspaceAuditLogs: (workspaceId: string) => [{ workspaceId }] as const,
   getWorkspaceUsers: (workspaceId: string) => [{ workspaceId }] as const,
-  getWorkspaceMachineMemberships: (workspaceId: string) => [{ workspaceId }, "workspace-machine-memberships"] as const
+  getWorkspaceIdentityMemberships: (workspaceId: string) => [{ workspaceId }, "workspace-identity-memberships"] as const
 };
 
 const fetchWorkspaceById = async (workspaceId: string) => {
@@ -356,97 +356,92 @@ export const useUpdateUserWorkspaceRole = () => {
   });
 };
 
-export const useAddMachineToWorkspace = () => {
+export const useAddIdentityToWorkspace = () => {
   const queryClient = useQueryClient();
   return useMutation({
     mutationFn: async ({
-      machineId,
+      identityId,
       workspaceId,
       role
     }: {
-      machineId: string;
+      identityId: string;
       workspaceId: string;
       role?: string;
     }) => {
 
       const {
-        data: { serviceMembership }
-      } = await apiRequest.post(`/api/v2/workspace/${workspaceId}/machine-memberships/${machineId}`, {
+        data: { identityMembership }
+      } = await apiRequest.post(`/api/v2/workspace/${workspaceId}/identity-memberships/${identityId}`, {
         role
       });
       
-      return serviceMembership;
+      return identityMembership;
     },
     onSuccess: (_, { workspaceId }) => {
-      queryClient.invalidateQueries(workspaceKeys.getWorkspaceMachineMemberships(workspaceId));
+      queryClient.invalidateQueries(workspaceKeys.getWorkspaceIdentityMemberships(workspaceId));
     }
   });
 };
 
-export const useUpdateMachineWorkspaceRole = () => {
+export const useUpdateIdentityWorkspaceRole = () => {
   const queryClient = useQueryClient();
   return useMutation({
     mutationFn: async ({
-      machineId,
+      identityId,
       workspaceId,
       role
     }: {
-      machineId: string;
+      identityId: string;
       workspaceId: string;
       role?: string;
     }) => {
 
       const {
-        data: { serviceMembership }
-      } = await apiRequest.patch(`/api/v2/workspace/${workspaceId}/machine-memberships/${machineId}`, {
+        data: { identityMembership }
+      } = await apiRequest.patch(`/api/v2/workspace/${workspaceId}/identity-memberships/${identityId}`, {
         role
       });
-      
-      return serviceMembership;
+
+      return identityMembership;
     },
     onSuccess: (_, { workspaceId }) => {
-      queryClient.invalidateQueries(workspaceKeys.getWorkspaceMachineMemberships(workspaceId));
+      queryClient.invalidateQueries(workspaceKeys.getWorkspaceIdentityMemberships(workspaceId));
     }
   });
 };
 
-export const useDeleteMachineFromWorkspace = () => {
+export const useDeleteIdentityFromWorkspace = () => {
   const queryClient = useQueryClient();
   return useMutation({
     mutationFn: async ({
-      machineId,
+      identityId,
       workspaceId,
     }: {
-      machineId: string;
+      identityId: string;
       workspaceId: string;
     }) => {
-      
       const {
-        data: { serviceMembership }
-      } = await apiRequest.delete(`/api/v2/workspace/${workspaceId}/machine-memberships/${machineId}`);
-      
-      return serviceMembership;
+        data: { identityMembership }
+      } = await apiRequest.delete(`/api/v2/workspace/${workspaceId}/identity-memberships/${identityId}`);
+      return identityMembership;
     },
     onSuccess: (_, { workspaceId }) => {
-      queryClient.invalidateQueries(workspaceKeys.getWorkspaceMachineMemberships(workspaceId));
+      queryClient.invalidateQueries(workspaceKeys.getWorkspaceIdentityMemberships(workspaceId));
     }
   });
 };
 
-
-export const useGetWorkspaceMachineMemberships = (workspaceId: string) => {
+export const useGetWorkspaceIdentityMemberships = (workspaceId: string) => {
   return useQuery({
-    queryKey: workspaceKeys.getWorkspaceMachineMemberships(workspaceId),
+    queryKey: workspaceKeys.getWorkspaceIdentityMemberships(workspaceId),
     queryFn: async () => {
-      
       const {
-        data: { machineMemberships }
-      } = await apiRequest.get<{ machineMemberships: MachineMembership[] }>(
-        `/api/v2/workspace/${workspaceId}/machine-memberships`
+        data: { identityMemberships }
+      } = await apiRequest.get<{ identityMemberships: IdentityMembership[] }>(
+        `/api/v2/workspace/${workspaceId}/identity-memberships`
       );
-
-      return machineMemberships;
+      return identityMemberships;
     },
     enabled: true
   });
-};
+};