@docupace/pipeline 1.0.24-alpha-4 → 1.0.24

package/src/auth0/alias.js

@@ -1,75 +1,75 @@
-import axios from 'axios';
-
-import {
-  createAlias
-} from '../next/alias.js';
-
-import {getAuth0AuthToken} from './configure.js';
-
-import {
-  getVaultSecrets,
-} from './vault.js';
-
-import {
-  getVaultSecretsConfigs,
-} from '../next/config.js';
-
-import {
-  cloneEnvRepository,
-  readDeployConfig,
-} from '../next/deploy.js';
-
-export async function getCCAlias ({application, auth0Domain, auth0AuthToken}){
-  console.log(`Forming alias name for application ${application}...`);
-
-  try {
-    const auth0Response = await axios.get(`https://${auth0Domain}/api/v2/clients`, {
-      headers: {authorization: `Bearer ${auth0AuthToken}`},
-    });
-
-    const appAuth0ClientIdData = auth0Response.data.find(client => client.name === `${application}`);
-    const appAuth0ClientId = appAuth0ClientIdData.client_id;
-
-    console.log(`Client Credentials Alias: ${appAuth0ClientId}@clients`);
-    return `${appAuth0ClientId}@clients`;
-  } catch (err) {
-    console.error(`Failed to form alias name for application: ${application}: ${err.message}`);
-  }
-}
-
-export async function configureAlias(site, env, username, password, realm) {
-
-  console.log(`Creating alias for site: ${site} in env: ${env}`);
-
-  const commonSecretsPath = getVaultSecretsConfigs(site).commonSecretsPath;
-  console.log(`commonSecretsPath => ${commonSecretsPath}`)
-  const commonSecrets = await getVaultSecrets(commonSecretsPath);
-
-  // Site Common Secrets
-  const siteCommonSecretsPath = getVaultSecretsConfigs(site).siteCommonSecretsPath;
-  console.log(`siteCommonSecretsPath => ${siteCommonSecretsPath}`)
-  const siteCommonSecrets = await getVaultSecrets(siteCommonSecretsPath);
-
-  const auth0Domain = `docupace-${env}-${site}.us.auth0.com`
-  const auth0ClientId = siteCommonSecrets.AUTH0_CLIENT_ID;
-  const auth0ClientSecret = siteCommonSecrets.AUTH0_CLIENT_SECRET;
-  const auth0Token = await getAuth0AuthToken(auth0Domain, auth0ClientId, auth0ClientSecret);
-
-  await cloneEnvRepository(env);
-
-  const { deployConfig: deployGraphQLServerConfig} = await readDeployConfig('graphql-server', env, site, 'values');
-  const coreUrl = deployGraphQLServerConfig.graphqlServer.coreUrl;
-
-  const clientCredentialsAlias = await getCCAlias({
-    application: 'docupace-graphql-client-credentials',
-    auth0Domain: auth0Domain,
-    auth0AuthToken: auth0Token
-  });
-
-  await createAlias(
-    coreUrl,
-    username,
-    password,
-    realm,
-    clientCredentialsAlias);
-}
+import axios from 'axios';
+
+import {
+  createAlias
+} from '../next/alias.js';
+
+import {getAuth0AuthToken} from './configure.js';
+
+import {
+  getVaultSecrets,
+} from './vault.js';
+
+import {
+  getVaultSecretsConfigs,
+} from '../next/config.js';
+
+import {
+  cloneEnvRepository,
+  readDeployConfig,
+} from '../next/deploy.js';
+
+export async function getCCAlias ({application, auth0Domain, auth0AuthToken}){
+  console.log(`Forming alias name for application ${application}...`);
+
+  try {
+    const auth0Response = await axios.get(`https://${auth0Domain}/api/v2/clients`, {
+      headers: {authorization: `Bearer ${auth0AuthToken}`},
+    });
+
+    const appAuth0ClientIdData = auth0Response.data.find(client => client.name === `${application}`);
+    const appAuth0ClientId = appAuth0ClientIdData.client_id;
+
+    console.log(`Client Credentials Alias: ${appAuth0ClientId}@clients`);
+    return `${appAuth0ClientId}@clients`;
+  } catch (err) {
+    console.error(`Failed to form alias name for application: ${application}: ${err.message}`);
+  }
+}
+
+export async function configureAlias(site, env, username, password, realm) {
+
+  console.log(`Creating alias for site: ${site} in env: ${env}`);
+
+  const commonSecretsPath = getVaultSecretsConfigs(site).commonSecretsPath;
+  console.log(`commonSecretsPath => ${commonSecretsPath}`)
+  const commonSecrets = await getVaultSecrets(commonSecretsPath);
+
+  // Site Common Secrets
+  const siteCommonSecretsPath = getVaultSecretsConfigs(site).siteCommonSecretsPath;
+  console.log(`siteCommonSecretsPath => ${siteCommonSecretsPath}`)
+  const siteCommonSecrets = await getVaultSecrets(siteCommonSecretsPath);
+
+  const auth0Domain = `docupace-${env}-${site}.us.auth0.com`
+  const auth0ClientId = siteCommonSecrets.AUTH0_CLIENT_ID;
+  const auth0ClientSecret = siteCommonSecrets.AUTH0_CLIENT_SECRET;
+  const auth0Token = await getAuth0AuthToken(auth0Domain, auth0ClientId, auth0ClientSecret);
+
+  await cloneEnvRepository(env);
+
+  const { deployConfig: deployGraphQLServerConfig} = await readDeployConfig('graphql-server', env, site, 'values');
+  const coreUrl = deployGraphQLServerConfig.graphqlServer.coreUrl;
+
+  const clientCredentialsAlias = await getCCAlias({
+    application: 'docupace-graphql-client-credentials',
+    auth0Domain: auth0Domain,
+    auth0AuthToken: auth0Token
+  });
+
+  await createAlias(
+    coreUrl,
+    username,
+    password,
+    realm,
+    clientCredentialsAlias);
+}

