@aifabrix/builder 2.22.1 → 2.31.0

package/jest.config.coverage.js

@@ -0,0 +1,37 @@
+/**
+ * Jest Configuration for Coverage Reports
+ * Extends base config with coverage settings
+ */
+
+const baseConfig = require('./jest.config');
+
+module.exports = {
+  ...baseConfig,
+  collectCoverageFrom: [
+    'lib/**/*.js',
+    'bin/**/*.js',
+    '!**/node_modules/**',
+    '!**/tests/**',
+    '!lib/infra.js',
+    '!bin/aifabrix.js'
+  ],
+  coverageDirectory: 'coverage',
+  coverageReporters: [
+    'text',
+    'lcov',
+    'html'
+  ],
+  coverageProvider: 'v8',
+  coverageThreshold: {
+    global: {
+      branches: 80,
+      functions: 80,
+      lines: 80,
+      statements: 80
+    }
+  },
+  // Memory management for coverage runs
+  maxWorkers: 2,
+  workerIdleMemoryLimit: '500MB'
+};
+

package/lib/api/pipeline.api.js

@@ -105,18 +105,19 @@ async function publishDatasourceViaPipeline(dataplaneUrl, systemKey, authConfig,
  * POST /api/v1/pipeline/{systemKey}/{datasourceKey}/test
  * @async
  * @function testDatasourceViaPipeline
- * @param {string} dataplaneUrl - Dataplane base URL
- * @param {string} systemKey - System key
- * @param {string} datasourceKey - Datasource key
- * @param {Object} authConfig - Authentication configuration
- * @param {Object} testData - Test data
- * @param {Object} testData.payloadTemplate - Test payload template
- * @param {Object} [options] - Request options
- * @param {number} [options.timeout] - Request timeout in milliseconds
+ * @param {Object} params - Function parameters
+ * @param {string} params.dataplaneUrl - Dataplane base URL
+ * @param {string} params.systemKey - System key
+ * @param {string} params.datasourceKey - Datasource key
+ * @param {Object} params.authConfig - Authentication configuration
+ * @param {Object} params.testData - Test data
+ * @param {Object} params.testData.payloadTemplate - Test payload template
+ * @param {Object} [params.options] - Request options
+ * @param {number} [params.options.timeout] - Request timeout in milliseconds
  * @returns {Promise<Object>} Test response
  * @throws {Error} If test fails
  */
-async function testDatasourceViaPipeline(dataplaneUrl, systemKey, datasourceKey, authConfig, testData, options = {}) {
+async function testDatasourceViaPipeline({ dataplaneUrl, systemKey, datasourceKey, authConfig, testData, options = {} }) {
   const client = new ApiClient(dataplaneUrl, authConfig);
   const requestOptions = {
     body: testData

package/lib/app-deploy.js

@@ -208,23 +208,13 @@ function validateDeploymentConfig(deploymentConfig) {
 }
 
 /**
- * Loads deployment configuration from variables.yaml and gets/refreshes token
+ * Configure deployment environment settings
  * @async
- * @param {string} appName - Application name
  * @param {Object} options - CLI options
- * @returns {Promise<Object>} Deployment configuration with token
- * @throws {Error} If configuration is invalid
+ * @param {Object} deploymentConfig - Deployment configuration to update
+ * @returns {Promise<void>}
  */
-async function loadDeploymentConfig(appName, options) {
-  // Detect app type and get correct path (integration or builder)
-  const { appPath } = await detectAppType(appName);
-  await validateAppDirectory(appPath, appName);
-
-  const variablesPath = path.join(appPath, 'variables.yaml');
-  const variables = await loadVariablesFile(variablesPath);
-
-  const deploymentConfig = extractDeploymentConfig(options, variables);
-
+async function configureDeploymentEnvironment(options, deploymentConfig) {
   // Update root-level environment if provided
   if (options.environment) {
     await config.setCurrentEnvironment(options.environment);
@@ -233,7 +223,17 @@ async function loadDeploymentConfig(appName, options) {
   // Get current environment from root-level config
   const currentEnvironment = await config.getCurrentEnvironment();
   deploymentConfig.envKey = deploymentConfig.envKey || currentEnvironment;
+}
 
+/**
+ * Refresh deployment token and configure authentication
+ * @async
+ * @param {string} appName - Application name
+ * @param {Object} deploymentConfig - Deployment configuration to update
+ * @returns {Promise<void>}
+ * @throws {Error} If authentication fails
+ */
+async function refreshDeploymentToken(appName, deploymentConfig) {
   // Get controller URL
   if (!deploymentConfig.controllerUrl) {
     throw new Error('Controller URL is required. Set it in variables.yaml or use --controller flag');
@@ -257,6 +257,28 @@ async function loadDeploymentConfig(appName, options) {
   } catch (error) {
     throw new Error(`Failed to get authentication: ${error.message}`);
   }
+}
+
+/**
+ * Loads deployment configuration from variables.yaml and gets/refreshes token
+ * @async
+ * @param {string} appName - Application name
+ * @param {Object} options - CLI options
+ * @returns {Promise<Object>} Deployment configuration with token
+ * @throws {Error} If configuration is invalid
+ */
+async function loadDeploymentConfig(appName, options) {
+  // Detect app type and get correct path (integration or builder)
+  const { appPath } = await detectAppType(appName);
+  await validateAppDirectory(appPath, appName);
+
+  const variablesPath = path.join(appPath, 'variables.yaml');
+  const variables = await loadVariablesFile(variablesPath);
+
+  const deploymentConfig = extractDeploymentConfig(options, variables);
+
+  await configureDeploymentEnvironment(options, deploymentConfig);
+  await refreshDeploymentToken(appName, deploymentConfig);
 
   validateDeploymentConfig(deploymentConfig);
 

package/lib/app-list.js

@@ -16,6 +16,54 @@ const { formatApiError } = require('./utils/api-error-handler');
 const { formatAuthenticationError } = require('./utils/error-formatters/http-status-errors');
 const logger = require('./utils/logger');
 
+/**
+ * Extract wrapped array format: { success: true, data: { success: true, data: [...] } }
+ * @param {Object} apiResponse - API response data
+ * @returns {Array|null} Applications array or null if not this format
+ */
+function extractWrappedArray(apiResponse) {
+  if (apiResponse && apiResponse.data && Array.isArray(apiResponse.data)) {
+    return apiResponse.data;
+  }
+  return null;
+}
+
+/**
+ * Extract direct array format: { success: true, data: [...] }
+ * @param {Object} apiResponse - API response data
+ * @returns {Array|null} Applications array or null if not this format
+ */
+function extractDirectArray(apiResponse) {
+  if (Array.isArray(apiResponse)) {
+    return apiResponse;
+  }
+  return null;
+}
+
+/**
+ * Extract paginated items format: { success: true, data: { items: [...] } }
+ * @param {Object} apiResponse - API response data
+ * @returns {Array|null} Applications array or null if not this format
+ */
+function extractPaginatedItems(apiResponse) {
+  if (apiResponse && Array.isArray(apiResponse.items)) {
+    return apiResponse.items;
+  }
+  return null;
+}
+
+/**
+ * Extract wrapped paginated items format: { success: true, data: { success: true, data: { items: [...] } } }
+ * @param {Object} apiResponse - API response data
+ * @returns {Array|null} Applications array or null if not this format
+ */
+function extractWrappedPaginatedItems(apiResponse) {
+  if (apiResponse && apiResponse.data && apiResponse.data.items && Array.isArray(apiResponse.data.items)) {
+    return apiResponse.data.items;
+  }
+  return null;
+}
+
 /**
  * Extract applications array from API response
  * Handles multiple response formats:
@@ -29,21 +77,14 @@ const logger = require('./utils/logger');
  */
 function extractApplications(response) {
   const apiResponse = response.data;
-  let applications;
 
-  // Check if apiResponse.data is an array (wrapped format)
-  if (apiResponse && apiResponse.data && Array.isArray(apiResponse.data)) {
-    applications = apiResponse.data;
-  } else if (Array.isArray(apiResponse)) {
-    // Check if apiResponse is directly an array
-    applications = apiResponse;
-  } else if (apiResponse && Array.isArray(apiResponse.items)) {
-    // Check if apiResponse.items is an array (paginated format)
-    applications = apiResponse.items;
-  } else if (apiResponse && apiResponse.data && apiResponse.data.items && Array.isArray(apiResponse.data.items)) {
-    // Check if apiResponse.data.items is an array (wrapped paginated format)
-    applications = apiResponse.data.items;
-  } else {
+  // Try each format in sequence
+  const applications = extractWrappedArray(apiResponse) ||
+    extractDirectArray(apiResponse) ||
+    extractPaginatedItems(apiResponse) ||
+    extractWrappedPaginatedItems(apiResponse);
+
+  if (!applications) {
     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));
@@ -55,6 +96,36 @@ function extractApplications(response) {
   return applications;
 }
 
+/**
+ * Find device token from config by trying each stored URL
+ * @async
+ * @param {Object} deviceConfig - Device configuration object
+ * @returns {Promise<Object|null>} Token result with token and controllerUrl, or null if not found
+ */
+async function findDeviceTokenFromConfig(deviceConfig) {
+  const deviceUrls = Object.keys(deviceConfig);
+  if (deviceUrls.length === 0) {
+    return null;
+  }
+
+  for (const storedUrl of deviceUrls) {
+    try {
+      const normalizedStoredUrl = normalizeControllerUrl(storedUrl);
+      const deviceToken = await getOrRefreshDeviceToken(normalizedStoredUrl);
+      if (deviceToken && deviceToken.token) {
+        return {
+          token: deviceToken.token,
+          controllerUrl: deviceToken.controller || normalizedStoredUrl
+        };
+      }
+    } catch (error) {
+      // Continue to next URL
+    }
+  }
+
+  return null;
+}
+
 /**
  * Display applications list
  * @param {Array} applications - Array of application objects
@@ -79,58 +150,57 @@ function displayApplications(applications, environment) {
 }
 
 /**
- * List applications in an environment
+ * Try to get device token from controller URL
  * @async
- * @param {Object} options - Command options
- * @param {string} options.environment - Environment ID or key
- * @param {string} [options.controller] - Controller URL (optional, uses configured controller if not provided)
- * @throws {Error} If listing fails
+ * @param {string} controllerUrl - Controller URL
+ * @returns {Promise<Object|null>} Object with token and controllerUrl, or null
  */
-async function listApplications(options) {
-  const config = await getConfig();
-
-  // Get controller URL with priority: options.controller > device tokens
-  const controllerUrl = options.controller || null;
-  let token = null;
-  let actualControllerUrl = null;
-
-  // If controller URL provided, try to get device token
-  if (controllerUrl) {
-    try {
-      const normalizedUrl = normalizeControllerUrl(controllerUrl);
-      const deviceToken = await getOrRefreshDeviceToken(normalizedUrl);
-      if (deviceToken && deviceToken.token) {
-        token = deviceToken.token;
-        actualControllerUrl = deviceToken.controller || normalizedUrl;
-      }
-    } catch (error) {
-      // Show which controller URL failed
-      logger.error(chalk.red(`❌ Failed to authenticate with controller: ${controllerUrl}`));
-      logger.error(chalk.gray(`Error: ${error.message}`));
-      process.exit(1);
+async function tryGetTokenFromController(controllerUrl) {
+  try {
+    const normalizedUrl = normalizeControllerUrl(controllerUrl);
+    const deviceToken = await getOrRefreshDeviceToken(normalizedUrl);
+    if (deviceToken && deviceToken.token) {
+      return {
+        token: deviceToken.token,
+        actualControllerUrl: deviceToken.controller || normalizedUrl
+      };
     }
+  } catch (error) {
+    logger.error(chalk.red(`❌ Failed to authenticate with controller: ${controllerUrl}`));
+    logger.error(chalk.gray(`Error: ${error.message}`));
+    process.exit(1);
   }
+  return null;
+}
 
-  // If no token yet, try to find any device token in config
-  if (!token && config.device) {
-    const deviceUrls = Object.keys(config.device);
-    if (deviceUrls.length > 0) {
-      for (const storedUrl of deviceUrls) {
-        try {
-          const normalizedStoredUrl = normalizeControllerUrl(storedUrl);
-          const deviceToken = await getOrRefreshDeviceToken(normalizedStoredUrl);
-          if (deviceToken && deviceToken.token) {
-            token = deviceToken.token;
-            actualControllerUrl = deviceToken.controller || normalizedStoredUrl;
-            break;
-          }
-        } catch (error) {
-          // Continue to next URL
-        }
-      }
-    }
+/**
+ * Try to find device token from config
+ * @async
+ * @param {Object} deviceConfig - Device configuration
+ * @returns {Promise<Object|null>} Object with token and controllerUrl, or null
+ */
+async function tryGetTokenFromConfig(deviceConfig) {
+  if (!deviceConfig) {
+    return null;
   }
+  const tokenResult = await findDeviceTokenFromConfig(deviceConfig);
+  if (tokenResult) {
+    return {
+      token: tokenResult.token,
+      actualControllerUrl: tokenResult.controllerUrl
+    };
+  }
+  return null;
+}
 
+/**
+ * Validate and return authentication token or exit
+ * @param {string|null} token - Authentication token
+ * @param {string|null} actualControllerUrl - Controller URL
+ * @param {string} controllerUrl - Original controller URL (for error message)
+ * @returns {Object} Object with token and actualControllerUrl
+ */
+function validateAuthToken(token, actualControllerUrl, controllerUrl) {
   if (!token || !actualControllerUrl) {
     const formattedError = formatAuthenticationError({
       controllerUrl: controllerUrl || undefined,
@@ -139,23 +209,73 @@ async function listApplications(options) {
     logger.error(formattedError);
     process.exit(1);
   }
+  return { token, actualControllerUrl };
+}
+
+/**
+ * Get authentication token for listing applications
+ * @async
+ * @param {string} [controllerUrl] - Optional controller URL
+ * @param {Object} config - Configuration object
+ * @returns {Promise<Object>} Object with token and actualControllerUrl
+ * @throws {Error} If authentication fails
+ */
+async function getListAuthToken(controllerUrl, config) {
+  // Try to get token from controller URL first
+  let authResult = null;
+  if (controllerUrl) {
+    authResult = await tryGetTokenFromController(controllerUrl);
+  }
+
+  // If no token yet, try to find device token from config
+  if (!authResult && config.device) {
+    authResult = await tryGetTokenFromConfig(config.device);
+  }
+
+  // Validate and return token or exit
+  return validateAuthToken(authResult?.token || null, authResult?.actualControllerUrl || null, controllerUrl);
+}
+
+/**
+ * Handle API response and extract applications
+ * @param {Object} response - API response
+ * @param {string} actualControllerUrl - Controller URL
+ * @returns {Array} Extracted applications
+ * @throws {Error} If response is invalid
+ */
+function handleListResponse(response, actualControllerUrl) {
+  if (!response.success || !response.data) {
+    const formattedError = response.formattedError || formatApiError(response, actualControllerUrl);
+    logger.error(formattedError);
+    logger.error(chalk.gray(`\nController URL: ${actualControllerUrl}`));
+    logger.error(chalk.gray('\nFull response for debugging:'));
+    logger.error(chalk.gray(JSON.stringify(response, null, 2)));
+    process.exit(1);
+  }
+
+  return extractApplications(response);
+}
+
+/**
+ * List applications in an environment
+ * @async
+ * @param {Object} options - Command options
+ * @param {string} options.environment - Environment ID or key
+ * @param {string} [options.controller] - Controller URL (optional, uses configured controller if not provided)
+ * @throws {Error} If listing fails
+ */
+async function listApplications(options) {
+  const config = await getConfig();
+
+  // Get authentication token
+  const controllerUrl = options.controller || null;
+  const { token, actualControllerUrl } = await getListAuthToken(controllerUrl, config);
 
   // Use centralized API client
   const authConfig = { type: 'bearer', token: token };
   try {
     const response = await listEnvironmentApplications(actualControllerUrl, options.environment, authConfig);
-
-    if (!response.success || !response.data) {
-      const formattedError = response.formattedError || formatApiError(response, actualControllerUrl);
-      logger.error(formattedError);
-      logger.error(chalk.gray(`\nController URL: ${actualControllerUrl}`));
-      // Log full response for debugging
-      logger.error(chalk.gray('\nFull response for debugging:'));
-      logger.error(chalk.gray(JSON.stringify(response, null, 2)));
-      process.exit(1);
-    }
-
-    const applications = extractApplications(response);
+    const applications = handleListResponse(response, actualControllerUrl);
     displayApplications(applications, options.environment);
   } catch (error) {
     logger.error(chalk.red(`❌ Failed to list applications from controller: ${actualControllerUrl}`));

package/lib/app-prompts.js

@@ -300,6 +300,75 @@ function resolveOptionalBoolean(optionValue, answerValue, defaultValue) {
   return answerValue !== undefined ? answerValue : defaultValue;
 }
 
+/**
+ * Resolve a single config field from options or answers
+ * @function resolveConfigField
+ * @param {Object} options - Provided options
+ * @param {Object} answers - Prompt answers
+ * @param {string} fieldName - Field name to resolve
+ * @param {*} defaultValue - Default value
+ * @returns {*} Resolved value
+ */
+function resolveConfigField(options, answers, fieldName, defaultValue) {
+  return resolveField(options[fieldName], answers[fieldName], defaultValue);
+}
+
+/**
+ * Resolve a single external system field if present
+ * @function resolveExternalSystemField
+ * @param {Object} options - Provided options
+ * @param {Object} answers - Prompt answers
+ * @param {string} fieldName - Field name to resolve
+ * @param {*} defaultValue - Default value
+ * @returns {*|null} Resolved value or null if not present
+ */
+function resolveExternalSystemField(options, answers, fieldName, defaultValue) {
+  if (answers[fieldName] || options[fieldName]) {
+    return resolveField(options[fieldName], answers[fieldName], defaultValue);
+  }
+  return null;
+}
+
+/**
+ * Resolve external system fields and add to config
+ * @function resolveExternalSystemFields
+ * @param {Object} options - Provided options
+ * @param {Object} answers - Prompt answers
+ * @param {Object} config - Configuration object to update
+ * @returns {void}
+ */
+function resolveExternalSystemFields(options, answers, config) {
+  const systemKey = resolveExternalSystemField(options, answers, 'systemKey', undefined);
+  if (systemKey !== null) {
+    config.systemKey = systemKey;
+  }
+
+  const systemDisplayName = resolveExternalSystemField(options, answers, 'systemDisplayName', undefined);
+  if (systemDisplayName !== null) {
+    config.systemDisplayName = systemDisplayName;
+  }
+
+  const systemDescription = resolveExternalSystemField(options, answers, 'systemDescription', undefined);
+  if (systemDescription !== null) {
+    config.systemDescription = systemDescription;
+  }
+
+  const systemType = resolveExternalSystemField(options, answers, 'systemType', 'openapi');
+  if (systemType !== null) {
+    config.systemType = systemType;
+  }
+
+  const authType = resolveExternalSystemField(options, answers, 'authType', 'apikey');
+  if (authType !== null) {
+    config.authType = authType;
+  }
+
+  const datasourceCount = resolveExternalSystemField(options, answers, 'datasourceCount', 1);
+  if (datasourceCount !== null) {
+    config.datasourceCount = parseInt(datasourceCount, 10);
+  }
+}
+
 /**
  * Resolves conflicts between options and answers
  * @function resolveConflicts
@@ -309,36 +378,18 @@ function resolveOptionalBoolean(optionValue, answerValue, defaultValue) {
  */
 function resolveConflicts(options, answers) {
   const config = {
-    port: parseInt(resolveField(options.port, answers.port, 3000), 10),
-    language: resolveField(options.language, answers.language, 'typescript'),
-    database: resolveField(options.database, answers.database, false),
-    redis: resolveField(options.redis, answers.redis, false),
-    storage: resolveField(options.storage, answers.storage, false),
-    authentication: resolveField(options.authentication, answers.authentication, false),
+    port: parseInt(resolveConfigField(options, answers, 'port', 3000), 10),
+    language: resolveConfigField(options, answers, 'language', 'typescript'),
+    database: resolveConfigField(options, answers, 'database', false),
+    redis: resolveConfigField(options, answers, 'redis', false),
+    storage: resolveConfigField(options, answers, 'storage', false),
+    authentication: resolveConfigField(options, answers, 'authentication', false),
     github: resolveOptionalBoolean(options.github, answers.github, false),
     controller: resolveOptionalBoolean(options.controller, answers.controller, false),
-    controllerUrl: resolveField(options.controllerUrl, answers.controllerUrl, undefined)
+    controllerUrl: resolveConfigField(options, answers, 'controllerUrl', undefined)
   };
 
-  // Add external system fields if present
-  if (answers.systemKey || options.systemKey) {
-    config.systemKey = resolveField(options.systemKey, answers.systemKey, undefined);
-  }
-  if (answers.systemDisplayName || options.systemDisplayName) {
-    config.systemDisplayName = resolveField(options.systemDisplayName, answers.systemDisplayName, undefined);
-  }
-  if (answers.systemDescription || options.systemDescription) {
-    config.systemDescription = resolveField(options.systemDescription, answers.systemDescription, undefined);
-  }
-  if (answers.systemType || options.systemType) {
-    config.systemType = resolveField(options.systemType, answers.systemType, 'openapi');
-  }
-  if (answers.authType || options.authType) {
-    config.authType = resolveField(options.authType, answers.authType, 'apikey');
-  }
-  if (answers.datasourceCount || options.datasourceCount) {
-    config.datasourceCount = parseInt(resolveField(options.datasourceCount, answers.datasourceCount, 1), 10);
-  }
+  resolveExternalSystemFields(options, answers, config);
 
   return config;
 }