feat: add LDAP support for dynamic secrets

backend/package-lock.json

@@ -61,10 +61,12 @@
         "jwks-rsa": "^3.1.0",
         "knex": "^3.0.1",
         "ldapjs": "^3.0.7",
+        "ldif": "^0.5.1",
         "libsodium-wrappers": "^0.7.13",
         "lodash.isequal": "^4.5.0",
         "mongodb": "^6.8.1",
         "ms": "^2.1.3",
+        "mustache": "^4.2.0",
         "mysql2": "^3.9.8",
         "nanoid": "^3.3.4",
         "nodemailer": "^6.9.9",
@@ -108,6 +110,7 @@
         "@types/jsrp": "^0.2.6",
         "@types/libsodium-wrappers": "^0.7.13",
         "@types/lodash.isequal": "^4.5.8",
+        "@types/mustache": "^4.2.5",
         "@types/node": "^20.9.5",
         "@types/nodemailer": "^6.4.14",
         "@types/passport-github": "^1.1.12",
@@ -7074,6 +7077,13 @@
       "resolved": "https://registry.npmjs.org/@types/ms/-/ms-0.7.34.tgz",
       "integrity": "sha512-nG96G3Wp6acyAgJqGasjODb+acrI7KltPiRxzHPXnP3NgI28bpQDRv53olbqGXbfcgF5aiiHmO3xpwEpS5Ld9g=="
     },
+    "node_modules/@types/mustache": {
+      "version": "4.2.5",
+      "resolved": "https://registry.npmjs.org/@types/mustache/-/mustache-4.2.5.tgz",
+      "integrity": "sha512-PLwiVvTBg59tGFL/8VpcGvqOu3L4OuveNvPi0EYbWchRdEVP++yRUXJPFl+CApKEq13017/4Nf7aQ5lTtHUNsA==",
+      "dev": true,
+      "license": "MIT"
+    },
     "node_modules/@types/node": {
       "version": "20.9.5",
       "resolved": "https://registry.npmjs.org/@types/node/-/node-20.9.5.tgz",
@@ -13008,6 +13018,12 @@
         "verror": "^1.10.1"
       }
     },
+    "node_modules/ldif": {
+      "version": "0.5.1",
+      "resolved": "https://registry.npmjs.org/ldif/-/ldif-0.5.1.tgz",
+      "integrity": "sha512-8s46m/r2lSFO2+DqMxqWiJ10iiL4tuR5LC/KndV+E5//OAOzOx5s3HS5O34PJ5+kyaCA+K2oCaEPaDRfXUnQow==",
+      "license": "MIT"
+    },
     "node_modules/leven": {
       "version": "2.1.0",
       "resolved": "https://registry.npmjs.org/leven/-/leven-2.1.0.tgz",
@@ -13704,6 +13720,15 @@
         "node": ">= 6"
       }
     },
