@aifabrix/builder 2.31.0 → 2.32.1

package/lib/datasource/list.js

@@ -0,0 +1,223 @@
+/**
+ * Datasource List Command
+ *
+ * Lists datasources from an environment via controller API.
+ *
+ * @fileoverview Datasource listing for AI Fabrix Builder
+ * @author AI Fabrix Team
+ * @version 2.0.0
+ */
+
+const chalk = require('chalk');
+const { getConfig } = require('../core/config');
+const { getOrRefreshDeviceToken } = require('../utils/token-manager');
+const { listEnvironmentDatasources } = require('../api/environments.api');
+const { formatApiError } = require('../utils/api-error-handler');
+const logger = require('../utils/logger');
+
+/**
+ * Extracts datasources array from API response
+ * Handles multiple response formats similar to applications list
+ *
+ * @function extractDatasources
+ * @param {Object} response - API response from centralized API client
+ * @returns {Array} Array of datasources
+ * @throws {Error} If response format is invalid
+ */
+/**
+ * Extracts datasources from wrapped format
+ * @function extractFromWrappedFormat
+ * @param {Object} apiResponse - API response object
+ * @returns {Array|null} Datasources array or null
+ */
+function extractFromWrappedFormat(apiResponse) {
+  if (apiResponse && apiResponse.data && Array.isArray(apiResponse.data)) {
+    return apiResponse.data;
+  }
+  return null;
+}
+
+/**
+ * Extracts datasources from direct array format
+ * @function extractFromDirectArray
+ * @param {Object} apiResponse - API response object
+ * @returns {Array|null} Datasources array or null
+ */
+function extractFromDirectArray(apiResponse) {
+  if (Array.isArray(apiResponse)) {
+    return apiResponse;
+  }
+  return null;
+}
+
+/**
+ * Extracts datasources from paginated format
+ * @function extractFromPaginatedFormat
+ * @param {Object} apiResponse - API response object
+ * @returns {Array|null} Datasources array or null
+ */
+function extractFromPaginatedFormat(apiResponse) {
+  if (apiResponse && Array.isArray(apiResponse.items)) {
+    return apiResponse.items;
+  }
+  if (apiResponse && apiResponse.data && apiResponse.data.items && Array.isArray(apiResponse.data.items)) {
+    return apiResponse.data.items;
+  }
+  return null;
+}
+
+/**
+ * Logs error for invalid response format
+ * @function logInvalidResponseError
+ * @param {Object} apiResponse - API response object
+ */
+function logInvalidResponseError(apiResponse) {
+  logger.error(chalk.red('❌ Invalid response: expected data array or items array'));
+  logger.error(chalk.gray('\nAPI response type:'), typeof apiResponse);
+  logger.error(chalk.gray('API response:'), JSON.stringify(apiResponse, null, 2));
+}
+
+function extractDatasources(response) {
+  if (!response.success || !response.data) {
+    throw new Error('Invalid API response: missing success or data');
+  }
+
+  const apiResponse = response.data;
+
+  // Try different response formats
+  const datasources = extractFromWrappedFormat(apiResponse) ||
+    extractFromDirectArray(apiResponse) ||
+    extractFromPaginatedFormat(apiResponse);
+
+  if (!datasources) {
+    logInvalidResponseError(apiResponse);
+    throw new Error('Invalid API response format: expected array of datasources');
+  }
+
+  return datasources;
+}
+
+/**
+ * Displays datasources in a formatted table
+ *
+ * @function displayDatasources
+ * @param {Array} datasources - Array of datasource objects
+ * @param {string} environment - Environment key
+ */
+function displayDatasources(datasources, environment) {
+  if (datasources.length === 0) {
+    logger.log(chalk.yellow(`\nNo datasources found in environment: ${environment}`));
+    return;
+  }
+
+  logger.log(chalk.blue(`\n📋 Datasources in environment: ${environment}\n`));
+  logger.log(chalk.gray('Key'.padEnd(30) + 'Display Name'.padEnd(30) + 'System Key'.padEnd(20) + 'Version'.padEnd(15) + 'Status'));
+  logger.log(chalk.gray('-'.repeat(120)));
+
+  datasources.forEach((ds) => {
+    const key = (ds.key || 'N/A').padEnd(30);
+    const displayName = (ds.displayName || 'N/A').padEnd(30);
+    const systemKey = (ds.systemKey || 'N/A').padEnd(20);
+    const version = (ds.version || 'N/A').padEnd(15);
+    const status = ds.enabled !== false ? chalk.green('enabled') : chalk.red('disabled');
+    logger.log(`${key}${displayName}${systemKey}${version}${status}`);
+  });
+  logger.log('');
+}
+
+/**
+ * Lists datasources from an environment
+ *
+ * @async
+ * @function listDatasources
+ * @param {Object} options - Command options
+ * @param {string} options.environment - Environment ID or key
+ * @throws {Error} If listing fails
+ */
+/**
+ * Gets device token from config
+ * @async
+ * @function getDeviceTokenFromConfig
+ * @param {Object} config - Configuration object
+ * @returns {Promise<Object|null>} Object with token and controllerUrl or null
+ */
+async function getDeviceTokenFromConfig(config) {
+  if (!config.device) {
+    return null;
+  }
+
+  const deviceUrls = Object.keys(config.device);
+  if (deviceUrls.length === 0) {
+    return null;
+  }
+
+  const controllerUrl = deviceUrls[0];
+  const deviceToken = await getOrRefreshDeviceToken(controllerUrl);
+  if (deviceToken && deviceToken.token) {
+    return {
+      token: deviceToken.token,
+      controllerUrl: deviceToken.controller
+    };
+  }
+
+  return null;
+}
+
+/**
+ * Validates authentication for datasource listing
+ * @function validateDatasourceListingAuth
+ * @param {string|null} token - Authentication token
+ * @param {string|null} controllerUrl - Controller URL
+ */
+function validateDatasourceListingAuth(token, controllerUrl) {
+  if (!token || !controllerUrl) {
+    logger.error(chalk.red('❌ Not logged in. Run: aifabrix login'));
+    logger.error(chalk.gray('   Use device code flow: aifabrix login --method device --controller <url>'));
+    process.exit(1);
+  }
+}
+
+/**
+ * Handles API response errors
+ * @function handleDatasourceApiError
+ * @param {Object} response - API response
+ */
+function handleDatasourceApiError(response) {
+  const formattedError = response.formattedError || formatApiError(response);
+  logger.error(formattedError);
+  logger.error(chalk.gray('\nFull response for debugging:'));
+  logger.error(chalk.gray(JSON.stringify(response, null, 2)));
+  process.exit(1);
+}
+
+async function listDatasources(options) {
+  const config = await getConfig();
+
+  // Try to get device token
+  const authInfo = await getDeviceTokenFromConfig(config);
+  validateDatasourceListingAuth(authInfo?.token, authInfo?.controllerUrl);
+
+  // Call controller API using centralized API client
+  // Note: validateDatasourceListingAuth will exit if auth is missing, so this check is defensive
+  if (!authInfo || !authInfo.token || !authInfo.controllerUrl) {
+    validateDatasourceListingAuth(null, null); // This will exit
+    return; // Never reached, but satisfies linter
+  }
+  const authConfig = { type: 'bearer', token: authInfo.token };
+  const response = await listEnvironmentDatasources(authInfo.controllerUrl, options.environment, authConfig);
+
+  if (!response.success || !response.data) {
+    handleDatasourceApiError(response);
+    return; // Ensure we don't continue after exit
+  }
+
+  const datasources = extractDatasources(response);
+  displayDatasources(datasources, options.environment);
+}
+
+module.exports = {
+  listDatasources,
+  displayDatasources,
+  extractDatasources
+};
+