package/src/auth0/cli.js

@@ -1,42 +1,41 @@
-#!/usr/bin/env node
-
-import { Command } from 'commander';
-import {
-  configureFromSite
-} from './configure.js';
-import {
-  getVaultSecrets
-} from './vault.js'
-
-import dotenv from 'dotenv';
-import {
-  configureAlias
-} from "./alias.js";
-
-dotenv.config({ path: ['.env.pipeline.local', 'config/.env.pipeline.local'] });
-
-const program = new Command();
-
-program
-    .command('configureFromSite <fromSite> <toSite> <fromEnv> <toEnv> <deployUI> <deployGraphQLServer> <useNewDomain>')
-    .description('Configure the Auth0 tenants in env for the given site')
-    .action(async (fromSite, toSite, fromEnv,toEnv, deployUI, deployGraphQLServer, useNewDomain) => {
-        await configureFromSite(fromSite, toSite, fromEnv, toEnv, deployUI, deployGraphQLServer, useNewDomain);
-    });
-
-program
-  .command('getVaultSecrets <vaultPath>')
-  .description('Get Secrets for Vault PATH')
-  .action(async (vaultPath) => {
-    const data = await getVaultSecrets(vaultPath);
-    console.log(JSON.stringify(data, 'null', 2));
-  });
-
-program
-  .command('configureAlias <site> <env> <username> <password> <realm>')
-  .description('Configure Core Alias for the given site')
-  .action(async (site, env, username, password, realm) => {
-    await configureAlias(site, env, username, password, realm);
-  });
-
-program.parse(process.argv);
+#!/usr/bin/env node
+
+import { Command } from 'commander';
+import {
+  configureFromSite
+} from './configure.js';
+import {
+  getVaultSecrets
+} from './vault.js'
+
+import dotenv from 'dotenv';
+import {
+  configureAlias
+} from "./alias.js";
+
+dotenv.config({ path: ['.env.pipeline.local', 'config/.env.pipeline.local'] });
+
+const program = new Command();
+
+program
+    .command('configureFromSite <fromSite> <toSite> <fromEnv> <toEnv> <deployUI> <deployGraphQLServer> <useNewDomain> <configureMFA>')
+    .description('Configure the Auth0 tenants in env for the given site')
+    .action(async (fromSite, toSite, fromEnv,toEnv, deployUI, deployGraphQLServer, useNewDomain, configureMFA) => {
+        await configureFromSite(fromSite, toSite, fromEnv, toEnv, deployUI, deployGraphQLServer, useNewDomain, configureMFA);
+    });
+
+program
+  .command('getVaultSecrets <vaultPath>')
+  .description('Get Secrets for Vault PATH')
+  .action(async (vaultPath) => {
+    await getVaultSecrets(vaultPath);
+  });
+
+program
+  .command('configureAlias <site> <env> <username> <password> <realm>')
+  .description('Configure Core Alias for the given site')
+  .action(async (site, env, username, password, realm) => {
+    await configureAlias(site, env, username, password, realm);
+  });
+
+program.parse(process.argv);