+    "node_modules/mustache": {
+      "version": "4.2.0",
+      "resolved": "https://registry.npmjs.org/mustache/-/mustache-4.2.0.tgz",
+      "integrity": "sha512-71ippSywq5Yb7/tVYyGbkBggbU8H3u5Rz56fH60jGFgr8uHwxs+aSKeqmluIVzM0m0kB7xQjKS6qPfd0b2ZoqQ==",
+      "license": "MIT",
+      "bin": {
+        "mustache": "bin/mustache"
+      }
+    },
     "node_modules/mylas": {
       "version": "2.1.13",
       "resolved": "https://registry.npmjs.org/mylas/-/mylas-2.1.13.tgz",

backend/package.json

@@ -71,6 +71,7 @@
     "@types/jsrp": "^0.2.6",
     "@types/libsodium-wrappers": "^0.7.13",
     "@types/lodash.isequal": "^4.5.8",
+    "@types/mustache": "^4.2.5",
     "@types/node": "^20.9.5",
     "@types/nodemailer": "^6.4.14",
     "@types/passport-github": "^1.1.12",
@@ -158,10 +159,12 @@
     "jwks-rsa": "^3.1.0",
     "knex": "^3.0.1",
     "ldapjs": "^3.0.7",
+    "ldif": "^0.5.1",
     "libsodium-wrappers": "^0.7.13",
     "lodash.isequal": "^4.5.0",
     "mongodb": "^6.8.1",
     "ms": "^2.1.3",
+    "mustache": "^4.2.0",
     "mysql2": "^3.9.8",
     "nanoid": "^3.3.4",
     "nodemailer": "^6.9.9",

backend/src/ee/services/dynamic-secret/providers/index.ts

@@ -3,6 +3,7 @@ import { AwsIamProvider } from "./aws-iam";
 import { AzureEntraIDProvider } from "./azure-entra-id";
 import { CassandraProvider } from "./cassandra";
 import { ElasticSearchProvider } from "./elastic-search";
+import { LdapProvider } from "./ldap";
 import { DynamicSecretProviders } from "./models";
 import { MongoAtlasProvider } from "./mongo-atlas";
 import { MongoDBProvider } from "./mongo-db";
@@ -20,5 +21,6 @@ export const buildDynamicSecretProviders = () => ({
   [DynamicSecretProviders.MongoDB]: MongoDBProvider(),
   [DynamicSecretProviders.ElasticSearch]: ElasticSearchProvider(),
   [DynamicSecretProviders.RabbitMq]: RabbitMqProvider(),
-  [DynamicSecretProviders.AzureEntraID]: AzureEntraIDProvider()
+  [DynamicSecretProviders.AzureEntraID]: AzureEntraIDProvider(),
+  [DynamicSecretProviders.Ldap]: LdapProvider()
 });

backend/src/ee/services/dynamic-secret/providers/models.ts

@@ -174,6 +174,17 @@ export const AzureEntraIDSchema = z.object({
   clientSecret: z.string().trim().min(1)
 });
 
+export const LdapSchema = z.object({
+  url: z.string().trim().min(1),
+  binddn: z.string().trim().min(1),
+  bindpass: z.string().trim().min(1),
+  ca: z.string().optional(),
+
+  creationLdif: z.string().trim().min(1),
+  revocationLdif: z.string().trim().min(1),
+  rollbackLdif: z.string().trim().min(1)
+});
+
 export enum DynamicSecretProviders {
   SqlDatabase = "sql-database",
   Cassandra = "cassandra",
@@ -184,7 +195,8 @@ export enum DynamicSecretProviders {
   ElasticSearch = "elastic-search",
   MongoDB = "mongo-db",
   RabbitMq = "rabbit-mq",
-  AzureEntraID = "azure-entra-id"
+  AzureEntraID = "azure-entra-id",
+  Ldap = "ldap"
 }
 
 export const DynamicSecretProviderSchema = z.discriminatedUnion("type", [
@@ -197,7 +209,8 @@ export const DynamicSecretProviderSchema = z.discriminatedUnion("type", [
   z.object({ type: z.literal(DynamicSecretProviders.ElasticSearch), inputs: DynamicSecretElasticSearchSchema }),
   z.object({ type: z.literal(DynamicSecretProviders.MongoDB), inputs: DynamicSecretMongoDBSchema }),
   z.object({ type: z.literal(DynamicSecretProviders.RabbitMq), inputs: DynamicSecretRabbitMqSchema }),
-  z.object({ type: z.literal(DynamicSecretProviders.AzureEntraID), inputs: AzureEntraIDSchema })
+  z.object({ type: z.literal(DynamicSecretProviders.AzureEntraID), inputs: AzureEntraIDSchema }),
+  z.object({ type: z.literal(DynamicSecretProviders.Ldap), inputs: LdapSchema })
 ]);
 
 export type TDynamicProviderFns = {

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

@@ -25,7 +25,8 @@ export enum DynamicSecretProviders {
   ElasticSearch = "elastic-search",
   MongoDB = "mongo-db",
   RabbitMq = "rabbit-mq",
-  AzureEntraId = "azure-entra-id"
+  AzureEntraId = "azure-entra-id",
+  Ldap = "ldap"
 }
 
 export enum SqlProviders {
@@ -188,7 +189,20 @@ export type TDynamicSecretProvider =
         applicationId: string;
         clientSecret: string;
       };
-  };
+  }
+  | {
+      type: DynamicSecretProviders.Ldap;
+      inputs: {
+        url: string;
+        binddn: string;
+        bindpass: string;
+        ca?: string | undefined;
+        creationLdif: string;
+        revocationLdif: string;
+        rollbackLdif: string;
+      };
+    };
+  ;
 
 export type TCreateDynamicSecretDTO = {
   projectSlug: string;

frontend/src/views/SecretMainPage/components/ActionBar/CreateDynamicSecretForm/CreateDynamicSecretForm.tsx

@@ -14,6 +14,7 @@ import { AwsIamInputForm } from "./AwsIamInputForm";
 import { AzureEntraIdInputForm } from "./AzureEntraIdInputForm";
 import { CassandraInputForm } from "./CassandraInputForm";
 import { ElasticSearchInputForm } from "./ElasticSearchInputForm";
+import { LdapInputForm } from "./LdapInputForm";
 import { MongoAtlasInputForm } from "./MongoAtlasInputForm";
 import { MongoDBDatabaseInputForm } from "./MongoDBInputForm";
 import { RabbitMqInputForm } from "./RabbitMqInputForm";
@@ -83,6 +84,11 @@ const DYNAMIC_SECRET_LIST = [
     icon: <SiMicrosoftazure size="1.5rem" />,
     provider: DynamicSecretProviders.AzureEntraId,
     title: "Azure Entra ID",
+  },
+  {
+    icon: <SiMicrosoftazure size="1.5rem" />,
+    provider: DynamicSecretProviders.Ldap,
+    title: "LDAP",
   }
 ];
 
@@ -325,6 +331,26 @@ export const CreateDynamicSecretForm = ({
               </motion.div>
             )
           }
+          {wizardStep === WizardSteps.ProviderInputs &&
+            selectedProvider === DynamicSecretProviders.Ldap && (
+              <motion.div
+                key="dynamic-ldap-step"
+                transition={{ duration: 0.1 }}
+                initial={{ opacity: 0, translateX: 30 }}
+                animate={{ opacity: 1, translateX: 0 }}
+                exit={{ opacity: 0, translateX: -30 }}
+              >
+                <LdapInputForm
+                  onCompleted={handleFormReset}
+                  onCancel={handleFormReset}
+                  projectSlug={projectSlug}
+                  secretPath={secretPath}
+                  environment={environment}
+                />
+              </motion.div>
+            )
+          }
+
         </AnimatePresence>
       </ModalContent>
     </Modal>

frontend/src/views/SecretMainPage/components/ActionBar/CreateDynamicSecretForm/LdapInputForm.tsx

@@ -0,0 +1,283 @@
+import { Controller, useForm } from "react-hook-form";
+import { zodResolver } from "@hookform/resolvers/zod";
+import ms from "ms";
+import { z } from "zod";
+
+import { TtlFormLabel } from "@app/components/features";
+import { createNotification } from "@app/components/notifications";
+import { Button, FormControl, Input, TextArea } from "@app/components/v2";
+import { useCreateDynamicSecret } from "@app/hooks/api";
+import { DynamicSecretProviders } from "@app/hooks/api/dynamicSecret/types";
+
+const formSchema = z.object({
+    provider: z.object({
+        url: z.string().trim().min(1),
+        binddn: z.string().trim().min(1),
+        bindpass: z.string().trim().min(1),
+        ca: z.string().optional(),
+
+        creationLdif: z.string().trim().min(1),
+        revocationLdif: z.string().trim().min(1),
+        rollbackLdif: z.string().trim().min(1),
+    }),
+
+    defaultTTL: z.string().superRefine((val, ctx) => {
+        const valMs = ms(val);
+        if (valMs < 60 * 1000)
+            ctx.addIssue({ code: z.ZodIssueCode.custom, message: "TTL must be a greater than 1min" });
+        // a day
+        if (valMs > 24 * 60 * 60 * 1000)
+            ctx.addIssue({ code: z.ZodIssueCode.custom, message: "TTL must be less than a day" });
+    }),
+    maxTTL: z
+        .string()
+        .optional()
+        .superRefine((val, ctx) => {
+            if (!val) return;
+            const valMs = ms(val);
+            if (valMs < 60 * 1000)
+                ctx.addIssue({ code: z.ZodIssueCode.custom, message: "TTL must be a greater than 1min" });
+            // a day
+            if (valMs > 24 * 60 * 60 * 1000)
+                ctx.addIssue({ code: z.ZodIssueCode.custom, message: "TTL must be less than a day" });
+        }),
+    name: z.string().refine((val) => val.toLowerCase() === val, "Must be lowercase")
+});
+
+type TForm = z.infer<typeof formSchema>;
+
+type Props = {
+    onCompleted: () => void;
+    onCancel: () => void;
+    secretPath: string;
+    projectSlug: string;
+    environment: string;
+};
+
+export const LdapInputForm = (
+    {
+        onCompleted,
+        onCancel,
+        secretPath,
+        projectSlug,
+        environment,
+    }: Props
+) => {
+    const {
+        control,
+        formState: { isSubmitting },
+        handleSubmit
+    } = useForm<TForm>({
+        resolver: zodResolver(formSchema),
+        defaultValues: {
+            provider: {
+                url: "",
+                binddn: "",
+                bindpass: "",
+                ca: "",
+                creationLdif: "",
+                revocationLdif: "",
+                rollbackLdif: ""
+            },
+        }
+    });
+
+    const createDynamicSecret = useCreateDynamicSecret();
+
+    const handleCreateDynamicSecret = async ({ name, maxTTL, provider, defaultTTL }: TForm) => {
+        // wait till previous request is finished
+        if (createDynamicSecret.isLoading) return;
+        try {
+            await createDynamicSecret.mutateAsync({
+                provider: { type: DynamicSecretProviders.Ldap, inputs: provider },
+                maxTTL,
+                name,
+                path: secretPath,
+                defaultTTL,
+                projectSlug,
+                environmentSlug: environment
+            });
+            onCompleted();
+        } catch (err) {
+            createNotification({
+                type: "error",
+                text: "Failed to create dynamic secret"
+            });
+        }
+    };
+
+    return (
+        <form onSubmit={handleSubmit(handleCreateDynamicSecret)} autoComplete="off">
+                <div>
+                    <div className="flex items-center space-x-2">
+                        <div className="flex-grow">
+                            <Controller
+                                control={control}
+                                defaultValue=""
+                                name="name"
+                                render={({ field, fieldState: { error } }) => (
+                                    <FormControl
+                                        label="Secret Name"
+                                        isError={Boolean(error)}
+                                        errorText={error?.message}
+                                    >
+                                        <Input {...field} placeholder="dynamic-secret" />
+                                    </FormControl>
+                                )}
+                            />
+                        </div>
+                        <div className="w-32">
+                            <Controller
+                                control={control}
+                                name="defaultTTL"
+                                defaultValue="1h"
+                                render={({ field, fieldState: { error } }) => (
+                                    <FormControl
+                                        label={<TtlFormLabel label="Default TTL" />}
+                                        isError={Boolean(error?.message)}
+                                        errorText={error?.message}
+                                    >
+                                        <Input {...field} />
+                                    </FormControl>
+                                )}
+                            />
+                        </div>
+                        <div className="w-32">
+                            <Controller
+                                control={control}
+                                name="maxTTL"
+                                defaultValue="24h"
+                                render={({ field, fieldState: { error } }) => (
+                                    <FormControl
+                                        label={<TtlFormLabel label="Max TTL" />}
+                                        isError={Boolean(error?.message)}
+                                        errorText={error?.message}
+                                    >
+                                        <Input {...field} />
+                                    </FormControl>
+                                )}
+                            />
+                        </div>
+                    </div>
+                    <div>
+                        <div className="mb-4 mt-4 border-b border-mineshaft-500 pb-2 pl-1 font-medium text-mineshaft-200">
+                            Configuration
+                        </div>
+                        <div className="flex flex-col">
+                            <div className="flex items-center space-x-2">
+                                <div className="flex-grow">
+                                    <Controller
+                                        control={control}
+                                        name="provider.url"
+                                        render={({ field, fieldState: { error } }) => (
+                                            <FormControl
+                                                label="URL"
+                                                isError={Boolean(error?.message)}
+                                                errorText={error?.message}
+                                            >
+                                                <Input {...field} />
+                                            </FormControl>
+                                        )}
+                                    />
+
+                                    <Controller
+                                        control={control}
+                                        name="provider.binddn"
+                                        render={({ field, fieldState: { error } }) => (
+                                            <FormControl
+                                                label="Bind DN"
+                                                isError={Boolean(error?.message)}
+                                                errorText={error?.message}
+                                            >
+                                                <Input {...field} />
+                                            </FormControl>
+                                        )}
+                                    />
+
+                                    <Controller
+                                        control={control}
+                                        name="provider.bindpass"
+                                        render={({ field, fieldState: { error } }) => (
+                                            <FormControl
+                                                label="Bind Password"
+                                                isError={Boolean(error?.message)}
+                                                errorText={error?.message}
+                                            >
+                                                <Input {...field} />
+                                            </FormControl>
+                                        )}
+                                    />
+
+                                    <Controller
+                                        control={control}
+                                        name="provider.ca"
+                                        render={({ field, fieldState: { error } }) => (
+                                            <FormControl
+                                                label="CA"
+                                                isError={Boolean(error?.message)}
+                                                errorText={error?.message}
+                                            >
+                                                <TextArea {...field} placeholder="-----BEGIN CERTIFICATE----- ..." />    
+                                            </FormControl>
+                                        )}
+                                    />
+
+                                    <Controller
+                                        control={control}
+                                        name="provider.creationLdif"
+                                        render={({ field, fieldState: { error } }) => (
+                                            <FormControl
+                                                label="Creation LDIF"
+                                                isError={Boolean(error?.message)}
+                                                errorText={error?.message}
+                                            >
+                                                <TextArea {...field} />
+                                            </FormControl>
+                                        )}
+                                    />
+
+                                    <Controller
+                                        control={control}
+                                        name="provider.revocationLdif"
+                                        render={({ field, fieldState: { error } }) => (
+                                            <FormControl
+                                                label="Revocation LDIF"
+                                                isError={Boolean(error?.message)}
+                                                errorText={error?.message}
+                                            >
+                                                <TextArea {...field} />
+                                            </FormControl>
+                                        )}
+                                    />
+
+                                    <Controller
+                                        control={control}
+                                        name="provider.rollbackLdif"
+                                        render={({ field, fieldState: { error } }) => (
+                                            <FormControl
+                                                label="Rollback LDIF"
+                                                isError={Boolean(error?.message)}
+                                                errorText={error?.message}
+                                            >
+                                                <TextArea {...field} />
+                                            </FormControl>
+                                        )}
+                                    />
+
+
+                                </div>
+                            </div>
+                        </div>
+                    </div>
+                </div>
+                <div className="mt-4 flex items-center space-x-4">
+                    <Button type="submit" isLoading={isSubmitting}>
+                        Submit
+                    </Button>
+                    <Button variant="outline_bg" onClick={onCancel}>
+                        Cancel
+                    </Button>
+                </div>
+            </form>
+    )
+};

frontend/src/views/SecretMainPage/components/DynamicSecretListView/CreateDynamicSecretLease.tsx

@@ -194,6 +194,31 @@ const renderOutputForm = (provider: DynamicSecretProviders, data: unknown) => {
     );
   }
 
+  if (provider === DynamicSecretProviders.Ldap) {
+    const { USERNAME, PASSWORD, DN_ARRAY } = data as {
+      USERNAME: string;
+      PASSWORD: string;
+      DN_ARRAY: string[];
+    };
+
+    return (
+      <div>
+        <OutputDisplay label="Username" value={USERNAME} />
+        <OutputDisplay
+          label="Password"
+          value={PASSWORD}
+          helperText="Important: Copy these credentials now. You will not be able to see them again after you close the modal."
+        />
+        <SecretInput
+          isReadOnly
+          isVisible
+          value={JSON.stringify(DN_ARRAY)}
+          containerClassName="text-bunker-300 hover:border-primary-400/50 border border-mineshaft-600 bg-mineshaft-900 px-2 py-1.5"
+        />
+      </div>
+    );
+  }
+
   return null;
 };
 

frontend/src/views/SecretMainPage/components/DynamicSecretListView/EditDynamicSecretForm/EditDynamicSecretForm.tsx

@@ -9,6 +9,7 @@ import { EditDynamicSecretAwsIamForm } from "./EditDynamicSecretAwsIamForm";
 import { EditDynamicSecretAzureEntraIdForm } from "./EditDynamicSecretAzureEntraIdForm";
 import { EditDynamicSecretCassandraForm } from "./EditDynamicSecretCassandraForm";
 import { EditDynamicSecretElasticSearchForm } from "./EditDynamicSecretElasticSearchForm";
+import { EditDynamicSecretLdapForm } from "./EditDynamicSecretLdapForm";
 import { EditDynamicSecretMongoAtlasForm } from "./EditDynamicSecretMongoAtlasForm";
 import { EditDynamicSecretMongoDBForm } from "./EditDynamicSecretMongoDBForm";
 import { EditDynamicSecretRabbitMqForm } from "./EditDynamicSecretRabbitMqForm";
@@ -221,6 +222,24 @@ export const EditDynamicSecretForm = ({
           />
         </motion.div>
       )}
+
+      {dynamicSecretDetails?.type === DynamicSecretProviders.Ldap && (
+        <motion.div
+          key="ldap-edit"
+          transition={{ duration: 0.1 }}
+          initial={{ opacity: 0, translateX: 30 }}
+          animate={{ opacity: 1, translateX: 0 }}
+          exit={{ opacity: 0, translateX: -30 }}
+          >
+            <EditDynamicSecretLdapForm
+              onClose={onClose}
+              projectSlug={projectSlug}
+              secretPath={secretPath}
+              dynamicSecret={dynamicSecretDetails}
+              environment={environment}
+            />
+          </motion.div>
+        )}
     </AnimatePresence>
   );
 };