package/lib/{datasource-validate.js → datasource/validate.js}

@@ -9,8 +9,8 @@
  */
 
 const fs = require('fs');
-const { loadExternalDataSourceSchema } = require('./utils/schema-loader');
-const { formatValidationErrors } = require('./utils/error-formatter');
+const { loadExternalDataSourceSchema } = require('../utils/schema-loader');
+const { formatValidationErrors } = require('../utils/error-formatter');
 
 /**
  * Validates a datasource file against external-datasource schema

package/lib/{deployer.js → deployment/deployer.js}

@@ -10,12 +10,12 @@
  */
 
 const chalk = require('chalk');
-const auditLogger = require('./audit-logger');
-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');
+const auditLogger = require('../core/audit-logger');
+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');
 
 /**
  * Build validation data for deployment
@@ -27,7 +27,7 @@ const { handleValidationResponse } = require('./utils/deployment-validation-help
  * @returns {Promise<Object>} Object with validationData and pipelineAuthConfig
  */
 async function buildValidationData(manifest, validatedEnvKey, authConfig, options) {
-  const tokenManager = require('./utils/token-manager');
+  const tokenManager = require('../utils/token-manager');
   const { clientId, clientSecret } = await tokenManager.extractClientCredentials(
     authConfig,
     manifest.key,
@@ -242,25 +242,55 @@ function convertToPipelineAuthConfig(authConfig) {
  * @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'}`);
+/**
+ * Handles error response from deployment status check
+ * @function handleDeploymentStatusError
+ * @param {Object} response - API response
+ * @param {string} deploymentId - Deployment ID
+ * @throws {Error} Appropriate error message
+ */
+function handleDeploymentStatusError(response, deploymentId) {
+  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'}`);
+}
 
+/**
+ * Extracts deployment data from response
+ * @function extractDeploymentData
+ * @param {Object} response - API response
+ * @returns {Object} Deployment data
+ */
+function extractDeploymentData(response) {
   const responseData = response.data;
-  const deploymentData = responseData.data || responseData;
+  return responseData.data || responseData;
+}
+
+/**
+ * Logs deployment progress
+ * @function logDeploymentProgress
+ * @param {Object} deploymentData - Deployment data
+ * @param {number} attempt - Current attempt
+ * @param {number} maxAttempts - Maximum attempts
+ */
+function logDeploymentProgress(deploymentData, attempt, maxAttempts) {
   const status = deploymentData.status;
+  const progress = deploymentData.progress || 0;
+  logger.log(chalk.blue(`   Status: ${status} (${progress}%) (attempt ${attempt + 1}/${maxAttempts})`));
+}
 
-  if (isTerminalStatus(status)) {
-    return deploymentData;
+async function processDeploymentStatusResponse(response, attempt, maxAttempts, interval, deploymentId) {
+  if (!response.success || !response.data) {
+    handleDeploymentStatusError(response, deploymentId);
   }
 
-  const progress = deploymentData.progress || 0;
-  logger.log(chalk.blue(`   Status: ${status} (${progress}%) (attempt ${attempt + 1}/${maxAttempts})`));
+  const deploymentData = extractDeploymentData(response);
+  if (isTerminalStatus(deploymentData.status)) {
+    return deploymentData;
+  }
 
+  logDeploymentProgress(deploymentData, attempt, maxAttempts);
   if (attempt < maxAttempts - 1) {
     await new Promise(resolve => setTimeout(resolve, interval));
   }

package/lib/{environment-deploy.js → deployment/environment.js}

@@ -10,14 +10,14 @@
  */
 
 const chalk = require('chalk');
-const logger = require('./utils/logger');
-const config = require('./config');
-const { validateControllerUrl, validateEnvironmentKey } = require('./utils/deployment-validation');
-const { getOrRefreshDeviceToken } = require('./utils/token-manager');
-const { getEnvironmentStatus } = require('./api/environments.api');
-const { deployEnvironment: deployEnvironmentInfra } = require('./api/deployments.api');
-const { handleDeploymentErrors } = require('./utils/deployment-errors');
-const auditLogger = require('./audit-logger');
+const logger = require('../utils/logger');
+const config = require('../core/config');
+const { validateControllerUrl, validateEnvironmentKey } = require('../utils/deployment-validation');
+const { getOrRefreshDeviceToken } = require('../utils/token-manager');
+const { getEnvironmentStatus } = require('../api/environments.api');
+const { deployEnvironment: deployEnvironmentInfra } = require('../api/deployments.api');
+const { handleDeploymentErrors } = require('../utils/deployment-errors');
+const auditLogger = require('../core/audit-logger');
 
 /**
  * Validates environment deployment prerequisites
@@ -76,51 +76,78 @@ async function getEnvironmentAuth(controllerUrl) {
  * @returns {Promise<Object>} Deployment result
  * @throws {Error} If deployment fails
  */
-async function sendEnvironmentDeployment(controllerUrl, envKey, authConfig, options = {}) {
-  const validatedUrl = validateControllerUrl(controllerUrl);
-  const validatedEnvKey = validateEnvironmentKey(envKey);
-
-  // Build environment deployment request
-  const deploymentRequest = {
+/**
+ * Builds environment deployment request
+ * @function buildEnvironmentDeploymentRequest
+ * @param {string} validatedEnvKey - Validated environment key
+ * @param {Object} options - Deployment options
+ * @returns {Object} Deployment request object
+ */
+function buildEnvironmentDeploymentRequest(validatedEnvKey, options) {
+  const capitalized = validatedEnvKey.charAt(0).toUpperCase() + validatedEnvKey.slice(1);
+  const request = {
     key: validatedEnvKey,
-    displayName: `${validatedEnvKey.charAt(0).toUpperCase() + validatedEnvKey.slice(1)} Environment`,
-    description: `${validatedEnvKey.charAt(0).toUpperCase() + validatedEnvKey.slice(1)} environment for application deployments`
+    displayName: `${capitalized} Environment`,
+    description: `${capitalized} environment for application deployments`
   };
 
-  // Add configuration if provided
   if (options.config) {
-    // TODO: Load and parse config file if provided
-    // For now, just include the config path in description
-    deploymentRequest.description += ` (config: ${options.config})`;
+    request.description += ` (config: ${options.config})`;
   }
 
-  // Log deployment attempt for audit
+  return request;
+}
+
+/**
+ * Handles deployment API error response
+ * @function handleDeploymentApiError
+ * @param {Object} response - API response
+ * @throws {Error} Deployment error
+ */
+function handleDeploymentApiError(response) {
+  const error = new Error(response.formattedError || response.error || 'Environment deployment failed');
+  error.status = response.status;
+  error.data = response.errorData || response.data;
+  throw error;
+}
+
+/**
+ * Builds deployment result from API response
+ * @function buildDeploymentResult
+ * @param {Object} response - API response
+ * @param {string} validatedEnvKey - Validated environment key
+ * @param {string} validatedUrl - Validated controller URL
+ * @returns {Object} Deployment result
+ */
+function buildDeploymentResult(response, validatedEnvKey, validatedUrl) {
+  const responseData = response.data.data || response.data || {};
+  return {
+    success: true,
+    environment: validatedEnvKey,
+    deploymentId: responseData.deploymentId || responseData.id,
+    status: responseData.status || 'initiated',
+    url: responseData.url || `${validatedUrl}/environments/${validatedEnvKey}`,
+    message: responseData.message
+  };
+}
+
+async function sendEnvironmentDeployment(controllerUrl, envKey, authConfig, options = {}) {
+  const validatedUrl = validateControllerUrl(controllerUrl);
+  const validatedEnvKey = validateEnvironmentKey(envKey);
+  const deploymentRequest = buildEnvironmentDeploymentRequest(validatedEnvKey, options);
+
   await auditLogger.logDeploymentAttempt(validatedEnvKey, validatedUrl, options);
 
   try {
-    // Use centralized API client
     const apiAuthConfig = { type: 'bearer', token: authConfig.token };
     const response = await deployEnvironmentInfra(validatedUrl, validatedEnvKey, apiAuthConfig, deploymentRequest);
 
     if (!response.success) {
-      const error = new Error(response.formattedError || response.error || 'Environment deployment failed');
-      error.status = response.status;
-      error.data = response.errorData || response.data;
-      throw error;
+      handleDeploymentApiError(response);
     }
 
-    // Handle response structure
-    const responseData = response.data.data || response.data || {};
-    return {
-      success: true,
-      environment: validatedEnvKey,
-      deploymentId: responseData.deploymentId || responseData.id,
-      status: responseData.status || 'initiated',
-      url: responseData.url || `${validatedUrl}/environments/${validatedEnvKey}`,
-      message: responseData.message
-    };
+    return buildDeploymentResult(response, validatedEnvKey, validatedUrl);
   } catch (error) {
-    // Use unified error handler
     await handleDeploymentErrors(error, validatedEnvKey, validatedUrl, false);
     throw error;
   }
@@ -241,60 +268,112 @@ function displayDeploymentResults(result) {
  * @example
  * await deployEnvironment('dev', { controller: 'https://controller.aifabrix.ai' });
  */
-async function deployEnvironment(envKey, options = {}) {
-  try {
-    // 1. Input validation
-    if (!envKey || typeof envKey !== 'string' || envKey.trim().length === 0) {
-      throw new Error('Environment key is required');
-    }
+/**
+ * Validates deployment input parameters
+ * @function validateDeploymentInput
+ * @param {string} envKey - Environment key
+ * @param {Object} options - Deployment options
+ * @returns {string} Controller URL
+ * @throws {Error} If validation fails
+ */
+function validateDeploymentInput(envKey, options) {
+  if (!envKey || typeof envKey !== 'string' || envKey.trim().length === 0) {
+    throw new Error('Environment key is required');
+  }
 
-    const controllerUrl = options.controller || options['controller-url'];
-    if (!controllerUrl) {
-      throw new Error('Controller URL is required. Use --controller flag');
-    }
+  const controllerUrl = options.controller || options['controller-url'];
+  if (!controllerUrl) {
+    throw new Error('Controller URL is required. Use --controller flag');
+  }
 
-    // 2. Validate prerequisites
-    if (!options.skipValidation) {
-      validateEnvironmentPrerequisites(envKey, controllerUrl);
-    }
+  return controllerUrl;
+}
+
+/**
+ * Prepares environment deployment
+ * @async
+ * @function prepareEnvironmentDeployment
+ * @param {string} envKey - Environment key
+ * @param {string} controllerUrl - Controller URL
+ * @param {Object} options - Deployment options
+ * @returns {Promise<Object>} Authentication configuration
+ */
+async function prepareEnvironmentDeployment(envKey, controllerUrl, options) {
+  // Validate prerequisites
+  if (!options.skipValidation) {
+    validateEnvironmentPrerequisites(envKey, controllerUrl);
+  }
 
-    // 3. Update root-level environment in config.yaml
-    await config.setCurrentEnvironment(envKey);
+  // Update root-level environment in config.yaml
+  await config.setCurrentEnvironment(envKey);
 
-    // 4. Get authentication (device token)
-    logger.log(chalk.blue(`\n📋 Deploying environment '${envKey}' to ${controllerUrl}...`));
-    const authConfig = await getEnvironmentAuth(controllerUrl);
-    logger.log(chalk.green('✓ Environment validated'));
-    logger.log(chalk.green('✓ Authentication successful'));
+  // Get authentication (device token)
+  logger.log(chalk.blue(`\n📋 Deploying environment '${envKey}' to ${controllerUrl}...`));
+  const authConfig = await getEnvironmentAuth(controllerUrl);
+  logger.log(chalk.green('✓ Environment validated'));
+  logger.log(chalk.green('✓ Authentication successful'));
 
-    // 5. Send environment deployment request
-    logger.log(chalk.blue('\n🚀 Deploying environment infrastructure...'));
-    const validatedControllerUrl = validateControllerUrl(authConfig.controller);
-    const result = await sendEnvironmentDeployment(validatedControllerUrl, envKey, authConfig, options);
-
-    logger.log(chalk.blue(`📤 Sending deployment request to ${validatedControllerUrl}/api/v1/environments/${envKey}/deploy...`));
-
-    // 6. Poll for status if enabled
-    const shouldPoll = options.poll !== false && !options.noPoll;
-    if (shouldPoll && result.deploymentId) {
-      const pollResult = await pollEnvironmentStatus(
-        result.deploymentId,
-        validatedControllerUrl,
-        envKey,
-        authConfig,
-        {
-          pollInterval: 5000,
-          maxAttempts: 60
-        }
-      );
-      result.status = pollResult.status;
-      result.message = pollResult.message;
-    }
+  return authConfig;
+}
+
+/**
+ * Executes environment deployment
+ * @async
+ * @function executeEnvironmentDeployment
+ * @param {string} validatedControllerUrl - Validated controller URL
+ * @param {string} envKey - Environment key
+ * @param {Object} authConfig - Authentication configuration
+ * @param {Object} options - Deployment options
+ * @returns {Promise<Object>} Deployment result
+ */
+async function executeEnvironmentDeployment(validatedControllerUrl, envKey, authConfig, options) {
+  logger.log(chalk.blue('\n🚀 Deploying environment infrastructure...'));
+  const result = await sendEnvironmentDeployment(validatedControllerUrl, envKey, authConfig, options);
+  logger.log(chalk.blue(`📤 Sending deployment request to ${validatedControllerUrl}/api/v1/environments/${envKey}/deploy...`));
+  return result;
+}
+
+/**
+ * Polls deployment status if enabled
+ * @async
+ * @function pollDeploymentStatusIfEnabled
+ * @param {Object} result - Deployment result
+ * @param {string} validatedControllerUrl - Validated controller URL
+ * @param {string} envKey - Environment key
+ * @param {Object} authConfig - Authentication configuration
+ * @param {Object} options - Deployment options
+ * @returns {Promise<Object>} Updated result with status
+ */
+async function pollDeploymentStatusIfEnabled(result, validatedControllerUrl, envKey, authConfig, options) {
+  const shouldPoll = options.poll !== false && !options.noPoll;
+  if (shouldPoll && result.deploymentId) {
+    const pollResult = await pollEnvironmentStatus(
+      result.deploymentId,
+      validatedControllerUrl,
+      envKey,
+      authConfig,
+      {
+        pollInterval: 5000,
+        maxAttempts: 60
+      }
+    );
+    result.status = pollResult.status;
+    result.message = pollResult.message;
+  }
+  return result;
+}
 
-    // 7. Display results
-    displayDeploymentResults(result);
+async function deployEnvironment(envKey, options = {}) {
+  try {
+    const controllerUrl = validateDeploymentInput(envKey, options);
+    const authConfig = await prepareEnvironmentDeployment(envKey, controllerUrl, options);
+
+    const validatedControllerUrl = validateControllerUrl(authConfig.controller);
+    const result = await executeEnvironmentDeployment(validatedControllerUrl, envKey, authConfig, options);
+    const finalResult = await pollDeploymentStatusIfEnabled(result, validatedControllerUrl, envKey, authConfig, options);
 
-    return result;
+    displayDeploymentResults(finalResult);
+    return finalResult;
   } catch (error) {
     // Error handling is done in sendEnvironmentDeployment and pollEnvironmentStatus
     // Re-throw with context

package/lib/{push.js → deployment/push.js}

@@ -12,7 +12,7 @@
 const { exec } = require('child_process');
 const { promisify } = require('util');
 const chalk = require('chalk');
-const logger = require('./utils/logger');
+const logger = require('../utils/logger');
 
 const execAsync = promisify(exec);