@aifabrix/builder 2.22.2 → 2.31.0

package/lib/external-system-download.js

@@ -20,6 +20,7 @@ const { getDataplaneUrl } = require('./datasource-deploy');
 const { getConfig } = require('./config');
 const { detectAppType } = require('./utils/paths');
 const logger = require('./utils/logger');
+const { generateEnvTemplate } = require('./utils/external-system-env-helpers');
 
 /**
  * Validates system type from downloaded application
@@ -95,55 +96,11 @@ function handlePartialDownload(systemKey, systemData, datasourceErrors) {
 }
 
 /**
- * Extracts environment variables from authentication configuration
- * @param {Object} application - External system configuration
- * @returns {string} Environment variables template content
+ * Extract OAuth2 environment variables
+ * @param {Object} oauth2 - OAuth2 configuration
+ * @param {string} systemKey - System key
+ * @param {Array<string>} lines - Lines array to append to
  */
-function generateEnvTemplate(application) {
-  const lines = ['# Environment variables for external system'];
-  lines.push(`# System: ${application.key || 'unknown'}`);
-  lines.push('');
-
-  if (!application.authentication) {
-    return lines.join('\n');
-  }
-
-  const auth = application.authentication;
-
-  // OAuth2 configuration
-  if (auth.type === 'oauth2' && auth.oauth2) {
-    if (auth.oauth2.clientId && auth.oauth2.clientId.includes('{{')) {
-      const key = auth.oauth2.clientId.replace(/[{}]/g, '').trim();
-      lines.push(`${key}=kv://secrets/${application.key}/client-id`);
-    }
-    if (auth.oauth2.clientSecret && auth.oauth2.clientSecret.includes('{{')) {
-      const key = auth.oauth2.clientSecret.replace(/[{}]/g, '').trim();
-      lines.push(`${key}=kv://secrets/${application.key}/client-secret`);
-    }
-  }
-
-  // API Key configuration
-  if (auth.type === 'apikey' && auth.apikey) {
-    if (auth.apikey.key && auth.apikey.key.includes('{{')) {
-      const key = auth.apikey.key.replace(/[{}]/g, '').trim();
-      lines.push(`${key}=kv://secrets/${application.key}/api-key`);
-    }
-  }
-
-  // Basic Auth configuration
-  if (auth.type === 'basic' && auth.basic) {
-    if (auth.basic.username && auth.basic.username.includes('{{')) {
-      const key = auth.basic.username.replace(/[{}]/g, '').trim();
-      lines.push(`${key}=kv://secrets/${application.key}/username`);
-    }
-    if (auth.basic.password && auth.basic.password.includes('{{')) {
-      const key = auth.basic.password.replace(/[{}]/g, '').trim();
-      lines.push(`${key}=kv://secrets/${application.key}/password`);
-    }
-  }
-
-  return lines.join('\n');
-}
 
 /**
  * Generates variables.yaml with externalIntegration block
@@ -244,6 +201,235 @@ function generateReadme(systemKey, application, dataSources) {
   return lines.join('\n');
 }
 
+/**
+ * Setup authentication and get dataplane URL
+ * @async
+ * @param {string} systemKey - System key
+ * @param {Object} options - Download options
+ * @param {Object} config - Configuration object
+ * @returns {Promise<Object>} Object with authConfig and dataplaneUrl
+ * @throws {Error} If authentication fails
+ */
+async function setupAuthenticationAndDataplane(systemKey, options, config) {
+  const environment = options.environment || 'dev';
+  const controllerUrl = options.controller || config.deployment?.controllerUrl || 'http://localhost:3000';
+  const authConfig = await getDeploymentAuth(controllerUrl, environment, systemKey);
+
+  if (!authConfig.token && !authConfig.clientId) {
+    throw new Error('Authentication required. Run "aifabrix login" or "aifabrix app register" first.');
+  }
+
+  logger.log(chalk.blue('🌐 Getting dataplane URL from controller...'));
+  const dataplaneUrl = await getDataplaneUrl(controllerUrl, systemKey, environment, authConfig);
+  logger.log(chalk.green(`✓ Dataplane URL: ${dataplaneUrl}`));
+
+  return { authConfig, dataplaneUrl };
+}
+
+/**
+ * Download system configuration from dataplane
+ * @async
+ * @param {string} dataplaneUrl - Dataplane URL
+ * @param {string} systemKey - System key
+ * @param {Object} authConfig - Authentication configuration
+ * @returns {Promise<Object>} Object with application and dataSources
+ * @throws {Error} If download fails
+ */
+async function downloadSystemConfiguration(dataplaneUrl, systemKey, authConfig) {
+  logger.log(chalk.blue(`📡 Downloading system configuration: ${systemKey}`));
+  const response = await getExternalSystemConfig(dataplaneUrl, systemKey, authConfig);
+
+  if (!response.success || !response.data) {
+    throw new Error(`Failed to download system configuration: ${response.error || response.formattedError || 'Unknown error'}`);
+  }
+
+  const downloadData = response.data.data || response.data;
+  const application = downloadData.application;
+  const dataSources = downloadData.dataSources || [];
+
+  if (!application) {
+    throw new Error('Application configuration not found in download response');
+  }
+
+  return { application, dataSources };
+}
+
+/**
+ * Generate files in temporary directory
+ * @async
+ * @param {string} tempDir - Temporary directory path
+ * @param {string} systemKey - System key
+ * @param {Object} application - Application configuration
+ * @param {Array} dataSources - Array of datasource configurations
+ * @returns {Promise<Object>} Object with file paths
+ * @throws {Error} If file generation fails
+ */
+async function generateFilesInTempDir(tempDir, systemKey, application, dataSources) {
+  const systemFileName = `${systemKey}-deploy.json`;
+  const systemFilePath = path.join(tempDir, systemFileName);
+  await fs.writeFile(systemFilePath, JSON.stringify(application, null, 2), 'utf8');
+
+  // Generate datasource files
+  const datasourceErrors = [];
+  const datasourceFiles = [];
+  for (const datasource of dataSources) {
+    try {
+      const entityKey = datasource.entityKey || datasource.key.split('-').pop();
+      const datasourceFileName = `${systemKey}-deploy-${entityKey}.json`;
+      const datasourceFilePath = path.join(tempDir, datasourceFileName);
+      await fs.writeFile(datasourceFilePath, JSON.stringify(datasource, null, 2), 'utf8');
+      datasourceFiles.push(datasourceFilePath);
+    } catch (error) {
+      datasourceErrors.push(new Error(`Failed to write datasource ${datasource.key}: ${error.message}`));
+    }
+  }
+
+  // Handle partial downloads
+  if (datasourceErrors.length > 0) {
+    handlePartialDownload(systemKey, application, datasourceErrors);
+  }
+
+  // Generate variables.yaml
+  const variables = generateVariablesYaml(systemKey, application, dataSources);
+  const variablesPath = path.join(tempDir, 'variables.yaml');
+  await fs.writeFile(variablesPath, yaml.dump(variables, { indent: 2, lineWidth: 120, noRefs: true }), 'utf8');
+
+  // Generate env.template
+  const envTemplate = generateEnvTemplate(application);
+  const envTemplatePath = path.join(tempDir, 'env.template');
+  await fs.writeFile(envTemplatePath, envTemplate, 'utf8');
+
+  // Generate README.md
+  const readme = generateReadme(systemKey, application, dataSources);
+  const readmePath = path.join(tempDir, 'README.md');
+  await fs.writeFile(readmePath, readme, 'utf8');
+
+  return {
+    systemFilePath,
+    variablesPath,
+    envTemplatePath,
+    readmePath,
+    datasourceFiles
+  };
+}
+
+/**
+ * Move files from temporary directory to final location
+ * @async
+ * @param {string} tempDir - Temporary directory path
+ * @param {string} finalPath - Final destination path
+ * @param {string} systemKey - System key
+ * @param {Object} filePaths - Object with file paths
+ * @throws {Error} If file move fails
+ */
+async function moveFilesToFinalLocation(tempDir, finalPath, systemKey, filePaths) {
+  logger.log(chalk.blue(`📁 Creating directory: ${finalPath}`));
+  await fs.mkdir(finalPath, { recursive: true });
+
+  const systemFileName = `${systemKey}-deploy.json`;
+  const filesToMove = [
+    { from: filePaths.systemFilePath, to: path.join(finalPath, systemFileName) },
+    { from: filePaths.variablesPath, to: path.join(finalPath, 'variables.yaml') },
+    { from: filePaths.envTemplatePath, to: path.join(finalPath, 'env.template') },
+    { from: filePaths.readmePath, to: path.join(finalPath, 'README.md') }
+  ];
+
+  for (const dsFile of filePaths.datasourceFiles) {
+    const fileName = path.basename(dsFile);
+    filesToMove.push({ from: dsFile, to: path.join(finalPath, fileName) });
+  }
+
+  for (const file of filesToMove) {
+    await fs.copyFile(file.from, file.to);
+    logger.log(chalk.green(`✓ Created: ${path.relative(process.cwd(), file.to)}`));
+  }
+}
+
+/**
+ * Validate system key format
+ * @param {string} systemKey - System key to validate
+ * @throws {Error} If system key format is invalid
+ */
+function validateSystemKeyFormat(systemKey) {
+  if (!systemKey || typeof systemKey !== 'string') {
+    throw new Error('System key is required and must be a string');
+  }
+  if (!/^[a-z0-9-_]+$/.test(systemKey)) {
+    throw new Error('System key must contain only lowercase letters, numbers, hyphens, and underscores');
+  }
+}
+
+/**
+ * Handle dry run mode
+ * @param {string} systemKey - System key
+ * @param {string} dataplaneUrl - Dataplane URL
+ */
+function handleDryRun(systemKey, dataplaneUrl) {
+  logger.log(chalk.yellow('🔍 Dry run mode - would download from:'));
+  logger.log(chalk.gray(`  ${dataplaneUrl}/api/v1/external/systems/${systemKey}/config`));
+  logger.log(chalk.yellow('\nWould create:'));
+  logger.log(chalk.gray(`  integration/${systemKey}/`));
+  logger.log(chalk.gray(`  integration/${systemKey}/variables.yaml`));
+  logger.log(chalk.gray(`  integration/${systemKey}/${systemKey}-deploy.json`));
+  logger.log(chalk.gray(`  integration/${systemKey}/env.template`));
+  logger.log(chalk.gray(`  integration/${systemKey}/README.md`));
+}
+
+/**
+ * Validate and log downloaded data
+ * @param {Object} application - Application configuration
+ * @param {Array} dataSources - Array of datasource configurations
+ * @returns {string} System type
+ */
+function validateAndLogDownloadedData(application, dataSources) {
+  logger.log(chalk.blue('🔍 Validating downloaded data...'));
+  validateDownloadedData(application, dataSources);
+  const systemType = validateSystemType(application);
+  logger.log(chalk.green(`✓ System type: ${systemType}`));
+  logger.log(chalk.green(`✓ Found ${dataSources.length} datasource(s)`));
+  return systemType;
+}
+
+/**
+ * Process downloaded system (generate files, move, cleanup)
+ * @async
+ * @param {string} systemKey - System key
+ * @param {Object} application - Application configuration
+ * @param {Array} dataSources - Array of datasource configurations
+ * @param {string} tempDir - Temporary directory path
+ * @returns {Promise<string>} Final destination path
+ * @throws {Error} If processing fails
+ */
+async function processDownloadedSystem(systemKey, application, dataSources, tempDir) {
+  // Generate files in temporary folder first
+  const filePaths = await generateFilesInTempDir(tempDir, systemKey, application, dataSources);
+
+  // Determine final destination (integration folder)
+  const { appPath } = await detectAppType(systemKey);
+  const finalPath = appPath || path.join(process.cwd(), 'integration', systemKey);
+
+  // Move files from temp to final location
+  await moveFilesToFinalLocation(tempDir, finalPath, systemKey, filePaths);
+
+  // Clean up temporary folder
+  await fs.rm(tempDir, { recursive: true, force: true });
+
+  return finalPath;
+}
+
+/**
+ * Display download success message
+ * @param {string} systemKey - System key
+ * @param {string} finalPath - Final destination path
+ * @param {number} datasourceCount - Number of datasources
+ */
+function displayDownloadSuccess(systemKey, finalPath, datasourceCount) {
+  logger.log(chalk.green('\n✅ External system downloaded successfully!'));
+  logger.log(chalk.blue(`Location: ${finalPath}`));
+  logger.log(chalk.blue(`System: ${systemKey}`));
+  logger.log(chalk.blue(`Datasources: ${datasourceCount}`));
+}
+
 /**
  * Downloads external system from dataplane to local development structure
  * @async
@@ -257,147 +443,34 @@ function generateReadme(systemKey, application, dataSources) {
  * @throws {Error} If download fails
  */
 async function downloadExternalSystem(systemKey, options = {}) {
-  if (!systemKey || typeof systemKey !== 'string') {
-    throw new Error('System key is required and must be a string');
-  }
-
-  // Validate system key format (alphanumeric, hyphens, underscores)
-  if (!/^[a-z0-9-_]+$/.test(systemKey)) {
-    throw new Error('System key must contain only lowercase letters, numbers, hyphens, and underscores');
-  }
+  validateSystemKeyFormat(systemKey);
 
   try {
     logger.log(chalk.blue(`\n📥 Downloading external system: ${systemKey}`));
 
-    // Get authentication
+    // Get authentication and dataplane URL
     const config = await getConfig();
-    const environment = options.environment || 'dev';
-    const controllerUrl = options.controller || config.deployment?.controllerUrl || 'http://localhost:3000';
-    const authConfig = await getDeploymentAuth(controllerUrl, environment, systemKey);
-
-    if (!authConfig.token && !authConfig.clientId) {
-      throw new Error('Authentication required. Run "aifabrix login" or "aifabrix app register" first.');
-    }
-
-    // Get dataplane URL from controller
-    logger.log(chalk.blue('🌐 Getting dataplane URL from controller...'));
-    const dataplaneUrl = await getDataplaneUrl(controllerUrl, systemKey, environment, authConfig);
-    logger.log(chalk.green(`✓ Dataplane URL: ${dataplaneUrl}`));
-
-    // Download system configuration using centralized API client
-    logger.log(chalk.blue(`📡 Downloading system configuration: ${systemKey}`));
+    const { authConfig, dataplaneUrl } = await setupAuthenticationAndDataplane(systemKey, options, config);
 
+    // Handle dry run
     if (options.dryRun) {
-      logger.log(chalk.yellow('🔍 Dry run mode - would download from:'));
-      logger.log(chalk.gray(`  ${dataplaneUrl}/api/v1/external/systems/${systemKey}/config`));
-      logger.log(chalk.yellow('\nWould create:'));
-      logger.log(chalk.gray(`  integration/${systemKey}/`));
-      logger.log(chalk.gray(`  integration/${systemKey}/variables.yaml`));
-      logger.log(chalk.gray(`  integration/${systemKey}/${systemKey}-deploy.json`));
-      logger.log(chalk.gray(`  integration/${systemKey}/env.template`));
-      logger.log(chalk.gray(`  integration/${systemKey}/README.md`));
+      handleDryRun(systemKey, dataplaneUrl);
       return;
     }
 
-    const response = await getExternalSystemConfig(dataplaneUrl, systemKey, authConfig);
-
-    if (!response.success || !response.data) {
-      throw new Error(`Failed to download system configuration: ${response.error || response.formattedError || 'Unknown error'}`);
-    }
-
-    const downloadData = response.data.data || response.data;
-    const application = downloadData.application;
-    const dataSources = downloadData.dataSources || [];
-
-    if (!application) {
-      throw new Error('Application configuration not found in download response');
-    }
+    // Download system configuration
+    const { application, dataSources } = await downloadSystemConfiguration(dataplaneUrl, systemKey, authConfig);
 
     // Validate downloaded data
-    logger.log(chalk.blue('🔍 Validating downloaded data...'));
-    validateDownloadedData(application, dataSources);
-    const systemType = validateSystemType(application);
-    logger.log(chalk.green(`✓ System type: ${systemType}`));
-    logger.log(chalk.green(`✓ Found ${dataSources.length} datasource(s)`));
+    validateAndLogDownloadedData(application, dataSources);
 
     // Create temporary folder for validation
     const tempDir = path.join(os.tmpdir(), `aifabrix-download-${systemKey}-${Date.now()}`);
     await fs.mkdir(tempDir, { recursive: true });
 
     try {
-      // Generate files in temporary folder first
-      const systemFileName = `${systemKey}-deploy.json`;
-      const systemFilePath = path.join(tempDir, systemFileName);
-      await fs.writeFile(systemFilePath, JSON.stringify(application, null, 2), 'utf8');
-
-      // Generate datasource files
-      const datasourceErrors = [];
-      const datasourceFiles = [];
-      for (const datasource of dataSources) {
-        try {
-          const entityKey = datasource.entityKey || datasource.key.split('-').pop();
-          const datasourceFileName = `${systemKey}-deploy-${entityKey}.json`;
-          const datasourceFilePath = path.join(tempDir, datasourceFileName);
-          await fs.writeFile(datasourceFilePath, JSON.stringify(datasource, null, 2), 'utf8');
-          datasourceFiles.push(datasourceFilePath);
-        } catch (error) {
-          datasourceErrors.push(new Error(`Failed to write datasource ${datasource.key}: ${error.message}`));
-        }
-      }
-
-      // Handle partial downloads
-      if (datasourceErrors.length > 0) {
-        handlePartialDownload(systemKey, application, datasourceErrors);
-      }
-
-      // Generate variables.yaml
-      const variables = generateVariablesYaml(systemKey, application, dataSources);
-      const variablesPath = path.join(tempDir, 'variables.yaml');
-      await fs.writeFile(variablesPath, yaml.dump(variables, { indent: 2, lineWidth: 120, noRefs: true }), 'utf8');
-
-      // Generate env.template
-      const envTemplate = generateEnvTemplate(application);
-      const envTemplatePath = path.join(tempDir, 'env.template');
-      await fs.writeFile(envTemplatePath, envTemplate, 'utf8');
-
-      // Generate README.md
-      const readme = generateReadme(systemKey, application, dataSources);
-      const readmePath = path.join(tempDir, 'README.md');
-      await fs.writeFile(readmePath, readme, 'utf8');
-
-      // Determine final destination (integration folder)
-      const { appPath } = await detectAppType(systemKey);
-      const finalPath = appPath || path.join(process.cwd(), 'integration', systemKey);
-
-      // Create final directory
-      await fs.mkdir(finalPath, { recursive: true });
-
-      // Move files from temp to final location
-      logger.log(chalk.blue(`📁 Creating directory: ${finalPath}`));
-      const filesToMove = [
-        { from: systemFilePath, to: path.join(finalPath, systemFileName) },
-        { from: variablesPath, to: path.join(finalPath, 'variables.yaml') },
-        { from: envTemplatePath, to: path.join(finalPath, 'env.template') },
-        { from: readmePath, to: path.join(finalPath, 'README.md') }
-      ];
-
-      for (const dsFile of datasourceFiles) {
-        const fileName = path.basename(dsFile);
-        filesToMove.push({ from: dsFile, to: path.join(finalPath, fileName) });
-      }
-
-      for (const file of filesToMove) {
-        await fs.copyFile(file.from, file.to);
-        logger.log(chalk.green(`✓ Created: ${path.relative(process.cwd(), file.to)}`));
-      }
-
-      // Clean up temporary folder
-      await fs.rm(tempDir, { recursive: true, force: true });
-
-      logger.log(chalk.green('\n✅ External system downloaded successfully!'));
-      logger.log(chalk.blue(`Location: ${finalPath}`));
-      logger.log(chalk.blue(`System: ${systemKey}`));
-      logger.log(chalk.blue(`Datasources: ${dataSources.length}`));
+      const finalPath = await processDownloadedSystem(systemKey, application, dataSources, tempDir);
+      displayDownloadSuccess(systemKey, finalPath, dataSources.length);
     } catch (error) {
       // Clean up temporary folder on error
       try {