@aifabrix/builder 2.22.1 → 2.31.0

package/lib/environment-deploy.js

@@ -126,6 +126,39 @@ async function sendEnvironmentDeployment(controllerUrl, envKey, authConfig, opti
   }
 }
 
+/**
+ * Process environment status response
+ * @param {Object} response - API response
+ * @param {string} validatedEnvKey - Validated environment key
+ * @returns {Object|null} Status result if ready, null if needs to continue polling
+ * @throws {Error} If deployment failed
+ */
+function processEnvironmentStatusResponse(response, validatedEnvKey) {
+  if (!response.success || !response.data) {
+    return null;
+  }
+
+  const responseData = response.data.data || response.data;
+  const status = responseData.status || responseData.ready;
+  const isReady = status === 'ready' || status === 'completed' || responseData.ready === true;
+
+  if (isReady) {
+    return {
+      success: true,
+      environment: validatedEnvKey,
+      status: 'ready',
+      message: 'Environment is ready for application deployments'
+    };
+  }
+
+  // Check for terminal failure states
+  if (status === 'failed' || status === 'error') {
+    throw new Error(`Environment deployment failed: ${responseData.message || 'Unknown error'}`);
+  }
+
+  return null;
+}
+
 /**
  * Polls environment deployment status
  * @async
@@ -153,25 +186,9 @@ async function pollEnvironmentStatus(deploymentId, controllerUrl, envKey, authCo
       await new Promise(resolve => setTimeout(resolve, pollInterval));
 
       const response = await getEnvironmentStatus(validatedUrl, validatedEnvKey, apiAuthConfig);
-
-      if (response.success && response.data) {
-        const responseData = response.data.data || response.data;
-        const status = responseData.status || responseData.ready;
-        const isReady = status === 'ready' || status === 'completed' || responseData.ready === true;
-
-        if (isReady) {
-          return {
-            success: true,
-            environment: validatedEnvKey,
-            status: 'ready',
-            message: 'Environment is ready for application deployments'
-          };
-        }
-
-        // Check for terminal failure states
-        if (status === 'failed' || status === 'error') {
-          throw new Error(`Environment deployment failed: ${responseData.message || 'Unknown error'}`);
-        }
+      const statusResult = processEnvironmentStatusResponse(response, validatedEnvKey);
+      if (statusResult) {
+        return statusResult;
       }
     } catch (error) {
       // If it's a terminal error (not a timeout), throw it

package/lib/external-system-deploy.js

@@ -194,6 +194,132 @@ async function buildExternalSystem(appName, options = {}) {
   }
 }
 
+/**
+ * Validate deployment prerequisites
+ * @async
+ * @param {string} appName - Application name
+ * @returns {Promise<Object>} Validation result with systemFiles, datasourceFiles, and systemKey
+ */
+async function validateDeploymentPrerequisites(appName) {
+  const { systemFiles: _systemFiles, datasourceFiles, systemKey } = await validateExternalSystemFiles(appName);
+  return { systemFiles: _systemFiles, datasourceFiles, systemKey };
+}
+
+/**
+ * Prepare deployment files and get authentication
+ * @async
+ * @param {string} appName - Application name
+ * @param {Object} options - Deployment options
+ * @returns {Promise<Object>} Object with applicationSchema, authConfig, controllerUrl, environment, and systemKey
+ */
+async function prepareDeploymentFiles(appName, options) {
+  logger.log(chalk.blue('📋 Generating application schema...'));
+  const applicationSchema = await generateExternalSystemApplicationSchema(appName);
+  logger.log(chalk.green('✓ Application schema generated'));
+
+  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, appName);
+
+  if (!authConfig.token && !authConfig.clientId) {
+    throw new Error('Authentication required. Run "aifabrix login" or "aifabrix app register" first.');
+  }
+
+  const { systemKey } = await validateDeploymentPrerequisites(appName);
+
+  return { applicationSchema, authConfig, controllerUrl, environment, systemKey };
+}
+
+/**
+ * Upload application and get upload ID
+ * @async
+ * @param {string} dataplaneUrl - Dataplane URL
+ * @param {Object} authConfig - Authentication configuration
+ * @param {Object} applicationSchema - Application schema
+ * @returns {Promise<string>} Upload ID
+ * @throws {Error} If upload fails
+ */
+async function uploadApplication(dataplaneUrl, authConfig, applicationSchema) {
+  logger.log(chalk.blue('📤 Uploading application configuration...'));
+  const uploadResponse = await uploadApplicationViaPipeline(dataplaneUrl, authConfig, applicationSchema);
+
+  if (!uploadResponse.success || !uploadResponse.data) {
+    throw new Error(`Failed to upload application: ${uploadResponse.error || uploadResponse.formattedError || 'Unknown error'}`);
+  }
+
+  const uploadData = uploadResponse.data.data || uploadResponse.data;
+  const uploadId = uploadData.uploadId || uploadData.id;
+
+  if (!uploadId) {
+    throw new Error('Upload ID not found in upload response');
+  }
+
+  logger.log(chalk.green(`✓ Upload successful (ID: ${uploadId})`));
+  return uploadId;
+}
+
+/**
+ * Validate upload and display changes
+ * @async
+ * @param {string} dataplaneUrl - Dataplane URL
+ * @param {string} uploadId - Upload ID
+ * @param {Object} authConfig - Authentication configuration
+ * @returns {Promise<void>}
+ * @throws {Error} If validation fails
+ */
+async function validateUpload(dataplaneUrl, uploadId, authConfig) {
+  logger.log(chalk.blue('🔍 Validating upload...'));
+  const validateResponse = await validateUploadViaPipeline(dataplaneUrl, uploadId, authConfig);
+
+  if (!validateResponse.success || !validateResponse.data) {
+    throw new Error(`Validation failed: ${validateResponse.error || validateResponse.formattedError || 'Unknown error'}`);
+  }
+
+  const validateData = validateResponse.data.data || validateResponse.data;
+
+  // Display changes
+  if (validateData.changes && validateData.changes.length > 0) {
+    logger.log(chalk.blue('\n📋 Changes to be published:'));
+    for (const change of validateData.changes) {
+      const changeType = change.type || 'unknown';
+      const changeEntity = change.entity || change.key || 'unknown';
+      const emoji = changeType === 'new' ? '➕' : changeType === 'modified' ? '✏️' : '🗑️';
+      logger.log(chalk.gray(`  ${emoji} ${changeType}: ${changeEntity}`));
+    }
+  }
+
+  if (validateData.summary) {
+    logger.log(chalk.blue(`\n📊 Summary: ${validateData.summary}`));
+  }
+
+  logger.log(chalk.green('✓ Validation successful'));
+}
+
+/**
+ * Publish application
+ * @async
+ * @param {string} dataplaneUrl - Dataplane URL
+ * @param {string} uploadId - Upload ID
+ * @param {Object} authConfig - Authentication configuration
+ * @param {Object} options - Publish options
+ * @param {boolean} [options.generateMcpContract] - Generate MCP contract (default: true)
+ * @returns {Promise<Object>} Publish response data
+ * @throws {Error} If publish fails
+ */
+async function publishApplication(dataplaneUrl, uploadId, authConfig, options) {
+  const generateMcpContract = options.generateMcpContract !== false; // Default to true
+  logger.log(chalk.blue(`📢 Publishing application (MCP contract: ${generateMcpContract ? 'enabled' : 'disabled'})...`));
+
+  const publishResponse = await publishUploadViaPipeline(dataplaneUrl, uploadId, authConfig, { generateMcpContract });
+
+  if (!publishResponse.success || !publishResponse.data) {
+    throw new Error(`Failed to publish application: ${publishResponse.error || publishResponse.formattedError || 'Unknown error'}`);
+  }
+
+  return publishResponse.data.data || publishResponse.data;
+}
+
 /**
  * Publishes external system to dataplane using application-level workflow
  * Uses upload → validate → publish workflow for atomic deployment
@@ -212,23 +338,11 @@ async function deployExternalSystem(appName, options = {}) {
   try {
     logger.log(chalk.blue(`\n🚀 Publishing external system: ${appName}`));
 
-    // Validate files
-    const { systemFiles: _systemFiles, datasourceFiles, systemKey } = await validateExternalSystemFiles(appName);
-
-    // Generate application-schema.json structure
-    logger.log(chalk.blue('📋 Generating application schema...'));
-    const applicationSchema = await generateExternalSystemApplicationSchema(appName);
-    logger.log(chalk.green('✓ Application schema generated'));
+    // Validate prerequisites
+    const { datasourceFiles } = await validateDeploymentPrerequisites(appName);
 
-    // Get authentication
-    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, appName);
-
-    if (!authConfig.token && !authConfig.clientId) {
-      throw new Error('Authentication required. Run "aifabrix login" or "aifabrix app register" first.');
-    }
+    // Prepare deployment files and get authentication
+    const { applicationSchema, authConfig, controllerUrl, environment, systemKey } = await prepareDeploymentFiles(appName, options);
 
     // Get dataplane URL from controller
     logger.log(chalk.blue('🌐 Getting dataplane URL from controller...'));
@@ -236,65 +350,19 @@ async function deployExternalSystem(appName, options = {}) {
     logger.log(chalk.green(`✓ Dataplane URL: ${dataplaneUrl}`));
 
     // Step 1: Upload application
-    logger.log(chalk.blue('📤 Uploading application configuration...'));
-    const uploadResponse = await uploadApplicationViaPipeline(dataplaneUrl, authConfig, applicationSchema);
-
-    if (!uploadResponse.success || !uploadResponse.data) {
-      throw new Error(`Failed to upload application: ${uploadResponse.error || uploadResponse.formattedError || 'Unknown error'}`);
-    }
-
-    const uploadData = uploadResponse.data.data || uploadResponse.data;
-    const uploadId = uploadData.uploadId || uploadData.id;
-
-    if (!uploadId) {
-      throw new Error('Upload ID not found in upload response');
-    }
-
-    logger.log(chalk.green(`✓ Upload successful (ID: ${uploadId})`));
+    const uploadId = await uploadApplication(dataplaneUrl, authConfig, applicationSchema);
 
     // Step 2: Validate upload (optional, can be skipped)
     if (!options.skipValidation) {
-      logger.log(chalk.blue('🔍 Validating upload...'));
-      const validateResponse = await validateUploadViaPipeline(dataplaneUrl, uploadId, authConfig);
-
-      if (!validateResponse.success || !validateResponse.data) {
-        throw new Error(`Validation failed: ${validateResponse.error || validateResponse.formattedError || 'Unknown error'}`);
-      }
-
-      const validateData = validateResponse.data.data || validateResponse.data;
-
-      // Display changes
-      if (validateData.changes && validateData.changes.length > 0) {
-        logger.log(chalk.blue('\n📋 Changes to be published:'));
-        for (const change of validateData.changes) {
-          const changeType = change.type || 'unknown';
-          const changeEntity = change.entity || change.key || 'unknown';
-          const emoji = changeType === 'new' ? '➕' : changeType === 'modified' ? '✏️' : '🗑️';
-          logger.log(chalk.gray(`  ${emoji} ${changeType}: ${changeEntity}`));
-        }
-      }
-
-      if (validateData.summary) {
-        logger.log(chalk.blue(`\n📊 Summary: ${validateData.summary}`));
-      }
-
-      logger.log(chalk.green('✓ Validation successful'));
+      await validateUpload(dataplaneUrl, uploadId, authConfig);
     } else {
       logger.log(chalk.yellow('⚠ Skipping validation step'));
     }
 
     // Step 3: Publish application
-    const generateMcpContract = options.generateMcpContract !== false; // Default to true
-    logger.log(chalk.blue(`📢 Publishing application (MCP contract: ${generateMcpContract ? 'enabled' : 'disabled'})...`));
-
-    const publishResponse = await publishUploadViaPipeline(dataplaneUrl, uploadId, authConfig, { generateMcpContract });
-
-    if (!publishResponse.success || !publishResponse.data) {
-      throw new Error(`Failed to publish application: ${publishResponse.error || publishResponse.formattedError || 'Unknown error'}`);
-    }
-
-    const publishData = publishResponse.data.data || publishResponse.data;
+    const publishData = await publishApplication(dataplaneUrl, uploadId, authConfig, options);
 
+    // Display success summary
     logger.log(chalk.green('\n✅ External system published successfully!'));
     logger.log(chalk.blue(`System: ${systemKey}`));
     if (publishData.systems && publishData.systems.length > 0) {