Merge branch 'main' into feat/terraformCloudIntegration

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

@@ -79,6 +79,8 @@ export type TAccessApprovalRequest = {
     member: string;
     status: string;
   }[];
+
+  note?: string;
 };
 
 export type TAccessApproval = {
@@ -119,6 +121,7 @@ export type TProjectUserPrivilege = {
 
 export type TCreateAccessRequestDTO = {
   projectSlug: string;
+  note?: string;
 } & Omit<TProjectUserPrivilege, "id" | "createdAt" | "updatedAt" | "slug" | "projectMembershipId">;
 
 export type TGetAccessApprovalRequestsDTO = {

frontend/src/hooks/api/index.tsx

@@ -41,6 +41,7 @@ export * from "./serverDetails";
 export * from "./serviceTokens";
 export * from "./sshCa";
 export * from "./sshCertificateTemplates";
+export * from "./sshHost";
 export * from "./ssoConfig";
 export * from "./subscriptions";
 export * from "./tags";

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

@@ -12,3 +12,47 @@ export const sshCertTypeToNameMap: { [K in SshCertType]: string } = {
   [SshCertType.USER]: "User",
   [SshCertType.HOST]: "Host"
 };
+
+export enum SshCaKeySource {
+  INTERNAL = "internal",
+  EXTERNAL = "external"
+}
+
+export enum SshCertKeyAlgorithm {
+  RSA_2048 = "RSA_2048",
+  RSA_4096 = "RSA_4096",
+  ECDSA_P256 = "EC_prime256v1",
+  ECDSA_P384 = "EC_secp384r1",
+  ED25519 = "ED25519"
+}
+
+export const sshCertKeyAlgorithmToNameMap: { [K in SshCertKeyAlgorithm]: string } = {
+  [SshCertKeyAlgorithm.RSA_2048]: "RSA 2048",
+  [SshCertKeyAlgorithm.RSA_4096]: "RSA 4096",
+  [SshCertKeyAlgorithm.ECDSA_P256]: "ECDSA P256",
+  [SshCertKeyAlgorithm.ECDSA_P384]: "ECDSA P384",
+  [SshCertKeyAlgorithm.ED25519]: "ED25519"
+};
+
+export const sshCertKeyAlgorithms = [
+  {
+    label: sshCertKeyAlgorithmToNameMap[SshCertKeyAlgorithm.RSA_2048],
+    value: SshCertKeyAlgorithm.RSA_2048
+  },
+  {
+    label: sshCertKeyAlgorithmToNameMap[SshCertKeyAlgorithm.RSA_4096],
+    value: SshCertKeyAlgorithm.RSA_4096
+  },
+  {
+    label: sshCertKeyAlgorithmToNameMap[SshCertKeyAlgorithm.ECDSA_P256],
+    value: SshCertKeyAlgorithm.ECDSA_P256
+  },
+  {
+    label: sshCertKeyAlgorithmToNameMap[SshCertKeyAlgorithm.ECDSA_P384],
+    value: SshCertKeyAlgorithm.ECDSA_P384
+  },
+  {
+    label: sshCertKeyAlgorithmToNameMap[SshCertKeyAlgorithm.ED25519],
+    value: SshCertKeyAlgorithm.ED25519
+  }
+];

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

@@ -1,5 +1,4 @@
-import { CertKeyAlgorithm } from "../certificates/enums";
-import { SshCaStatus, SshCertType } from "./constants";
+import { SshCaKeySource, SshCaStatus, SshCertKeyAlgorithm, SshCertType } from "./constants";
 
 export type TSshCertificate = {
   id: string;
@@ -18,17 +17,28 @@ export type TSshCertificateAuthority = {
   projectId: string;
   status: SshCaStatus;
   friendlyName: string;
-  keyAlgorithm: CertKeyAlgorithm;
+  keyAlgorithm: SshCertKeyAlgorithm;
+  keySource: SshCaKeySource;
   createdAt: string;
   updatedAt: string;
   publicKey: string;
 };
 
-export type TCreateSshCaDTO = {
-  projectId: string;
-  friendlyName?: string;
-  keyAlgorithm: CertKeyAlgorithm;
-};
+export type TCreateSshCaDTO =
+  | {
+      projectId: string;
+      friendlyName?: string;
+      keySource: SshCaKeySource.INTERNAL;
+      keyAlgorithm: SshCertKeyAlgorithm;
+    }
+  | {
+      projectId: string;
+      friendlyName?: string;
+      keySource: SshCaKeySource.EXTERNAL;
+      keyAlgorithm: SshCertKeyAlgorithm;
+      publicKey: string;
+      privateKey: string;
+    };
 
 export type TUpdateSshCaDTO = {
   caId: string;
@@ -58,7 +68,7 @@ export type TSignSshKeyResponse = {
 export type TIssueSshCredsDTO = {
   projectId: string;
   certificateTemplateId: string;
-  keyAlgorithm: CertKeyAlgorithm;
+  keyAlgorithm: SshCertKeyAlgorithm;
   certType: SshCertType;
   principals: string[];
   ttl?: string;
@@ -70,5 +80,5 @@ export type TIssueSshCredsResponse = {
   signedKey: string;
   privateKey: string;
   publicKey: string;
-  keyAlgorithm: CertKeyAlgorithm;
+  keyAlgorithm: SshCertKeyAlgorithm;
 };

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

@@ -0,0 +1,2 @@
+export { useCreateSshHost, useDeleteSshHost, useUpdateSshHost } from "./mutations";
+export { fetchSshHostUserCaPublicKey, useGetSshHostById } from "./queries";

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

@@ -0,0 +1,45 @@
+import { useMutation, useQueryClient } from "@tanstack/react-query";
+
+import { apiRequest } from "@app/config/request";
+
+import { workspaceKeys } from "../workspace/query-keys";
+import { TCreateSshHostDTO, TDeleteSshHostDTO, TSshHost, TUpdateSshHostDTO } from "./types";
+
+export const useCreateSshHost = () => {
+  const queryClient = useQueryClient();
+  return useMutation<TSshHost, object, TCreateSshHostDTO>({
+    mutationFn: async (body) => {
+      const { data: host } = await apiRequest.post("/api/v1/ssh/hosts", body);
+      return host;
+    },
+    onSuccess: ({ projectId }) => {
+      queryClient.invalidateQueries({ queryKey: workspaceKeys.getWorkspaceSshHosts(projectId) });
+    }
+  });
+};
+
+export const useUpdateSshHost = () => {
+  const queryClient = useQueryClient();
+  return useMutation<TSshHost, object, TUpdateSshHostDTO>({
+    mutationFn: async ({ sshHostId, ...body }) => {
+      const { data: host } = await apiRequest.patch(`/api/v1/ssh/hosts/${sshHostId}`, body);
+      return host;
+    },
+    onSuccess: ({ projectId }) => {
+      queryClient.invalidateQueries({ queryKey: workspaceKeys.getWorkspaceSshHosts(projectId) });
+    }
+  });
+};
+
+export const useDeleteSshHost = () => {
+  const queryClient = useQueryClient();
+  return useMutation<TSshHost, object, TDeleteSshHostDTO>({
+    mutationFn: async ({ sshHostId }) => {
+      const { data: host } = await apiRequest.delete(`/api/v1/ssh/hosts/${sshHostId}`);
+      return host;
+    },
+    onSuccess: ({ projectId }) => {
+      queryClient.invalidateQueries({ queryKey: workspaceKeys.getWorkspaceSshHosts(projectId) });
+    }
+  });
+};

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

@@ -0,0 +1,28 @@
+import { useQuery } from "@tanstack/react-query";
+
+import { apiRequest } from "@app/config/request";
+
+import { TSshHost } from "./types";
+
+export const sshHostKeys = {
+  getSshHostById: (sshHostId: string) => [{ sshHostId }, "ssh-host"],
+  getSshHostUserCaPublicKey: (sshHostId: string) => [{ sshHostId }, "ssh-host-user-ca-public-key"]
+};
+
+export const useGetSshHostById = (sshHostId: string) => {
+  return useQuery({
+    queryKey: sshHostKeys.getSshHostById(sshHostId),
+    queryFn: async () => {
+      const { data: sshHost } = await apiRequest.get<TSshHost>(`/api/v1/ssh/hosts/${sshHostId}`);
+      return sshHost;
+    },
+    enabled: Boolean(sshHostId)
+  });
+};
+
+export const fetchSshHostUserCaPublicKey = async (sshHostId: string): Promise<string> => {
+  const { data } = await apiRequest.get<string>(
+    `/api/v1/ssh/hosts/${sshHostId}/user-ca-public-key`
+  );
+  return data;
+};

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

@@ -0,0 +1,43 @@
+export type TSshHost = {
+  id: string;
+  projectId: string;
+  hostname: string;
+  userCertTtl: string;
+  hostCertTtl: string;
+  loginMappings: {
+    loginUser: string;
+    allowedPrincipals: {
+      usernames: string[];
+    };
+  }[];
+};
+
+export type TCreateSshHostDTO = {
+  projectId: string;
+  hostname: string;
+  userCertTtl?: string;
+  hostCertTtl?: string;
+  loginMappings: {
+    loginUser: string;
+    allowedPrincipals: {
+      usernames: string[];
+    };
+  }[];
+};
+
+export type TUpdateSshHostDTO = {
+  sshHostId: string;
+  hostname?: string;
+  userCertTtl?: string;
+  hostCertTtl?: string;
+  loginMappings?: {
+    loginUser: string;
+    allowedPrincipals: {
+      usernames: string[];
+    };
+  }[];
+};
+
+export type TDeleteSshHostDTO = {
+  sshHostId: string;
+};

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

@@ -36,6 +36,7 @@ export {
   useListWorkspaceSshCas,
   useListWorkspaceSshCertificates,
   useListWorkspaceSshCertificateTemplates,
+  useListWorkspaceSshHosts,
   useNameWorkspaceSecrets,
   useSearchProjects,
   useToggleAutoCapitalization,

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

@@ -17,6 +17,7 @@ import { TPkiCollection } from "../pkiCollections/types";
 import { EncryptedSecret } from "../secrets/types";
 import { TSshCertificate, TSshCertificateAuthority } from "../sshCa/types";
 import { TSshCertificateTemplate } from "../sshCertificateTemplates/types";
+import { TSshHost } from "../sshHost/types";
 import { userKeys } from "../users/query-keys";
 import { TWorkspaceUser } from "../users/types";
 import { ProjectSlackConfig } from "../workflowIntegrations/types";
@@ -827,6 +828,19 @@ export const useListWorkspaceSshCas = (projectId: string) => {
   });
 };
 
+export const useListWorkspaceSshHosts = (projectId: string) => {
+  return useQuery({
+    queryKey: workspaceKeys.getWorkspaceSshHosts(projectId),
+    queryFn: async () => {
+      const {
+        data: { hosts }
+      } = await apiRequest.get<{ hosts: TSshHost[] }>(`/api/v2/workspace/${projectId}/ssh-hosts`);
+      return hosts;
+    },
+    enabled: Boolean(projectId)
+  });
+};
+
 export const useListWorkspaceSshCertificateTemplates = (projectId: string) => {
   return useQuery({
     queryKey: workspaceKeys.getWorkspaceSshCertificateTemplates(projectId),

frontend/src/hooks/api/workspace/query-keys.tsx

@@ -58,6 +58,7 @@ export const workspaceKeys = {
   getWorkspaceSshCas: (projectId: string) => [{ projectId }, "workspace-ssh-cas"] as const,
   allWorkspaceSshCertificates: (projectId: string) =>
     [{ projectId }, "workspace-ssh-certificates"] as const,
+  getWorkspaceSshHosts: (projectId: string) => [{ projectId }, "workspace-ssh-hosts"] as const,
   specificWorkspaceSshCertificates: ({
     offset,
     limit,