package/src/auth0/configure.js

@@ -2,6 +2,7 @@ import fs from 'fs';
 import path from 'path';
 import axios from 'axios';
 import crypto from 'crypto';
+import { deploy } from 'auth0-deploy-cli';
 import fl from 'fs/promises';
 
 import {
@@ -53,6 +54,297 @@ async function copyDirectory(source, destination) {
   }
 }
 
+async function addApplicationToApi ({application, auth0Domain, auth0AuthToken, coreApiIdentifier}){
+  console.log("Adding application to API authorized applications...");
+
+  try {
+    const auth0Response = await axios.get(`https://${auth0Domain}/api/v2/clients`, {
+      headers: {authorization: `Bearer ${auth0AuthToken}`},
+    });
+
+    const appAuth0ClientIdData = auth0Response.data.find(client => client.name === `${application}`);
+    const appAuth0ClientId = appAuth0ClientIdData.client_id;
+
+    await axios.post(
+          `https://${auth0Domain}/api/v2/client-grants`,
+      {
+        client_id: appAuth0ClientId,
+        audience: `${coreApiIdentifier}`,
+        scope: [],
+      },
+      {
+        headers: {
+          Authorization: `Bearer ${auth0AuthToken}`,
+          "Content-Type": "application/json",
+        },
+      }
+    );
+    console.log(`Application (${appAuth0ClientId}) authorized for API: ${coreApiIdentifier}`);
+  } catch (err) {
+    console.error(`Failed to add application: ${application}: ${err.message}`);
+  }
+
+}
+
+async function initializeAuth0Configuration({
+                                              initConfiguration,
+                                              auth0Domain,
+                                              auth0AuthToken,
+                                              coreApiIdentifier,
+                                            }) {
+  if (initConfiguration === "true") {
+    try {
+      // Create a new resource server in Auth0
+      console.log("Creating resource server in Auth0...");
+
+      const resourceServerResponse = await axios.post(
+        `https://${auth0Domain}/api/v2/resource-servers`,
+        {
+          name: "docupace-core",
+          identifier: `${coreApiIdentifier}`,
+          token_lifetime: 86400,
+          allow_offline_access: false,
+          signing_alg: "RS256",
+          skip_consent_for_verifiable_first_party_clients: true,
+          scopes: [],
+        },
+        {
+          headers: {
+            Authorization: `Bearer ${auth0AuthToken}`,
+            "Content-Type": "application/json",
+          },
+        }
+      );
+
+      const apiId = resourceServerResponse.data.id;
+
+      // Update tenant settings with the default audience
+      console.log("Updating tenant settings...");
+      await axios.patch(
+        `https://${auth0Domain}/api/v2/tenants/settings`,
+        {
+          default_audience: `${coreApiIdentifier}`,
+        },
+        {
+          headers: {
+            Authorization: `Bearer ${auth0AuthToken}`,
+            "Content-Type": "application/json",
+          },
+        }
+      );
+      console.log("Tenant settings updated successfully.");
+    } catch (error) {
+      console.error("Error during Auth0 configuration:", error.response?.data || error.message);
+    }
+  }
+}
+
+async function importAuth0Templates(directoryPath, auth0Domain, auth0ClientID, auth0ClientSecret) {
+  try {
+    const config = {
+      input_file: directoryPath,
+      config: {
+        AUTH0_DOMAIN: auth0Domain,
+        AUTH0_CLIENT_ID: auth0ClientID,
+        AUTH0_CLIENT_SECRET: auth0ClientSecret,
+      },
+      debug: true,
+    };
+
+    console.log('Starting Auth0 template import...');
+    await deploy(config);
+    console.log('Auth0 template import completed successfully!');
+  } catch (error) {
+    console.error('Error during Auth0 template import:', error.message);
+    process.exit(1); // Exit with an error code
+  }
+}
+
+async function updateJsonFile(filePath, updates) {
+  const content = await fs.promises.readFile(filePath, 'utf8');
+  const jsonContent = JSON.parse(content);
+  const updatedContent = JSON.stringify({...jsonContent, ...updates}, null, 2);
+  await fs.promises.writeFile(filePath, updatedContent);
+}
+
+async function replaceInFile(filePath, replacements) {
+  let content = await fs.promises.readFile(filePath, 'utf8');
+
+  for (const [search, replace] of replacements) {
+    const escapedSearch = search.replace(/[-\/\\^$*+?.()|[\]{}]/g, '\\$&'); // Escape special chars
+    content = content.replace(new RegExp(escapedSearch, 'g'), replace);
+  }
+  await fs.promises.writeFile(filePath, content, 'utf8');
+}
+
+async function templateAuth0(siteUrl, coreApiContext, env, filePaths, deployUI, deployGraphQLServer, commonSecrets, configureMFA) {
+  try {
+    let uiAllowedCallbacksUrls,
+      uiAllowedLogoutUrls;
+    let graphqlAllowedCallbacksUrls,
+      graphqlAllowedLogoutUrls;
+    let connectAllowedCallbacksUrls,
+      connectlAllowedLogoutUrls;
+
+    let connectClientMetadata,
+        connectCallbacks,
+        connectAddons;
+    // Configure URLs based on environment
+    if (env === 'prd') {
+      uiAllowedCallbacksUrls = [`${siteUrl}/api/auth/callback`];
+      uiAllowedLogoutUrls = [`${siteUrl}`];
+
+      graphqlAllowedCallbacksUrls = [`${siteUrl}/api/graphql/callback`];
+      graphqlAllowedLogoutUrls = [`${siteUrl}/api/graphql/`];
+
+      connectAllowedCallbacksUrls = [`${siteUrl}/connect/samlCallback?client_name=auth0`];
+      connectlAllowedLogoutUrls = [ `${siteUrl}/connect`];
+    } else {
+      uiAllowedCallbacksUrls = [
+        `${siteUrl}/api/auth/callback`,
+        `http://localhost:3000/api/auth/callback`,
+      ];
+      uiAllowedLogoutUrls = [
+        `${siteUrl}`,
+        `http://localhost:3000`,
+      ];
+      graphqlAllowedCallbacksUrls = [
+        `${siteUrl}/api/graphql/callback`,
+        `http://localhost:4000/api/graphql/callback`,
+      ];
+      graphqlAllowedLogoutUrls = [
+        `http://localhost:4000/api/graphql/`,
+        `${siteUrl}/api/graphql/`,
+      ];
+      connectAllowedCallbacksUrls = [
+        `${siteUrl}/connect/samlCallback?client_name=auth0`,
+        `http://localhost:9000/connect/samlCallback?client_name=auth0`,
+      ];
+      connectlAllowedLogoutUrls = [
+        `${siteUrl}/connect`
+      ];
+
+      const siteUrlNoPrefix=siteUrl.replace(/^https?:\/\//, '');
+      connectClientMetadata ={
+        "docupaceContext" : "core",
+        "docupaceHost" : `${siteUrlNoPrefix}`,
+        "docupace_context" : "core",
+        "docupace_host" : `${siteUrlNoPrefix}  `
+      };
+
+      connectCallbacks = [
+        `${siteUrl}/connect/samlCallback?client_name=auth0`
+      ];
+
+      connectAddons = {
+        "samlp": {
+          "audience": `${siteUrl}/connect`,
+          "recipient": `${siteUrl}/connect/samlCallback?client_name=auth0`,
+          "destination": `${siteUrl}/connect/samlCallback?client_name=auth0`,
+          "nameIdentifierFormat": "urn:oasis:names:tc:SAML:1.1:nameid-format:unspecified",
+          "binding": "urn:oasis:names:tc:SAML:2.0:bindings:HTTP-POST",
+          "nameIdentifierProbes": [
+            "http://schemas.xmlsoap.org/ws/2005/05/identity/claims/docupace-username"
+          ],
+          "mappings": {
+            "proposalHandle": "ProposalHandle"
+          }
+        }
+      };
+
+    }
+
+
+    const configureUI = deployUI === 'true';
+    if (configureUI) {
+      console.log('ui_allowed_callbacks_urls ->', uiAllowedCallbacksUrls);
+      console.log('ui_allowed_logout_urls ->', uiAllowedLogoutUrls);
+
+      await updateJsonFile(filePaths.uiJson, {
+        callbacks: uiAllowedCallbacksUrls,
+        allowed_logout_urls: uiAllowedLogoutUrls,
+      });
+
+
+      //TODO: move to separate function for connect
+      console.log('connect_allowed_callbacks_urls ->', connectAllowedCallbacksUrls);
+      console.log('connect_allowed_logout_urls ->', connectlAllowedLogoutUrls);
+
+      // update allowed callback url
+      await updateJsonFile(filePaths.connectJson, {
+        callbacks: connectAllowedCallbacksUrls,
+        allowed_logout_urls: connectlAllowedLogoutUrls,
+        client_metadata: connectClientMetadata,
+        addons: connectAddons
+      });
+
+
+
+      console.log('Updated URLs for main UI...');
+    } else {
+      await fs.promises.unlink(filePaths.uiJson);
+      await updateJsonFile(filePaths.databaseJson, {
+        enabled_clients: (content) => content.enabled_clients.filter((client) => client !== 'docupace-ui-main'),
+      });
+      console.log("Removed 'docupace-ui-main' from enabled_clients in database.json");
+    }
+
+    const configureGraphqlServer = deployGraphQLServer === 'true';
+    if (configureGraphqlServer) {
+      console.log('graphql_allowed_callbacks_urls ->', graphqlAllowedCallbacksUrls);
+      console.log('graphql_allowed_logout_urls ->', graphqlAllowedLogoutUrls);
+
+      await updateJsonFile(filePaths.graphqlJson, {
+        callbacks: graphqlAllowedCallbacksUrls,
+        allowed_logout_urls: graphqlAllowedLogoutUrls,
+      });
+      console.log('Updated URLs for GraphQL server...');
+    } else {
+      await fs.promises.unlink(filePaths.graphqlJson);
+      await updateJsonFile(filePaths.databaseJson, {
+        enabled_clients: (content) => content.enabled_clients.filter((client) => client !== 'docupace-graphql'),
+      });
+      console.log("Removed 'docupace-graphql' from enabled_clients in database.json");
+    }
+
+    // TWILIO configuration
+    await replaceInFile(filePaths.twilioJson, [
+      ['twilioauthtokenplaceholder', commonSecrets.TWILIO_AUTH_TOKEN],
+      ['twiliosidplaceholder', commonSecrets.TWILIO_SID],
+      ['twiliofromplaceholder', commonSecrets.TWILIO_FROM_NUMBER],
+    ]);
+
+    console.log('TWILIO configuration updated...');
+
+    const tmpSiteUrl = siteUrl.replace(/^https?:\/\//, '');
+    // Database configuration
+    await replaceInFile(filePaths.databaseLoginJs, [
+      ['${docupaceHost}', tmpSiteUrl],
+      ['${docupaceContext}', coreApiContext],
+    ]);
+
+    console.log('MFA Template configuration started...');
+
+    try {
+      const sourceDir = configureMFA === 'DISABLED' ? 'auth0-site-setup/templateNoMFA/' : 'auth0-site-setup/templateMFA/';
+      const destinationDir = 'auth0-site-setup/template/';
+
+      console.log(`AUTH0 MFA is ${configureMFA === 'DISABLED' ? 'disabled' : 'enabled'}`);
+      await copyDirectory(sourceDir, destinationDir);
+
+      console.log('MFA configuration completed.');
+    } catch (err) {
+      console.error('Error configuring MFA:', err);
+      throw err;
+    }
+
+    console.log('Template configuration completed.');
+  } catch (err) {
+    // console.error('Error configuring Auth0 templates:', err);
+    throw err;
+  }
+}
+
 export async function getAuth0AuthToken(auth0Domain, clientId, clientSecret) {
   try {
     const response = await axios.post(`https://${auth0Domain}/oauth/token`, {
@@ -312,7 +604,8 @@ ingress:
   }
 }
 
-export async function configureFromSite(fromSite, toSite, fromEnv,toEnv, deployUI, deployGraphQLServer, useNewDomain) {
+
+export async function configureFromSite(fromSite, toSite, fromEnv,toEnv, deployUI, deployGraphQLServer, useNewDomain, configureMFA) {
   console.log(`Configuring Auth0 tenants and ArgoCD apps for site: ${toSite} in env: ${toEnv} from site: ${fromSite}`);
   // Common Secrets
   const commonSecretsPath = getVaultSecretsConfigs(toSite).commonSecretsPath;
@@ -340,17 +633,17 @@ export async function configureFromSite(fromSite, toSite, fromEnv,toEnv, deployU
   let repoPathFromEnv ="";
   let repoPathToEnv = "";
   // Clone repositories
-  if ( fromEnv === toEnv ) {
+  if ( fromEnv == toEnv ) {
      repoPathFromEnv = await cloneEnvRepository(fromEnv);
      repoPathToEnv = repoPathFromEnv;
-  } else {
+  }else {
      repoPathFromEnv = await cloneEnvRepository(fromEnv);
      repoPathToEnv = await cloneEnvRepository(toEnv);
   }
 
   //TODO: clone fromEnv and toEnv. replace above with this
 
-  // const auth0RepoPath = await cloneRepository('auth0-site-setup');
+  const auth0RepoPath = await cloneRepository('auth0-site-setup');
 
   // Read deploy configs
   const { deployConfig: deployUIConfig } = await readDeployConfig('ui', fromEnv, fromSite, 'values');
@@ -396,6 +689,9 @@ export async function configureFromSite(fromSite, toSite, fromEnv,toEnv, deployU
     CONNECT_URL = `${oldUrl}_ui`;
   }
 
+  await templateAuth0(SITE_HOST, CORE_API_CONTEXT, toEnv, filePaths, deployUI, deployGraphQLServer, commonSecrets, configureMFA);
+  await importAuth0Templates('./auth0-site-setup/template', auth0Domain, auth0ClientId, auth0ClientSecret);
+
   if (deployUI === 'true') {
     await configureUI(SITE_HOST, CORE_URL, DOCUPACE_HOST, toSite, toEnv, useNewDomain, auth0Domain, auth0ClientId, auth0ClientSecret, auth0Token, uiSecretsPath, uiImageTag, repoPathToEnv);
   }
@@ -403,4 +699,17 @@ export async function configureFromSite(fromSite, toSite, fromEnv,toEnv, deployU
   await configureGraphQLServer(SITE_HOST, CORE_URL, DOCUPACE_HOST, toSite, toEnv, auth0Domain, auth0ClientId, auth0ClientSecret, auth0Token, graphqlSecretsPath, graphqlImageTag, graphqlStandardConfigRemoteBranch, repoPathToEnv, commonSecrets);
   await pushDeployConfig(repoPathToEnv, `Config update for ${toSite} from ${fromSite} with UI: ${uiImageTag} and GraphQL: ${graphqlImageTag}`);
 
+  await initializeAuth0Configuration({
+    initConfiguration: "true",
+    auth0Domain: auth0Domain,
+    auth0AuthToken: auth0Token,
+    coreApiIdentifier: commonSecrets.CORE_API_IDENTIFIER,
+  });
+
+  await addApplicationToApi({
+    application: 'docupace-graphql-client-credentials',
+    auth0Domain: auth0Domain,
+    auth0AuthToken: auth0Token,
+    coreApiIdentifier: commonSecrets.CORE_API_IDENTIFIER
+  })
 }

package/src/auth0/vault.js

@@ -7,16 +7,16 @@ import axios from 'axios';
  */
 export async function getVaultSecrets(vaultPath) {
   if (!vaultPath) {
-    console.error("Error: VAULT_PATH is required.");
-    throw new Error("VAULT_PATH is required.");
+    console.error('Error: VAULT_PATH is required.');
+    throw new Error('VAULT_PATH is required.');
   }
 
   const vaultToken = process.env.VAULT_TOKEN;
   const vaultAddr = process.env.VAULT_ADDR;
 
   if (!vaultToken || !vaultAddr) {
-    console.error("Error: VAULT_TOKEN and VAULT_ADDR must be set.");
-    throw new Error("VAULT_TOKEN and VAULT_ADDR must be set.");
+    console.error('Error: VAULT_TOKEN and VAULT_ADDR must be set.');
+    throw new Error('VAULT_TOKEN and VAULT_ADDR must be set.');
   }
 
   try {
@@ -38,8 +38,8 @@ export async function getVaultSecrets(vaultPath) {
       // console.log(`Secrets fetched successfully from Vault at ${JSON.stringify(data.data.data)})`);
       return data.data.data;
     } else {
-      console.error("Error: Invalid JSON received from Vault.");
-      throw new Error("Invalid JSON received from Vault.");
+      console.error('Error: Invalid JSON received from Vault.');
+      throw new Error('Invalid JSON received from Vault.');
     }
   } catch (error) {
     if (error.response) {
@@ -61,16 +61,16 @@ export async function getVaultSecrets(vaultPath) {
  */
 export async function updateVaultSecrets(vaultPath, secretData) {
   if (!vaultPath || !secretData) {
-    console.error("Usage: updateVaultSecret(vaultPath, secretData)");
-    throw new Error("Both vaultPath and secretData are required.");
+    console.error('Usage: updateVaultSecret(vaultPath, secretData)');
+    throw new Error('Both vaultPath and secretData are required.');
   }
 
   const vaultToken = process.env.VAULT_TOKEN;
   const vaultAddr = process.env.VAULT_ADDR;
 
   if (!vaultToken || !vaultAddr) {
-    console.error("Error: VAULT_TOKEN and VAULT_ADDR must be set.");
-    throw new Error("VAULT_TOKEN and VAULT_ADDR must be set.");
+    console.error('Error: VAULT_TOKEN and VAULT_ADDR must be set.');
+    throw new Error('VAULT_TOKEN and VAULT_ADDR must be set.');
   }
 
   try {