refactor(integration): make hashicorp vault integration easier to use

* Makes `namespace` optional allowing to use self-hosted OSS hashicorp vault

frontend/src/helpers/string.ts

@@ -3,3 +3,12 @@ export const removeTrailingSlash = (str: string) => {
 
   return str.endsWith("/") ? str.slice(0, -1) : str;
 };
+
+export const isValidPath = (val: string): boolean => {
+  if (val.length === 0) return false;
+  if (val === "/") return true;
+
+  // Check for valid characters and no consecutive slashes
+  const validPathRegex = /^[a-zA-Z0-9-_.:]+(?:\/[a-zA-Z0-9-_.:]+)*$/;
+  return validPathRegex.test(val);
+}

frontend/src/pages/integrations/hashicorp-vault/authorize.tsx

@@ -1,83 +1,69 @@
-import { useState } from "react";
+import { Controller, useForm } from "react-hook-form";
 import Head from "next/head";
 import Image from "next/image";
 import Link from "next/link";
 import { useRouter } from "next/router";
 import { faArrowUpRightFromSquare, faBookOpen } from "@fortawesome/free-solid-svg-icons";
 import { FontAwesomeIcon } from "@fortawesome/react-fontawesome";
+import { zodResolver } from "@hookform/resolvers/zod";
+import axios from "axios";
+import { z } from "zod";
 
+import { createNotification } from "@app/components/notifications";
 import { useSaveIntegrationAccessToken } from "@app/hooks/api";
 
