@aifabrix/builder 2.22.2 → 2.31.0

package/lib/datasource-deploy.js

@@ -55,19 +55,13 @@ async function getDataplaneUrl(controllerUrl, appKey, environment, authConfig) {
 }
 
 /**
- * Deploys datasource to dataplane
- *
- * @async
- * @function deployDatasource
+ * Validate deployment inputs
  * @param {string} appKey - Application key
- * @param {string} filePath - Path to datasource JSON file
- * @param {Object} options - Deployment options
- * @param {string} options.controller - Controller URL
- * @param {string} options.environment - Environment key
- * @returns {Promise<Object>} Deployment result
- * @throws {Error} If deployment fails
+ * @param {string} filePath - File path
+ * @param {Object} options - Options
+ * @throws {Error} If validation fails
  */
-async function deployDatasource(appKey, filePath, options) {
+function validateDeploymentInputs(appKey, filePath, options) {
   if (!appKey || typeof appKey !== 'string') {
     throw new Error('Application key is required');
   }
@@ -80,10 +74,16 @@ async function deployDatasource(appKey, filePath, options) {
   if (!options.environment) {
     throw new Error('Environment is required (-e, --environment)');
   }
+}
 
-  logger.log(chalk.blue('📋 Deploying datasource...\n'));
-
-  // Validate datasource file
+/**
+ * Validate and load datasource file
+ * @async
+ * @param {string} filePath - Path to datasource file
+ * @returns {Promise<Object>} Datasource configuration
+ * @throws {Error} If validation or loading fails
+ */
+async function validateAndLoadDatasourceFile(filePath) {
   logger.log(chalk.blue('🔍 Validating datasource file...'));
   const validation = await validateDatasourceFile(filePath);
   if (!validation.valid) {
@@ -95,32 +95,45 @@ async function deployDatasource(appKey, filePath, options) {
   }
   logger.log(chalk.green('✓ Datasource file is valid'));
 
-  // Load datasource configuration
   const content = fs.readFileSync(filePath, 'utf8');
-  let datasourceConfig;
   try {
-    datasourceConfig = JSON.parse(content);
+    return JSON.parse(content);
   } catch (error) {
     throw new Error(`Failed to parse datasource file: ${error.message}`);
   }
+}
 
-  // Extract systemKey
-  const systemKey = datasourceConfig.systemKey;
-  if (!systemKey) {
-    throw new Error('systemKey is required in datasource configuration');
-  }
-
-  // Get authentication
+/**
+ * Setup authentication and get dataplane URL
+ * @async
+ * @param {string} controllerUrl - Controller URL
+ * @param {string} environment - Environment key
+ * @param {string} appKey - Application key
+ * @returns {Promise<Object>} Object with authConfig and dataplaneUrl
+ */
+async function setupDeploymentAuth(controllerUrl, environment, appKey) {
   logger.log(chalk.blue('🔐 Getting authentication...'));
-  const authConfig = await getDeploymentAuth(options.controller, options.environment, appKey);
+  const authConfig = await getDeploymentAuth(controllerUrl, environment, appKey);
   logger.log(chalk.green('✓ Authentication successful'));
 
-  // Get dataplane URL from controller
   logger.log(chalk.blue('🌐 Getting dataplane URL from controller...'));
-  const dataplaneUrl = await getDataplaneUrl(options.controller, appKey, options.environment, authConfig);
+  const dataplaneUrl = await getDataplaneUrl(controllerUrl, appKey, environment, authConfig);
   logger.log(chalk.green(`✓ Dataplane URL: ${dataplaneUrl}`));
 
-  // Publish to dataplane using pipeline workflow endpoint
+  return { authConfig, dataplaneUrl };
+}
+
+/**
+ * Publish datasource to dataplane
+ * @async
+ * @param {string} dataplaneUrl - Dataplane URL
+ * @param {string} systemKey - System key
+ * @param {Object} authConfig - Authentication configuration
+ * @param {Object} datasourceConfig - Datasource configuration
+ * @returns {Promise<Object>} Publish response
+ * @throws {Error} If publish fails
+ */
+async function publishDatasourceToDataplane(dataplaneUrl, systemKey, authConfig, datasourceConfig) {
   logger.log(chalk.blue('\n🚀 Publishing datasource to dataplane...'));
 
   const publishResponse = await publishDatasourceViaPipeline(dataplaneUrl, systemKey, authConfig, datasourceConfig);
@@ -133,9 +146,56 @@ async function deployDatasource(appKey, filePath, options) {
   }
 
   logger.log(chalk.green('\n✓ Datasource published successfully!'));
+  return publishResponse;
+}
+
+/**
+ * Display deployment results
+ * @param {Object} datasourceConfig - Datasource configuration
+ * @param {string} systemKey - System key
+ * @param {string} environment - Environment key
+ */
+function displayDeploymentResults(datasourceConfig, systemKey, environment) {
   logger.log(chalk.blue(`\nDatasource: ${datasourceConfig.key || datasourceConfig.displayName}`));
   logger.log(chalk.blue(`System: ${systemKey}`));
-  logger.log(chalk.blue(`Environment: ${options.environment}`));
+  logger.log(chalk.blue(`Environment: ${environment}`));
+}
+
+/**
+ * Deploys datasource to dataplane
+ *
+ * @async
+ * @function deployDatasource
+ * @param {string} appKey - Application key
+ * @param {string} filePath - Path to datasource JSON file
+ * @param {Object} options - Deployment options
+ * @param {string} options.controller - Controller URL
+ * @param {string} options.environment - Environment key
+ * @returns {Promise<Object>} Deployment result
+ * @throws {Error} If deployment fails
+ */
+async function deployDatasource(appKey, filePath, options) {
+  validateDeploymentInputs(appKey, filePath, options);
+
+  logger.log(chalk.blue('📋 Deploying datasource...\n'));
+
+  // Validate and load datasource file
+  const datasourceConfig = await validateAndLoadDatasourceFile(filePath);
+
+  // Extract systemKey
+  const systemKey = datasourceConfig.systemKey;
+  if (!systemKey) {
+    throw new Error('systemKey is required in datasource configuration');
+  }
+
+  // Setup authentication and get dataplane URL
+  const { authConfig, dataplaneUrl } = await setupDeploymentAuth(options.controller, options.environment, appKey);
+
+  // Publish to dataplane
+  await publishDatasourceToDataplane(dataplaneUrl, systemKey, authConfig, datasourceConfig);
+
+  // Display results
+  displayDeploymentResults(datasourceConfig, systemKey, options.environment);
 
   return {
     success: true,

package/lib/deployer.js

@@ -15,25 +15,18 @@ const logger = require('./utils/logger');
 const { validateControllerUrl, validateEnvironmentKey } = require('./utils/deployment-validation');
 const { handleDeploymentError, handleDeploymentErrors } = require('./utils/deployment-errors');
 const { validatePipeline, deployPipeline, getPipelineDeployment } = require('./api/pipeline.api');
+const { handleValidationResponse } = require('./utils/deployment-validation-helpers');
 
 /**
- * Validates deployment configuration via validate endpoint
- * This is the first step in the deployment process
- *
+ * Build validation data for deployment
  * @async
- * @param {string} url - Controller URL
- * @param {string} envKey - Environment key (miso, dev, tst, pro)
- * @param {Object} manifest - Deployment manifest (applicationConfig)
+ * @param {Object} manifest - Application manifest/config
+ * @param {string} validatedEnvKey - Validated environment key
  * @param {Object} authConfig - Authentication configuration
- * @param {Object} options - Validation options (repositoryUrl, timeout, retries, etc.)
- * @returns {Promise<Object>} Validation result with validateToken
- * @throws {Error} If validation fails
+ * @param {Object} options - Additional options
+ * @returns {Promise<Object>} Object with validationData and pipelineAuthConfig
  */
-async function validateDeployment(url, envKey, manifest, authConfig, options = {}) {
-  const validatedEnvKey = validateEnvironmentKey(envKey);
-  const maxRetries = options.maxRetries || 3;
-
-  // Extract clientId and clientSecret
+async function buildValidationData(manifest, validatedEnvKey, authConfig, options) {
   const tokenManager = require('./utils/token-manager');
   const { clientId, clientSecret } = await tokenManager.extractClientCredentials(
     authConfig,
@@ -42,7 +35,6 @@ async function validateDeployment(url, envKey, manifest, authConfig, options = {
     options
   );
 
-  // Build validation request
   const repositoryUrl = options.repositoryUrl || `https://github.com/aifabrix/${manifest.key}`;
   const validationData = {
     clientId: clientId,
@@ -51,58 +43,40 @@ async function validateDeployment(url, envKey, manifest, authConfig, options = {
     applicationConfig: manifest
   };
 
-  // Use centralized API client with retry logic
   const pipelineAuthConfig = {
     type: 'client-credentials',
     clientId: clientId,
     clientSecret: clientSecret
   };
 
+  return { validationData, pipelineAuthConfig };
+}
+
+/**
+ * Validates deployment configuration via validate endpoint
+ * This is the first step in the deployment process
+ *
+ * @async
+ * @param {string} url - Controller URL
+ * @param {string} envKey - Environment key (miso, dev, tst, pro)
+ * @param {Object} manifest - Deployment manifest (applicationConfig)
+ * @param {Object} authConfig - Authentication configuration
+ * @param {Object} options - Validation options (repositoryUrl, timeout, retries, etc.)
+ * @returns {Promise<Object>} Validation result with validateToken
+ * @throws {Error} If validation fails
+ */
+async function validateDeployment(url, envKey, manifest, authConfig, options = {}) {
+  const validatedEnvKey = validateEnvironmentKey(envKey);
+  const maxRetries = options.maxRetries || 3;
+
+  // Build validation data
+  const { validationData, pipelineAuthConfig } = await buildValidationData(manifest, validatedEnvKey, authConfig, options);
+
   let lastError;
   for (let attempt = 1; attempt <= maxRetries; attempt++) {
     try {
       const response = await validatePipeline(url, validatedEnvKey, pipelineAuthConfig, validationData);
-
-      // Handle successful validation (200 OK with valid: true)
-      if (response.success && response.data) {
-        const responseData = response.data.data || response.data;
-        if (responseData.valid === true) {
-          return {
-            success: true,
-            validateToken: responseData.validateToken,
-            draftDeploymentId: responseData.draftDeploymentId,
-            imageServer: responseData.imageServer,
-            imageUsername: responseData.imageUsername,
-            imagePassword: responseData.imagePassword,
-            expiresAt: responseData.expiresAt
-          };
-        }
-        // Handle validation failure (valid: false)
-        if (responseData.valid === false) {
-          const errorMessage = responseData.errors && responseData.errors.length > 0
-            ? `Validation failed: ${responseData.errors.join(', ')}`
-            : 'Validation failed: Invalid configuration';
-          const error = new Error(errorMessage);
-          error.status = 400;
-          error.data = responseData;
-          throw error;
-        }
-      }
-
-      // Handle validation errors (non-success responses)
-      if (!response.success) {
-        const error = new Error(`Validation request failed: ${response.formattedError || response.error || 'Unknown error'}`);
-        error.status = response.status || 400;
-        error.data = response.data;
-        throw error;
-      }
-
-      // If we get here, response.success is true but valid is not true and not false
-      // This is an unexpected state, throw an error
-      const error = new Error('Validation response is in an unexpected state');
-      error.status = 400;
-      error.data = response.data;
-      throw error;
+      return handleValidationResponse(response);
     } catch (error) {
       lastError = error;
       const shouldRetry = attempt < maxRetries && error.status && error.status >= 500;
@@ -119,6 +93,83 @@ async function validateDeployment(url, envKey, manifest, authConfig, options = {
   throw lastError;
 }
 
+/**
+ * Validate client credentials for deployment
+ * @param {Object} authConfig - Authentication configuration
+ * @throws {Error} If credentials are missing
+ */
+function validateDeploymentCredentials(authConfig) {
+  if (!authConfig.clientId || !authConfig.clientSecret) {
+    throw new Error('Client ID and Client Secret are required for deployment. These should have been loaded during validation.');
+  }
+}
+
+/**
+ * Build deployment data and auth config
+ * @param {string} validateToken - Validation token
+ * @param {Object} authConfig - Authentication configuration
+ * @param {Object} options - Deployment options
+ * @returns {Object} Object with deployData and pipelineAuthConfig
+ */
+function buildDeploymentData(validateToken, authConfig, options) {
+  const imageTag = options.imageTag || 'latest';
+  const deployData = {
+    validateToken: validateToken,
+    imageTag: imageTag
+  };
+
+  const pipelineAuthConfig = {
+    type: 'client-credentials',
+    clientId: authConfig.clientId,
+    clientSecret: authConfig.clientSecret
+  };
+
+  return { deployData, pipelineAuthConfig };
+}
+
+/**
+ * Handle deployment response
+ * @param {Object} response - API response
+ * @returns {Object} Deployment result
+ * @throws {Error} If deployment failed
+ */
+function handleDeploymentResponse(response) {
+  if (response.success) {
+    return response.data.data || response.data;
+  }
+
+  // Handle deployment errors
+  if (response.status >= 400) {
+    const error = new Error(`Deployment request failed: ${response.formattedError || response.error || 'Unknown error'}`);
+    error.status = response.status;
+    error.data = response.data;
+    throw error;
+  }
+
+  throw new Error('Deployment request failed: Unknown error');
+}
+
+/**
+ * Preserve error information from last error
+ * @param {Error} lastError - Last error encountered
+ * @param {number} maxRetries - Maximum retry attempts
+ * @throws {Error} Formatted error with preserved information
+ */
+function throwDeploymentError(lastError, maxRetries) {
+  const errorMessage = lastError.formatted || lastError.message;
+  const error = new Error(`Deployment failed after ${maxRetries} attempts: ${errorMessage}`);
+  if (lastError.formatted) {
+    error.formatted = lastError.formatted;
+  }
+  if (lastError.status) {
+    error.status = lastError.status;
+  }
+  if (lastError.data) {
+    error.data = lastError.data;
+  }
+  throw error;
+}
+
 /**
  * Sends deployment request using validateToken from validation step
  * This is the second step in the deployment process
@@ -136,45 +187,18 @@ async function sendDeploymentRequest(url, envKey, validateToken, authConfig, opt
   const validatedEnvKey = validateEnvironmentKey(envKey);
   const maxRetries = options.maxRetries || 3;
 
-  // Extract clientId and clientSecret for deploy endpoint
-  // These should have been loaded during validation and stored in authConfig
-  if (!authConfig.clientId || !authConfig.clientSecret) {
-    throw new Error('Client ID and Client Secret are required for deployment. These should have been loaded during validation.');
-  }
-  const clientId = authConfig.clientId;
-  const clientSecret = authConfig.clientSecret;
+  // Validate credentials
+  validateDeploymentCredentials(authConfig);
 
-  // Build deployment request
-  const imageTag = options.imageTag || 'latest';
-  const deployData = {
-    validateToken: validateToken,
-    imageTag: imageTag
-  };
-
-  // Use centralized API client with retry logic
-  const pipelineAuthConfig = {
-    type: 'client-credentials',
-    clientId: clientId,
-    clientSecret: clientSecret
-  };
+  // Build deployment data
+  const { deployData, pipelineAuthConfig } = buildDeploymentData(validateToken, authConfig, options);
 
   // Wrap API call with retry logic
   let lastError;
   for (let attempt = 1; attempt <= maxRetries; attempt++) {
     try {
       const response = await deployPipeline(url, validatedEnvKey, pipelineAuthConfig, deployData);
-
-      if (response.success) {
-        return response.data.data || response.data;
-      }
-
-      // Handle deployment errors
-      if (response.status >= 400) {
-        const error = new Error(`Deployment request failed: ${response.formattedError || response.error || 'Unknown error'}`);
-        error.status = response.status;
-        error.data = response.data;
-        throw error;
-      }
+      return handleDeploymentResponse(response);
     } catch (error) {
       lastError = error;
       if (attempt < maxRetries) {
@@ -185,19 +209,7 @@ async function sendDeploymentRequest(url, envKey, validateToken, authConfig, opt
     }
   }
 
-  // Preserve formatted error if available
-  const errorMessage = lastError.formatted || lastError.message;
-  const error = new Error(`Deployment failed after ${maxRetries} attempts: ${errorMessage}`);
-  if (lastError.formatted) {
-    error.formatted = lastError.formatted;
-  }
-  if (lastError.status) {
-    error.status = lastError.status;
-  }
-  if (lastError.data) {
-    error.data = lastError.data;
-  }
-  throw error;
+  throwDeploymentError(lastError, maxRetries);
 }
 
 /**
@@ -210,6 +222,52 @@ function isTerminalStatus(status) {
   return status === 'completed' || status === 'failed' || status === 'cancelled';
 }
 
+/**
+ * Convert authConfig to pipeline auth config format
+ * @param {Object} authConfig - Authentication configuration
+ * @returns {Object} Pipeline auth config
+ */
+function convertToPipelineAuthConfig(authConfig) {
+  return authConfig.type === 'bearer'
+    ? { type: 'bearer', token: authConfig.token }
+    : { type: 'client-credentials', clientId: authConfig.clientId, clientSecret: authConfig.clientSecret };
+}
+
+/**
+ * Process deployment status response
+ * @param {Object} response - API response
+ * @param {number} attempt - Current attempt number
+ * @param {number} maxAttempts - Maximum attempts
+ * @param {number} interval - Polling interval
+ * @param {string} deploymentId - Deployment ID for error messages
+ * @returns {Object|null} Deployment data if terminal, null if needs to continue polling
+ */
+async function processDeploymentStatusResponse(response, attempt, maxAttempts, interval, deploymentId) {
+  if (!response.success || !response.data) {
+    if (response.status === 404) {
+      throw new Error(`Deployment ${deploymentId || response.deploymentId || 'unknown'} not found`);
+    }
+    throw new Error(`Status check failed: ${response.formattedError || response.error || 'Unknown error'}`);
+  }
+
+  const responseData = response.data;
+  const deploymentData = responseData.data || responseData;
+  const status = deploymentData.status;
+
+  if (isTerminalStatus(status)) {
+    return deploymentData;
+  }
+
+  const progress = deploymentData.progress || 0;
+  logger.log(chalk.blue(`   Status: ${status} (${progress}%) (attempt ${attempt + 1}/${maxAttempts})`));
+
+  if (attempt < maxAttempts - 1) {
+    await new Promise(resolve => setTimeout(resolve, interval));
+  }
+
+  return null;
+}
+
 /**
  * Polls deployment status from controller
  * Uses pipeline endpoint for CI/CD monitoring with minimal deployment info
@@ -227,37 +285,14 @@ async function pollDeploymentStatus(deploymentId, controllerUrl, envKey, authCon
   const maxAttempts = options.maxAttempts || 60;
 
   const validatedEnvKey = validateEnvironmentKey(envKey);
-
-  // Convert authConfig to format expected by API client
-  const pipelineAuthConfig = authConfig.type === 'bearer'
-    ? { type: 'bearer', token: authConfig.token }
-    : { type: 'client-credentials', clientId: authConfig.clientId, clientSecret: authConfig.clientSecret };
+  const pipelineAuthConfig = convertToPipelineAuthConfig(authConfig);
 
   for (let attempt = 0; attempt < maxAttempts; attempt++) {
     try {
       const response = await getPipelineDeployment(controllerUrl, validatedEnvKey, deploymentId, pipelineAuthConfig);
-
-      if (response.success && response.data) {
-        // OpenAPI spec: Response structure { success: boolean, data: { status, progress, ... }, timestamp: string }
-        const responseData = response.data;
-        const deploymentData = responseData.data || responseData;
-        const status = deploymentData.status;
-
-        if (isTerminalStatus(status)) {
-          return deploymentData;
-        }
-
-        const progress = deploymentData.progress || 0;
-        logger.log(chalk.blue(`   Status: ${status} (${progress}%) (attempt ${attempt + 1}/${maxAttempts})`));
-
-        if (attempt < maxAttempts - 1) {
-          await new Promise(resolve => setTimeout(resolve, interval));
-        }
-      } else {
-        if (response.status === 404) {
-          throw new Error(`Deployment ${deploymentId} not found`);
-        }
-        throw new Error(`Status check failed: ${response.formattedError || response.error || 'Unknown error'}`);
+      const deploymentData = await processDeploymentStatusResponse(response, attempt, maxAttempts, interval, deploymentId);
+      if (deploymentData) {
+        return deploymentData;
       }
     } catch (error) {
       if (error.message && error.message.includes('not found')) {

package/lib/diff.js

@@ -14,6 +14,65 @@ const path = require('path');
 const chalk = require('chalk');
 const logger = require('./utils/logger');
 
+/**
+ * Handle added field in comparison
+ * @param {string} key - Field key
+ * @param {*} value - Field value
+ * @param {string} path - Field path
+ * @param {Object} result - Result object to update
+ */
+function handleAddedField(key, value, path, result) {
+  result.added.push({
+    path: path,
+    value: value,
+    type: typeof value
+  });
+  result.identical = false;
+}
+
+/**
+ * Handle removed field in comparison
+ * @param {string} key - Field key
+ * @param {*} value - Field value
+ * @param {string} path - Field path
+ * @param {Object} result - Result object to update
+ */
+function handleRemovedField(key, value, path, result) {
+  result.removed.push({
+    path: path,
+    value: value,
+    type: typeof value
+  });
+  result.identical = false;
+}
+
+/**
+ * Handle changed field in comparison
+ * @param {*} oldValue - Old value
+ * @param {*} newValue - New value
+ * @param {string} path - Field path
+ * @param {Object} result - Result object to update
+ */
+function handleChangedField(oldValue, newValue, path, result) {
+  result.changed.push({
+    path: path,
+    oldValue: oldValue,
+    newValue: newValue,
+    oldType: typeof oldValue,
+    newType: typeof newValue
+  });
+  result.identical = false;
+}
+
+/**
+ * Check if value is a nested object (not array, not null)
+ * @param {*} value - Value to check
+ * @returns {boolean} True if nested object
+ */
+function isNestedObject(value) {
+  return typeof value === 'object' && value !== null && !Array.isArray(value);
+}
+
 /**
  * Performs deep comparison of two objects
  * Returns differences as structured result
@@ -40,20 +99,10 @@ function compareObjects(obj1, obj2, currentPath = '') {
     const val2 = obj2 && obj2[key];
 
     if (!(key in obj1)) {
-      result.added.push({
-        path: newPath,
-        value: val2,
-        type: typeof val2
-      });
-      result.identical = false;
+      handleAddedField(key, val2, newPath, result);
     } else if (!(key in obj2)) {
-      result.removed.push({
-        path: newPath,
-        value: val1,
-        type: typeof val1
-      });
-      result.identical = false;
-    } else if (typeof val1 === 'object' && typeof val2 === 'object' && val1 !== null && val2 !== null && !Array.isArray(val1) && !Array.isArray(val2)) {
+      handleRemovedField(key, val1, newPath, result);
+    } else if (isNestedObject(val1) && isNestedObject(val2)) {
       // Recursively compare nested objects
       const nestedResult = compareObjects(val1, val2, newPath);
       result.added.push(...nestedResult.added);
@@ -63,14 +112,7 @@ function compareObjects(obj1, obj2, currentPath = '') {
         result.identical = false;
       }
     } else if (JSON.stringify(val1) !== JSON.stringify(val2)) {
-      result.changed.push({
-        path: newPath,
-        oldValue: val1,
-        newValue: val2,
-        oldType: typeof val1,
-        newType: typeof val2
-      });
-      result.identical = false;
+      handleChangedField(val1, val2, newPath, result);
     }
   }