frontend/src/views/SecretMainPage/components/DynamicSecretListView/EditDynamicSecretForm/EditDynamicSecretLdapForm.tsx

@@ -0,0 +1,268 @@
+import { Controller, useForm } from "react-hook-form";
+import { zodResolver } from "@hookform/resolvers/zod";
+import ms from "ms";
+import { z } from "zod";
+
+import { TtlFormLabel } from "@app/components/features";
+import { createNotification } from "@app/components/notifications";
+import { Button, FormControl, Input, TextArea } from "@app/components/v2";
+import { useUpdateDynamicSecret } from "@app/hooks/api";
+import { TDynamicSecret } from "@app/hooks/api/dynamicSecret/types";
+
+const formSchema = z.object({
+  inputs: z
+    .object({
+        url: z.string().trim().min(1),
+        binddn: z.string().trim().min(1),
+        bindpass: z.string().trim().min(1),
+        ca: z.string().optional(),
+        creationLdif: z.string().trim().min(1),
+        revocationLdif: z.string().trim().min(1),
+        rollbackLdif: z.string().trim().min(1),
+    })
+    .partial(),
+  defaultTTL: z.string().superRefine((val, ctx) => {
+    const valMs = ms(val);
+    if (valMs < 60 * 1000)
+      ctx.addIssue({ code: z.ZodIssueCode.custom, message: "TTL must be a greater than 1min" });
+    // a day
+    if (valMs > 24 * 60 * 60 * 1000)
+      ctx.addIssue({ code: z.ZodIssueCode.custom, message: "TTL must be less than a day" });
+  }),
+  maxTTL: z
+    .string()
+    .optional()
+    .superRefine((val, ctx) => {
+      if (!val) return;
+      const valMs = ms(val);
+      if (valMs < 60 * 1000)
+        ctx.addIssue({ code: z.ZodIssueCode.custom, message: "TTL must be a greater than 1min" });
+      // a day
+      if (valMs > 24 * 60 * 60 * 1000)
+        ctx.addIssue({ code: z.ZodIssueCode.custom, message: "TTL must be less than a day" });
+    })
+    .nullable(),
+  newName: z
+    .string()
+    .refine((val) => val.toLowerCase() === val, "Must be lowercase")
+    .optional()
+});
+type TForm = z.infer<typeof formSchema>;
+
+type Props = {
+  onClose: () => void;
+  dynamicSecret: TDynamicSecret & { inputs: unknown };
+  secretPath: string;
+  environment: string;
+  projectSlug: string;
+};
+
+export const EditDynamicSecretLdapForm = ({
+    onClose,
+    dynamicSecret,
+    environment,
+    secretPath,
+    projectSlug
+  }: Props) => {
+    const {
+      control,
+      formState: { isSubmitting },
+      handleSubmit
+    } = useForm<TForm>({
+      resolver: zodResolver(formSchema),
+      values: {
+        defaultTTL: dynamicSecret.defaultTTL,
+        maxTTL: dynamicSecret.maxTTL,
+        newName: dynamicSecret.name,
+        inputs: {
+          ...(dynamicSecret.inputs as TForm["inputs"])
+        }
+      }
+    });
+  
+    const updateDynamicSecret = useUpdateDynamicSecret();
+  
+    const handleUpdateDynamicSecret = async ({ inputs, maxTTL, defaultTTL, newName }: TForm) => {
+      // wait till previous request is finished
+      if (updateDynamicSecret.isLoading) return;
+      try {
+        await updateDynamicSecret.mutateAsync({
+          name: dynamicSecret.name,
+          path: secretPath,
+          projectSlug,
+          environmentSlug: environment,
+          data: {
+            maxTTL: maxTTL || undefined,
+            defaultTTL,
+            inputs,
+            newName: newName === dynamicSecret.name ? undefined : newName
+          }
+        });
+        onClose();
+        createNotification({
+          type: "success",
+          text: "Successfully updated dynamic secret"
+        });
+      } catch (err) {
+        createNotification({
+          type: "error",
+          text: "Failed to update dynamic secret"
+        });
+      }
+    };
+  
+    return (
+      <div>
+        <form onSubmit={handleSubmit(handleUpdateDynamicSecret)} autoComplete="off">
+        <div className="flex items-center space-x-2">
+          <div className="flex-grow">
+            <Controller
+              control={control}
+              name="newName"
+              render={({ field, fieldState: { error } }) => (
+                <FormControl
+                  label="Secret Name"
+                  isError={Boolean(error)}
+                  errorText={error?.message}
+                >
+                  <Input {...field} placeholder="DYN-1" />
+                </FormControl>
+              )}
+            />
+          </div>
+          <div className="w-32">
+            <Controller
+              control={control}
+              name="defaultTTL"
+              render={({ field, fieldState: { error } }) => (
+                <FormControl
+                  label={<TtlFormLabel label="Default TTL" />}
+                  isError={Boolean(error?.message)}
+                  errorText={error?.message}
+                >
+                  <Input {...field} />
+                </FormControl>
+              )}
+            />
+          </div>
+          <div className="w-32">
+            <Controller
+              control={control}
+              name="maxTTL"
+              render={({ field, fieldState: { error } }) => (
+                <FormControl
+                  label={<TtlFormLabel label="Max TTL" />}
+                  isError={Boolean(error?.message)}
+                  errorText={error?.message}
+                >
+                  <Input {...field} value={field.value || ""} />
+                </FormControl>
+              )}
+            />
+          </div>
+        </div>
+        <div className="mt-4">
+            <Controller
+                control={control}
+                name="inputs.url"
+                render={({ field, fieldState: { error } }) => (
+                <FormControl
+                    label="URL"
+                    isError={Boolean(error)}
+                    errorText={error?.message}
+                >
+                    <Input {...field} />
+                </FormControl>
+                )}
+            />
+            <Controller
+                control={control}
+                name="inputs.binddn"
+                render={({ field, fieldState: { error } }) => (
+                <FormControl
+                    label="Bind DN"
+                    isError={Boolean(error)}
+                    errorText={error?.message}
+                >
+                    <Input {...field} />
+                </FormControl>
+                )}
+            />
+            <Controller
+                control={control}
+                name="inputs.bindpass"
+                render={({ field, fieldState: { error } }) => (
+                <FormControl
+                    label="Bind Password"
+                    isError={Boolean(error)}
+                    errorText={error?.message}
+                >
+                    <Input {...field} />
+                </FormControl>
+                )}
+            />
+            <Controller
+                control={control}
+                name="inputs.ca"
+                render={({ field, fieldState: { error } }) => (
+                    <FormControl
+                    label="CA"
+                    isError={Boolean(error)}
+                    errorText={error?.message}
+                    >
+                    <TextArea {...field} />
+                </FormControl>
+                )}
+                />
+            <Controller
+                control={control}
+                name="inputs.creationLdif"
+                render={({ field, fieldState: { error } }) => (
+                    <FormControl
+                    label="Creation LDIF"
+                    isError={Boolean(error)}
+                    errorText={error?.message}
+                    >
+                    <TextArea {...field} />
+                </FormControl>
+                )}
+                />
+            <Controller
+                control={control}
+                name="inputs.revocationLdif"
+                render={({ field, fieldState: { error } }) => (
+                    <FormControl
+                    label="Revocation LDIF"
+                    isError={Boolean(error)}
+                    errorText={error?.message}
+                    >
+                    <TextArea {...field} />
+                </FormControl>
+                )}
+            />
+            <Controller
+                control={control}
+                name="inputs.rollbackLdif"
+                render={({ field, fieldState: { error } }) => (
+                    <FormControl
+                    label="Rollback LDIF"
+                    isError={Boolean(error)}
+                    errorText={error?.message}
+                    >
+                    <TextArea {...field} />
+                </FormControl>
+                )}
+            />
+            </div>
+            <div className="mt-4 flex items-center space-x-4">
+                <Button type="submit" isLoading={isSubmitting}>
+                    Submit
+                </Button>
+                <Button variant="outline_bg" onClick={onClose}>
+                    Cancel
+                </Button>
+            </div>
+      </form>
+      </div>
+    )
+}