@aifabrix/builder 2.31.0 → 2.32.1

package/lib/utils/app-register-auth.js

@@ -10,7 +10,7 @@
 
 const chalk = require('chalk');
 const logger = require('./logger');
-const { getConfig, normalizeControllerUrl } = require('../config');
+const { getConfig, normalizeControllerUrl } = require('../core/config');
 const { getOrRefreshDeviceToken } = require('./token-manager');
 const { formatAuthenticationError } = require('./error-formatters/http-status-errors');
 
@@ -86,66 +86,191 @@ async function findDeviceTokenFromConfig(deviceConfig, attemptedUrls) {
  * @param {string} [environment] - Optional environment key
  * @returns {Promise<{apiUrl: string, token: string, controllerUrl: string}>} Configuration with API URL, token, and controller URL
  */
-async function checkAuthentication(controllerUrl, environment) {
+/**
+ * Tries to get device token for provided controller URL
+ * @async
+ * @function tryGetDeviceTokenForController
+ * @param {string} controllerUrl - Controller URL
+ * @param {Array<string>} attemptedUrls - Array to track attempted URLs
+ * @returns {Promise<Object|null>} Token result or null
+ */
+async function tryGetDeviceTokenForController(controllerUrl, attemptedUrls) {
+  if (!controllerUrl) {
+    return null;
+  }
+  attemptedUrls.push(controllerUrl);
   try {
-    const config = await getConfig();
-
-    // Try to get controller URL from parameter, config, or device tokens
-    // Handle empty string as falsy (treat same as undefined/null)
-    const normalizedControllerUrl = (controllerUrl && controllerUrl.trim()) ? normalizeControllerUrl(controllerUrl) : null;
-    let finalControllerUrl = normalizedControllerUrl;
-    let token = null;
-    let lastError = null;
-    const attemptedUrls = []; // Track all attempted URLs
-
-    // If controller URL provided, try to get device token
-    if (finalControllerUrl) {
-      attemptedUrls.push(finalControllerUrl);
-      try {
-        const deviceToken = await getOrRefreshDeviceToken(finalControllerUrl);
-        if (deviceToken && deviceToken.token) {
-          token = deviceToken.token;
-          finalControllerUrl = deviceToken.controller || finalControllerUrl;
-        }
-      } catch (error) {
-        lastError = error;
-        logger.warn(chalk.yellow(`⚠️  Failed to get token for controller ${finalControllerUrl}: ${error.message}`));
-      }
+    const deviceToken = await getOrRefreshDeviceToken(controllerUrl);
+    if (deviceToken && deviceToken.token) {
+      return {
+        token: deviceToken.token,
+        controllerUrl: deviceToken.controller || controllerUrl
+      };
     }
+  } catch (error) {
+    logger.warn(chalk.yellow(`⚠️  Failed to get token for controller ${controllerUrl}: ${error.message}`));
+    return { error };
+  }
+  return null;
+}
 
-    // If no token yet, try to find any device token in config
-    if (!token && config.device) {
-      const tokenResult = await findDeviceTokenFromConfig(config.device, attemptedUrls);
-      if (tokenResult) {
-        token = tokenResult.token;
-        finalControllerUrl = tokenResult.controllerUrl;
-      }
+/**
+ * Tries to find device token from config
+ * @async
+ * @function tryFindDeviceTokenFromConfig
+ * @param {Object} deviceConfig - Device config from main config
+ * @param {Array<string>} attemptedUrls - Array to track attempted URLs
+ * @returns {Promise<Object|null>} Token result or null
+ */
+async function tryFindDeviceTokenFromConfig(deviceConfig, attemptedUrls) {
+  if (!deviceConfig) {
+    return null;
+  }
+  const tokenResult = await findDeviceTokenFromConfig(deviceConfig, attemptedUrls);
+  if (tokenResult) {
+    return {
+      token: tokenResult.token,
+      controllerUrl: tokenResult.controllerUrl
+    };
+  }
+  return null;
+}
+
+/**
+ * Creates error data for authentication failure
+ * @function createAuthErrorData
+ * @param {Error|null} lastError - Last error encountered
+ * @param {string|null} controllerUrl - Original controller URL
+ * @param {Array<string>} attemptedUrls - Attempted URLs
+ * @returns {Object} Error data object
+ */
+function createAuthErrorData(lastError, controllerUrl, attemptedUrls) {
+  return {
+    message: lastError ? lastError.message : 'No valid authentication found',
+    controllerUrl: controllerUrl || (attemptedUrls.length > 0 ? attemptedUrls[0] : undefined),
+    attemptedUrls: attemptedUrls.length > 1 ? attemptedUrls : undefined,
+    correlationId: undefined
+  };
+}
+
+/**
+ * Normalizes controller URL
+ * @function normalizeControllerUrlIfProvided
+ * @param {string|null} controllerUrl - Controller URL
+ * @returns {string|null} Normalized controller URL or null
+ */
+function normalizeControllerUrlIfProvided(controllerUrl) {
+  // Handle empty string as falsy (treat same as undefined/null)
+  return (controllerUrl && controllerUrl.trim()) ? normalizeControllerUrl(controllerUrl) : null;
+}
+
+/**
+ * Attempts to get device token for provided controller URL
+ * @async
+ * @function attemptDeviceTokenForController
+ * @param {string|null} finalControllerUrl - Final controller URL
+ * @param {string[]} attemptedUrls - Array of attempted URLs
+ * @returns {Promise<Object|null>} Device token result or null
+ */
+async function attemptDeviceTokenForController(finalControllerUrl, attemptedUrls) {
+  if (!finalControllerUrl) {
+    return null;
+  }
+
+  const deviceTokenResult = await tryGetDeviceTokenForController(finalControllerUrl, attemptedUrls);
+  return deviceTokenResult;
+}
+
+/**
+ * Attempts to find device token from config
+ * @async
+ * @function attemptDeviceTokenFromConfig
+ * @param {Object} deviceConfig - Device configuration
+ * @param {string[]} attemptedUrls - Array of attempted URLs
+ * @returns {Promise<Object|null>} Device token result or null
+ */
+async function attemptDeviceTokenFromConfig(deviceConfig, attemptedUrls) {
+  if (!deviceConfig) {
+    return null;
+  }
+
+  return await tryFindDeviceTokenFromConfig(deviceConfig, attemptedUrls);
+}
+
+/**
+ * Validates authentication result
+ * @function validateAuthenticationResult
+ * @param {string|null} token - Authentication token
+ * @param {string|null} finalControllerUrl - Final controller URL
+ * @param {Error|null} lastError - Last error encountered
+ * @param {string|null} originalControllerUrl - Original controller URL
+ * @param {string[]} attemptedUrls - Array of attempted URLs
+ */
+function validateAuthenticationResult(token, finalControllerUrl, lastError, originalControllerUrl, attemptedUrls) {
+  if (!token || !finalControllerUrl) {
+    const errorData = createAuthErrorData(lastError, originalControllerUrl, attemptedUrls);
+    displayAuthenticationError(lastError, errorData);
+  }
+}
+
+/**
+ * Attempts to get authentication token
+ * @async
+ * @function attemptGetAuthenticationToken
+ * @param {string|null} normalizedControllerUrl - Normalized controller URL
+ * @param {Object} config - Configuration object
+ * @param {string[]} attemptedUrls - Array of attempted URLs
+ * @returns {Promise<Object>} Object with token, finalControllerUrl, and lastError
+ */
+async function attemptGetAuthenticationToken(normalizedControllerUrl, config, attemptedUrls) {
+  let finalControllerUrl = normalizedControllerUrl;
+  let token = null;
+  let lastError = null;
+
+  // If controller URL provided, try to get device token
+  const deviceTokenResult = await attemptDeviceTokenForController(finalControllerUrl, attemptedUrls);
+  if (deviceTokenResult) {
+    if (deviceTokenResult.error) {
+      lastError = deviceTokenResult.error;
+    } else {
+      token = deviceTokenResult.token;
+      finalControllerUrl = deviceTokenResult.controllerUrl;
     }
+  }
 
-    // If still no token, check for client token (requires environment and app)
-    if (!token && environment) {
-      // For app register, we don't have an app yet, so client tokens won't work
-      // This is expected - device tokens should be used for registration
+  // If no token yet, try to find any device token in config
+  if (!token) {
+    const configTokenResult = await attemptDeviceTokenFromConfig(config.device, attemptedUrls);
+    if (configTokenResult) {
+      token = configTokenResult.token;
+      finalControllerUrl = configTokenResult.controllerUrl;
     }
+  }
+
+  return { token, finalControllerUrl, lastError };
+}
+
+async function checkAuthentication(controllerUrl, _environment) {
+  try {
+    const config = await getConfig();
+    const normalizedControllerUrl = normalizeControllerUrlIfProvided(controllerUrl);
+    const attemptedUrls = [];
+
+    const { token, finalControllerUrl, lastError } = await attemptGetAuthenticationToken(
+      normalizedControllerUrl,
+      config,
+      attemptedUrls
+    );
 
     // If no token found, display error with attempted URLs
-    if (!token || !finalControllerUrl) {
-      const errorData = {
-        message: lastError ? lastError.message : 'No valid authentication found',
-        controllerUrl: controllerUrl || (attemptedUrls.length > 0 ? attemptedUrls[0] : undefined),
-        attemptedUrls: attemptedUrls.length > 1 ? attemptedUrls : undefined,
-        correlationId: undefined
-      };
-      displayAuthenticationError(lastError, errorData);
-    }
+    validateAuthenticationResult(token, finalControllerUrl, lastError, controllerUrl, attemptedUrls);
 
     return {
       apiUrl: finalControllerUrl,
       token: token,
-      controllerUrl: finalControllerUrl // Return the actual URL used
+      controllerUrl: finalControllerUrl
     };
   } catch (error) {
-    // Handle any unexpected errors during authentication check
     displayAuthenticationError(error, { controllerUrl: controllerUrl });
   }
 }

package/lib/utils/app-register-config.js

@@ -15,13 +15,7 @@ const yaml = require('js-yaml');
 const logger = require('./logger');
 const { detectAppType } = require('./paths');
 
-// Import createApp to auto-generate config if missing
-let createApp;
-try {
-  createApp = require('../app').createApp;
-} catch {
-  createApp = null;
-}
+// createApp is imported dynamically in createMinimalAppIfNeeded to handle test mocking
 
 /**
  * Load variables.yaml file for an application
@@ -55,11 +49,13 @@ async function loadVariablesYaml(appKey) {
  * @returns {Promise<Object>} Variables after creation
  */
 async function createMinimalAppIfNeeded(appKey, options) {
-  if (!createApp) {
+  // Re-import createApp to check current availability (handles dynamic mocking in tests)
+  const { createApp: currentCreateApp } = require('../app');
+  if (!currentCreateApp) {
     throw new Error('Cannot auto-create application: createApp function not available');
   }
 
-  await createApp(appKey, {
+  await currentCreateApp(appKey, {
     port: options.port,
     language: 'typescript',
     database: false,
@@ -69,7 +65,11 @@ async function createMinimalAppIfNeeded(appKey, options) {
   });
 
   // Detect app type and get correct path (integration or builder)
-  const { appPath } = await detectAppType(appKey);
+  const appTypeResult = await detectAppType(appKey);
+  if (!appTypeResult || !appTypeResult.appPath) {
+    throw new Error('Failed to detect app type after creation');
+  }
+  const { appPath } = appTypeResult;
   const variablesPath = path.join(appPath, 'variables.yaml');
   const variablesContent = await fs.readFile(variablesPath, 'utf-8');
   return yaml.load(variablesContent);
@@ -96,6 +96,71 @@ function buildImageReference(variables, appKey) {
  * @param {Object} externalIntegration - External integration config from variables.yaml
  * @returns {Promise<{url: string, apiKey?: string}>} URL and optional API key
  */
+/**
+ * Resolves system file path
+ * @function resolveSystemFilePath
+ * @param {string} appPath - Application path
+ * @param {string} schemaBasePath - Schema base path
+ * @param {string} systemFileName - System file name
+ * @returns {string} Resolved system file path
+ */
+function resolveSystemFilePath(appPath, schemaBasePath, systemFileName) {
+  return path.isAbsolute(schemaBasePath)
+    ? path.join(schemaBasePath, systemFileName)
+    : path.join(appPath, schemaBasePath, systemFileName);
+}
+
+/**
+ * Extracts URL from system JSON
+ * @function extractUrlFromSystemJson
+ * @param {Object} systemJson - System JSON object
+ * @param {string} systemFileName - System file name
+ * @returns {string} Base URL
+ * @throws {Error} If URL is missing
+ */
+function extractUrlFromSystemJson(systemJson, systemFileName) {
+  const url = systemJson.environment?.baseUrl;
+  if (!url) {
+    throw new Error(`Missing environment.baseUrl in ${systemFileName}`);
+  }
+  return url;
+}
+
+/**
+ * Extracts API key from system JSON if present
+ * @function extractApiKeyFromSystemJson
+ * @param {Object} systemJson - System JSON object
+ * @returns {string|undefined} API key or undefined
+ */
+function extractApiKeyFromSystemJson(systemJson) {
+  if (!systemJson.authentication?.apikey?.key) {
+    return undefined;
+  }
+
+  // If it's a kv:// reference, we can't resolve it here, so leave it undefined
+  // The API will handle kv:// references
+  const keyValue = systemJson.authentication.apikey.key;
+  if (keyValue.startsWith('kv://') || keyValue.startsWith('{{')) {
+    return undefined;
+  }
+
+  return keyValue;
+}
+
+/**
+ * Handles file read errors
+ * @function handleFileReadError
+ * @param {Error} error - Error object
+ * @param {string} systemFilePath - System file path
+ * @throws {Error} Formatted error
+ */
+function handleFileReadError(error, systemFilePath) {
+  if (error.code === 'ENOENT') {
+    throw new Error(`External system file not found: ${systemFilePath}`);
+  }
+  throw new Error(`Failed to read external system file: ${error.message}`);
+}
+
 async function extractExternalIntegrationUrl(appKey, externalIntegration) {
   if (!externalIntegration || !externalIntegration.systems || externalIntegration.systems.length === 0) {
     throw new Error('externalIntegration.systems is required for external type applications');
@@ -107,37 +172,18 @@ async function extractExternalIntegrationUrl(appKey, externalIntegration) {
   const systemFileName = externalIntegration.systems[0];
 
   // Resolve system file path (handle both relative and absolute paths)
-  const systemFilePath = path.isAbsolute(schemaBasePath)
-    ? path.join(schemaBasePath, systemFileName)
-    : path.join(appPath, schemaBasePath, systemFileName);
+  const systemFilePath = resolveSystemFilePath(appPath, schemaBasePath, systemFileName);
 
   try {
     const systemContent = await fs.readFile(systemFilePath, 'utf-8');
     const systemJson = JSON.parse(systemContent);
 
-    // Extract URL from environment.baseUrl
-    const url = systemJson.environment?.baseUrl;
-    if (!url) {
-      throw new Error(`Missing environment.baseUrl in ${systemFileName}`);
-    }
-
-    // Extract optional API key from authentication if present
-    let apiKey;
-    if (systemJson.authentication?.apikey?.key) {
-      // If it's a kv:// reference, we can't resolve it here, so leave it undefined
-      // The API will handle kv:// references
-      const keyValue = systemJson.authentication.apikey.key;
-      if (!keyValue.startsWith('kv://') && !keyValue.startsWith('{{')) {
-        apiKey = keyValue;
-      }
-    }
+    const url = extractUrlFromSystemJson(systemJson, systemFileName);
+    const apiKey = extractApiKeyFromSystemJson(systemJson);
 
     return { url, apiKey };
   } catch (error) {
-    if (error.code === 'ENOENT') {
-      throw new Error(`External system file not found: ${systemFilePath}`);
-    }
-    throw new Error(`Failed to read external system file: ${error.message}`);
+    handleFileReadError(error, systemFilePath);
   }
 }
 
@@ -149,34 +195,47 @@ async function extractExternalIntegrationUrl(appKey, externalIntegration) {
  * @param {Object} options - Registration options
  * @returns {Promise<Object>} Extracted configuration
  */
-async function extractAppConfiguration(variables, appKey, options) {
-  const appKeyFromFile = variables.app?.key || appKey;
-  const displayName = variables.app?.name || options.name || appKey;
-  const description = variables.app?.description || '';
-
-  // Handle external type
-  if (variables.app?.type === 'external') {
-    // Extract URL from external system JSON file
-    const { url, apiKey } = await extractExternalIntegrationUrl(appKey, variables.externalIntegration);
-
-    // Build simplified externalIntegration object for registration API
-    const externalIntegration = { url };
-    if (apiKey) {
-      externalIntegration.apiKey = apiKey;
-    }
-
-    return {
-      appKey: appKeyFromFile,
-      displayName,
-      description,
-      appType: 'external',
-      externalIntegration,
-      port: null, // External systems don't need ports
-      image: null, // External systems don't need images
-      language: null // External systems don't need language
-    };
+/**
+ * Extracts external app configuration
+ * @async
+ * @function extractExternalAppConfiguration
+ * @param {string} appKey - Application key
+ * @param {Object} variables - Variables object
+ * @param {string} appKeyFromFile - App key from file
+ * @param {string} displayName - Display name
+ * @param {string} description - Description
+ * @returns {Promise<Object>} External app configuration
+ */
+async function extractExternalAppConfiguration(appKey, variables, appKeyFromFile, displayName, description) {
+  const { url, apiKey } = await extractExternalIntegrationUrl(appKey, variables.externalIntegration);
+  const externalIntegration = { url };
+  if (apiKey) {
+    externalIntegration.apiKey = apiKey;
   }
 
+  return {
+    appKey: appKeyFromFile,
+    displayName,
+    description,
+    appType: 'external',
+    externalIntegration,
+    port: null,
+    image: null,
+    language: null
+  };
+}
+
+/**
+ * Extracts webapp/service configuration
+ * @function extractWebappConfiguration
+ * @param {Object} variables - Variables object
+ * @param {string} appKeyFromFile - App key from file
+ * @param {string} displayName - Display name
+ * @param {string} description - Description
+ * @param {Object} options - Options object
+ * @returns {Object} Webapp configuration
+ */
+function extractWebappConfiguration(variables, appKeyFromFile, displayName, description, options) {
   const appType = variables.build?.language === 'typescript' ? 'webapp' : 'service';
   const registryMode = variables.image?.registryMode || 'external';
   const port = variables.build?.port || options.port || 3000;
@@ -195,6 +254,18 @@ async function extractAppConfiguration(variables, appKey, options) {
   };
 }
 
+async function extractAppConfiguration(variables, appKey, options) {
+  const appKeyFromFile = variables.app?.key || appKey;
+  const displayName = variables.app?.name || options.name || appKey;
+  const description = variables.app?.description || '';
+
+  if (variables.app?.type === 'external') {
+    return await extractExternalAppConfiguration(appKey, variables, appKeyFromFile, displayName, description);
+  }
+
+  return extractWebappConfiguration(variables, appKeyFromFile, displayName, description, options);
+}
+
 module.exports = {
   loadVariablesYaml,
   createMinimalAppIfNeeded,

package/lib/utils/app-run-containers.js

@@ -52,10 +52,36 @@ async function checkImageExists(imageName, tag = 'latest', debug = false) {
  * @param {boolean} [debug=false] - Enable debug logging
  * @returns {Promise<boolean>} True if container is running
  */
+/**
+ * Gets container name from app name and developer ID
+ * @function getContainerName
+ * @param {string} appName - Application name
+ * @param {number|string} developerId - Developer ID
+ * @returns {string} Container name
+ */
+function getContainerName(appName, developerId) {
+  const idNum = typeof developerId === 'string' ? parseInt(developerId, 10) : developerId;
+  return idNum === 0 ? `aifabrix-${appName}` : `aifabrix-dev${developerId}-${appName}`;
+}
+
+/**
+ * Logs debug information about container
+ * @async
+ * @function logContainerDebugInfo
+ * @param {string} containerName - Container name
+ */
+async function logContainerDebugInfo(containerName) {
+  const statusCmd = `docker ps --filter "name=${containerName}" --format "{{.Status}}"`;
+  const { stdout: status } = await execAsync(statusCmd);
+  const portsCmd = `docker ps --filter "name=${containerName}" --format "{{.Ports}}"`;
+  const { stdout: ports } = await execAsync(portsCmd);
+  logger.log(chalk.gray(`[DEBUG] Container status: ${status.trim()}`));
+  logger.log(chalk.gray(`[DEBUG] Container ports: ${ports.trim()}`));
+}
+
 async function checkContainerRunning(appName, developerId, debug = false) {
   try {
-    const idNum = typeof developerId === 'string' ? parseInt(developerId, 10) : developerId;
-    const containerName = idNum === 0 ? `aifabrix-${appName}` : `aifabrix-dev${developerId}-${appName}`;
+    const containerName = getContainerName(appName, developerId);
     const cmd = `docker ps --filter "name=${containerName}" --format "{{.Names}}"`;
     if (debug) {
       logger.log(chalk.gray(`[DEBUG] Executing: ${cmd}`));
@@ -65,12 +91,7 @@ async function checkContainerRunning(appName, developerId, debug = false) {
     if (debug) {
       logger.log(chalk.gray(`[DEBUG] Container ${containerName} running: ${isRunning}`));
       if (isRunning) {
-        const statusCmd = `docker ps --filter "name=${containerName}" --format "{{.Status}}"`;
-        const { stdout: status } = await execAsync(statusCmd);
-        const portsCmd = `docker ps --filter "name=${containerName}" --format "{{.Ports}}"`;
-        const { stdout: ports } = await execAsync(portsCmd);
-        logger.log(chalk.gray(`[DEBUG] Container status: ${status.trim()}`));
-        logger.log(chalk.gray(`[DEBUG] Container ports: ${ports.trim()}`));
+        await logContainerDebugInfo(containerName);
       }
     }
     return isRunning;

package/lib/utils/build-helpers.js

@@ -55,7 +55,7 @@ async function determineDockerfile(appName, options, generateDockerfileFn) {
  */
 async function loadAndValidateConfig(appName) {
   const { loadVariablesYaml } = require('../build');
-  const validator = require('../validator');
+  const validator = require('../validation/validator');
 
   const variables = await loadVariablesYaml(appName);