-import { Button, Card, CardTitle, FormControl, Input } from "../../../components/v2";
+import { Button, Card, CardBody, CardTitle, FormControl, Input } from "../../../components/v2";
+
+const formSchema = z.object({
+  vaultURL: z.string().url({ message: "Invalid Hashicorp Vault URL" }),
+  vaultNamespace: z.string().optional(),
+  vaultRoleID: z.string().uuid({ message: "Role ID has be a valid UUID" }),
+  vaultSecretID: z.string().uuid({ message: "Role ID has be a valid UUID" })
+});
+
+type TForm = z.infer<typeof formSchema>;
 
 export default function HashiCorpVaultAuthorizeIntegrationPage() {
   const router = useRouter();
   const { mutateAsync } = useSaveIntegrationAccessToken();
 
-  const [vaultURL, setVaultURL] = useState("");
+  const {
-  const [vaultURLErrorText, setVaultURLErrorText] = useState("");
+    control,
+    handleSubmit,
+    formState: { isSubmitting }
+  } = useForm<TForm>({
+    resolver: zodResolver(formSchema),
+    defaultValues: {
+      vaultURL: "",
+      vaultNamespace: "",
+      vaultRoleID: "",
+      vaultSecretID: ""
+    }
+  });
 
-  const [vaultNamespace, setVaultNamespace] = useState("");
+  const handleFormSubmit = async (formData: TForm) => {
-  const [vaultNamespaceErrorText, setVaultNamespaceErrorText] = useState("");
-
-  const [vaultRoleID, setVaultRoleID] = useState("");
-  const [vaultRoleIDErrorText, setVaultRoleIDErrorText] = useState("");
-
-  const [vaultSecretID, setVaultSecretID] = useState("");
-  const [vaultSecretIDErrorText, setVaultSecretIDErrorText] = useState("");
-
-  const [isLoading, setIsLoading] = useState(false);
-
-  const handleButtonClick = async () => {
     try {
-      if (vaultURL.length === 0) {
-        setVaultURLErrorText("Vault Cluster URL cannot be blank");
-      } else {
-        setVaultURLErrorText("");
-      }
-
-      if (vaultNamespace.length === 0) {
-        setVaultNamespaceErrorText("Vault Namespace cannot be blank");
-      } else {
-        setVaultNamespaceErrorText("");
-      }
-
-      if (vaultRoleID.length === 0) {
-        setVaultRoleIDErrorText("Vault Role ID cannot be blank");
-      } else {
-        setVaultRoleIDErrorText("");
-      }
-
-      if (vaultSecretID.length === 0) {
-        setVaultSecretIDErrorText("Vault Secret ID cannot be blank");
-      } else {
-        setVaultSecretIDErrorText("");
-      }
-      if (
-        vaultURL.length === 0 ||
-        vaultNamespace.length === 0 ||
-        vaultRoleID.length === 0 ||
-        vaultSecretID.length === 0
-      ) {
-        return;
-      }
-
-      setIsLoading(true);
-
       const integrationAuth = await mutateAsync({
         workspaceId: localStorage.getItem("projectData.id"),
         integration: "hashicorp-vault",
-        accessId: vaultRoleID,
+        accessId: formData.vaultRoleID,
-        accessToken: vaultSecretID,
+        accessToken: formData.vaultSecretID,
-        url: vaultURL,
+        url: formData.vaultURL,
-        namespace: vaultNamespace
+        namespace: formData.vaultNamespace
       });
-
-      setIsLoading(false);
-
       router.push(`/integrations/hashicorp-vault/create?integrationAuthId=${integrationAuth.id}`);
     } catch (err) {
       console.error(err);
+      let errorMessage: string = "Something went wrong!";
+      if (axios.isAxiosError(err)) {
+        const { message } = err?.response?.data as { message: string };
+        errorMessage = message;
+      }
+
+      createNotification({
+        text: errorMessage,
+        type: "error"
+      });
     }
   };
 
@@ -93,7 +79,7 @@ export default function HashiCorpVaultAuthorizeIntegrationPage() {
           subTitle="After connecting to Vault, you will be prompted to set up an integration for a particular Infisical project and environment."
         >
           <div className="flex flex-row items-center">
-            <div className="inline flex items-center">
+            <div className="inline-flex items-center">
               <Image
                 src="/images/integrations/Vault.png"
                 height={30}
@@ -116,59 +102,84 @@ export default function HashiCorpVaultAuthorizeIntegrationPage() {
             </Link>
           </div>
         </CardTitle>
-        <FormControl
+        <CardBody className="px-6 pb-6 pt-0">
-          label="Vault Cluster URL"
+          <form onSubmit={handleSubmit(handleFormSubmit)} noValidate>
-          errorText={vaultURLErrorText}
+            <Controller
-          isError={vaultURLErrorText !== "" ?? false}
+              control={control}
-          className="px-6"
+              name="vaultURL"
-        >
+              render={({ field, fieldState: { error } }) => (
-          <Input placeholder="" value={vaultURL} onChange={(e) => setVaultURL(e.target.value)} />
+                <FormControl
-        </FormControl>
+                  label="Vault Cluster URL"
-        <FormControl
+                  errorText={error?.message}
-          label="Vault Namespace"
+                  isError={Boolean(error)}
-          errorText={vaultNamespaceErrorText}
+                  isRequired
-          isError={vaultNamespaceErrorText !== "" ?? false}
+                >
-          className="px-6"
+                  <Input autoCorrect="off" spellCheck={false} placeholder="" {...field} />
-        >
+                </FormControl>
-          <Input
+              )}
-            placeholder="admin/education"
+            />
-            value={vaultNamespace}
+            <Controller
-            onChange={(e) => setVaultNamespace(e.target.value)}
+              control={control}
-          />
+              name="vaultNamespace"
-        </FormControl>
+              render={({ field, fieldState: { error } }) => (
-        <FormControl
+                <FormControl
-          label="Vault RoleID"
+                  label="Vault Namespace"
-          errorText={vaultRoleIDErrorText}
+                  errorText={error?.message}
-          isError={vaultRoleIDErrorText !== "" ?? false}
+                  isError={Boolean(error)}
-          className="px-6"
+                  isRequired={false}
-        >
+                >
-          <Input
+                  <Input
-            placeholder=""
+                    autoCorrect="off"
-            value={vaultRoleID}
+                    spellCheck={false}
-            onChange={(e) => setVaultRoleID(e.target.value)}
+                    placeholder="admin/education"
-          />
+                    {...field}
-        </FormControl>
+                  />
-        <FormControl
+                </FormControl>
-          label="Vault SecretID"
+              )}
-          errorText={vaultSecretIDErrorText}
+            />
-          isError={vaultSecretIDErrorText !== "" ?? false}
+            <Controller
-          className="px-6"
+              control={control}
-        >
+              name="vaultRoleID"
-          <Input
+              render={({ field, fieldState: { error } }) => (
-            placeholder=""
+                <FormControl
-            value={vaultSecretID}
+                  label="Vault RoleID"
-            onChange={(e) => setVaultSecretID(e.target.value)}
+                  errorText={error?.message}
-          />
+                  isError={Boolean(error)}
-        </FormControl>
+                  isRequired
-        <Button
+                >
-          onClick={handleButtonClick}
+                  <Input
-          colorSchema="primary"
+                    autoCorrect="off"
-          variant="outline_bg"
+                    spellCheck={false}
-          className="mb-6 mt-2 ml-auto mr-6 w-min"
+                    placeholder="aaaaaaa-bbbb-cccc-dddd-aaaaaaaaaaa"
-          isLoading={isLoading}
+                    {...field}
-        >
+                  />
-          Connect to Vault
+                </FormControl>
-        </Button>
+              )}
+            />
+            <Controller
+              control={control}
+              name="vaultSecretID"
+              render={({ field, fieldState: { error } }) => (
+                <FormControl
+                  label="Vault SecretID"
+                  errorText={error?.message}
+                  isError={Boolean(error)}
+                  isRequired
+                >
+                  <Input
+                    autoCorrect="off"
+                    spellCheck={false}
+                    placeholder="aaaaaaa-bbbb-cccc-dddd-aaaaaaaaaaa"
+                    {...field}
+                  />
+                </FormControl>
+              )}
+            />
+            <Button type="submit" isLoading={isSubmitting}>
+              Connect to Vault
+            </Button>
+          </form>
+        </CardBody>
       </Card>
     </div>
   );

frontend/src/pages/integrations/hashicorp-vault/create.tsx

@@ -1,4 +1,5 @@
-import { useState } from "react";
+import { useMemo } from "react";
+import { Controller, useForm } from "react-hook-form";
 import Head from "next/head";
 import Image from "next/image";
 import Link from "next/link";
@@ -10,13 +11,19 @@ import {
   faCircleInfo
 } from "@fortawesome/free-solid-svg-icons";
 import { FontAwesomeIcon } from "@fortawesome/react-fontawesome";
+import { zodResolver } from "@hookform/resolvers/zod";
+import axios from "axios";
 import queryString from "query-string";
+import { z } from "zod";
 
+import { createNotification } from "@app/components/notifications";
+import { isValidPath } from "@app/helpers/string";
 import { useCreateIntegration } from "@app/hooks/api";
 
 import {
   Button,
   Card,
+  CardBody,
   CardTitle,
   FormControl,
   Input,
@@ -26,6 +33,29 @@ import {
 import { useGetIntegrationAuthById } from "../../../hooks/api/integrationAuth";
 import { useGetWorkspaceById } from "../../../hooks/api/workspace";
 
+const generateFormSchema = (availableEnvironmentNames: string[]) => {
+  return z.object({
+    secretPath: z.string().min(1).refine((val) => isValidPath(val), {
+      message: "Vault secret path has to be a valid path"
+    }),
+    vaultEnginePath: z
+      .string()
+      .min(1)
+      .refine((val) => isValidPath(val), {
+        message: "Vault engine path has to be a valid path"
+      }),
+    vaultSecretPath: z
+      .string()
+      .min(1)
+      .refine((val) => isValidPath(val), {
+        message: "Vault secret path has to be a valid path"
+      }),
+    selectedSourceEnvironment: z.enum(availableEnvironmentNames as any as [string, ...string[]])
+  });
+};
+
+type TForm = z.infer<ReturnType<typeof generateFormSchema>>;
+
 export default function HashiCorpVaultCreateIntegrationPage() {
   const router = useRouter();
   const { mutateAsync } = useCreateIntegration();
@@ -37,54 +67,48 @@ export default function HashiCorpVaultCreateIntegrationPage() {
     (integrationAuthId as string) ?? ""
   );
 
-  const [vaultEnginePath, setVaultEnginePath] = useState("");
+  const formSchema = useMemo(() => {
-  const [vaultEnginePathErrorText, setVaultEnginePathErrorText] = useState("");
+    return generateFormSchema(workspace?.environments.map((env) => env.slug) ?? []);
+  }, [workspace?.environments]);
 
-  const [vaultSecretPath, setVaultSecretPath] = useState("");
+  const {
-  const [vaultSecretPathErrorText, setVaultSecretPathErrorText] = useState("");
+    control,
+    handleSubmit,
+    formState: { isSubmitting }
+  } = useForm<TForm>({
+    resolver: zodResolver(formSchema),
+    defaultValues: {
+      secretPath: "/",
+      vaultEnginePath: "",
+      vaultSecretPath: "",
+      selectedSourceEnvironment: ""
+    }
+  });
 
-  const [selectedSourceEnvironment, setSelectedSourceEnvironment] = useState("");
+  const handleFormSubmit = async (formData: TForm) => {
-  const [secretPath, setSecretPath] = useState("/");
-  const [isLoading, setIsLoading] = useState(false);
-
-  const isValidVaultPath = (vaultPath: string) => {
-    return !(vaultPath.length === 0 || vaultPath.startsWith("/") || vaultPath.endsWith("/"));
-  };
-
-  const handleButtonClick = async () => {
     try {
       if (!integrationAuth?.id) return;
-
-      if (!isValidVaultPath(vaultEnginePath)) {
-        setVaultEnginePathErrorText("Vault KV Secrets Engine Path must be valid like kv");
-      } else {
-        setVaultEnginePathErrorText("");
-      }
-
-      if (!isValidVaultPath(vaultSecretPath)) {
-        setVaultSecretPathErrorText("Vault Secret(s) Path must be valid like machine/dev");
-      } else {
-        setVaultSecretPathErrorText("");
-      }
-
-      if (!isValidVaultPath || !isValidVaultPath(vaultSecretPath)) return;
-
-      setIsLoading(true);
-
       await mutateAsync({
         integrationAuthId: integrationAuth?.id,
         isActive: true,
-        app: vaultEnginePath,
+        app: formData.vaultEnginePath,
-        sourceEnvironment: selectedSourceEnvironment,
+        sourceEnvironment: formData.selectedSourceEnvironment,
-        path: vaultSecretPath,
+        path: formData.vaultSecretPath,
-        secretPath
+        secretPath: formData.secretPath
       });
-
-      setIsLoading(false);
-
       router.push(`/integrations/${localStorage.getItem("projectData.id")}`);
     } catch (err) {
       console.error(err);
+      let errorMessage: string = "Something went wrong!";
+      if (axios.isAxiosError(err)) {
+        const { message } = err?.response?.data as { message: string };
+        errorMessage = message;
+      }
+
+      createNotification({
+        text: errorMessage,
+        type: "error"
+      });
     }
   };
 
@@ -100,7 +124,7 @@ export default function HashiCorpVaultCreateIntegrationPage() {
           subTitle="Select which environment or folder in Infisical you want to sync to which path in HashiCorp Vault."
         >
           <div className="flex flex-row items-center">
-            <div className="inline flex items-center">
+            <div className="inline-flex items-center">
               <Image
                 src="/images/integrations/Vault.png"
                 height={30}
@@ -123,63 +147,83 @@ export default function HashiCorpVaultCreateIntegrationPage() {
             </Link>
           </div>
         </CardTitle>
-        <FormControl label="Project Environment" className="px-6">
+        <CardBody>
-          <Select
+          <form onSubmit={handleSubmit(handleFormSubmit)} noValidate>
-            value={selectedSourceEnvironment}
+            <Controller
-            onValueChange={(val) => setSelectedSourceEnvironment(val)}
+              control={control}
-            className="w-full border border-mineshaft-500"
+              name="selectedSourceEnvironment"
-          >
+              render={({ field, fieldState: { error } }) => (
-            {workspace?.environments.map((sourceEnvironment) => (
+                <FormControl errorText={error?.message}
-              <SelectItem
+                isError={Boolean(error)} isRequired label="Project Environment" >
-                value={sourceEnvironment.slug}
+                  <Select
-                key={`vault-environment-${sourceEnvironment.slug}`}
+                    value={field.value}
-              >
+                    onValueChange={field.onChange}
-                {sourceEnvironment.name}
+                    className="w-full border border-mineshaft-500"
-              </SelectItem>
+                  >
-            ))}
+                    {workspace?.environments.map((sourceEnvironment) => (
-          </Select>
+                      <SelectItem
-        </FormControl>
+                        value={sourceEnvironment.slug}
-        <FormControl label="Secrets Path" className="px-6">
+                        key={`vault-environment-${sourceEnvironment.slug}`}
-          <Input
+                      >
-            value={secretPath}
+                        {sourceEnvironment.name}
-            onChange={(evt) => setSecretPath(evt.target.value)}
+                      </SelectItem>
-            placeholder="Provide a path, default is /"
+                    ))}
-          />
+                  </Select>
-        </FormControl>
+                </FormControl>
-        <FormControl
+              )}
-          label="Vault KV Secrets Engine Path"
+            />
-          errorText={vaultEnginePathErrorText}
+
-          isError={vaultEnginePathErrorText !== "" ?? false}
+            <Controller
-          className="px-6"
+              control={control}
-        >
+              name="secretPath"
-          <Input
+              render={({ field, fieldState: { error } }) => (
-            placeholder="kv"
+                <FormControl errorText={error?.message}
-            value={vaultEnginePath}
+                isError={Boolean(error)} isRequired label="Secrets Path" helperText="A path to your secrets in Infisical.">
-            onChange={(e) => setVaultEnginePath(e.target.value)}
+                  <Input {...field} autoCorrect="off" spellCheck={false} placeholder="/" />
-          />
+                </FormControl>
-        </FormControl>
+              )}
-        <FormControl
+            />
-          label="Vault Secret(s) Path"
+
-          errorText={vaultSecretPathErrorText}
+            <Controller
-          isError={vaultSecretPathErrorText !== "" ?? false}
+              control={control}
-          className="px-6"
+              name="vaultEnginePath"
-        >
+              render={({ field, fieldState: { error } }) => (
-          <Input
+                <FormControl
-            placeholder="machine/dev"
+                  label="Vault KV Secrets Engine Path"
-            value={vaultSecretPath}
+                  errorText={error?.message}
-            onChange={(e) => setVaultSecretPath(e.target.value)}
+                  isError={Boolean(error)}
-          />
+                  helperText="A path where your KV Secrets Engine is enabled."
-        </FormControl>
+                  isRequired
-        <Button
+                >
-          onClick={handleButtonClick}
+                  <Input autoCorrect="off" spellCheck={false} {...field} placeholder="kv" />
-          colorSchema="primary"
+                </FormControl>
-          variant="outline_bg"
+              )}
-          className="mb-6 mt-2 ml-auto mr-6 w-min"
+            />
-          isLoading={isLoading}
+
-          isDisabled={!(isValidVaultPath(vaultEnginePath) && isValidVaultPath(vaultSecretPath))}
+            <Controller
-        >
+              control={control}
-          Create Integration
+              name="vaultSecretPath"
-        </Button>
+              render={({ field, fieldState: { error } }) => (
+                <FormControl
+                  label="Vault Secret(s) Path"
+                  errorText={error?.message}
+                  isError={Boolean(error)}
+                  helperText="A path for storing secrets within the KV Secrets Engine."
+                  isRequired
+                >
+                  <Input autoCorrect="off" spellCheck={false} {...field} placeholder="machine/dev" />
+                </FormControl>
+              )}
+            />
+
+            <Button
+              type="submit"
+              isLoading={isSubmitting}
+            >
+              Create Integration
+            </Button>
+          </form>
+        </CardBody>
       </Card>
       <div className="mt-6 w-full max-w-md border-t border-mineshaft-800" />
       <div className="mt-6 flex w-full max-w-lg flex-col rounded-md border border-mineshaft-600 bg-mineshaft-800 p-4">

frontend/src/views/IntegrationsPage/components/IntegrationsSection/IntegrationsSection.tsx

@@ -238,7 +238,7 @@ export const IntegrationsSection = ({
                       }
                     >
                       <div className="flex items-center space-x-2 text-white">
-                        <div>Sync Status</div>
+                        <div>{integration.isSynced ? "Synced" : "Not synced"}</div>
                         {!integration.isSynced && <FontAwesomeIcon icon={faWarning} />}
                       </div>
                     </Tooltip>